ts-json-schema-generator 2.4.1-next.1 → 2.5.0--canary.2413.011011e.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-json-schema-generator",
-  "version": "2.4.1-next.1",
+  "version": "2.5.0--canary.2413.011011e.0",
   "description": "Generate JSON schema from your Typescript sources",
   "keywords": [
     "ts",
@@ -49,51 +49,51 @@
     "prepublishOnly": "npm run build",
     "release": "npm run build && auto shipit",
     "run": "tsx ts-json-schema-generator.ts",
-    "test": "jest test/ --verbose",
-    "test:coverage": "npm run jest -- test/ --collectCoverage=true",
-    "test:fast": "cross-env FAST_TEST=1 jest test/ --verbose",
-    "test:update": "cross-env UPDATE_SCHEMA=true npm run test:fast",
+    "test": "tsx --test \"test/**/*.test.ts\"",
+    "test:debug": "tsx --inspect-brk --test-concurrency=1 --test",
+    "test:fast": "cross-env FAST_TEST=1 tsx --test \"test/**/*.test.ts\"",
+    "test:update": "cross-env FAST_TEST=1 UPDATE_SCHEMA=true tsx --test \"test/**/*.test.ts\"",
+    "test:coverage": "c8 --reporter lcov --reporter text tsx --test \"test/**/*.test.ts\"",
     "watch": "tsc -w"
   },
   "dependencies": {
     "@types/json-schema": "^7.0.15",
-    "commander": "^13.1.0",
-    "glob": "^11.0.1",
+    "@typescript/vfs": "1.6.2",
+    "commander": "^14.0.2",
+    "glob": "^13.0.0",
     "json5": "^2.2.3",
     "normalize-path": "^3.0.0",
     "safe-stable-stringify": "^2.5.0",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.2"
+    "typescript": "^5.9.3"
   },
   "devDependencies": {
-    "@auto-it/conventional-commits": "^11.3.0",
-    "@auto-it/first-time-contributor": "^11.3.0",
-    "@babel/core": "^7.26.10",
-    "@babel/preset-env": "^7.26.9",
-    "@babel/preset-typescript": "^7.27.0",
-    "@eslint/js": "^9.23.0",
+    "@auto-it/conventional-commits": "^11.3.6",
+    "@auto-it/first-time-contributor": "^11.3.6",
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "@eslint/js": "^9.39.1",
     "@types/eslint": "^9.6.1",
-    "@types/glob": "^8.1.0",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.14",
+    "@types/node": "^24.10.1",
     "@types/normalize-path": "^3.0.2",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "auto": "^11.3.0",
-    "chai": "^5.2.0",
-    "cross-env": "^7.0.3",
-    "eslint": "9.26.0",
-    "eslint-config-prettier": "^10.1.1",
-    "eslint-plugin-prettier": "^5.2.5",
-    "jest": "^29.7.0",
-    "jest-junit": "^16.0.0",
-    "prettier": "^3.5.3",
-    "tsx": "^4.19.3",
-    "typescript-eslint": "^8.28.0",
-    "vega": "^6.1.2",
-    "vega-lite": "^6.1.0"
+    "auto": "^11.3.6",
+    "chai": "^6.2.1",
+    "cross-env": "^10.1.0",
+    "eslint": "9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.5.0",
+    "prettier": "^3.7.3",
+    "try": "^1.0.1",
+    "tsx": "^4.21.0",
+    "typescript-eslint": "^8.48.0",
+    "vega": "^6.2.0",
+    "vega-lite": "^6.4.1"
   },
-  "packageManager": "npm@11.2.0",
+  "packageManager": "npm@11.6.4",
   "engines": {
     "node": ">=18.0.0"
   }

package/src/AnnotationsReader/ExtendedAnnotationsReader.ts

@@ -2,6 +2,7 @@ import json5 from "json5";
 import type ts from "typescript";
 import type { Annotations } from "../Type/AnnotatedType.js";
 import { symbolAtNode } from "../Utils/symbolAtNode.js";
