@openpkg-ts/sdk 0.45.0 → 0.47.0

package/dist/index.d.ts

@@ -17,8 +17,6 @@ interface ExtractOptions {
 	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) */
@@ -36,10 +34,20 @@ interface ExtractOptions {
 	/** Max properties to serialize per object type (default: 500) */
 	maxProperties?: number;
 	/**
-	* Register referenced-but-not-exported types from dependencies as named
-	* types[] entries. true → all packages; string[] → listed packages (plus
-	* workspace siblings); false → disable the expansion pass; default →
-	* workspace sibling packages only.
+	* Controls how types from outside the entry package are handled.
+	*
+	* By default, ambient/global types (lib.dom, bun-types) and non-workspace
+	* `node_modules` packages register as **opaque external stubs** — a `types[]`
+	* entry with `external: true` and an `x-ts-type` name, so `$ref`s stay
+	* resolvable without inlining a foreign package's full (and
+	* environment-dependent) member surface. Referenced-but-not-exported types
+	* from the entry package and workspace siblings always expand fully.
+	*
+	* - `true` → fully expand every referenced package (restores pre-stub
+	*   behavior; output becomes environment-dependent for global types)
+	* - `string[]` → fully expand the listed packages (plus workspace siblings)
+	* - `false` → disable the reachability-expansion pass entirely
+	* - default → workspace siblings only; everything else stubbed
 	*/
 	followExternal?: boolean | string[];
 	/** Callback when properties are truncated */
@@ -1157,6 +1165,7 @@ declare function listExports(options: ListExportsOptions): Promise<ListExportsRe
 * ```
 */
 declare const extractSpec: (options: ExtractOptions) => Promise<ExtractResult>;
+import { assertSpec, getAvailableVersions, getValidationErrors, LATEST_VERSION, SchemaVersion, SpecError, validateSpec } from "@openpkg-ts/spec";
 import { SpecType as SpecType4 } from "@openpkg-ts/spec";
 import ts2 from "typescript";
 import ts from "typescript";
@@ -1182,6 +1191,12 @@ interface SerializerContext {
 	maxProperties: number;
 	/** Callback when properties are truncated */
 	onTruncation?: (typeName: string, actual: number, limit: number) => void;
+	/**
+	* Location gate for structural expansion of referenced types. When set and
+	* it rejects a symbol, the registry records an opaque external stub instead
+	* of the full member surface. Unset → expand everything (unit-test contexts).
+	*/
+	shouldExpandExternal?: (symbol: ts.Symbol) => boolean;
 }
 declare class TypeRegistry {
 	private types;
@@ -1620,24 +1635,165 @@ declare const arktypeAdapter: SchemaAdapter;
 declare const typeboxAdapter: SchemaAdapter;
 declare const valibotAdapter: SchemaAdapter;
 declare const zodAdapter: SchemaAdapter;
-import { SpecExport as SpecExport9 } from "@openpkg-ts/spec";
+import { OpenPkg as OpenPkg12, SpecExport as SpecExport9, SpecType as SpecType6 } from "@openpkg-ts/spec";
+interface AsStandardSchemaOptions {
+	keepExtensions?: boolean;
+}
+/**
+* Wrap an export, type, or named subject as a StandardJSONSchemaV1 producer.
+* A string subject is resolved against the spec (exports first, then types).
+*/
+declare function asStandardSchema(subject: SpecExport9 | SpecType6 | string, spec: OpenPkg12, options?: AsStandardSchemaOptions): StandardJSONSchemaV1;
+import { SpecSchema as SpecSchema2 } from "@openpkg-ts/spec";
+/** Object-shaped SpecSchema (excludes the string shorthand) — spreadable. */
+type BuiltinSchema = Extract<SpecSchema2, object>;
+/**
+* Structural JSON Schema approximations for JS/TS built-in types.
+* Used when serializing references to lib types (which are never registered
+* in a spec's types[]) and by adapters mapping refs for external consumers.
+*/
+declare const BUILTIN_TYPE_SCHEMAS: Record<string, BuiltinSchema>;
+import { OpenPkg as OpenPkg13, SpecExport as SpecExport11, SpecType as SpecType8 } from "@openpkg-ts/spec";
+import { SpecExport as SpecExport10, SpecMember as SpecMember3, SpecSchema as SpecSchema3, SpecType as SpecType7 } from "@openpkg-ts/spec";
+/**
+* Options for schema normalization
+*/
+interface NormalizeOptions {
+	/** Include $schema field in output */
+	includeSchemaField?: boolean;
+}
+/**
+* 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;
+declare function normalizeExport(exp: SpecExport10, options?: NormalizeOptions): SpecExport10;
+/**
+* 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: SpecType7, options?: NormalizeOptions): SpecType7;
+/**
+* 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;
+interface ToJsonSchemaOptions {
+	/** Root the document at a single or type (by name). Default: whole-spec $defs catalogue. */
+	root?: string;
+	/** Keep x-ts-* keys (default false). */
+	keepExtensions?: boolean;
+	/** Include the $schema field (default true). */
+	includeSchemaField?: boolean;
+}
+interface JsonSchemaDocument extends Record<string, unknown> {
+	$schema?: string;
+	$defs?: Record<string, JSONSchema>;
+}
+/**
+* Root a JSON Schema document at a single or type, bundling only its
+* transitively-referenced types into `$defs`.
+*/
+declare function exportToJsonSchema(subject: SpecExport11 | SpecType8, spec: OpenPkg13, options?: Omit<ToJsonSchemaOptions, "root">): JsonSchemaDocument;
+/**
+* Lift a whole spec (or, with `root`, a single named export/type) into a
+* standalone JSON Schema 2020-12 document.
+*/
+declare function toJsonSchema(spec: OpenPkg13, options?: ToJsonSchemaOptions): JsonSchemaDocument;
+import { OpenPkg as OpenPkg14, SpecSchema as SpecSchema4 } from "@openpkg-ts/spec";
+/** Strip TypeScript-specific extension keywords from a schema tree (deep). */
+declare function stripTsExtensions(schema: JSONSchema): JSONSchema;
+interface BundleOptions {
+	/** Keep x-ts-* extension keys (default false — stripped). */
+	keepExtensions?: boolean;
+	/** Names to treat as unresolvable generics (export/type type parameters). */
+	typeParameterNames?: readonly string[];
+	/** Dangling-ref strategy (default 'permissive': replace with {} + warning). */
+	onUnresolved?: "permissive" | "error";
+}
+interface BundleResult {
+	/** Root schema, refs rewritten to #/$defs/<key>. */
+	schema: JSONSchema;
+	/** Transitively collected + rewritten type definitions. */
+	defs: Record<string, JSONSchema>;
+	/** Dangling refs, name collisions, pruned nodes. */
+	warnings: string[];
+}
+/**
+* Bundle a spec schema into a self-contained JSON Schema fragment.
+*
+* Every `#/types/Name` ref becomes either an inlined builtin schema, an
+* `x-ts-type` marker (type parameters), or a `#/$defs/<key>` ref whose target
+* is collected (transitively, cycle-safe) into `defs`.
+*/
+declare function bundleRefs(root: SpecSchema4, spec: OpenPkg14, options?: BundleOptions): BundleResult;
+import { OpenPkg as OpenPkg15, SpecExport as SpecExport12 } from "@openpkg-ts/spec";
+type ToolSchemaProvider = "openai-strict" | "anthropic";
+interface ToToolSchemaOptions {
+	provider: ToolSchemaProvider;
+	/** Overload to use (default 0). */
+	signatureIndex?: number;
+}
+interface ToolSchemaResult {
+	/** Export name — the tool name. */
+	name: string;
+	description?: string;
+	/** { type:'object', properties, required, [additionalProperties], [$defs] } */
+	parameters: JSONSchema;
+	/** Pruned props, lowered unions, dangling refs. */
+	warnings: string[];
+}
+/**
+* Build an AI tool-use parameter schema for a function export.
+* Throws for non-function exports (class/variable support is out of scope in v1).
+*/
+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): SpecExport9 | null;
-import { SpecExport as SpecExport10 } from "@openpkg-ts/spec";
+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): SpecExport10 | null;
-import { SpecExport as SpecExport11 } from "@openpkg-ts/spec";
+declare function serializeEnum(node: ts9.EnumDeclaration, ctx: SerializerContext): SpecExport14 | null;
+import { SpecExport as SpecExport15 } from "@openpkg-ts/spec";
 import ts10 from "typescript";
