ts-json-schema-generator 2.4.1-next.0 → 2.5.0--canary.76e1a68.0

package/factory/generator.ts

@@ -7,7 +7,7 @@ import { createProgram } from "./program.js";
 
 export function createGenerator(config: Config): SchemaGenerator {
     const completedConfig = { ...DEFAULT_CONFIG, ...config };
-    const program = createProgram(completedConfig);
+    const program = config.tsProgram || createProgram(completedConfig);
     const parser = createParser(program, completedConfig);
     const formatter = createFormatter(completedConfig);
 

package/factory/parser.ts

@@ -16,6 +16,7 @@ import { BooleanLiteralNodeParser } from "../src/NodeParser/BooleanLiteralNodePa
 import { BooleanTypeNodeParser } from "../src/NodeParser/BooleanTypeNodeParser.js";
 import { CallExpressionParser } from "../src/NodeParser/CallExpressionParser.js";
 import { ConditionalTypeNodeParser } from "../src/NodeParser/ConditionalTypeNodeParser.js";
+import { NewExpressionParser } from "../src/NodeParser/NewExpressionParser.js";
 import { ConstructorNodeParser } from "../src/NodeParser/ConstructorNodeParser.js";
 import { EnumNodeParser } from "../src/NodeParser/EnumNodeParser.js";
 import { ExpressionWithTypeArgumentsNodeParser } from "../src/NodeParser/ExpressionWithTypeArgumentsNodeParser.js";
@@ -59,6 +60,9 @@ import type { SubNodeParser } from "../src/SubNodeParser.js";
 import { TopRefNodeParser } from "../src/TopRefNodeParser.js";
 import { SatisfiesNodeParser } from "../src/NodeParser/SatisfiesNodeParser.js";
 import { PromiseNodeParser } from "../src/NodeParser/PromiseNodeParser.js";
+import { SpreadElementNodeParser } from "../src/NodeParser/SpreadElementNodeParser.js";
+import { IdentifierNodeParser } from "../src/NodeParser/IdentifierNodeParser.js";
+import { castArray } from "../src/Utils/castArray.js";
 
 export type ParserAugmentor = (parser: MutableParser) => void;
 
@@ -70,14 +74,22 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         return new ExposeNodeParser(typeChecker, nodeParser, config.expose, config.jsDoc);
     }
     function withTopRef(nodeParser: NodeParser): NodeParser {
-        return new TopRefNodeParser(chainNodeParser, config.type, config.topRef);
+        const typeArr = castArray(config.type);
+        // If we have multiple types, don't set a top-level $ref.
+        const topRefFullName = typeArr && typeArr.length === 1 ? typeArr[0] : undefined;
+        return new TopRefNodeParser(chainNodeParser, topRefFullName, config.topRef);
     }
     function withJsDoc(nodeParser: SubNodeParser): SubNodeParser {
         const extraTags = new Set(config.extraTags);
         if (config.jsDoc === "extended") {
             return new AnnotatedNodeParser(
                 nodeParser,
-                new ExtendedAnnotationsReader(typeChecker, extraTags, config.markdownDescription),
+                new ExtendedAnnotationsReader(
+                    typeChecker,
+                    extraTags,
+                    config.markdownDescription,
+                    config.fullDescription,
+                ),
             );
         } else if (config.jsDoc === "basic") {
             return new AnnotatedNodeParser(nodeParser, new BasicAnnotationsReader(extraTags));
@@ -138,8 +150,11 @@ export function createParser(program: ts.Program, config: CompletedConfig, augme
         .addNodeParser(new NamedTupleMemberNodeParser(chainNodeParser))
         .addNodeParser(new OptionalTypeNodeParser(chainNodeParser))
         .addNodeParser(new RestTypeNodeParser(chainNodeParser))
+        .addNodeParser(new IdentifierNodeParser(chainNodeParser, typeChecker))
+        .addNodeParser(new SpreadElementNodeParser(chainNodeParser))
 
         .addNodeParser(new CallExpressionParser(typeChecker, chainNodeParser))
+        .addNodeParser(new NewExpressionParser(typeChecker, chainNodeParser))
         .addNodeParser(new PropertyAccessExpressionParser(typeChecker, chainNodeParser))
 
         .addNodeParser(withCircular(withExpose(withJsDoc(new TypeAliasNodeParser(typeChecker, chainNodeParser)))))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-json-schema-generator",
-  "version": "2.4.1-next.0",
+  "version": "2.5.0--canary.76e1a68.0",
   "description": "Generate JSON schema from your Typescript sources",
   "keywords": [
     "ts",
@@ -57,43 +57,44 @@
   },
   "dependencies": {
     "@types/json-schema": "^7.0.15",
-    "commander": "^13.1.0",
-    "glob": "^11.0.1",
+    "commander": "^14.0.0",
+    "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.8.3",
+    "@typescript/vfs": "1.6.2"
   },
   "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",
+    "@babel/core": "^7.28.0",
+    "@babel/preset-env": "^7.28.0",
+    "@babel/preset-typescript": "^7.27.1",
+    "@eslint/js": "^9.30.1",
     "@types/eslint": "^9.6.1",
-    "@types/glob": "^8.1.0",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.14",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.0.10",
     "@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.24.0",
-    "eslint-config-prettier": "^10.1.1",
-    "eslint-plugin-prettier": "^5.2.5",
-    "jest": "^29.7.0",
+    "chai": "^6.0.1",
+    "cross-env": "^10.0.0",
+    "eslint": "9.39.1",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.1",
+    "globals": "^16.3.0",
+    "jest": "^30.0.4",
     "jest-junit": "^16.0.0",
-    "prettier": "^3.5.3",
-    "tsx": "^4.19.3",
-    "typescript-eslint": "^8.28.0",
+    "prettier": "^3.6.2",
+    "tsx": "^4.20.3",
+    "typescript-eslint": "^8.35.1",
     "vega": "^6.1.2",
-    "vega-lite": "^6.1.0"
+    "vega-lite": "^6.2.0"
   },
-  "packageManager": "npm@11.2.0",
+  "packageManager": "npm@11.4.2",
   "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/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

@@ -16,7 +16,7 @@ import { ObjectProperty, ObjectType } from "../Type/ObjectType.js";
 import { StringType } from "../Type/StringType.js";
 import { SymbolType } from "../Type/SymbolType.js";
 import { UnionType } from "../Type/UnionType.js";
-import { derefAnnotatedType, derefType } from "../Utils/derefType.js";
+import { derefAnnotatedType, derefType, isDeepLiteralUnion } from "../Utils/derefType.js";
 import { getKey } from "../Utils/nodeKey.js";
 import { preserveAnnotation } from "../Utils/preserveAnnotation.js";
 import { removeUndefined } from "../Utils/removeUndefined.js";
@@ -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) {
@@ -158,6 +158,10 @@ export class MappedTypeNodeParser implements SubNodeParser {
         keyListType: UnionType,
         context: Context,
     ): BaseType | boolean {
+        if (isDeepLiteralUnion(keyListType)) {
+            return this.additionalProperties;
+        }
+
         const key = keyListType.getTypes().filter((type) => !(derefType(type) instanceof LiteralType))[0];
 
         if (key) {

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/TypeFormatter/LiteralUnionTypeFormatter.ts

@@ -55,12 +55,18 @@ export class LiteralUnionTypeFormatter implements SubTypeFormatter {
             appendTypeValues(type, typeValues);
         }
 
-        const schema = {
-            type: toEnumType(Array.from(typeNames)),
-            enum: Array.from(typeValues),
-        };
-
-        return preserveLiterals ? { anyOf: [{ type: "string" }, schema] } : schema;
+        const schema =
+            typeNames.size === 1 && typeValues.size === 1
+                ? {
+                      type: toEnumType(Array.from(typeNames)),
+                      const: Array.from(typeValues)[0],
+                  }
+                : {
+                      type: toEnumType(Array.from(typeNames)),
+                      enum: Array.from(typeValues),
+                  };
+
+        return hasString ? { anyOf: [{ type: "string" }, schema] } : schema;
     }
 
     public getChildren(): BaseType[] {

package/src/TypeFormatter/PrimitiveUnionTypeFormatter.ts

@@ -6,7 +6,6 @@ import type { BaseType } from "../Type/BaseType.js";
 import { BooleanType } from "../Type/BooleanType.js";
 import { NullType } from "../Type/NullType.js";
 import { NumberType } from "../Type/NumberType.js";
-import { PrimitiveType } from "../Type/PrimitiveType.js";
 import { StringType } from "../Type/StringType.js";
 import { UnionType } from "../Type/UnionType.js";
 import { uniqueArray } from "../Utils/uniqueArray.js";
@@ -25,7 +24,15 @@ export class PrimitiveUnionTypeFormatter implements SubTypeFormatter {
     }
 
     protected isPrimitiveUnion(type: UnionType): boolean {
-        return type.getTypes().every((item) => item instanceof PrimitiveType);
+        return type
+            .getTypes()
+            .every(
+                (item) =>
+                    item instanceof StringType ||
+                    item instanceof NumberType ||
+                    item instanceof BooleanType ||
+                    item instanceof NullType,
+            );
     }
 
     protected getPrimitiveType(item: BaseType): RawTypeName {