+import { getFullDescription } from "../Utils/getFullDescription.js";
 import { BasicAnnotationsReader } from "./BasicAnnotationsReader.js";
 
 export class ExtendedAnnotationsReader extends BasicAnnotationsReader {
@@ -9,6 +10,7 @@ export class ExtendedAnnotationsReader extends BasicAnnotationsReader {
         private typeChecker: ts.TypeChecker,
         extraTags?: Set<string>,
         private markdownDescription?: boolean,
+        private fullDescription?: boolean,
     ) {
         super(extraTags);
     }
@@ -44,21 +46,34 @@ export class ExtendedAnnotationsReader extends BasicAnnotationsReader {
             return undefined;
         }
 
+        const annotations: { description?: string; markdownDescription?: string; fullDescription?: string } = {};
+
         const comments: ts.SymbolDisplayPart[] = symbol.getDocumentationComment(this.typeChecker);
-        if (!comments || !comments.length) {
-            return undefined;
-        }
 
-        const markdownDescription = comments
-            .map((comment) => comment.text)
-            .join(" ")
-            .replace(/\r/g, "")
-            .trim();
+        if (comments && comments.length) {
+            const markdownDescription = comments
+                .map((comment) => comment.text)
+                .join(" ")
+                .replace(/\r/g, "")
+                .trim();
 
-        const description = markdownDescription.replace(/(?<=[^\n])\n(?=[^\n*-])/g, " ").trim();
+            annotations.description = markdownDescription.replace(/(?<=[^\n])\n(?=[^\n*-])/g, " ").trim();
+
+            if (this.markdownDescription) {
+                annotations.markdownDescription = markdownDescription;
+            }
+        }
 
-        return this.markdownDescription ? { description, markdownDescription } : { description };
+        if (this.fullDescription) {
+            const fullDescription = getFullDescription(node)?.trim();
+            if (fullDescription) {
+                annotations.fullDescription = fullDescription;
+            }
+        }
+
+        return Object.keys(annotations).length ? annotations : undefined;
     }