-declare function serializeFunctionExport(node: ts10.FunctionDeclaration | ts10.ArrowFunction | ts10.FunctionExpression, ctx: SerializerContext, nameOverride?: string): SpecExport11 | null;
-import { SpecExport as SpecExport12 } from "@openpkg-ts/spec";
+declare function serializeFunctionExport(node: ts10.FunctionDeclaration | ts10.ArrowFunction | ts10.FunctionExpression, ctx: SerializerContext, nameOverride?: string): SpecExport15 | null;
+import { SpecExport as SpecExport16 } from "@openpkg-ts/spec";
 import ts11 from "typescript";
-declare function serializeInterface(node: ts11.InterfaceDeclaration, ctx: SerializerContext): SpecExport12 | null;
-import { SpecExport as SpecExport13 } from "@openpkg-ts/spec";
+declare function serializeInterface(node: ts11.InterfaceDeclaration, ctx: SerializerContext): SpecExport16 | null;
+import { SpecExport as SpecExport17 } from "@openpkg-ts/spec";
 import ts12 from "typescript";
-declare function serializeTypeAlias(node: ts12.TypeAliasDeclaration, ctx: SerializerContext): SpecExport13 | null;
-import { SpecExport as SpecExport14 } from "@openpkg-ts/spec";
+declare function serializeTypeAlias(node: ts12.TypeAliasDeclaration, ctx: SerializerContext): SpecExport17 | null;
+import { SpecExport as SpecExport18 } from "@openpkg-ts/spec";
 import ts13 from "typescript";
