@openpkg-ts/sdk 0.1.0 → 0.30.0

package/dist/index.d.ts

@@ -1,55 +1,1390 @@
-interface OpenPkgOptions {
-	includePrivate?: boolean;
-	followImports?: boolean;
-	maxDepth?: number;
-	resolveExternalTypes?: boolean;
+interface ListExportsOptions {
+	/** Entry point file path */
+	entryFile: string;
+	/** Base directory for resolution */
+	baseDir?: string;
+	/** Optional in-memory content (for testing) */
+	content?: string;
+}
+interface ExportItem {
+	/** Export name */
+	name: string;
+	/** Export kind */
+	kind: "function" | "class" | "interface" | "type" | "enum" | "variable" | "namespace";
+	/** Source file path */
+	file: string;
+	/** Line number (1-indexed) */
+	line: number;
+	/** JSDoc description (first line, max 80 chars) */
+	description?: string;
+	/** Whether is deprecated */
+	deprecated?: boolean;
+	/** Whether this is a re-from another module */
+	reexport?: boolean;
+}
+interface ListExportsResult {
+	exports: ExportItem[];
+	errors: string[];
+}
+/**
+* List all exports from a TypeScript entry point
+*/
+declare function listExports(options: ListExportsOptions): Promise<ListExportsResult>;
+import { SpecExport, SpecType } from "@openpkg-ts/spec";
+interface GetExportOptions {
+	/** Entry point file path */
+	entryFile: string;
+	/** Export name to get */
+	exportName: string;
+	/** Base directory for resolution */
+	baseDir?: string;
+	/** Optional in-memory content (for testing) */
+	content?: string;
+	/** Max depth for type resolution */
+	maxTypeDepth?: number;
+}
+interface GetExportResult {
+	/** The spec, or null if not found */
+	export: SpecExport | null;
+	/** Related types referenced by the */
+	types: SpecType[];
+	/** Errors encountered */
+	errors: string[];
 }
-import { z } from "zod";
+/**
+* Get detailed spec for a single */
+declare function getExport2(options: GetExportOptions): Promise<GetExportResult>;
 import { OpenPkg } from "@openpkg-ts/spec";
-declare const openPkgSchema: z.ZodTypeAny;
-type OpenPkgSpec = OpenPkg;
-declare function extractPackageSpec(entryFile: string, packageDir?: string, content?: string, options?: OpenPkgOptions): Promise<OpenPkgSpec>;
-interface FilterOptions {
-	include?: string[];
-	exclude?: string[];
+interface ExtractOptions {
+	entryFile: string;
+	baseDir?: string;
+	content?: string;
+	maxTypeDepth?: number;
+	maxExternalTypeDepth?: number;
+	resolveExternalTypes?: boolean;
+	schemaExtraction?: "static" | "hybrid";
+	/** Target JSON Schema dialect for runtime schema extraction */
+	schemaTarget?: "draft-2020-12" | "draft-07" | "openapi-3.0";
+	/** Include $schema URL in output */
+	includeSchema?: boolean;
+	/** Only extract these exports (supports * wildcards) */
+	only?: string[];
+	/** Ignore these exports (supports * wildcards) */
+	ignore?: string[];
+	/** Progress callback for tracking extraction progress */
+	onProgress?: (current: number, total: number, item: string) => void;
+	/** Whether source is a .d.ts file (degraded mode - TSDoc may be missing) */
+	isDtsSource?: boolean;
+}
+interface ExtractResult {
+	spec: OpenPkg;
+	diagnostics: Diagnostic[];
+	forgottenExports?: ForgottenExport[];
+	/** Metadata about runtime schema extraction (when schemaExtraction: 'hybrid') */
+	runtimeSchemas?: {
+		/** Number of schema exports found */
+		extracted: number;
+		/** Number of schemas successfully merged with static types */
+		merged: number;
+		/** Schema vendors detected (e.g., 'zod', 'arktype', 'valibot', 'typebox') */
+		vendors: string[];
+		/** Any errors encountered during runtime extraction */
+		errors: string[];
+		/** Extraction method used: 'compiled' or 'direct-ts (runtime)' */
+		method?: string;
+	};
+	/** Degraded mode info when extracting from .d.ts files */
+	degradedMode?: {
+		reason: "dts-source";
+		stats: {
+			exportsWithoutDescription: number;
+			paramsWithoutDocs: number;
+			missingExamples: number;
+		};
+	};
+	/** Export verification comparing discovered vs extracted */
+	verification?: ExportVerification;
 }
 interface Diagnostic {
 	message: string;
 	severity: "error" | "warning" | "info";
+	code?: string;
+	suggestion?: string;
 	location?: {
-		file: string
-		line?: number
-		column?: number
+		file?: string;
+		line?: number;
+		column?: number;
 	};
 }
-interface AnalysisResult {
-	spec: OpenPkgSpec;
-	diagnostics: Diagnostic[];
-	metadata: AnalysisMetadata;
+/** Context tracking for type references in public API */
+interface TypeReference2 {
+	typeName: string;
+	exportName: string;
+	location: "return" | "parameter" | "property" | "extends" | "type-parameter";
+	path?: string;
 }
-interface AnalysisMetadata {
-	baseDir: string;
-	configPath?: string;
-	packageJsonPath?: string;
-	hasNodeModules: boolean;
+/** Structured data for forgotten exports */
+interface ForgottenExport {
+	name: string;
+	definedIn?: string;
+	referencedBy: TypeReference2[];
+	isExternal: boolean;
+	fix?: string;
+}
+/** Tracks status of each discovered through serialization pipeline */
+interface ExportTracker {
+	name: string;
+	discovered: boolean;
+	status: "pending" | "success" | "skipped" | "failed";
+	skipReason?: "filtered" | "no-declaration" | "internal";
+	error?: string;
+	kind?: string;
+}
+/** Verification result comparing discovered vs extracted exports */
+interface ExportVerification {
+	/** Total exports discovered by TypeScript */
+	discovered: number;
+	/** Exports successfully extracted */
+	extracted: number;
+	/** Exports skipped (filtered, no-declaration, internal) */
+	skipped: number;
+	/** Exports that failed during serialization */
+	failed: number;
+	/** Delta: discovered - extracted */
+	delta: number;
+	details: {
+		skipped: Array<{
+			name: string;
+			reason: "filtered" | "no-declaration" | "internal";
+		}>;
+		failed: Array<{
+			name: string;
+			error: string;
+		}>;
+	};
+}
+/**
+* Extract full OpenPkg spec from a TypeScript entry point
+*
+* @example
+* ```typescript
+* import { extractSpec } from '@openpkg-ts/sdk';
+*
+* const result = await extractSpec({
+*   entryFile: './src/index.ts'
+* });
+*
+* console.log(result.spec.exports.length);
+* ```
+*/
+declare const extractSpec: (options: ExtractOptions) => Promise<ExtractResult>;
+import { diffSpec, categorizeBreakingChanges, recommendSemverBump, calculateNextVersion, SpecDiff, BreakingSeverity, CategorizedBreaking, MemberChangeInfo, SemverBump, SemverRecommendation } from "@openpkg-ts/spec";
+import { diffSpec as diffSpec2 } from "@openpkg-ts/spec";
+import { OpenPkg as OpenPkg2, SpecExport as SpecExport2, SpecMember, SpecSchema, SpecSignature, SpecType as SpecType2, SpecTypeParameter } from "@openpkg-ts/spec";
+interface FormatSchemaOptions {
+	/** Include package attribution for external types */
+	includePackage?: boolean;
+}
+/**
+* Format a schema to a human-readable type string.
+*
+* @param schema - The schema to format
+* @param options - Formatting options
+* @returns Formatted type string
+*
+* @example
+* ```ts
+* formatSchema({ type: 'string' }) // 'string'
+* formatSchema({ $ref: '#/types/User' }) // 'User'
+* formatSchema({ anyOf: [{ type: 'string' }, { type: 'number' }] }) // 'string | number'
+* formatSchema({ type: 'integer', 'x-ts-type': 'bigint' }) // 'bigint'
+* formatSchema({ 'x-ts-type': 'Response', 'x-ts-package': 'express' }, { includePackage: true }) // 'Response (from express)'
+* ```
+*/
+declare function formatSchema(schema: SpecSchema | undefined, options?: FormatSchemaOptions): 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>'
+* formatTypeParameters([{ name: 'T', variance: 'in' }]) // '<in T>'
+* ```
+*/
+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: SpecExport2, 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: OpenPkg2): 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[];
+/**
+* Conditional type structure from the spec.
+*/
+interface SpecConditionalType {
+	checkType: SpecSchema;
+	extendsType: SpecSchema;
+	trueType: SpecSchema;
+	falseType: SpecSchema;
+}
+/**
+* Mapped type structure from the spec.
+*/
+interface SpecMappedType {
+	keyType: SpecSchema;
+	valueType: SpecSchema;
+	readonly?: boolean | "add" | "remove";
+	optional?: boolean | "add" | "remove";
+}
+/**
+* Format a conditional type to a human-readable string.
+*
+* @param condType - The conditional type structure
+* @returns Formatted conditional type string
+*
+* @example
+* ```ts
+* formatConditionalType({
+*   checkType: { 'x-ts-type': 'T' },
+*   extendsType: { type: 'string' },
+*   trueType: { type: 'boolean', const: true },
+*   falseType: { type: 'boolean', const: false }
+* })
+* // 'T extends string ? true : false'
+* ```
+*/
+declare function formatConditionalType(condType: SpecConditionalType): string;
+/**
+* Format a mapped type to a human-readable string.
+*
+* @param mappedType - The mapped type structure
+* @returns Formatted mapped type string
+*
+* @example
+* ```ts
+* formatMappedType({
+*   keyType: { 'x-ts-type': 'K in keyof T' },
+*   valueType: { 'x-ts-type': 'T[K]' },
+*   readonly: true
+* })
+* // '{ readonly [K in keyof T]: T[K] }'
+* ```
+*/
+declare function formatMappedType(mappedType: SpecMappedType): string;
+import { SpecMember as SpecMember2 } from "@openpkg-ts/spec";
+/**
+* Extract badge strings from a member's visibility and flags.
+* Handles: visibility (if not public), static, readonly, async, abstract
+*/
+declare function getMemberBadges(member: SpecMember2): string[];
+/**
+* Format badges array into a display string (space-separated).
+*/
+declare function formatBadges(badges: string[]): string;
+import { OpenPkg as OpenPkg3, SpecExportKind } 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: SpecExportKind;
+	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: SpecExportKind;
+	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/sdk'
+*
+* const docs = createDocs('./openpkg.json')
+* const index = docs.toSearchIndex({ baseUrl: '/api' })
+* // { records: [...], version: '1.0.0', packageName: 'my-lib' }
+* ```
+*/
+declare function toSearchIndex2(spec: OpenPkg3, 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: OpenPkg3, 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: OpenPkg3, 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: OpenPkg3, options?: SearchOptions & {
+	pretty?: boolean;
+}): string;
+import { OpenPkg as OpenPkg8, SpecExport as SpecExport4, SpecExportKind as SpecExportKind4, SpecType as SpecType3 } from "@openpkg-ts/spec";
+import { OpenPkg as OpenPkg4 } 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/sdk'
+*
+* 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: OpenPkg4, options?: HTMLOptions): string;
+import { OpenPkg as OpenPkg5, SpecExportKind as SpecExportKind2 } 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: SpecExportKind2;
+	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<SpecExportKind2, 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/sdk'
+*
+* 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: OpenPkg5, 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: OpenPkg5, options?: JSONOptions & {
+	pretty?: boolean;
+}): string;
+import { OpenPkg as OpenPkg6, SpecExport as SpecExport3 } 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: SpecExport3, 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/sdk'
+*
+* const docs = createDocs('./openpkg.json')
+*
+* // Full spec
+* const fullMdx = docs.toMarkdown()
+*
+* // Single * const fnMdx = docs.toMarkdown({ export: 'greet' })
+* ```
+*/
+declare function toMarkdown2(spec: OpenPkg6, options?: ExportMarkdownOptions): string;
+import { OpenPkg as OpenPkg7, SpecExportKind as SpecExportKind3 } 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<SpecExportKind3, 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/sdk'
+*
+* 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: OpenPkg7, 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: OpenPkg7, 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: OpenPkg7, options?: Omit<NavOptions, "format">): string;
+interface LoadOptions {
+	/** Path to openpkg.json file or the spec object directly */
+	input: string | OpenPkg8;
+}
+interface DocsInstance {
+	/** The parsed OpenPkg spec */
+	spec: OpenPkg8;
+	/** Get an by its ID */
+	getExport(id: string): SpecExport4 | undefined;
+	/** Get a type definition by its ID */
+	getType(id: string): SpecType3 | undefined;
+	/** Get all exports of a specific kind */
+	getExportsByKind(kind: SpecExportKind4): SpecExport4[];
+	/** Get all exports */
+	getAllExports(): SpecExport4[];
+	/** Get all type definitions */
+	getAllTypes(): SpecType3[];
+	/** Get exports by JSDoc tag (e.g., '@beta', '@internal') */
+	getExportsByTag(tagName: string): SpecExport4[];
+	/** Search exports by name or description */
+	search(query: string): SpecExport4[];
+	/** Get exports belonging to a specific module/namespace */
+	getModule(moduleName: string): SpecExport4[];
+	/** Get deprecated exports */
+	getDeprecated(): SpecExport4[];
+	/** Get exports grouped by kind */
+	groupByKind(): Record<SpecExportKind4, SpecExport4[]>;
+	/** 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/sdk'
+*
+* // From spec object
+* import spec from './openpkg.json'
+* const docs = loadSpec(spec)
+* ```
+*/
+declare function loadSpec(spec: OpenPkg8): DocsInstance;
+/**
+* Creates a docs instance for querying and rendering API documentation.
+*
+* @example
+* ```ts
+* import { createDocs } from '@openpkg-ts/sdk'
+*
+* // 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 | OpenPkg8): DocsInstance;
+import { SpecType as SpecType4 } from "@openpkg-ts/spec";
+import ts2 from "typescript";
+import ts from "typescript";
+interface SerializerContext {
+	typeChecker: ts.TypeChecker;
+	program: ts.Program;
+	sourceFile: ts.SourceFile;
+	maxTypeDepth: number;
+	maxExternalTypeDepth: number;
+	currentDepth: number;
 	resolveExternalTypes: boolean;
+	typeRegistry: TypeRegistry;
+	exportedIds: Set<string>;
+	/** Track visited types to prevent infinite recursion */
+	visitedTypes: Set<ts.Type>;
+	/** Flag to indicate we're processing tuple elements - skip Array prototype methods */
+	inTupleElement?: boolean;
+}
+declare class TypeRegistry {
+	private types;
+	private processing;
+	add(type: SpecType4): void;
+	get(id: string): SpecType4 | undefined;
+	has(id: string): boolean;
+	getAll(): SpecType4[];
+	/**
+	* Register a type from a ts.Type with structured schema.
+	* Returns the type ID if registered, undefined if skipped.
+	*/
+	registerType(type: ts2.Type, ctx: SerializerContext): string | undefined;
+	/**
+	* Build a SpecType with structured schema using buildSchema.
+	*/
+	private buildSpecType;
+	/**
+	* Check if schema is a self-referential $ref
+	*/
+	private isSelfRef;
+	/**
+	* Build object schema from type properties (for interfaces/classes)
+	*/
+	private buildObjectSchemaFromType;
+}
+import ts3 from "typescript";
+/**
+* Check if an symbol is a type-only (type { X }).
+*/
+declare function isTypeOnlyExport(symbol: ts3.Symbol): boolean;
+/**
+* Follows aliases back to the declaration that carries the type info.
+*/
+declare function resolveExportTarget(symbol: ts3.Symbol, checker: ts3.TypeChecker): {
+	declaration?: ts3.Declaration;
+	targetSymbol: ts3.Symbol;
+	isTypeOnly: boolean;
+};
+import { SpecExample, SpecSource, SpecTag, SpecTypeParameter as SpecTypeParameter2 } from "@openpkg-ts/spec";
+import ts4 from "typescript";
+declare function getJSDocComment(node: ts4.Node, symbol?: ts4.Symbol, checker?: ts4.TypeChecker): {
+	description?: string;
+	tags: SpecTag[];
+	examples: SpecExample[];
+};
+declare function getSourceLocation(node: ts4.Node, sourceFile: ts4.SourceFile): SpecSource;
+/**
+* Get description for a destructured parameter property from JSDoc @param tags.
+* Matches patterns like:
+* - @param paramName - exact match
+* - @param opts.paramName - dotted notation with alias
+* - @param {type} paramName - type annotation format
+*/
+declare function getParamDescription(propertyName: string, jsdocTags: readonly ts4.JSDocTag[], inferredAlias?: string): string | undefined;
+type DeclarationWithTypeParams = ts4.FunctionDeclaration | ts4.ClassDeclaration | ts4.InterfaceDeclaration | ts4.TypeAliasDeclaration | ts4.MethodDeclaration | ts4.ArrowFunction;
+/**
+* Extract type parameters from declarations like `<T extends Base, K = Default>`
+* Also captures variance annotations (in/out) and const modifier.
+*/
+declare function extractTypeParameters(node: DeclarationWithTypeParams, checker: ts4.TypeChecker): SpecTypeParameter2[] | undefined;
+/**
+* Check if a symbol is marked as deprecated via @deprecated JSDoc tag.
+*/
+declare function isSymbolDeprecated(symbol: ts4.Symbol | undefined): boolean;
+import ts5 from "typescript";
+interface ProgramOptions {
+	entryFile: string;
+	baseDir?: string;
+	content?: string;
+}
+interface ProgramResult {
+	program: ts5.Program;
+	compilerHost: ts5.CompilerHost;
+	compilerOptions: ts5.CompilerOptions;
+	sourceFile?: ts5.SourceFile;
+	configPath?: string;
+	/** Resolved project references (workspace packages) */
+	projectReferences?: ts5.ResolvedProjectReference[];
+}
+declare function createProgram({ entryFile, baseDir, content }: ProgramOptions): ProgramResult;
+import * as TS from "typescript";
+/**
+* A schema adapter can detect and extract output types from a specific
+* schema validation library.
+*/
+interface SchemaAdapter {
+	/** Unique identifier for this adapter */
+	readonly id: string;
+	/** npm package name(s) this adapter handles */
+	readonly packages: readonly string[];
+	/**
+	* Check if a type matches this adapter's schema library.
+	* Should be fast - called for every export.
+	*/
+	matches(type: TS.Type, checker: TS.TypeChecker): boolean;
+	/**
+	* Extract the output type from a schema type.
+	* Returns null if extraction fails.
+	*/
+	extractOutputType(type: TS.Type, checker: TS.TypeChecker): TS.Type | null;
+	/**
+	* Extract the input type from a schema type (optional).
+	* Useful for transforms where input differs from output.
+	*/
+	extractInputType?(type: TS.Type, checker: TS.TypeChecker): TS.Type | null;
+}
+/**
+* Result of schema type extraction
+*/
+interface SchemaExtractionResult {
+	/** The adapter that matched */
+	adapter: SchemaAdapter;
+	/** The extracted output type */
+	outputType: TS.Type;
+	/** The extracted input type (if different from output) */
+	inputType?: TS.Type;
+}
+/**
+* Utility: Check if type is an object type reference (has type arguments)
+*/
+declare function isTypeReference(type: TS.Type): type is TS.TypeReference;
+/**
+* Utility: Remove undefined/null from a union type
+*/
+declare function getNonNullableType(type: TS.Type): TS.Type;
+declare function registerAdapter(adapter: SchemaAdapter): void;
+declare function findAdapter(type: TS.Type, checker: TS.TypeChecker): SchemaAdapter | undefined;
+declare function isSchemaType(type: TS.Type, checker: TS.TypeChecker): boolean;
+declare function extractSchemaType(type: TS.Type, checker: TS.TypeChecker): SchemaExtractionResult | null;
+declare const arktypeAdapter: SchemaAdapter;
+declare const typeboxAdapter: SchemaAdapter;
+declare const valibotAdapter: SchemaAdapter;
+declare const zodAdapter: SchemaAdapter;
+/**
+* Target version for JSON Schema generation.
+* @see https://standardschema.dev/json-schema
+*/
+type StandardJSONSchemaTarget = "draft-2020-12" | "draft-07" | "openapi-3.0" | (string & {});
+/**
+* Options for JSON Schema generation methods.
+*/
+interface StandardJSONSchemaOptions {
+	/** Specifies the target version of the generated JSON Schema */
+	readonly target: StandardJSONSchemaTarget;
+	/** Vendor-specific parameters */
+	readonly libraryOptions?: Record<string, unknown>;
+}
+/**
+* Standard JSON Schema v1 interface.
+* @see https://standardschema.dev/json-schema
+*/
+interface StandardJSONSchemaV1<
+	Input = unknown,
+	Output = Input
+> {
+	"~standard": {
+		/** The version number of the standard (always 1) */
+		version: 1;
+		/** The vendor name of the schema library */
+		vendor: string;
+		/** Inferred types (optional) */
+		types?: {
+			input: Input;
+			output: Output;
+		};
+		/** JSON Schema conversion methods */
+		jsonSchema: {
+			/** Converts input type to JSON Schema */
+			input: (options: StandardJSONSchemaOptions) => Record<string, unknown>;
+			/** Converts output type to JSON Schema */
+			output: (options: StandardJSONSchemaOptions) => Record<string, unknown>;
+		};
+	};
+}
+/**
+* Result of extracting Standard Schema from an export.
+*/
+interface StandardSchemaExtractionResult {
+	exportName: string;
+	vendor: string;
+	outputSchema: Record<string, unknown>;
+	inputSchema?: Record<string, unknown>;
+}
+/**
+* Options for runtime Standard Schema extraction.
+*/
+interface ExtractStandardSchemasOptions {
+	/** Timeout in milliseconds (default: 10000) */
+	timeout?: number;
+	/** JSON Schema target version (default: 'draft-2020-12') */
+	target?: StandardJSONSchemaTarget;
+	/** Vendor-specific options to pass through */
+	libraryOptions?: Record<string, unknown>;
+}
+/**
+* Result of Standard Schema extraction.
+*/
+interface StandardSchemaExtractionOutput {
+	schemas: Map<string, StandardSchemaExtractionResult>;
+	errors: string[];
+}
+/**
+* Check if an object implements StandardJSONSchemaV1.
+* This is a static type guard - doesn't require runtime.
+*/
+declare function isStandardJSONSchema(obj: unknown): obj is StandardJSONSchemaV1;
+/**
+* TypeScript runtime configuration.
+*/
+interface TsRuntime {
+	/** Command to execute */
+	cmd: string;
+	/** Arguments to pass before the script path */
+	args: string[];
+	/** Human-readable name */
+	name: string;
+}
+/**
+* Detect available TypeScript runtime.
+* Checks in order: Node 22+ native, bun, tsx, ts-node.
+* Returns null if no TS runtime is available.
+*/
+declare function detectTsRuntime(): TsRuntime | null;
+/**
+* Extract Standard Schema from a TypeScript file directly.
+* Uses detected TS runtime (bun, tsx, ts-node, or node 22+).
+*
+* @param tsFilePath - Path to TypeScript file
+* @param options - Extraction options
+* @returns Extraction results
+*/
+declare function extractStandardSchemasFromTs(tsFilePath: string, options?: ExtractStandardSchemasOptions): Promise<StandardSchemaExtractionOutput>;
+/**
+* Resolve compiled JS path from TypeScript source.
+* Reads tsconfig.json for outDir and tries multiple output patterns.
+* Supports .js, .mjs, and .cjs extensions.
+*/
+declare function resolveCompiledPath(tsPath: string, baseDir: string): string | null;
+/**
+* Extract Standard Schema JSON Schemas from a compiled JS module.
+*
+* **Security Note**: This executes the module in a subprocess.
+* Only use with trusted code (user's own packages).
+*
+* @param compiledJsPath - Path to compiled .js file
+* @param options - Extraction options
+* @returns Extraction results with schemas and any errors
+*/
+declare function extractStandardSchemas(compiledJsPath: string, options?: ExtractStandardSchemasOptions): Promise<StandardSchemaExtractionOutput>;
+/**
+* Result info from extractStandardSchemasFromProject
+*/
+interface ProjectExtractionInfo {
+	/** How schemas were extracted */
+	method: "compiled" | "direct-ts";
+	/** Runtime used (for direct-ts) */
+	runtime?: string;
+	/** Path that was used */
+	path: string;
+}
+/**
+* Extended options for project extraction
+*/
+interface ExtractFromProjectOptions extends ExtractStandardSchemasOptions {
+	/** Prefer direct TS execution even if compiled JS exists */
+	preferDirectTs?: boolean;
+}
+/**
+* Extended result for project extraction
+*/
+interface ProjectExtractionOutput extends StandardSchemaExtractionOutput {
+	/** Info about how extraction was performed */
+	info?: ProjectExtractionInfo;
+}
+/**
+* Extract Standard Schema from a TypeScript project.
+*
+* Tries in order:
+* 1. Compiled JS (if found)
+* 2. Direct TypeScript execution (if TS runtime available)
+*
+* @param entryFile - TypeScript entry file path
+* @param baseDir - Project base directory
+* @param options - Extraction options
+*/
+declare function extractStandardSchemasFromProject(entryFile: string, baseDir: string, options?: ExtractFromProjectOptions): Promise<ProjectExtractionOutput>;
+import { SpecExport as SpecExport5 } from "@openpkg-ts/spec";
+import ts6 from "typescript";
+declare function serializeClass(node: ts6.ClassDeclaration, ctx: SerializerContext): SpecExport5 | null;
+import { SpecExport as SpecExport6 } from "@openpkg-ts/spec";
+import ts7 from "typescript";
+declare function serializeEnum(node: ts7.EnumDeclaration, ctx: SerializerContext): SpecExport6 | null;
+import { SpecExport as SpecExport7 } from "@openpkg-ts/spec";
+import ts8 from "typescript";
+declare function serializeFunctionExport(node: ts8.FunctionDeclaration | ts8.ArrowFunction, ctx: SerializerContext): SpecExport7 | null;
+import { SpecExport as SpecExport8 } from "@openpkg-ts/spec";
+import ts9 from "typescript";
+declare function serializeInterface(node: ts9.InterfaceDeclaration, ctx: SerializerContext): SpecExport8 | null;
+import { SpecExport as SpecExport9 } from "@openpkg-ts/spec";
+import ts10 from "typescript";
+declare function serializeTypeAlias(node: ts10.TypeAliasDeclaration, ctx: SerializerContext): SpecExport9 | null;
+import { SpecExport as SpecExport10 } from "@openpkg-ts/spec";
+import ts11 from "typescript";
+declare function serializeVariable(node: ts11.VariableDeclaration, statement: ts11.VariableStatement, ctx: SerializerContext): SpecExport10 | null;
+import { SpecSignatureParameter } from "@openpkg-ts/spec";
+import ts12 from "typescript";
+declare function extractParameters(signature: ts12.Signature, ctx: SerializerContext): SpecSignatureParameter[];
+/**
+* Recursively register types referenced by a ts.Type.
+* Uses ctx.visitedTypes to prevent infinite recursion on circular types.
+*/
+declare function registerReferencedTypes(type: ts12.Type, ctx: SerializerContext, depth?: number): void;
+import { SpecSchema as SpecSchema2 } from "@openpkg-ts/spec";
+import ts13 from "typescript";
+/**
+* Built-in type schemas with JSON Schema format hints.
+* Used for types that have specific serialization formats.
+*/
+declare const BUILTIN_TYPE_SCHEMAS: Record<string, SpecSchema2>;
+declare const ARRAY_PROTOTYPE_METHODS: Set<string>;
+/**
+* Check if a name is a primitive type
+*/
+declare function isPrimitiveName(name: string): boolean;
+/**
+* Get the origin package name for a type if it comes from node_modules.
+* Returns undefined for types defined in the current project.
+*
+* @example
+* getTypeOrigin(trpcRouterType) // Returns '@trpc/server'
+* getTypeOrigin(localUserType) // Returns undefined
+*/
+declare function getTypeOrigin(type: ts13.Type, _checker: ts13.TypeChecker): string | undefined;
+/**
+* Check if a name is a built-in generic type
+*/
+declare function isBuiltinGeneric(name: string): boolean;
+/**
+* Check if a type is anonymous (no meaningful symbol name)
+*/
+declare function isAnonymous(type: ts13.Type): boolean;
+/**
+* Ensure schema is non-empty — fallback to x-ts-type string representation if empty.
+* Never emit {} as a schema; always include meaningful type info.
+*/
+declare function ensureNonEmptySchema(schema: SpecSchema2, type: ts13.Type, checker: ts13.TypeChecker): SpecSchema2;
+/**
+* Build a structured SpecSchema from a TypeScript type.
+* Uses $ref for named types and typeArguments for generics.
+* Guarantees non-empty schema output via ensureNonEmptySchema wrapper.
+*/
+declare function buildSchema(type: ts13.Type, checker: ts13.TypeChecker, ctx?: SerializerContext, _depth?: number): SpecSchema2;
+/**
+* Check if a schema is a pure $ref (only has $ref property)
+*/
+declare function isPureRefSchema(schema: SpecSchema2): schema is {
+	$ref: string;
+};
+/**
+* Add description to a schema, handling $ref properly.
+* For pure $ref schemas, wraps in allOf to preserve the reference.
+*/
+declare function withDescription(schema: SpecSchema2, description: string): SpecSchema2;
+/**
+* Check if a schema represents the 'any' type
+*/
+declare function schemaIsAny(schema: SpecSchema2): boolean;
+/**
+* Deep equality comparison for schemas
+*/
+declare function schemasAreEqual(left: SpecSchema2, right: SpecSchema2): boolean;
+/**
+* Remove duplicate schemas from an array while preserving order.
+*/
+declare function deduplicateSchemas(schemas: SpecSchema2[]): SpecSchema2[];
+/**
+* Find a discriminator property in a union of object types (tagged union pattern).
+* A valid discriminator has a unique literal value in each union member.
+*/
+declare function findDiscriminatorProperty(unionTypes: ts13.Type[], checker: ts13.TypeChecker): string | undefined;
+import { SpecExport as SpecExport11, SpecMember as SpecMember3, SpecSchema as SpecSchema3, SpecType as SpecType5 } from "@openpkg-ts/spec";
+/**
+* Options for schema normalization
+*/
+interface NormalizeOptions {
+	/** Include $schema field in output */
+	includeSchemaField?: boolean;
+	/** Target JSON Schema dialect (default: 'draft-2020-12') */
+	dialect?: "draft-2020-12" | "draft-07";
 }
-interface AnalyzeOptions {
-	filters?: FilterOptions;
-}
-declare class OpenPkg2 {
-	private readonly options;
-	constructor(options?: OpenPkgOptions);
-	analyze(code: string, fileName?: string, analyzeOptions?: AnalyzeOptions): Promise<OpenPkgSpec>;
-	analyzeFile(filePath: string, analyzeOptions?: AnalyzeOptions): Promise<OpenPkgSpec>;
-	analyzeProject(entryPath: string, analyzeOptions?: AnalyzeOptions): Promise<OpenPkgSpec>;
-	analyzeWithDiagnostics(code: string, fileName?: string, analyzeOptions?: AnalyzeOptions): Promise<AnalysisResult>;
-	analyzeFileWithDiagnostics(filePath: string, analyzeOptions?: AnalyzeOptions): Promise<AnalysisResult>;
-	private normalizeDiagnostic;
-	private mapSeverity;
-	private normalizeMetadata;
-	private applySpecFilters;
-}
-declare function analyze(code: string, options?: AnalyzeOptions): Promise<OpenPkgSpec>;
-declare function analyzeFile(filePath: string, options?: AnalyzeOptions): Promise<OpenPkgSpec>;
-export { openPkgSchema, extractPackageSpec, analyzeFile, analyze, OpenPkgSpec, OpenPkgOptions, OpenPkg2 as OpenPkg, FilterOptions, Diagnostic, AnalyzeOptions, AnalysisResult };
+/**
+* JSON Schema 2020-12 compatible output type.
+* Uses Record<string, unknown> for flexibility since JSON Schema is highly polymorphic.
+*/
+type JSONSchema = Record<string, unknown>;
+/**
+* Normalize a SpecSchema to JSON Schema 2020-12.
+*
+* @param schema - The SpecSchema to normalize
+* @param options - Normalization options
+* @returns JSON Schema 2020-12 compatible schema
+*/
+declare function normalizeSchema(schema: SpecSchema3, options?: NormalizeOptions): JSONSchema;
+/**
+* Normalize a SpecExport, normalizing its schema and nested schemas.
+*
+* For interfaces and classes, this function will:
+* 1. Normalize any existing schema
+* 2. Normalize member schemas
+* 3. Generate a JSON Schema from members if members exist (populates `schema` field)
+*/
+declare function normalizeExport(exp: SpecExport11, options?: NormalizeOptions): SpecExport11;
+/**
+* Normalize a SpecType, normalizing its schema and nested schemas.
+*
+* For interfaces and classes, this function will:
+* 1. Normalize any existing schema
+* 2. Normalize member schemas
+* 3. Generate a JSON Schema from members if members exist (populates `schema` field)
+*/
+declare function normalizeType(type: SpecType5, options?: NormalizeOptions): SpecType5;
+/**
+* Convert a members array to JSON Schema properties format.
+*
+* This function transforms the SpecMember[] array representation used by
+* interfaces/classes into a JSON Schema 2020-12 object schema with properties,
+* required array, and additionalProperties.
+*
+* Member Kind Mappings:
+* | Member Kind        | JSON Schema Output                                    |
+* |--------------------|-------------------------------------------------------|
+* | property           | Direct schema in properties                           |
+* | method             | { "x-ts-function": true, "x-ts-signatures": [...] }   |
+* | getter             | Schema in properties (read-only via extension)        |
+* | setter             | Schema in properties (write-only via extension)       |
+* | index              | additionalProperties schema                           |
+*
+* @param members - The members array from an interface/class
+* @param options - Normalization options
+* @returns JSON Schema object with properties, required, and additionalProperties
+*/
+declare function normalizeMembers(members: SpecMember3[], options?: NormalizeOptions): JSONSchema;
+import ts14 from "typescript";
+declare function isExported(node: ts14.Node): boolean;
+declare function getNodeName(node: ts14.Node): string | undefined;
+declare function extract(options: ExtractOptions): Promise<ExtractResult>;
+export { zodAdapter, withDescription, valibotAdapter, typeboxAdapter, 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, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveExportTarget, resolveCompiledPath, registerReferencedTypes, registerAdapter, recommendSemverBump, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, loadSpec, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isPureRefSchema, isProperty, isPrimitiveName, isMethod, isExported, isBuiltinGeneric, isAnonymous, groupByVisibility, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExport2 as getExport, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findDiscriminatorProperty, findAdapter, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, createProgram, createDocs, categorizeBreakingChanges, calculateNextVersion, buildSignatureString, buildSchema, arktypeAdapter, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecDiff, SpecConditionalType, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaExtractionResult, SchemaAdapter, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, JSONSchema, JSONOptions, HTMLOptions, GroupBy, GetExportResult, GetExportOptions, GenericNav, FumadocsMetaItem, FumadocsMeta, FormatSchemaOptions, ForgottenExport, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, ExtractFromProjectOptions, ExportVerification, ExportTracker, ExportMarkdownOptions, ExportItem, DocusaurusSidebarItem, DocusaurusSidebar, DocsInstance, Diagnostic, CategorizedBreaking, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };