@openpkg-ts/doc-generator 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,827 @@
+import { OpenPkg as OpenPkg9, SpecExample, SpecExport as SpecExport5, SpecExportKind as SpecExportKind5, SpecMember as SpecMember2, SpecSchema as SpecSchema2, SpecSignature as SpecSignature2, SpecSignatureParameter, SpecTag, SpecType as SpecType3, SpecTypeKind, SpecTypeParameter as SpecTypeParameter2 } from "@openpkg-ts/spec";
+import { OpenPkg, SpecExport } from "@openpkg-ts/spec";
+import { ComponentType, ReactNode } from "react";
+/**
+* Core interface for framework adapters.
+* Each adapter provides framework-specific file generation, components, and config helpers.
+*/
+interface DocFrameworkAdapter {
+	/** Unique identifier for this adapter */
+	name: string;
+	/** Display name for documentation */
+	displayName: string;
+	/** Supported doc framework version(s) */
+	version: string;
+	/** Generate framework-specific files from spec */
+	generate: FileGenerator;
+	/** Styled components tailored for the framework */
+	components: AdapterComponents;
+	/** Config helper for the framework */
+	config?: ConfigHelper;
+}
+/**
+* File generation functions for a doc framework.
+*/
+interface FileGenerator {
+	/** Generate MDX/MD files for each */
+	pages(spec: OpenPkg, options?: PageGeneratorOptions): GeneratedFile[];
+	/** Generate navigation/sidebar config */
+	navigation(spec: OpenPkg, options?: NavGeneratorOptions): GeneratedFile;
+	/** Generate search index */
+	searchIndex?(spec: OpenPkg, options?: SearchGeneratorOptions): GeneratedFile;
+}
+interface PageGeneratorOptions {
+	/** Output directory for generated files */
+	outDir?: string;
+	/** Base path for URLs */
+	basePath?: string;
+	/** Include frontmatter in generated files */
+	frontmatter?: boolean;
+	/** Group exports by kind, module, or tag */
+	groupBy?: "kind" | "module" | "tag" | "none";
+	/** Filter exports to include */
+	filter?: (exp: SpecExport) => boolean;
+}
+interface NavGeneratorOptions {
+	/** Output file path */
+	outFile?: string;
+	/** Base path for links */
+	basePath?: string;
+	/** Group navigation items */
+	groupBy?: "kind" | "module" | "tag";
+	/** Include type definitions in nav */
+	includeTypes?: boolean;
+}
+interface SearchGeneratorOptions {
+	/** Output file path */
+	outFile?: string;
+	/** Base URL for search results */
+	baseUrl?: string;
+	/** Fields to include in search index */
+	fields?: ("name" | "description" | "signature" | "examples")[];
+}
+interface GeneratedFile {
+	/** Relative path for the file */
+	path: string;
+	/** File contents */
+	content: string;
+	/** File type for logging/display */
+	type: "page" | "navigation" | "search" | "config";
+}
+/**
+* React components provided by an adapter.
+*/
+interface AdapterComponents {
+	/** Main API page wrapper */
+	APIPage: ComponentType<APIPageComponentProps>;
+	/** Function page */
+	FunctionPage: ComponentType<ExportPageProps>;
+	/** Class page */
+	ClassPage: ComponentType<ExportPageProps>;
+	/** Interface page */
+	InterfacePage: ComponentType<ExportPageProps>;
+	/** Enum page */
+	EnumPage: ComponentType<ExportPageProps>;
+	/** Variable/constant page */
+	VariablePage: ComponentType<ExportPageProps>;
+	/** Type alias page */
+	TypePage?: ComponentType<ExportPageProps>;
+}
+interface APIPageComponentProps {
+	/** The OpenPkg spec */
+	spec: OpenPkg;
+	/** Currently selected ID */
+	exportId?: string;
+	/** Children to render inside the page */
+	children?: ReactNode;
+}
+interface ExportPageProps {
+	/** The to render */
+	export: SpecExport;
+	/** The full spec for type resolution */
+	spec?: OpenPkg;
+	/** Additional children */
+	children?: ReactNode;
+}
+/**
+* Config helper for integrating with the doc framework.
+*/
+interface ConfigHelper {
+	/** Generate framework config snippet */
+	generateConfig(options?: ConfigOptions): string;
+	/** Validate existing config */
+	validateConfig?(configPath: string): ConfigValidationResult;
+}
+interface ConfigOptions {
+	/** Package name for the docs */
+	packageName?: string;
+	/** Base path for API docs */
+	basePath?: string;
+	/** Enable search integration */
+	search?: boolean;
+}
+interface ConfigValidationResult {
+	valid: boolean;
+	errors?: string[];
+	warnings?: string[];
+}
+/**
+* Registry for framework adapters.
+*/
+interface AdapterRegistry {
+	/** Register a new adapter */
+	register(adapter: DocFrameworkAdapter): void;
+	/** Get adapter by name */
+	get(name: string): DocFrameworkAdapter | undefined;
+	/** List all registered adapters */
+	list(): DocFrameworkAdapter[];
+}
+/**
+* Create a new adapter registry.
+*/
+declare function createAdapterRegistry(): AdapterRegistry;
+/**
+* Default adapter registry instance.
+*/
+declare const adapterRegistry: AdapterRegistry;
+import { OpenPkg as OpenPkg7, SpecExport as SpecExport3, SpecExportKind as SpecExportKind4, SpecType } from "@openpkg-ts/spec";
+import { OpenPkg as OpenPkg2 } from "@openpkg-ts/spec";
+interface HTMLOptions {
+	/** Page title override */
+	title?: string;
+	/** Include inline styles */
+	includeStyles?: boolean;
+	/** Custom CSS to inject */
+	customCSS?: string;
+	/** Custom head content */
+	headContent?: string;
+	/** Wrap in full HTML document */
+	fullDocument?: boolean;
+	/** Export to render (single mode) */
+	export?: string;
+}
+/**
+* Render spec to standalone HTML page.
+*
+* @param spec - The OpenPkg spec to render
+* @param options - HTML rendering options
+* @returns Complete HTML document or fragment
+*
+* @example
+* ```ts
+* import { createDocs } from '@openpkg-ts/doc-generator'
+*
+* const docs = createDocs('./openpkg.json')
+*
+* // Full HTML page
+* const html = docs.toHTML({ includeStyles: true })
+* fs.writeFileSync('api.html', html)
+*
+* // Single export, no document wrapper
+* const fragment = docs.toHTML({ export: 'greet', fullDocument: false })
+* ```
+*/
+declare function toHTML2(spec: OpenPkg2, options?: HTMLOptions): string;
+import { OpenPkg as OpenPkg3, SpecExportKind } from "@openpkg-ts/spec";
+interface JSONOptions {
+	/** Include raw spec data alongside simplified data */
+	includeRaw?: boolean;
+	/** Export to render (single mode) */
+	export?: string;
+	/** Include computed fields (signatures, formatted types) */
+	computed?: boolean;
+	/** Flatten nested structures */
+	flatten?: boolean;
+}
+interface SimplifiedParameter {
+	name: string;
+	type: string;
+	required: boolean;
+	description?: string;
+	default?: unknown;
+	rest?: boolean;
+}
+interface SimplifiedReturn {
+	type: string;
+	description?: string;
+}
+interface SimplifiedSignature {
+	parameters: SimplifiedParameter[];
+	returns?: SimplifiedReturn;
+	description?: string;
+	typeParameters?: string[];
+}
+interface SimplifiedMember {
+	name: string;
+	kind: "property" | "method";
+	type?: string;
+	description?: string;
+	visibility?: "public" | "protected" | "private";
+	signature?: SimplifiedSignature;
+}
+interface SimplifiedExample {
+	code: string;
+	title?: string;
+	description?: string;
+	language?: string;
+}
+interface SimplifiedExport {
+	id: string;
+	name: string;
+	kind: SpecExportKind;
+	signature: string;
+	description?: string;
+	deprecated: boolean;
+	tags: Array<{
+		name: string;
+		text: string;
+	}>;
+	parameters?: SimplifiedParameter[];
+	returns?: SimplifiedReturn;
+	members?: SimplifiedMember[];
+	examples?: SimplifiedExample[];
+	extends?: string;
+	implements?: string[];
+	sourceFile?: string;
+	sourceLine?: number;
+}
+interface SimplifiedSpec {
+	name: string;
+	version?: string;
+	description?: string;
+	exports: SimplifiedExport[];
+	byKind: Record<SpecExportKind, SimplifiedExport[]>;
+	totalExports: number;
+}
+/**
+* Render spec to simplified JSON structure.
+*
+* @param spec - The OpenPkg spec to simplify
+* @param options - JSON rendering options
+* @returns Simplified spec or single structure
+*
+* @example
+* ```ts
+* import { createDocs } from '@openpkg-ts/doc-generator'
+*
+* const docs = createDocs('./openpkg.json')
+*
+* // Full spec as simplified JSON
+* const json = docs.toJSON()
+* // { name, version, exports: [...], byKind: {...} }
+*
+* // Single * const fnJson = docs.toJSON({ export: 'greet' })
+* // { id, name, kind, signature, parameters, returns, ... }
+* ```
+*/
+declare function toJSON2(spec: OpenPkg3, options?: JSONOptions): SimplifiedSpec | SimplifiedExport;
+/**
+* Serialize to JSON string with formatting.
+*
+* @param spec - The OpenPkg spec to serialize
+* @param options - JSON options plus pretty formatting option
+* @returns JSON string
+*/
+declare function toJSONString(spec: OpenPkg3, options?: JSONOptions & {
+	pretty?: boolean;
+}): string;
+import { OpenPkg as OpenPkg4, SpecExport as SpecExport2 } from "@openpkg-ts/spec";
+interface MarkdownOptions {
+	/** Include frontmatter in output */
+	frontmatter?: boolean;
+	/** Sections to include */
+	sections?: {
+		signature?: boolean;
+		description?: boolean;
+		parameters?: boolean;
+		returns?: boolean;
+		examples?: boolean;
+		members?: boolean;
+		properties?: boolean;
+		methods?: boolean;
+	};
+	/** Custom frontmatter fields */
+	customFrontmatter?: Record<string, unknown>;
+	/** Use code fences for signatures */
+	codeSignatures?: boolean;
+	/** Heading level offset (0 = starts at h1, 1 = starts at h2) */
+	headingOffset?: number;
+}
+interface ExportMarkdownOptions extends MarkdownOptions {
+	/** Export to render */
+	export?: string;
+}
+/**
+* Render a single to MDX.
+*
+* @param exp - The to render
+* @param options - Markdown rendering options
+* @returns MDX string with frontmatter
+*
+* @example
+* ```ts
+* const mdx = exportToMarkdown(fn, {
+*   frontmatter: true,
+*   codeSignatures: true,
+*   sections: { examples: true }
+* })
+* ```
+*/
+declare function exportToMarkdown(exp: SpecExport2, options?: MarkdownOptions): string;
+/**
+* Render entire spec to MDX.
+*
+* @param spec - The OpenPkg spec to render
+* @param options - Markdown options, optionally with name for single mode
+* @returns MDX string
+*
+* @example
+* ```ts
+* import { createDocs } from '@openpkg-ts/doc-generator'
+*
+* const docs = createDocs('./openpkg.json')
+*
+* // Full spec
+* const fullMdx = docs.toMarkdown()
+*
+* // Single * const fnMdx = docs.toMarkdown({ export: 'greet' })
+* ```
+*/
+declare function toMarkdown2(spec: OpenPkg4, options?: ExportMarkdownOptions): string;
+import { OpenPkg as OpenPkg5, SpecExportKind as SpecExportKind2 } from "@openpkg-ts/spec";
+type NavFormat = "fumadocs" | "docusaurus" | "generic";
+type GroupBy = "kind" | "module" | "tag" | "none";
+interface NavOptions {
+	/** Output format */
+	format?: NavFormat;
+	/** How to group exports */
+	groupBy?: GroupBy;
+	/** Base path for links */
+	basePath?: string;
+	/** Custom slug generator */
+	slugify?: (name: string) => string;
+	/** Include index pages for groups */
+	includeGroupIndex?: boolean;
+	/** Custom kind labels */
+	kindLabels?: Partial<Record<SpecExportKind2, string>>;
+	/** Sort exports alphabetically */
+	sortAlphabetically?: boolean;
+}
+interface NavItem {
+	title: string;
+	href?: string;
+	items?: NavItem[];
+}
+interface NavGroup {
+	title: string;
+	items: NavItem[];
+	index?: string;
+}
+interface GenericNav {
+	title: string;
+	groups: NavGroup[];
+	items: NavItem[];
+}
+interface FumadocsMetaItem {
+	title: string;
+	pages?: string[];
+	defaultOpen?: boolean;
+}
+interface FumadocsMeta {
+	root?: boolean;
+	title?: string;
+	pages?: (string | FumadocsMetaItem)[];
+}
+interface DocusaurusSidebarItem {
+	type: "category" | "doc" | "link";
+	label: string;
+	items?: DocusaurusSidebarItem[];
+	id?: string;
+	href?: string;
+}
+type DocusaurusSidebar = DocusaurusSidebarItem[];
+/**
+* Generate navigation structure for doc frameworks.
+*
+* @param spec - The OpenPkg spec
+* @param options - Navigation options including format and grouping
+* @returns Navigation structure in requested format
+*
+* @example
+* ```ts
+* import { createDocs } from '@openpkg-ts/doc-generator'
+*
+* const docs = createDocs('./openpkg.json')
+*
+* // Generic nav
+* const nav = docs.toNavigation({ format: 'generic', groupBy: 'kind' })
+*
+* // Fumadocs meta.json
+* const meta = docs.toNavigation({ format: 'fumadocs' })
+*
+* // Docusaurus sidebar
+* const sidebar = docs.toNavigation({ format: 'docusaurus' })
+* ```
+*/
+declare function toNavigation2(spec: OpenPkg5, options?: NavOptions): GenericNav | FumadocsMeta | DocusaurusSidebar;
+/**
+* Generate Fumadocs meta.json file content.
+*
+* @param spec - The OpenPkg spec
+* @param options - Navigation options (format is forced to fumadocs)
+* @returns JSON string for meta.json file
+*
+* @example
+* ```ts
+* const meta = toFumadocsMetaJSON(spec, { groupBy: 'kind' })
+* fs.writeFileSync('docs/api/meta.json', meta)
+* ```
+*/
+declare function toFumadocsMetaJSON(spec: OpenPkg5, options?: Omit<NavOptions, "format">): string;
+/**
+* Generate Docusaurus sidebar config.
+*
+* @param spec - The OpenPkg spec
+* @param options - Navigation options (format is forced to docusaurus)
+* @returns JavaScript module.exports string for sidebars.js
+*
+* @example
+* ```ts
+* const sidebar = toDocusaurusSidebarJS(spec, { basePath: 'api' })
+* fs.writeFileSync('sidebars.js', sidebar)
+* ```
+*/
+declare function toDocusaurusSidebarJS(spec: OpenPkg5, options?: Omit<NavOptions, "format">): string;
+import { OpenPkg as OpenPkg6, SpecExportKind as SpecExportKind3 } from "@openpkg-ts/spec";
+interface SearchOptions {
+	/** Base URL for search result links */
+	baseUrl?: string;
+	/** Custom slug generator */
+	slugify?: (name: string) => string;
+	/** Include type signatures in search content */
+	includeSignatures?: boolean;
+	/** Include member names in search content */
+	includeMembers?: boolean;
+	/** Include parameter names in search content */
+	includeParameters?: boolean;
+	/** Weight multipliers for ranking */
+	weights?: {
+		name?: number;
+		description?: number;
+		signature?: number;
+		tags?: number;
+	};
+}
+interface PagefindRecord {
+	url: string;
+	content: string;
+	word_count: number;
+	filters: Record<string, string[]>;
+	meta: {
+		title: string;
+		kind?: string;
+		description?: string;
+		signature?: string;
+	};
+	anchors?: Array<{
+		element: string;
+		id: string;
+		text: string;
+	}>;
+	weighted_sections?: Array<{
+		weight: number;
+		text: string;
+	}>;
+}
+interface AlgoliaRecord {
+	objectID: string;
+	name: string;
+	kind: SpecExportKind3;
+	description?: string;
+	signature: string;
+	content: string;
+	tags: string[];
+	deprecated: boolean;
+	url: string;
+	hierarchy: {
+		lvl0: string;
+		lvl1: string;
+		lvl2?: string;
+	};
+	_rankingInfo?: {
+		nbTypos: number;
+		words: number;
+	};
+}
+interface SearchRecord {
+	id: string;
+	name: string;
+	kind: SpecExportKind3;
+	signature: string;
+	description?: string;
+	content: string;
+	keywords: string[];
+	url: string;
+	deprecated: boolean;
+}
+interface SearchIndex {
+	records: SearchRecord[];
+	version: string;
+	generatedAt: string;
+	packageName: string;
+}
+/**
+* Generate search index from spec.
+*
+* @param spec - The OpenPkg spec to index
+* @param options - Search index configuration
+* @returns Search index with records for each *
+* @example
+* ```ts
+* import { createDocs } from '@openpkg-ts/doc-generator'
+*
+* const docs = createDocs('./openpkg.json')
+* const index = docs.toSearchIndex({ baseUrl: '/api' })
+* // { records: [...], version: '1.0.0', packageName: 'my-lib' }
+* ```
+*/
+declare function toSearchIndex2(spec: OpenPkg6, options?: SearchOptions): SearchIndex;
+/**
+* Generate Pagefind-compatible records.
+*
+* @param spec - The OpenPkg spec to index
+* @param options - Search configuration including weights
+* @returns Array of Pagefind-compatible search records
+*
+* @example
+* ```ts
+* const records = toPagefindRecords(spec, {
+*   baseUrl: '/docs/api',
+*   weights: { name: 10, description: 5 }
+* })
+* ```
+*/
+declare function toPagefindRecords2(spec: OpenPkg6, options?: SearchOptions): PagefindRecord[];
+/**
+* Generate Algolia-compatible records.
+*
+* @param spec - The OpenPkg spec to index
+* @param options - Search configuration
+* @returns Array of Algolia-compatible search records with hierarchy
+*
+* @example
+* ```ts
+* const records = toAlgoliaRecords(spec, { baseUrl: '/api' })
+* // Upload to Algolia index
+* ```
+*/
+declare function toAlgoliaRecords2(spec: OpenPkg6, options?: SearchOptions): AlgoliaRecord[];
+/**
+* Serialize search index to JSON string.
+*
+* @param spec - The OpenPkg spec to index
+* @param options - Search options plus pretty formatting option
+* @returns JSON string of search index
+*
+* @example
+* ```ts
+* const json = toSearchIndexJSON(spec, { pretty: true })
+* fs.writeFileSync('search-index.json', json)
+* ```
+*/
+declare function toSearchIndexJSON(spec: OpenPkg6, options?: SearchOptions & {
+	pretty?: boolean;
+}): string;
+interface LoadOptions {
+	/** Path to openpkg.json file or the spec object directly */
+	input: string | OpenPkg7;
+}
+interface DocsInstance {
+	/** The parsed OpenPkg spec */
+	spec: OpenPkg7;
+	/** Get an by its ID */
+	getExport(id: string): SpecExport3 | undefined;
+	/** Get a type definition by its ID */
+	getType(id: string): SpecType | undefined;
+	/** Get all exports of a specific kind */
+	getExportsByKind(kind: SpecExportKind4): SpecExport3[];
+	/** Get all exports */
+	getAllExports(): SpecExport3[];
+	/** Get all type definitions */
+	getAllTypes(): SpecType[];
+	/** Get exports by JSDoc tag (e.g., '@beta', '@internal') */
+	getExportsByTag(tagName: string): SpecExport3[];
+	/** Search exports by name or description */
+	search(query: string): SpecExport3[];
+	/** Get exports belonging to a specific module/namespace */
+	getModule(moduleName: string): SpecExport3[];
+	/** Get deprecated exports */
+	getDeprecated(): SpecExport3[];
+	/** Get exports grouped by kind */
+	groupByKind(): Record<SpecExportKind4, SpecExport3[]>;
+	/** Render spec or single to MDX */
+	toMarkdown(options?: ExportMarkdownOptions): string;
+	/** Render spec or single to HTML */
+	toHTML(options?: HTMLOptions): string;
+	/** Render spec or single to JSON structure */
+	toJSON(options?: JSONOptions): SimplifiedSpec | SimplifiedExport;
+	/** Generate navigation structure */
+	toNavigation(options?: NavOptions): GenericNav | FumadocsMeta | DocusaurusSidebar;
+	/** Generate search index */
+	toSearchIndex(options?: SearchOptions): SearchIndex;
+	/** Generate Pagefind-compatible records */
+	toPagefindRecords(options?: SearchOptions): PagefindRecord[];
+	/** Generate Algolia-compatible records */
+	toAlgoliaRecords(options?: SearchOptions): AlgoliaRecord[];
+}
+/**
+* Loads an OpenPkg spec from file or object.
+*
+* @example
+* ```ts
+* import { loadSpec } from '@openpkg-ts/doc-generator'
+*
+* // From spec object
+* import spec from './openpkg.json'
+* const docs = loadSpec(spec)
+* ```
+*/
+declare function loadSpec(spec: OpenPkg7): DocsInstance;
+/**
+* Creates a docs instance for querying and rendering API documentation.
+*
+* @example
+* ```ts
+* import { createDocs } from '@openpkg-ts/doc-generator'
+*
+* // From file path
+* const docs = createDocs('./openpkg.json')
+*
+* // From spec object
+* import spec from './openpkg.json'
+* const docs = createDocs(spec)
+*
+* // Query
+* docs.getExport('useState')
+* docs.getExportsByKind('function')
+* docs.getExportsByTag('@beta')
+* docs.search('hook')
+* ```
+*/
+declare function createDocs(input: string | OpenPkg7): DocsInstance;
+import { OpenPkg as OpenPkg8, SpecExport as SpecExport4, SpecMember, SpecSchema, SpecSignature, SpecType as SpecType2, SpecTypeParameter } from "@openpkg-ts/spec";
+/**
+* Format a schema to a human-readable type string.
+*
+* @param schema - The schema to format
+* @returns Formatted type string
+*
+* @example
+* ```ts
+* formatSchema({ type: 'string' }) // 'string'
+* formatSchema({ $ref: '#/types/User' }) // 'User'
+* formatSchema({ anyOf: [{ type: 'string' }, { type: 'number' }] }) // 'string | number'
+* ```
+*/
+declare function formatSchema(schema: SpecSchema | undefined): string;
+/**
+* Format type parameters to a string like `<T, U extends string>`.
+*
+* @param typeParams - Array of type parameters
+* @returns Formatted type parameters string or empty string
+*
+* @example
+* ```ts
+* formatTypeParameters([{ name: 'T' }]) // '<T>'
+* formatTypeParameters([{ name: 'T', constraint: 'object' }]) // '<T extends object>'
+* formatTypeParameters([{ name: 'T', default: 'unknown' }]) // '<T = unknown>'
+* ```
+*/
+declare function formatTypeParameters(typeParams?: SpecTypeParameter[]): string;
+/**
+* Format function parameters to a string like `(a: string, b?: number)`.
+*
+* @param sig - The signature containing parameters
+* @returns Formatted parameters string
+*
+* @example
+* ```ts
+* formatParameters({ parameters: [{ name: 'id', schema: { type: 'string' } }] })
+* // '(id: string)'
+* ```
+*/
+declare function formatParameters(sig?: SpecSignature): string;
+/**
+* Format return type from signature.
+*
+* @param sig - The signature containing return type
+* @returns Formatted return type string
+*
+* @example
+* ```ts
+* formatReturnType({ returns: { schema: { type: 'Promise', items: { type: 'string' } } } })
+* // 'Promise<string>'
+* ```
+*/
+declare function formatReturnType(sig?: SpecSignature): string;
+/**
+* Build a full signature string for an export.
+*
+* @param exp - The to build a signature for
+* @param sigIndex - Index of signature to use for overloaded functions
+* @returns Complete signature string
+*
+* @example
+* ```ts
+* buildSignatureString({ kind: 'function', name: 'greet', signatures: [...] })
+* // 'function greet(name: string): string'
+*
+* buildSignatureString({ kind: 'class', name: 'Logger', extends: 'EventEmitter' })
+* // 'class Logger extends EventEmitter'
+* ```
+*/
+declare function buildSignatureString(exp: SpecExport4, sigIndex?: number): string;
+/**
+* Resolve a type reference to its definition.
+*
+* @param ref - Type reference string (e.g., '#/types/User')
+* @param spec - The OpenPkg spec containing type definitions
+* @returns The resolved type definition or undefined
+*
+* @example
+* ```ts
+* resolveTypeRef('#/types/User', spec)
+* // { id: 'User', name: 'User', kind: 'interface', ... }
+* ```
+*/
+declare function resolveTypeRef(ref: string, spec: OpenPkg8): SpecType2 | undefined;
+/**
+* Check if a member is a method (has signatures).
+*
+* @param member - The member to check
+* @returns True if the member is a method
+*
+* @example
+* ```ts
+* isMethod({ name: 'foo', signatures: [{ parameters: [] }] }) // true
+* isMethod({ name: 'bar', schema: { type: 'string' } }) // false
+* ```
+*/
+declare function isMethod(member: SpecMember): boolean;
+/**
+* Check if a member is a property (no signatures).
+*
+* @param member - The member to check
+* @returns True if the member is a property
+*/
+declare function isProperty(member: SpecMember): boolean;
+/**
+* Get methods from members list.
+*
+* @param members - Array of members to filter
+* @returns Array of method members
+*/
+declare function getMethods(members?: SpecMember[]): SpecMember[];
+/**
+* Get properties from members list.
+*
+* @param members - Array of members to filter
+* @returns Array of property members
+*/
+declare function getProperties(members?: SpecMember[]): SpecMember[];
+/**
+* Group members by visibility (public, protected, private).
+*
+* @param members - Array of members to group
+* @returns Object with public, protected, and private arrays
+*
+* @example
+* ```ts
+* const groups = groupByVisibility(classExport.members)
+* groups.public  // [{ name: 'foo', visibility: 'public' }]
+* groups.private // [{ name: 'bar', visibility: 'private' }]
+* ```
+*/
+declare function groupByVisibility(members?: SpecMember[]): {
+	public: SpecMember[];
+	protected: SpecMember[];
+	private: SpecMember[];
+};
+/**
+* Sort exports alphabetically by name.
+*
+* @param items - Array of items with a name property
+* @returns New sorted array
+*/
+declare function sortByName<T extends {
+	name: string;
+}>(items: T[]): T[];
+/**
+* Sort exports by kind, then name.
+* Kind order: function, class, interface, type, enum, variable, namespace, module, reference, external.
+*
+* @param exports - Array of exports to sort
+* @returns New sorted array
+*/
+declare function sortByKindThenName(exports: SpecExport4[]): SpecExport4[];
+export { toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, sortByName, sortByKindThenName, resolveTypeRef, loadSpec, isProperty, isMethod, groupByVisibility, getProperties, getMethods, formatTypeParameters, formatSchema, formatReturnType, formatParameters, exportToMarkdown, createDocs, createAdapterRegistry, buildSignatureString, adapterRegistry, SpecTypeParameter2 as SpecTypeParameter, SpecTypeKind, SpecType3 as SpecType, SpecTag, SpecSignatureParameter, SpecSignature2 as SpecSignature, SpecSchema2 as SpecSchema, SpecMember2 as SpecMember, SpecExportKind5 as SpecExportKind, SpecExport5 as SpecExport, SpecExample, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SearchRecord, SearchOptions, SearchIndex, SearchGeneratorOptions, PagefindRecord, PageGeneratorOptions, OpenPkg9 as OpenPkg, NavOptions, NavItem, NavGroup, NavGeneratorOptions, NavFormat, MarkdownOptions, LoadOptions, JSONOptions, HTMLOptions, GroupBy, GenericNav, GeneratedFile, FumadocsMetaItem, FumadocsMeta, FileGenerator, ExportPageProps, ExportMarkdownOptions, DocusaurusSidebarItem, DocusaurusSidebar, DocsInstance, DocFrameworkAdapter, ConfigValidationResult, ConfigOptions, ConfigHelper, AlgoliaRecord, AdapterRegistry, AdapterComponents, APIPageComponentProps };