-declare function serializeVariable(node: ts13.VariableDeclaration, statement: ts13.VariableStatement, ctx: SerializerContext): SpecExport14 | null;
+declare function serializeVariable(node: ts13.VariableDeclaration, statement: ts13.VariableStatement, ctx: SerializerContext): SpecExport18 | null;
 import { SpecSignatureParameter } from "@openpkg-ts/spec";
 import ts14 from "typescript";
 declare function extractParameters(signature: ts14.Signature, ctx: SerializerContext): SpecSignatureParameter[];
@@ -1646,14 +1802,9 @@ declare function extractParameters(signature: ts14.Signature, ctx: SerializerCon
 * Uses ctx.registeredTypes to prevent re-processing already-registered types.
 */
 declare function registerReferencedTypes(type: ts14.Type, ctx: SerializerContext, depth?: number): void;
-import { SpecSchema as SpecSchema2 } from "@openpkg-ts/spec";
+import { SpecSchema as SpecSchema5 } from "@openpkg-ts/spec";
 import ts15 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>;
-/**
 * Remove `import("<abs path>").` qualifiers from checker-rendered type text.
 * Machine-specific paths must never appear in a published spec.
 */
@@ -1680,7 +1831,7 @@ 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: SpecSchema2, prop: ts15.Symbol, propType: ts15.Type, checker: ts15.TypeChecker): SpecSchema2;
+declare function decoratePropertySchema(schema: SpecSchema5, prop: ts15.Symbol, propType: ts15.Type, checker: ts15.TypeChecker): SpecSchema5;
 /**
 * Alias-level x-ts-type is emitted when the alias RHS is a renderable
 * expression (array, instantiation, union, intersection, function, keyof, …).
@@ -1722,117 +1873,55 @@ declare function isAnonymous(type: ts15.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: ts15.Type, checker: ts15.TypeChecker): SpecSchema2;
+declare function ensureNonEmptySchema(schema: SpecSchema5, type: ts15.Type, checker: ts15.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): SpecSchema2;
+declare function buildSchema(type: ts15.Type, checker: ts15.TypeChecker, ctx?: SerializerContext): SpecSchema5;
 /**
 * Build schema for function types
 */
-declare function buildFunctionSchema(callSignatures: readonly ts15.Signature[], checker: ts15.TypeChecker, ctx: SerializerContext | undefined): SpecSchema2;
+declare function buildFunctionSchema(callSignatures: readonly ts15.Signature[], checker: ts15.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): SpecSchema2;
+declare function buildObjectSchema(properties: ts15.Symbol[], checker: ts15.TypeChecker, ctx: SerializerContext | undefined, originalType?: ts15.Type): SpecSchema5;
 /**
 * Check if a schema is a pure $ref (only has $ref property)
 */
-declare function isPureRefSchema(schema: SpecSchema2): schema is {
+declare function isPureRefSchema(schema: SpecSchema5): 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 withDescription2(schema: SpecSchema2, description: string): SpecSchema2;
+declare function withDescription2(schema: SpecSchema5, description: string): SpecSchema5;
 /**
 * Mark a schema as deprecated, handling $ref properly.
 * For pure $ref schemas, wraps in allOf to preserve the reference.
 */
-declare function withDeprecated(schema: SpecSchema2, reason?: string): SpecSchema2;
+declare function withDeprecated(schema: SpecSchema5, reason?: string): SpecSchema5;
 /**
 * Check if a schema represents the 'any' type
 */
-declare function schemaIsAny(schema: SpecSchema2): boolean;
+declare function schemaIsAny(schema: SpecSchema5): boolean;
 /**
 * Deep equality comparison for schemas
 */
-declare function schemasAreEqual(left: SpecSchema2, right: SpecSchema2): boolean;
+declare function schemasAreEqual(left: SpecSchema5, right: SpecSchema5): boolean;
 /**
 * Remove duplicate schemas from an array while preserving order.
 */
-declare function deduplicateSchemas(schemas: SpecSchema2[]): SpecSchema2[];
+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 { SpecExport as SpecExport15, SpecMember as SpecMember3, SpecSchema as SpecSchema3, SpecType as SpecType6 } 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";
-}
-/**
-* 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: SpecExport15, options?: NormalizeOptions): SpecExport15;
-/**
-* 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: SpecType6, options?: NormalizeOptions): SpecType6;
-/**
-* 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 ts16 from "typescript";
 declare function isExported(node: ts16.Node): boolean;
 declare function getNodeName(node: ts16.Node): string | undefined;
-export { zodAdapter, withDescription2 as withDescription, withDeprecated, 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, stripUndefinedFromType, 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, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getDeprecationMessage, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findMissingParamDocs, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, decoratePropertySchema, createProgram, createDocs, categorizeBreakingChanges, calculateNextVersion, buildSignatureString, buildSchema, buildObjectSchema, buildFunctionSchema, arktypeAdapter, analyzeSpec, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecDiff, SpecDiagnostics, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, 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, 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, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };
+export { zodAdapter, 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, 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 };