+
     private getTypeAnnotation(node: ts.Node): Annotations | undefined {
         const symbol = symbolAtNode(node);
         if (!symbol) {

package/src/Config.ts

@@ -1,32 +1,154 @@
+import type ts from "typescript";
+
 export interface Config {
+    /**
+     * Glob pattern(s) for source TypeScript files to process.
+     * If not provided, falls back to files from tsconfig.
+     */
     path?: string;
-    type?: string;
+
+    /**
+     * Name of the type(s)/interface(s) to generate schema for.
+     * Use "*" to generate schemas for all exported types.
+     */
+    type?: string | string[];
+
+    /**
+     * Minify the output JSON schema (no whitespace).
+     * When false, the schema is pretty-printed with 2-space indentation.
+     * @default false
+     */
     minify?: boolean;
+
+    /**
+     * Sets the `$id` property in the root of the generated schema.
+     * Used for schema identification and referencing.
+     */
     schemaId?: string;
+
+    /**
+     * Path to a custom tsconfig.json file for TypeScript compilation.
+     * If not provided, uses default TypeScript configuration.
+     */
     tsconfig?: string;
+
+    /**
+     * Controls which types are exposed as definitions in the schema.
+     * - "all": Exposes all types except type literals
+     * - "none": Exposes no types automatically
+     * - "export": Only exposes exported types (respects @internal JSDoc tag)
+     * @default "export"
+     */
     expose?: "all" | "none" | "export";
+
+    /**
+     * Wraps the root type in a `$ref` definition.
+     * When false, inlines the root type definition directly.
+     * @default true
+     */
     topRef?: boolean;
+
+    /**
+     * Controls how JSDoc comments are parsed and included in the schema.
+     * - "none": Ignores all JSDoc annotations
+     * - "basic": Parses standard JSON Schema JSDoc tags
+     * - "extended": Parses all tags plus descriptions, examples, and type overrides
+     * @default "extended"
+     */
     jsDoc?: "none" | "extended" | "basic";
+
+    /**
+     * Adds a `markdownDescription` field alongside `description` in the schema.
+     * Preserves markdown formatting including newlines.
+     * Only works with `jsDoc: "extended"`.
+     * @default false
+     */
     markdownDescription?: boolean;
+
+    /**
+     * Includes the complete raw JSDoc comment as `fullDescription` in the schema.
+     * Only works with `jsDoc: "extended"`.
+     * @default false
+     */
+    fullDescription?: boolean;
+
+    /**
+     * Sorts object properties alphabetically in the output.
+     * @default true
+     */
     sortProps?: boolean;
+
+    /**
+     * Controls whether tuples allow additional items beyond their defined length.
+     * @default false
+     */
     strictTuples?: boolean;
+
+    /**
+     * Skips TypeScript type checking to improve performance.
+     * Speeds up generation but may miss type errors.
+     * @default false
+     */
     skipTypeCheck?: boolean;
+
+    /**
+     * URI-encodes `$ref` values (e.g., `#/definitions/Foo%3CBar%3E`).
+     * When false, uses raw names in reference paths.
+     * @default true
+     */
     encodeRefs?: boolean;
+
+    /**
+     * Array of additional JSDoc tag names to include in the schema.
+     * Custom tags (e.g., `@customProperty`) are parsed and included in output.
+     * Values are parsed as JSON5.
+     * @default []
+     */
     extraTags?: string[];
+
+    /**
+     * Sets default value for `additionalProperties` on objects without index signatures.
+     * When false, objects get `additionalProperties: false` by default.
+     * When true, allows additional properties on all objects.
+     * @default false
+     */
     additionalProperties?: boolean;
+
+    /**
+     * Controls discriminator style for discriminated unions.
+     * - "json-schema": Uses `if`/`then`/`allOf` with properties containing discriminator enum
+     * - "open-api": Uses OpenAPI 3.x style with `discriminator: { propertyName }` and `oneOf`
+     * @default "json-schema"
+     */
     discriminatorType?: "json-schema" | "open-api";
+
+    /**
+     * Controls how function types are handled in the schema.
+     * - "fail": Throws error when encountering function types
+     * - "comment": Generates schema with `$comment` describing the function signature
+     * - "hide": Treats functions as NeverType (excluded from schema)
+     * @default "comment"
+     */
     functions?: FunctionOptions;
+
+    /**
+     * Pre-compiled TypeScript Program instance to use.
+     * Bypasses the default setup of a TypeScript program, and so some configuration options may not be applied.
+     * Useful for programmatic usage with existing TypeScript compilation, or for vfs scenarios where you do not want file-system representation.
+     */
+    tsProgram?: ts.Program;
 }
 
 export type CompletedConfig = Config & typeof DEFAULT_CONFIG;
 
 export type FunctionOptions = "fail" | "comment" | "hide";
 
-export const DEFAULT_CONFIG: Omit<Required<Config>, "path" | "type" | "schemaId" | "tsconfig"> = {
+export const DEFAULT_CONFIG: Omit<Required<Config>, "path" | "type" | "schemaId" | "tsconfig" | "tsProgram"> = {
     expose: "export",
     topRef: true,
     jsDoc: "extended",
     markdownDescription: false,
+    fullDescription: false,
     sortProps: true,
     strictTuples: false,
     skipTypeCheck: false,

package/src/Error/BaseError.ts

@@ -12,8 +12,6 @@ export type PartialDiagnostic = Omit<ts.Diagnostic, "category" | "file" | "start
     category?: ts.DiagnosticCategory;
 };
 
-const isTTY = process.env.TTY || process.stdout.isTTY;
-
 /**
  * Base error for ts-json-schema-generator
  */
@@ -51,7 +49,7 @@ export abstract class BaseError extends Error {
         );
     }
 
-    format() {
+    format(isTTY = process.env.TTY || process.stdout.isTTY): string {
         const formatter = isTTY ? ts.formatDiagnosticsWithColorAndContext : ts.formatDiagnostics;
 
         return formatter([this.diagnostic], {

package/src/NodeParser/BinaryExpressionNodeParser.ts

@@ -0,0 +1,99 @@
+import ts from "typescript";
+import type { Context, NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import { AnyType } from "../Type/AnyType.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { BooleanType } from "../Type/BooleanType.js";
+import { LiteralType } from "../Type/LiteralType.js";
+import { NumberType } from "../Type/NumberType.js";
+import { StringType } from "../Type/StringType.js";
+import { UnionType } from "../Type/UnionType.js";
+import { AliasType } from "../Type/AliasType.js";
+
+export class BinaryExpressionNodeParser implements SubNodeParser {
+    public constructor(protected childNodeParser: NodeParser) {}
+
+    public supportsNode(node: ts.Node): boolean {
+        return node.kind === ts.SyntaxKind.BinaryExpression;
+    }
+
+    public createType(node: ts.BinaryExpression, context: Context): BaseType {
+        const leftType = this.childNodeParser.createType(node.left, context);
+        const rightType = this.childNodeParser.createType(node.right, context);
+
+        if (leftType instanceof AnyType || rightType instanceof AnyType) {
+            return new AnyType();
+        }
+
+        if (this.isStringLike(leftType) || this.isStringLike(rightType)) {
+            return new StringType();
+        }
+
+        if (this.isDefinitelyNumberLike(leftType) && this.isDefinitelyNumberLike(rightType)) {
+            return new NumberType();
+        }
+
+        if (this.isBooleanLike(leftType) && this.isBooleanLike(rightType)) {
+            return new BooleanType();
+        }
+
+        // Anything else (objects, any, unknown, weird unions, etc.) return
+        // 'string' because at runtime + will usually go through ToPrimitive and
+        // end up in the "string concatenation" branch when non-numeric stuff is
+        // involved.
+        return new StringType();
+    }
+
+    private isStringLike(type: BaseType): boolean {
+        if (type instanceof AliasType) {
+            return this.isStringLike(type.getType());
+        }
+
+        if (type instanceof StringType) {
+            return true;
+        }
+
+        if (type instanceof LiteralType && type.isString()) {
+            return true;
+        }
+
+        // Any union member being string-like is enough.
+        if (type instanceof UnionType) {
+            return type.getTypes().some((t) => this.isStringLike(t));
+        }
+
+        return false;
+    }
+
+    private isBooleanLike(type: BaseType): boolean {
+        if (type instanceof BooleanType) {
+            return true;
+        }
+
+        if (type instanceof LiteralType && typeof type.getValue() === "boolean") {
+            return true;
+        }
+
+        return false;
+    }
+
+    private isDefinitelyNumberLike(type: BaseType): boolean {
+        if (type instanceof AliasType) {
+            return this.isDefinitelyNumberLike(type.getType());
+        }
+
+        if (type instanceof NumberType) {
+            return true;
+        }
+
+        if (type instanceof LiteralType && typeof type.getValue() === "number") {
+            return true;
+        }
+
+        if (type instanceof UnionType) {
+            return type.getTypes().every((t) => this.isDefinitelyNumberLike(t));
+        }
+
+        return false;
+    }
+}

package/src/NodeParser/IdentifierNodeParser.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+import type { Context, NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { UnknownNodeError } from "../Error/Errors.js";
+
+/**
+ * Resolves identifiers whose value is a compile-time constant
+ */
+export class IdentifierNodeParser implements SubNodeParser {
+    constructor(
+        private readonly childNodeParser: NodeParser,
+        private readonly checker: ts.TypeChecker,
+    ) {}
+
+    supportsNode(node: ts.Identifier): boolean {
+        return node.kind === ts.SyntaxKind.Identifier;
+    }
+
+    createType(node: ts.Identifier, context: Context): BaseType {
+        const symbol = this.checker.getSymbolAtLocation(node);
+        if (!symbol) {
+            throw new UnknownNodeError(node);
+        }
+
+        const decl = symbol.valueDeclaration;
+        if (
+            decl &&
+            ts.isVariableDeclaration(decl) &&
+            decl.initializer &&
+            ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const
+        ) {
+            return this.childNodeParser.createType(decl.initializer, context);
+        }
+
+        throw new UnknownNodeError(node);
+    }
+}

package/src/NodeParser/MappedTypeNodeParser.ts

@@ -65,7 +65,7 @@ export class MappedTypeNodeParser implements SubNodeParser {
                 return type instanceof NeverType ? new NeverType() : new ArrayType(type);
             }
             // Key type widens to `string`
-            const type = this.childNodeParser.createType(node.type!, context);
+            const type = this.childNodeParser.createType(node.type!, this.createSubContext(node, keyListType, context));
             // const resultType = type instanceof NeverType ? new NeverType() : new ObjectType(id, [], [], type);
             const resultType = new ObjectType(id, [], [], type);
             if (resultType) {

package/src/NodeParser/NewExpressionParser.ts

@@ -0,0 +1,46 @@
+import ts from "typescript";
+import type { NodeParser } from "../NodeParser.js";
+import { Context } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import type { BaseType } from "../Type/BaseType.js";
+import { UnknownNodeError } from "../Error/Errors.js";
+
+export class NewExpressionParser implements SubNodeParser {
+    public constructor(
+        protected typeChecker: ts.TypeChecker,
+        protected childNodeParser: NodeParser,
+    ) {}
+
+    public supportsNode(node: ts.NewExpression): boolean {
+        return node.kind === ts.SyntaxKind.NewExpression;
+    }
+
+    public createType(node: ts.NewExpression, context: Context): BaseType {
+        const type = this.typeChecker.getTypeAtLocation(node);
+
+        const symbol = type.symbol || type.aliasSymbol;
+
+        const decl =
+            this.typeChecker.typeToTypeNode(type, node, ts.NodeBuilderFlags.IgnoreErrors) ||
+            symbol?.valueDeclaration ||
+            symbol?.declarations?.[0];
+
+        if (!decl) {
+            throw new UnknownNodeError(node);
+        }
+
+        return this.childNodeParser.createType(decl, this.createSubContext(node, context));
+    }
+
+    protected createSubContext(node: ts.NewExpression, parentContext: Context): Context {
+        const subContext = new Context(node);
+
+        if (node.arguments) {
+            for (const arg of node.arguments) {
+                const type = this.childNodeParser.createType(arg, parentContext);
+                subContext.pushArgument(type);
+            }
+        }
+        return subContext;
+    }
+}

package/src/NodeParser/SpreadElementNodeParser.ts

@@ -0,0 +1,25 @@
+import ts from "typescript";
+import type { Context, NodeParser } from "../NodeParser.js";
+import type { SubNodeParser } from "../SubNodeParser.js";
+import type { ArrayType } from "../Type/ArrayType.js";
+import type { InferType } from "../Type/InferType.js";
+import type { TupleType } from "../Type/TupleType.js";
+import { RestType } from "../Type/RestType.js";
+
+/**
+ * Handles `...expr` inside an ArrayLiteralExpression.
+ * Turns it into RestType so TupleTypeFormatter can emit correct JSON-Schema.
+ */
+export class SpreadElementNodeParser implements SubNodeParser {
+    constructor(private readonly childNodeParser: NodeParser) {}
+
+    supportsNode(node: ts.SpreadElement): boolean {
+        return node.kind === ts.SyntaxKind.SpreadElement;
+    }
+
+    createType(node: ts.SpreadElement, context: Context) {
+        const inner = this.childNodeParser.createType(node.expression, context) as ArrayType | InferType | TupleType;
+
+        return new RestType(inner);
+    }
+}

package/src/NodeParser/TypeOperatorNodeParser.ts

@@ -2,7 +2,7 @@ import ts from "typescript";
 import type { Context, NodeParser } from "../NodeParser.js";
 import type { SubNodeParser } from "../SubNodeParser.js";
 import { ArrayType } from "../Type/ArrayType.js";
-import type { BaseType } from "../Type/BaseType.js";
+import { BaseType } from "../Type/BaseType.js";
 import { NumberType } from "../Type/NumberType.js";
 import { ObjectType } from "../Type/ObjectType.js";
 import { StringType } from "../Type/StringType.js";
@@ -28,7 +28,7 @@ export class TypeOperatorNodeParser implements SubNodeParser {
             return new NumberType();
         }
         const keys = getTypeKeys(type);
-        if (derefed instanceof ObjectType && derefed.getAdditionalProperties()) {
+        if (derefed instanceof ObjectType && derefed.getAdditionalProperties() instanceof BaseType) {
             return new UnionType([...keys, new StringType()]);
         }
 

package/src/NodeParser/TypeReferenceNodeParser.ts

@@ -56,7 +56,7 @@ export class TypeReferenceNodeParser implements SubNodeParser {
                 return new AnyType();
             }
 
-            return this.childNodeParser.createType(node.typeArguments[0], this.createSubContext(node, context));
+            return this.childNodeParser.createType(node.typeArguments[0], context);
         }
 
         if (typeSymbol.name === "Array" || typeSymbol.name === "ReadonlyArray") {

package/src/SchemaGenerator.ts

@@ -10,6 +10,7 @@ import type { TypeFormatter } from "./TypeFormatter.js";
 import type { StringMap } from "./Utils/StringMap.js";
 import { hasJsDocTag } from "./Utils/hasJsDocTag.js";
 import { removeUnreachable } from "./Utils/removeUnreachable.js";
+import { castArray } from "./Utils/castArray.js";
 import { symbolAtNode } from "./Utils/symbolAtNode.js";
 
 export class SchemaGenerator {
@@ -20,8 +21,8 @@ export class SchemaGenerator {
         protected readonly config?: Config,
     ) {}
 
-    public createSchema(fullName?: string): Schema {
-        const rootNodes = this.getRootNodes(fullName);
+    public createSchema(fullNames?: string | string[]): Schema {
+        const rootNodes = this.getRootNodes(castArray(fullNames));
         return this.createSchemaFromNodes(rootNodes);
     }
 
@@ -31,8 +32,8 @@ export class SchemaGenerator {
             rootType: this.nodeParser.createType(rootNode, new Context()),
         }));
 
-        const rootTypeDefinition =
-            roots.length === 1 ? this.getRootTypeDefinition(roots[0].rootType, roots[0].rootNode) : undefined;
+        const rootTypeDefinitions = roots.map((root) => this.getRootTypeDefinition(root.rootType, root.rootNode));
+        const rootTypeDefinition = rootTypeDefinitions.length === 1 ? rootTypeDefinitions[0] : undefined;
         const definitions: StringMap<Definition> = {};
 
         for (const root of roots) {
@@ -47,7 +48,10 @@ export class SchemaGenerator {
             }
         }
 
-        const reachableDefinitions = removeUnreachable(rootTypeDefinition, definitions);
+        const reachableDefinitions = rootTypeDefinitions.reduce<StringMap<Definition>>(
+            (acc, def) => Object.assign(acc, removeUnreachable(def, definitions)),
+            {},
+        );
 
         return {
             ...(this.config?.schemaId ? { $id: this.config.schemaId } : {}),
@@ -57,9 +61,15 @@ export class SchemaGenerator {
         };
     }
 
-    protected getRootNodes(fullName: string | undefined): ts.Node[] {
-        if (fullName && fullName !== "*") {
-            return [this.findNamedNode(fullName)];
+    protected getRootNodes(fullNames: string[] | undefined): ts.Node[] {
+        // ["*"] means generate everything.
+        if (fullNames && fullNames.includes("*") && fullNames.length > 1) {
+            throw new Error("Cannot mix '*' with specific type names");
+        }
+
+        const generateAll = !fullNames || fullNames.length === 0 || (fullNames.length === 1 && fullNames[0] === "*");
+        if (!generateAll) {
+            return fullNames.map((name) => this.findNamedNode(name));
         }
 
         const rootFileNames = this.program.getRootFileNames();
@@ -229,11 +239,18 @@ export class SchemaGenerator {
                 return;
             }
 
-            // export { variable } clauses
+            if (node.exportClause) {
+                // export { Foo } from './lib' or export { Foo };
+                // export * as Foo from './lib' should not import all exports
+                ts.forEachChild(node.exportClause, (subnode) => this.inspectNode(subnode, typeChecker, allTypes));
+                return;
+            }
+
             if (!node.moduleSpecifier) {
                 return;
             }
 
+            // export * from './lib'
             const symbol = typeChecker.getSymbolAtLocation(node.moduleSpecifier);
 
             // should never hit this (maybe type error in user's code)

package/src/Type/AnnotatedType.ts

@@ -1,9 +1,7 @@
 import { BaseType } from "./BaseType.js";
 import { hash } from "../Utils/nodeKey.js";
 
-export interface Annotations {
-    [name: string]: any;
-}
+export type Annotations = Record<string, unknown>;
 
 export class AnnotatedType extends BaseType {
     public constructor(