@openpkg-ts/sdk 0.50.1 → 0.52.0

package/README.md

@@ -8,6 +8,21 @@ Extract [OpenPkg](https://openpkg.dev) documents from TypeScript source and gene
 npm install @openpkg-ts/sdk
 ```
 
+## TypeScript version support
+
+The sdk drives the TypeScript **JS compiler API** and declares
+`typescript@^5.0.0 || ^6.0.0` as a regular dependency, so your package manager
+installs a compatible copy for the sdk automatically — extraction works even if
+your own project uses a different TypeScript version.
+
+**On a TypeScript 7 toolchain?** That's fine: TS7's `tsc` is a native binary and
+does not conflict with the sdk's nested TS5/6 copy. One caveat: do **not** force
+a workspace-wide `typescript@7` via `overrides`/`resolutions`. The extraction
+engine needs the JS compiler API, which TypeScript 7 removed — its main export
+is a version stub with no `createProgram`. Native TS7-backed extraction is
+planned as a separate opt-in package; the JS backend remains the default and is
+fully supported.
+
 ## Entry Points
 
 ```typescript
@@ -75,9 +90,30 @@ const { spec, diagnostics, verification } = await extractSpec({
   resolveExternalTypes: true,
   only: ['use*'],           // filter by pattern
   ignore: ['*Internal'],    // exclude by pattern
+  followExternal: ['@ai-sdk/*'], // or true, or 'auto' with decisions: 'jev'
 });
 ```
 
+`followExternal: 'auto'` scores referenced externals with Jev and expands the load-bearing ones. Requires `decisions: 'jev'`, `AI_GATEWAY_API_KEY`, and optional peer `ai` (≥7.0.105). Specs record `generation.entryPoint` and `generation.entryPointSource` (`types` / `exports` / `fallback` / `explicit` / `llm`).
+
+### resolveTarget
+
+Resolve a package and entry from a directory, cwd, intent, or git URL before extracting:
+
+```typescript
+import { resolveTarget, extractSpec } from '@openpkg-ts/sdk';
+
+const resolved = await resolveTarget({ input: '.', intent: 'sdk' });
+if (resolved.kind === 'ok') {
+  const { spec } = await extractSpec({
+    entryFile: resolved.entryFile,
+    entryPointSource: resolved.entryPointSource,
+  });
+}
+```
+
+`decisions: 'jev'` uses Jev when the heuristic is ambiguous. GitHub URLs clone via `gh` if present, else `git clone --depth 1`.
+
 ### diffSpecs
 
 Compare two specs for breaking changes.

package/dist/index.d.ts

@@ -1,5 +1,42 @@
 import { BreakingSeverity, CategorizedBreaking, calculateNextVersion, categorizeBreakingChanges, diffSpec, diffSpec as diffSpec2, MemberChangeInfo, recommendSemverBump, SemverBump, SemverRecommendation, SpecDiff } from "@openpkg-ts/spec";
-import { OpenPkg } from "@openpkg-ts/spec";
+import { EntryPointDetectionMethod, OpenPkg } from "@openpkg-ts/spec";
+declare const JEV_MODEL = "typesafe-ai/jev";
+declare const JEV_CONFIDENCE = .5;
+type ChoiceQuestion = {
+	type: "choice";
+	instructions: string;
+	criteria: Record<string, string>;
+};
+type ScoreQuestion = {
+	type: "score";
+	instructions: string;
+	criteria: string[];
+};
+type EvaluateQuestion = ChoiceQuestion | ScoreQuestion;
+type EvaluateRequest = {
+	model: string;
+	state: unknown;
+	questions: Record<string, EvaluateQuestion>;
+	providerOptions?: {
+		gateway?: {
+			zeroDataRetention?: boolean;
+		};
+	};
+};
+type EvaluateAnswer = {
+	choice?: string;
+	score?: number;
+	probabilities?: Record<string, number>;
+};
+type EvaluateResult = {
+	answers: Record<string, EvaluateAnswer>;
+	providerMetadata?: {
+		typesafe?: {
+			confidence?: Record<string, number>;
+		};
+	};
+};
+type EvaluateFn = (request: EvaluateRequest) => Promise<EvaluateResult>;
 /** Configuration for resolving external package re-exports */
 interface ExternalsConfig {
 	/** Package patterns to resolve (globs supported, e.g., "@myorg/*") */
@@ -11,6 +48,8 @@ interface ExternalsConfig {
 }
 interface ExtractOptions {
 	entryFile: string;
+	/** How the entry file was chosen. Default: explicit. */
+	entryPointSource?: EntryPointDetectionMethod;
 	baseDir?: string;
 	content?: string;
 	maxTypeDepth?: number;
@@ -49,7 +88,9 @@ interface ExtractOptions {
 	* - `false` → disable the reachability-expansion pass entirely
 	* - default → workspace siblings only; everything else stubbed
 	*/
-	followExternal?: boolean | string[];
+	followExternal?: boolean | string[] | "auto";
+	evaluate?: EvaluateFn;
+	decisions?: "heuristic" | "jev";
 	/** Callback when properties are truncated */
 	onTruncation?: (typeName: string, actual: number, limit: number) => void;
 }
@@ -161,11 +202,13 @@ interface OpenpkgConfig {
 	* them as opaque stubs. `true` follows every dependency; a string[] follows
 	* only the named packages (by declaring package name). Default: stub.
 	*/
-	followExternal?: boolean | string[];
+	followExternal?: boolean | string[] | "auto";
 	/** Only extract these exports (supports * wildcards). */
 	only?: string[];
 	/** Ignore these exports (supports * wildcards). */
 	ignore?: string[];
+	/** Use Jev for package/entry routing. Requires AI_GATEWAY_API_KEY. */
+	decisions?: "heuristic" | "jev";
 }
 /** Default config filename */
 declare const CONFIG_FILENAME = "openpkg.config.json";
@@ -1063,6 +1106,77 @@ declare class QueryBuilder {
 * Create a query builder for the given spec
 */
 declare function query(spec: OpenPkg10): QueryBuilder;
+import { EntryPointDetectionMethod as EntryPointDetectionMethod2 } from "@openpkg-ts/spec";
+type PackageRecord = {
+	name: string;
+	dir: string;
+	private: boolean;
+	description?: string;
+	types?: string;
+	typings?: string;
+	main?: string;
+	module?: string;
+	hasSrc: boolean;
+	hasDist: boolean;
+	scripts: string[];
+};
+type CloneFn = (input: string) => Promise<string>;
+type ResolveTargetOptions = {
+	input?: string;
+	intent?: string;
+	cwd?: string;
+	decisions?: "heuristic" | "jev";
+	evaluate?: EvaluateFn;
+	clone?: CloneFn;
+};
+type ResolveOk = {
+	kind: "ok";
+	package: PackageRecord;
+	entryFile: string;
+	entryPointSource: EntryPointDetectionMethod2;
+};
+type ResolveAmbiguous = {
+	kind: "ambiguous";
+	candidates: PackageRecord[];
+};
+type ResolveNeedsBuild = {
+	kind: "needs-build";
+	package: PackageRecord;
+	reason: string;
+	command?: string;
+};
+type ResolveEmpty = {
+	kind: "empty";
+	reason: string;
+};
+type ResolveRemote = {
+	kind: "remote";
+	input: string;
+};
+type ResolveExplicit = {
+	kind: "explicit";
+	entryFile: string;
+	entryPointSource: "explicit";
+};
+type ResolveUnavailable = {
+	kind: "unavailable";
+	reason: string;
+};
+type ResolveTargetResult = ResolveOk | ResolveAmbiguous | ResolveNeedsBuild | ResolveEmpty | ResolveRemote | ResolveExplicit | ResolveUnavailable;
+declare function isRemoteInput(input: string): boolean;
+declare function isEntryFilePath(input: string): boolean;
+declare function parseGithubRepo(input: string): {
+	owner: string;
+	repo: string;
+} | null;
+declare function cloneRemote(input: string): Promise<string>;
+declare function findWorkspaceRoot(start: string): string | undefined;
+declare function catalogPackages(start: string): PackageRecord[];
+declare function pickEntry(pkgDir: string): {
+	entryFile: string;
+	entryPointSource: EntryPointDetectionMethod2;
+} | null;
+declare function resolveTarget(options?: ResolveTargetOptions): Promise<ResolveTargetResult>;
 import { OpenPkg as OpenPkg11, SpecExportKind as SpecExportKind7 } from "@openpkg-ts/spec";
 type FilterCriteria = {
 	/** Filter by kinds */
@@ -1608,7 +1722,7 @@ interface ProgramResult {
 	workspacePackages?: Map<string, string>;
 }
 declare function createProgram(options: ProgramOptions): ProgramResult;
-import * as TS from "typescript";
+import ts8 from "typescript";
 /**
 * A schema adapter can detect and extract output types from a specific
 * schema validation library.
@@ -1622,17 +1736,17 @@ interface SchemaAdapter {
 	* 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;
+	matches(type: ts8.Type, checker: ts8.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;
+	extractOutputType(type: ts8.Type, checker: ts8.TypeChecker): ts8.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;
+	extractInputType?(type: ts8.Type, checker: ts8.TypeChecker): ts8.Type | null;
 }
 /**
 * Result of schema type extraction
@@ -1641,22 +1755,22 @@ interface SchemaExtractionResult {
 	/** The adapter that matched */
 	adapter: SchemaAdapter;
 	/** The extracted output type */
-	outputType: TS.Type;
+	outputType: ts8.Type;
 	/** The extracted input type (if different from output) */
-	inputType?: TS.Type;
+	inputType?: ts8.Type;
 }
 /**
 * Utility: Check if type is an object type reference (has type arguments)
 */
-declare function isTypeReference(type: TS.Type): type is TS.TypeReference;
+declare function isTypeReference(type: ts8.Type): type is ts8.TypeReference;
 /**
 * Utility: Remove undefined/null from a union type
 */
-declare function getNonNullableType(type: TS.Type): TS.Type;
+declare function getNonNullableType(type: ts8.Type): ts8.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 function findAdapter(type: ts8.Type, checker: ts8.TypeChecker): SchemaAdapter | undefined;
+declare function isSchemaType(type: ts8.Type, checker: ts8.TypeChecker): boolean;
+declare function extractSchemaType(type: ts8.Type, checker: ts8.TypeChecker): SchemaExtractionResult | null;
 declare const arktypeAdapter: SchemaAdapter;
 declare const typeboxAdapter: SchemaAdapter;
 declare const valibotAdapter: SchemaAdapter;
@@ -1803,33 +1917,33 @@ interface ToolSchemaResult {
 */
 declare function toToolSchema(exp: SpecExport12, spec: OpenPkg15, options: ToToolSchemaOptions): ToolSchemaResult;
 import { SpecExport as SpecExport13 } from "@openpkg-ts/spec";
-import ts8 from "typescript";
-declare function serializeClass(node: ts8.ClassDeclaration, ctx: SerializerContext): SpecExport13 | null;
-import { SpecExport as SpecExport14 } from "@openpkg-ts/spec";
 import ts9 from "typescript";
-declare function serializeEnum(node: ts9.EnumDeclaration, ctx: SerializerContext): SpecExport14 | null;
-import { SpecExport as SpecExport15 } from "@openpkg-ts/spec";
+declare function serializeClass(node: ts9.ClassDeclaration, ctx: SerializerContext): SpecExport13 | null;
+import { SpecExport as SpecExport14 } from "@openpkg-ts/spec";
 import ts10 from "typescript";
-declare function serializeFunctionExport(node: ts10.FunctionDeclaration | ts10.ArrowFunction | ts10.FunctionExpression, ctx: SerializerContext, nameOverride?: string): SpecExport15 | null;
-import { SpecExport as SpecExport16 } from "@openpkg-ts/spec";
+declare function serializeEnum(node: ts10.EnumDeclaration, ctx: SerializerContext): SpecExport14 | null;
+import { SpecExport as SpecExport15 } from "@openpkg-ts/spec";
 import ts11 from "typescript";
-declare function serializeInterface(node: ts11.InterfaceDeclaration, ctx: SerializerContext): SpecExport16 | null;
-import { SpecExport as SpecExport17 } from "@openpkg-ts/spec";
+declare function serializeFunctionExport(node: ts11.FunctionDeclaration | ts11.ArrowFunction | ts11.FunctionExpression, ctx: SerializerContext, nameOverride?: string): SpecExport15 | null;
+import { SpecExport as SpecExport16 } from "@openpkg-ts/spec";
 import ts12 from "typescript";
-declare function serializeTypeAlias(node: ts12.TypeAliasDeclaration, ctx: SerializerContext): SpecExport17 | null;
-import { SpecExport as SpecExport18 } from "@openpkg-ts/spec";
+declare function serializeInterface(node: ts12.InterfaceDeclaration, ctx: SerializerContext): SpecExport16 | null;
+import { SpecExport as SpecExport17 } from "@openpkg-ts/spec";
 import ts13 from "typescript";
-declare function serializeVariable(node: ts13.VariableDeclaration, statement: ts13.VariableStatement, ctx: SerializerContext): SpecExport18 | null;
-import { SpecSignatureParameter } from "@openpkg-ts/spec";
+declare function serializeTypeAlias(node: ts13.TypeAliasDeclaration, ctx: SerializerContext): SpecExport17 | null;
+import { SpecExport as SpecExport18 } from "@openpkg-ts/spec";
 import ts14 from "typescript";
-declare function extractParameters(signature: ts14.Signature, ctx: SerializerContext): SpecSignatureParameter[];
+declare function serializeVariable(node: ts14.VariableDeclaration, statement: ts14.VariableStatement, ctx: SerializerContext): SpecExport18 | null;
+import { SpecSignatureParameter } from "@openpkg-ts/spec";
+import ts15 from "typescript";
+declare function extractParameters(signature: ts15.Signature, ctx: SerializerContext): SpecSignatureParameter[];
 /**
 * Recursively register types referenced by a ts.Type.
 * Uses ctx.registeredTypes to prevent re-processing already-registered types.
 */
-declare function registerReferencedTypes(type: ts14.Type, ctx: SerializerContext, depth?: number): void;
+declare function registerReferencedTypes(type: ts15.Type, ctx: SerializerContext, depth?: number): void;
 import { SpecSchema as SpecSchema5 } from "@openpkg-ts/spec";
-import ts15 from "typescript";
+import ts16 from "typescript";
 /**
 * Remove `import("<abs path>").` qualifiers from checker-rendered type text.
 * Machine-specific paths must never appear in a published spec.
@@ -1839,7 +1953,7 @@ declare function scrubImportQualifiers(text: string): string;
 * Render the developer-facing type text at its owning declaration.
 * NoTruncation keeps long unions intact; import() qualifiers are scrubbed.
 */
-declare function renderTypeText(type: ts15.Type, checker: ts15.TypeChecker, enclosing?: ts15.Node, extraFlags?: ts15.TypeFormatFlags): string;
+declare function renderTypeText(type: ts16.Type, checker: ts16.TypeChecker, enclosing?: ts16.Node, extraFlags?: ts16.TypeFormatFlags): string;
 /**
 * The type exactly as the author WROTE it — the annotation node's source text.
 * `x-ts-type` carries the resolved truth (`Omit<T, K>` expanded to its mapped
@@ -1852,17 +1966,17 @@ declare function renderTypeText(type: ts15.Type, checker: ts15.TypeChecker, encl
 * formatting (a trailing `;`, `readonly T[]` vs `ReadonlyArray<T>`) or would
 * drag source comments into the spec, both of which are noise, not signal.
 */
-declare function writtenTypeText(typeNode: ts15.TypeNode | undefined): string | undefined;
+declare function writtenTypeText(typeNode: ts16.TypeNode | undefined): string | undefined;
 /** The annotation TypeNode on a declaration (property, alias, parameter), if any. */
-declare function declaredTypeNode(decl: ts15.Declaration | undefined): ts15.TypeNode | undefined;
+declare function declaredTypeNode(decl: ts16.Declaration | undefined): ts16.TypeNode | undefined;
 /**
 * Strip `undefined` from a union type when optionality is already expressed
 * elsewhere (`required: false`, `flags.optional`). Used for both schema shape
 * and x-ts-type text so neither re-encodes optionality as `| undefined`.
 */
-declare function stripUndefinedFromType(type: ts15.Type, checker: ts15.TypeChecker): ts15.Type;
+declare function stripUndefinedFromType(type: ts16.Type, checker: ts16.TypeChecker): ts16.Type;
 /** Declaration-modifier readonly check — matches the member-layer flags.readonly source. */
-declare function isReadonlyPropertySymbol(prop: ts15.Symbol): boolean;
+declare function isReadonlyPropertySymbol(prop: ts16.Symbol): boolean;
 /**
 * Decorate a property schema with TS-fidelity metadata:
 * - `x-ts-type`: checker-rendered text at the owning declaration. Emitted
@@ -1872,14 +1986,14 @@ declare function isReadonlyPropertySymbol(prop: ts15.Symbol): boolean;
 * - `x-ts-method`: declaration form marker for method-syntax members
 *   (SymbolFlags.Method survives on true methods, is stripped by mapping).
 */
-declare function decoratePropertySchema(schema: SpecSchema5, prop: ts15.Symbol, propType: ts15.Type, checker: ts15.TypeChecker): SpecSchema5;
+declare function decoratePropertySchema(schema: SpecSchema5, prop: ts16.Symbol, propType: ts16.Type, checker: ts16.TypeChecker): SpecSchema5;
 /**
 * Alias-level x-ts-type is emitted when the alias RHS is a renderable
 * expression (array, instantiation, union, intersection, function, keyof, …).
 * Type-literal and mapped bodies are skipped — their structure is already
 * carried by schema.properties and the text would be the whole literal body.
 */
-declare function shouldEmitAliasTypeText(typeNode: ts15.TypeNode): boolean;
+declare function shouldEmitAliasTypeText(typeNode: ts16.TypeNode): boolean;
 declare const PRIMITIVES: Set<string>;
 declare const ARRAY_PROTOTYPE_METHODS: Set<string>;
 declare const STRING_PROTOTYPE_METHODS: Set<string>;
@@ -1892,7 +2006,7 @@ declare function isPrimitiveName(name: string): boolean;
 * Check if a symbol is from TypeScript's built-in lib (lib.es*.d.ts).
 * Used to detect Array, Object, and other built-in types.
 */
-declare function isBuiltinSymbol(symbol: ts15.Symbol | undefined): boolean;
+declare function isBuiltinSymbol(symbol: ts16.Symbol | undefined): boolean;
 /**
 * Get the origin package name for a type if it comes from node_modules.
 * Returns undefined for types defined in the current project.
@@ -1901,7 +2015,7 @@ declare function isBuiltinSymbol(symbol: ts15.Symbol | undefined): boolean;
 * getTypeOrigin(trpcRouterType) // Returns '@trpc/server'
 * getTypeOrigin(localUserType) // Returns undefined
 */
-declare function getTypeOrigin(type: ts15.Type, _checker: ts15.TypeChecker): string | undefined;
+declare function getTypeOrigin(type: ts16.Type, _checker: ts16.TypeChecker): string | undefined;
 /**
 * Check if a name is a built-in generic type
 */
@@ -1909,26 +2023,26 @@ declare function isBuiltinGeneric(name: string): boolean;
 /**
 * Check if a type is anonymous (no meaningful symbol name)
 */
-declare function isAnonymous(type: ts15.Type): boolean;
+declare function isAnonymous(type: ts16.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: SpecSchema5, type: ts15.Type, checker: ts15.TypeChecker): SpecSchema5;
+declare function ensureNonEmptySchema(schema: SpecSchema5, type: ts16.Type, checker: ts16.TypeChecker): SpecSchema5;
 /**
 * 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: ts15.Type, checker: ts15.TypeChecker, ctx?: SerializerContext): SpecSchema5;
+declare function buildSchema(type: ts16.Type, checker: ts16.TypeChecker, ctx?: SerializerContext): SpecSchema5;
 /**
 * Build schema for function types
 */
-declare function buildFunctionSchema(callSignatures: readonly ts15.Signature[], checker: ts15.TypeChecker, ctx: SerializerContext | undefined): SpecSchema5;
+declare function buildFunctionSchema(callSignatures: readonly ts16.Signature[], checker: ts16.TypeChecker, ctx: SerializerContext | undefined): SpecSchema5;
 /**
 * Build schema for object types with properties
 */
-declare function buildObjectSchema(properties: ts15.Symbol[], checker: ts15.TypeChecker, ctx: SerializerContext | undefined, originalType?: ts15.Type): SpecSchema5;
+declare function buildObjectSchema(properties: ts16.Symbol[], checker: ts16.TypeChecker, ctx: SerializerContext | undefined, originalType?: ts16.Type): SpecSchema5;
 /**
 * Check if a schema is a pure $ref (only has $ref property)
 */
@@ -1961,8 +2075,8 @@ declare function deduplicateSchemas(schemas: SpecSchema5[]): SpecSchema5[];
 * 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: ts15.Type[], checker: ts15.TypeChecker): string | undefined;
-import ts16 from "typescript";
-declare function isExported(node: ts16.Node): boolean;
-declare function getNodeName(node: ts16.Node): string | undefined;
-export { zodAdapter, writtenTypeText, withDescription2 as withDescription, withDeprecated, validateSpec, valibotAdapter, typeboxAdapter, toToolSchema, toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJsonSchema, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, stripUndefinedFromType, stripTsExtensions, sortByName, shouldEmitAliasTypeText, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, scrubImportQualifiers, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveExportTarget, resolveCompiledPath, renderTypeText, registerReferencedTypes, registerAdapter, recommendSemverBump, query, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, mergeConfig, loadSpec, loadConfig, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isReadonlyPropertySymbol, isPureRefSchema, isProperty, isPrimitiveName, isMethod, isExported, isBuiltinSymbol, isBuiltinGeneric, isAnonymous, hasDeprecatedTag, groupByVisibility, getValidationErrors, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getDeprecationMessage, getAvailableVersions, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findMissingParamDocs, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, exportToJsonSchema, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, decoratePropertySchema, declaredTypeNode, createProgram, createDocs, categorizeBreakingChanges, calculateNextVersion, bundleRefs, buildSignatureString, buildSchema, buildObjectSchema, buildFunctionSchema, assertSpec, asStandardSchema, arktypeAdapter, analyzeSpec, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, ToolSchemaResult, ToolSchemaProvider, ToToolSchemaOptions, ToJsonSchemaOptions, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecError, SpecDiff, SpecDiagnostics, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaVersion, SchemaExtractionResult, SchemaAdapter, STRING_PROTOTYPE_METHODS, QueryBuilder, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, PRIMITIVES, OpenpkgConfig, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, NUMBER_PROTOTYPE_METHODS, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, LATEST_VERSION, JsonSchemaDocument, JSONSchema, JSONOptions, HTMLOptions, GroupBy, GetExportResult, GetExportOptions, GenericNav, FumadocsMetaItem, FumadocsMeta, FormatSchemaOptions, ForgottenExport, FilterResult, FilterCriteria, ExtractionWarningCode, ExtractionWarning, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, ExtractFromProjectOptions, ExternalsConfig, ExportVerification, ExportTracker, ExportMarkdownOptions, ExportItem, DocusaurusSidebarItem, DocusaurusSidebar, DocsInstance, DiagnosticItem, Diagnostic, CategorizedBreaking, CacheManagerOptions, CacheManager, CONFIG_FILENAME, BundleResult, BundleOptions, BuiltinSchema, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AsStandardSchemaOptions, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };
+declare function findDiscriminatorProperty(unionTypes: ts16.Type[], checker: ts16.TypeChecker): string | undefined;
+import ts17 from "typescript";
+declare function isExported(node: ts17.Node): boolean;
+declare function getNodeName(node: ts17.Node): string | undefined;
+export { zodAdapter, writtenTypeText, withDescription2 as withDescription, withDeprecated, validateSpec, valibotAdapter, typeboxAdapter, toToolSchema, toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJsonSchema, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, stripUndefinedFromType, stripTsExtensions, sortByName, shouldEmitAliasTypeText, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, scrubImportQualifiers, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveTarget, resolveExportTarget, resolveCompiledPath, renderTypeText, registerReferencedTypes, registerAdapter, recommendSemverBump, query, pickEntry, parseGithubRepo, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, mergeConfig, loadSpec, loadConfig, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isRemoteInput, isReadonlyPropertySymbol, isPureRefSchema, isProperty, isPrimitiveName, isMethod, isExported, isEntryFilePath, isBuiltinSymbol, isBuiltinGeneric, isAnonymous, hasDeprecatedTag, groupByVisibility, getValidationErrors, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getDeprecationMessage, getAvailableVersions, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findWorkspaceRoot, findMissingParamDocs, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, exportToJsonSchema, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, decoratePropertySchema, declaredTypeNode, createProgram, createDocs, cloneRemote, categorizeBreakingChanges, catalogPackages, calculateNextVersion, bundleRefs, buildSignatureString, buildSchema, buildObjectSchema, buildFunctionSchema, assertSpec, asStandardSchema, arktypeAdapter, analyzeSpec, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, ToolSchemaResult, ToolSchemaProvider, ToToolSchemaOptions, ToJsonSchemaOptions, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecError, SpecDiff, SpecDiagnostics, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaVersion, SchemaExtractionResult, SchemaAdapter, STRING_PROTOTYPE_METHODS, ResolveUnavailable, ResolveTargetResult, ResolveTargetOptions, ResolveRemote, ResolveOk, ResolveNeedsBuild, ResolveExplicit, ResolveEmpty, ResolveAmbiguous, QueryBuilder, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, PackageRecord, PRIMITIVES, OpenpkgConfig, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, NUMBER_PROTOTYPE_METHODS, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, LATEST_VERSION, JsonSchemaDocument, JSONSchema, JSONOptions, JEV_MODEL, JEV_CONFIDENCE, HTMLOptions, GroupBy, GetExportResult, GetExportOptions, GenericNav, FumadocsMetaItem, FumadocsMeta, FormatSchemaOptions, ForgottenExport, FilterResult, FilterCriteria, ExtractionWarningCode, ExtractionWarning, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, ExtractFromProjectOptions, ExternalsConfig, ExportVerification, ExportTracker, ExportMarkdownOptions, ExportItem, EvaluateResult, EvaluateRequest, EvaluateFn, DocusaurusSidebarItem, DocusaurusSidebar, DocsInstance, DiagnosticItem, Diagnostic, CloneFn, CategorizedBreaking, CacheManagerOptions, CacheManager, CONFIG_FILENAME, BundleResult, BundleOptions, BuiltinSchema, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AsStandardSchemaOptions, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };