@langchain/langgraph-api 0.0.30 → 0.0.31

package/dist/api/assistants.d.mts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/api/assistants.mjs

@@ -2,7 +2,8 @@ import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
 import { v4 as uuid } from "uuid";
 import { z } from "zod";
-import { getAssistantId, getGraph, getGraphSchema } from "../graph/load.mjs";
+import { getAssistantId, getGraph, getCachedStaticGraphSchema, } from "../graph/load.mjs";
+import { getRuntimeGraphSchema } from "../graph/parser/index.mjs";
 import { Assistants } from "../storage/ops.mjs";
 import * as schemas from "../schemas.mjs";
 import { HTTPException } from "hono/http-exception";
@@ -84,21 +85,29 @@ api.get("/assistants/:assistant_id/graph", zValidator("query", z.object({ xray:
     });
     return c.json(drawable.toJSON());
 });
-api.get("/assistants/:assistant_id/schemas", async (c) => {
+api.get("/assistants/:assistant_id/schemas", zValidator("json", z.object({ config: RunnableConfigSchema.optional() })), async (c) => {
     // Get Assistant Schemas
+    const json = c.req.valid("json");
     const assistantId = getAssistantId(c.req.param("assistant_id"));
     const assistant = await Assistants.get(assistantId, c.var.auth);
-    const graphSchema = await getGraphSchema(assistant.graph_id);
-    const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
-    if (!rootGraphId)
-        throw new Error("Failed to find root graph");
-    const rootGraphSchema = graphSchema[rootGraphId];
+    const config = getRunnableConfig(json.config);
+    const graph = await getGraph(assistant.graph_id, config);
+    const schema = await (async () => {
+        const runtimeSchema = await getRuntimeGraphSchema(graph);
+        if (runtimeSchema)
+            return runtimeSchema;
+        const graphSchema = await getCachedStaticGraphSchema(assistant.graph_id);
+        const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
+        if (!rootGraphId)
+            throw new HTTPException(404, { message: "Failed to find root graph" });
+        return graphSchema[rootGraphId];
+    })();
     return c.json({
         graph_id: assistant.graph_id,
-        input_schema: rootGraphSchema.input,
-        output_schema: rootGraphSchema.output,
-        state_schema: rootGraphSchema.state,
-        config_schema: rootGraphSchema.config,
+        input_schema: schema.input,
+        output_schema: schema.output,
+        state_schema: schema.state,
+        config_schema: schema.config,
     });
 });
 api.get("/assistants/:assistant_id/subgraphs/:namespace?", zValidator("param", z.object({ assistant_id: z.string(), namespace: z.string().optional() })), zValidator("query", z.object({ recurse: schemas.coercedBoolean.optional() })), async (c) => {
@@ -109,21 +118,28 @@ api.get("/assistants/:assistant_id/subgraphs/:namespace?", zValidator("param", z
     const assistant = await Assistants.get(assistantId, c.var.auth);
     const config = getRunnableConfig(assistant.config);
     const graph = await getGraph(assistant.graph_id, config);
-    const graphSchema = await getGraphSchema(assistant.graph_id);
-    const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
-    if (!rootGraphId) {
-        throw new HTTPException(404, { message: "Failed to find root graph" });
-    }
     const result = [];
     const subgraphsGenerator = "getSubgraphsAsync" in graph
         ? graph.getSubgraphsAsync.bind(graph)
         : // @ts-expect-error older versions of langgraph don't have getSubgraphsAsync
             graph.getSubgraphs.bind(graph);
-    for await (const [ns] of subgraphsGenerator(namespace, recurse)) {
-        result.push([
-            ns,
-            graphSchema[`${rootGraphId}|${ns}`] || graphSchema[rootGraphId],
-        ]);
+    let graphSchemaPromise;
+    for await (const [ns, subgraph] of subgraphsGenerator(namespace, recurse)) {
+        const schema = await (async () => {
+            const runtimeSchema = await getRuntimeGraphSchema(subgraph);
+            if (runtimeSchema)
+                return runtimeSchema;
+            graphSchemaPromise ??= getCachedStaticGraphSchema(assistant.graph_id);
+            const graphSchema = await graphSchemaPromise;
+            const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
+            if (!rootGraphId) {
+                throw new HTTPException(404, {
+                    message: "Failed to find root graph",
+                });
+            }
+            return graphSchema[`${rootGraphId}|${ns}`] || graphSchema[rootGraphId];
+        })();
+        result.push([ns, schema]);
     }
     return c.json(Object.fromEntries(result));
 });

package/dist/api/meta.d.mts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/api/runs.d.mts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/api/store.d.mts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/api/threads.d.mts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/auth/custom.d.mts

@@ -0,0 +1,12 @@
+import type { AuthEventValueMap } from "@langchain/langgraph-sdk/auth";
+import type { MiddlewareHandler } from "hono";
+import { type AuthContext, type AuthFilters } from "./index.mjs";
+declare module "hono" {
+    interface ContextVariableMap {
+        auth?: AuthContext | undefined;
+    }
+}
+export declare function isAuthMatching(metadata: Record<string, unknown> | undefined, filters: AuthFilters): boolean;
+export declare const handleAuthEvent: <T extends keyof AuthEventValueMap>(context: AuthContext | undefined, event: T, value: AuthEventValueMap[T]) => Promise<[AuthFilters | undefined, value: AuthEventValueMap[T]]>;
+export declare const auth: () => MiddlewareHandler;
+export { registerAuth } from "./index.mjs";

package/dist/auth/index.d.mts

@@ -31,7 +31,7 @@ export declare function authenticate(request: Request): Promise<{
         display_name: string;
         identity: string;
     };
-}>;
+} | undefined>;
 export declare function registerAuth(auth: {
     path?: string;
     disable_studio_auth?: boolean;

package/dist/cli/entrypoint.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/cli/utils/ipc/client.d.mts

@@ -0,0 +1,5 @@
+export type SendToParent = (data: Record<string, unknown>) => void;
+export type Parent = {
+    send: SendToParent | undefined;
+};
+export declare const connectToServer: (processId?: number) => Promise<SendToParent | undefined>;

package/dist/cli/utils/ipc/utils/get-pipe-path.d.mts

@@ -0,0 +1 @@
+export declare const getPipePath: (processId: number) => string;

package/dist/cli/utils/ipc/utils/temporary-directory.d.mts

@@ -0,0 +1,5 @@
+/**
+ * This ensures that the cache directory is unique per user
+ * and has the appropriate permissions
+ */
+export declare const tmpdir: string;

package/dist/command.d.mts

@@ -0,0 +1,11 @@
+import { Command } from "@langchain/langgraph";
+export interface RunSend {
+    node: string;
+    input?: unknown;
+}
+export interface RunCommand {
+    goto?: string | RunSend | Array<RunSend | string>;
+    update?: Record<string, unknown> | [string, unknown][];
+    resume?: unknown;
+}
+export declare const getLangGraphCommand: (command: RunCommand) => Command<unknown>;

package/dist/graph/load.d.mts

@@ -0,0 +1,16 @@
+import type { BaseCheckpointSaver, BaseStore, CompiledGraph, LangGraphRunnableConfig } from "@langchain/langgraph";
+import { type CompiledGraphFactory } from "./load.utils.mjs";
+import type { GraphSchema, GraphSpec } from "./parser/index.mjs";
+export declare const GRAPHS: Record<string, CompiledGraph<string> | CompiledGraphFactory<string>>;
+export declare const GRAPH_SPEC: Record<string, GraphSpec>;
+export declare const GRAPH_SCHEMA: Record<string, Record<string, GraphSchema>>;
+export declare const NAMESPACE_GRAPH: Uint8Array;
+export declare const getAssistantId: (graphId: string) => string;
+export declare function registerFromEnv(specs: Record<string, string>, options: {
+    cwd: string;
+}): Promise<(CompiledGraph<string, any, any, Record<string, any>, any, any> | CompiledGraphFactory<string>)[]>;
+export declare function getGraph(graphId: string, config: LangGraphRunnableConfig | undefined, options?: {
+    checkpointer?: BaseCheckpointSaver | null;
+    store?: BaseStore;
+}): Promise<CompiledGraph<string, any, any, Record<string, any>, any, any>>;
+export declare function getCachedStaticGraphSchema(graphId: string): Promise<Record<string, GraphSchema>>;

package/dist/graph/load.hooks.d.mts

@@ -0,0 +1,2 @@
+export function initialize(args: any): Promise<void>;
+export function resolve(specifier: any, context: any, nextResolve: any): Promise<any>;

package/dist/graph/load.mjs

@@ -2,7 +2,8 @@ import { z } from "zod";
 import * as uuid from "uuid";
 import { Assistants } from "../storage/ops.mjs";
 import { HTTPException } from "hono/http-exception";
-import { resolveGraph, runGraphSchemaWorker, } from "./load.utils.mjs";
+import { resolveGraph } from "./load.utils.mjs";
+import { getStaticGraphSchema } from "./parser/index.mjs";
 import { checkpointer } from "../storage/checkpoint.mjs";
 import { store } from "../storage/store.mjs";
 import { logger } from "../logging.mjs";
@@ -56,14 +57,26 @@ export async function getGraph(graphId, config, options) {
     compiled.store = options?.store ?? store;
     return compiled;
 }
-export async function getGraphSchema(graphId) {
+export async function getCachedStaticGraphSchema(graphId) {
     if (!GRAPH_SPEC[graphId])
         throw new HTTPException(404, {
             message: `Spec for "${graphId}" not found`,
         });
-    if (!GRAPH_SCHEMA[graphId] || true) {
+    if (!GRAPH_SCHEMA[graphId]) {
+        let timeoutMs = 30_000;
         try {
-            GRAPH_SCHEMA[graphId] = await runGraphSchemaWorker(GRAPH_SPEC[graphId]);
+            const envTimeout = Number.parseInt(process.env.LANGGRAPH_SCHEMA_RESOLVE_TIMEOUT_MS ?? "0", 10);
+            if (!Number.isNaN(envTimeout) && envTimeout > 0) {
+                timeoutMs = envTimeout;
+            }
+        }
+        catch {
+            // ignore
+        }
+        try {
+            GRAPH_SCHEMA[graphId] = await getStaticGraphSchema(GRAPH_SPEC[graphId], {
+                timeoutMs,
+            });
         }
         catch (error) {
             throw new Error(`Failed to extract schema for "${graphId}"`, {

package/dist/graph/load.utils.d.mts

@@ -0,0 +1,22 @@
+import type { CompiledGraph } from "@langchain/langgraph";
+export declare const GRAPHS: Record<string, CompiledGraph<string>>;
+export declare const NAMESPACE_GRAPH: Uint8Array;
+export type CompiledGraphFactory<T extends string> = (config: {
+    configurable?: Record<string, unknown>;
+}) => Promise<CompiledGraph<T>>;
+export declare function resolveGraph(spec: string, options: {
+    cwd: string;
+    onlyFilePresence?: false;
+}): Promise<{
+    sourceFile: string;
+    exportSymbol: string;
+    resolved: CompiledGraph<string> | CompiledGraphFactory<string>;
+}>;
+export declare function resolveGraph(spec: string, options: {
+    cwd: string;
+    onlyFilePresence: true;
+}): Promise<{
+    sourceFile: string;
+    exportSymbol: string;
+    resolved: undefined;
+}>;

package/dist/graph/load.utils.mjs

@@ -1,8 +1,7 @@
-import { Worker } from "node:worker_threads";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import * as uuid from "uuid";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { pathToFileURL } from "node:url";
 export const GRAPHS = {};
 export const NAMESPACE_GRAPH = uuid.parse("6ba7b821-9dad-11d1-80b4-00c04fd430c8");
 export async function resolveGraph(spec, options) {
@@ -11,7 +10,7 @@ export async function resolveGraph(spec, options) {
     // validate file exists
     await fs.stat(sourceFile);
     if (options?.onlyFilePresence) {
-        return { sourceFile: userFile, exportSymbol, resolved: undefined };
+        return { sourceFile, exportSymbol, resolved: undefined };
     }
     const isGraph = (graph) => {
         if (typeof graph !== "object" || graph == null)
@@ -37,34 +36,3 @@ export async function resolveGraph(spec, options) {
     })();
     return { sourceFile, exportSymbol, resolved };
 }
-export async function runGraphSchemaWorker(spec, options) {
-    let SCHEMA_RESOLVE_TIMEOUT_MS = 30_000;
-    try {
-        const envTimeout = Number.parseInt(process.env.LANGGRAPH_SCHEMA_RESOLVE_TIMEOUT_MS ?? "0", 10);
-        if (!Number.isNaN(envTimeout) && envTimeout > 0) {
-            SCHEMA_RESOLVE_TIMEOUT_MS = envTimeout;
-        }
-    }
-    catch {
-        // ignore
-    }
-    if (options?.mainThread) {
-        const { SubgraphExtractor } = await import("./parser/parser.mjs");
-        return SubgraphExtractor.extractSchemas(spec.sourceFile, spec.exportSymbol, { strict: false });
-    }
-    return await new Promise((resolve, reject) => {
-        const worker = new Worker(fileURLToPath(new URL("./parser/parser.worker.mjs", import.meta.url)), { argv: process.argv.slice(-1) });
-        // Set a timeout to reject if the worker takes too long
-        const timeoutId = setTimeout(() => {
-            worker.terminate();
-            reject(new Error("Schema extract worker timed out"));
-        }, SCHEMA_RESOLVE_TIMEOUT_MS);
-        worker.on("message", (result) => {
-            worker.terminate();
-            clearTimeout(timeoutId);
-            resolve(result);
-        });
-        worker.on("error", reject);
-        worker.postMessage(spec);
-    });
-}

package/dist/graph/parser/index.d.mts

@@ -0,0 +1,17 @@
+import type { JSONSchema7 } from "json-schema";
+import type { Pregel } from "@langchain/langgraph";
+export interface GraphSchema {
+    state: JSONSchema7 | undefined;
+    input: JSONSchema7 | undefined;
+    output: JSONSchema7 | undefined;
+    config: JSONSchema7 | undefined;
+}
+export interface GraphSpec {
+    sourceFile: string;
+    exportSymbol: string;
+}
+export declare function getStaticGraphSchema(spec: GraphSpec, options?: {
+    mainThread?: boolean;
+    timeoutMs?: number;
+}): Promise<Record<string, GraphSchema>>;
+export declare function getRuntimeGraphSchema(graph: Pregel<any, any, any, any, any>): Promise<GraphSchema | undefined>;

package/dist/graph/parser/index.mjs

@@ -0,0 +1,41 @@
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+export async function getStaticGraphSchema(spec, options) {
+    if (options?.mainThread) {
+        const { SubgraphExtractor } = await import("./parser.mjs");
+        return SubgraphExtractor.extractSchemas(spec.sourceFile, spec.exportSymbol, { strict: false });
+    }
+    return await new Promise((resolve, reject) => {
+        const worker = new Worker(fileURLToPath(new URL("./parser.worker.mjs", import.meta.url)), { argv: process.argv.slice(-1) });
+        // Set a timeout to reject if the worker takes too long
+        const timeoutId = setTimeout(() => {
+            worker.terminate();
+            reject(new Error("Schema extract worker timed out"));
+        }, options?.timeoutMs ?? 30000);
+        worker.on("message", (result) => {
+            worker.terminate();
+            clearTimeout(timeoutId);
+            resolve(result);
+        });
+        worker.on("error", reject);
+        worker.postMessage(spec);
+    });
+}
+export async function getRuntimeGraphSchema(graph) {
+    try {
+        const { getInputTypeSchema, getOutputTypeSchema, getUpdateTypeSchema, getConfigTypeSchema, } = await import("@langchain/langgraph/zod/schema");
+        const result = {
+            state: getUpdateTypeSchema(graph),
+            input: getInputTypeSchema(graph),
+            output: getOutputTypeSchema(graph),
+            config: getConfigTypeSchema(graph),
+        };
+        if (Object.values(result).every((i) => i == null))
+            return undefined;
+        return result;
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}

package/dist/graph/parser/parser.d.mts

@@ -0,0 +1,63 @@
+import * as ts from "typescript";
+import type { JSONSchema7 } from "json-schema";
+interface GraphSchema {
+    state: JSONSchema7 | undefined;
+    input: JSONSchema7 | undefined;
+    output: JSONSchema7 | undefined;
+    config: JSONSchema7 | undefined;
+}
+export declare class SubgraphExtractor {
+    protected program: ts.Program;
+    protected checker: ts.TypeChecker;
+    protected sourceFile: ts.SourceFile;
+    protected inferFile: ts.SourceFile;
+    protected anyPregelType: ts.Type;
+    protected anyGraphType: ts.Type;
+    protected strict: boolean;
+    constructor(program: ts.Program, sourceFile: ts.SourceFile, inferFile: ts.SourceFile, options?: {
+        strict?: boolean;
+    });
+    private findTypeByName;
+    private find;
+    protected findSubgraphs: (node: ts.Node, namespace?: string[]) => {
+        node: string;
+        namespace: string[];
+        subgraph: {
+            name: string;
+            node: ts.Node;
+        };
+    }[];
+    protected getSubgraphsVariables: (name: string) => {
+        node: string;
+        namespace: string[];
+        subgraph: {
+            name: string;
+            node: ts.Node;
+        };
+    }[];
+    getAugmentedSourceFile: (name: string) => {
+        files: [filePath: string, contents: string][];
+        exports: {
+            typeName: string;
+            valueName: string;
+            graphName: string;
+        }[];
+    };
+    protected findSubgraphIdentifiers: (acc: {
+        node: ts.Node;
+        name: string;
+    }[], node: ts.Node) => {
+        node: ts.Node;
+        name: string;
+    }[];
+    protected isGraphOrPregelType: (type: ts.Type) => boolean;
+    protected getText(node: ts.Node): string;
+    protected reduceChildren<Acc>(node: ts.Node, fn: (acc: Acc, node: ts.Node) => Acc, initial: Acc): Acc;
+    static extractSchemas(target: string | {
+        contents: string;
+        files?: [fileName: string, contents: string][];
+    }, name: string, options?: {
+        strict?: boolean;
+    }): Record<string, GraphSchema>;
+}
+export {};

package/dist/graph/parser/parser.mjs

@@ -161,7 +161,7 @@ export class SubgraphExtractor {
             this.getText(this.sourceFile),
             ...typeExports.map(({ typeName, valueName }) => `export type ${typeName} = typeof ${valueName}`),
         ].join("\n\n");
-        const inferFilePath = "__langraph__infer.mts";
+        const inferFilePath = "__langgraph__infer.mts";
         const inferContents = [
             ...typeExports.map(({ typeName }) => `import type { ${typeName}} from "./__langgraph__source.mts"`),
             this.inferFile.getText(this.inferFile),
@@ -281,7 +281,7 @@ export class SubgraphExtractor {
             system.writeFile(vfsPath(path.resolve(dirname, name)), source);
         }
         const extract = ts.createProgram({
-            rootNames: [path.resolve(dirname, "./__langraph__infer.mts")],
+            rootNames: [path.resolve(dirname, "./__langgraph__infer.mts")],
             options: compilerOptions,
             host,
         });
@@ -298,9 +298,9 @@ export class SubgraphExtractor {
         return Object.fromEntries(exports.map(({ typeName, graphName }) => [
             graphName,
             {
+                state: trySymbol(schemaGenerator, `${typeName}__update`),
                 input: trySymbol(schemaGenerator, `${typeName}__input`),
                 output: trySymbol(schemaGenerator, `${typeName}__output`),
-                state: trySymbol(schemaGenerator, `${typeName}__update`),
                 config: trySymbol(schemaGenerator, `${typeName}__config`),
             },
         ]));

package/dist/graph/parser/parser.worker.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/graph/parser/schema/types.d.mts

@@ -0,0 +1,154 @@
+import * as ts from "typescript";
+import type { JSONSchema7 } from "json-schema";
+type Args = {
+    ref: boolean;
+    aliasRef: boolean;
+    topRef: boolean;
+    titles: boolean;
+    defaultProps: boolean;
+    noExtraProps: boolean;
+    propOrder: boolean;
+    typeOfKeyword: boolean;
+    required: boolean;
+    strictNullChecks: boolean;
+    esModuleInterop: boolean;
+    experimentalDecorators: boolean;
+    out: string;
+    validationKeywords: string[];
+    include: string[];
+    excludePrivate: boolean;
+    uniqueNames: boolean;
+    rejectDateType: boolean;
+    id: string;
+    defaultNumberType: "number" | "integer";
+    constAsEnum: boolean;
+};
+type PartialArgs = Partial<Args>;
+type RedefinedFields = "items" | "additionalItems" | "contains" | "properties" | "patternProperties" | "additionalProperties" | "dependencies" | "propertyNames" | "if" | "then" | "else" | "allOf" | "anyOf" | "oneOf" | "not" | "definitions";
+type DefinitionOrBoolean = Definition | boolean;
+interface Definition extends Omit<JSONSchema7, RedefinedFields> {
+    propertyOrder?: string[];
+    defaultProperties?: string[];
+    typeof?: "function";
+    items?: DefinitionOrBoolean | DefinitionOrBoolean[];
+    additionalItems?: DefinitionOrBoolean;
+    contains?: JSONSchema7;
+    properties?: {
+        [key: string]: DefinitionOrBoolean;
+    };
+    patternProperties?: {
+        [key: string]: DefinitionOrBoolean;
+    };
+    additionalProperties?: DefinitionOrBoolean;
+    dependencies?: {
+        [key: string]: DefinitionOrBoolean | string[];
+    };
+    propertyNames?: DefinitionOrBoolean;
+    if?: DefinitionOrBoolean;
+    then?: DefinitionOrBoolean;
+    else?: DefinitionOrBoolean;
+    allOf?: DefinitionOrBoolean[];
+    anyOf?: DefinitionOrBoolean[];
+    oneOf?: DefinitionOrBoolean[];
+    not?: DefinitionOrBoolean;
+    definitions?: {
+        [key: string]: DefinitionOrBoolean;
+    };
+}
+type SymbolRef = {
+    name: string;
+    typeName: string;
+    fullyQualifiedName: string;
+    symbol: ts.Symbol;
+};
+declare class JsonSchemaGenerator {
+    private args;
+    private tc;
+    /**
+     * Holds all symbols within a custom SymbolRef object, containing useful
+     * information.
+     */
+    private symbols;
+    /**
+     * All types for declarations of classes, interfaces, enums, and type aliases
+     * defined in all TS files.
+     */
+    private allSymbols;
+    /**
+     * All symbols for declarations of classes, interfaces, enums, and type aliases
+     * defined in non-default-lib TS files.
+     */
+    private userSymbols;
+    /**
+     * Maps from the names of base types to the names of the types that inherit from
+     * them.
+     */
+    private inheritingTypes;
+    /**
+     * This map holds references to all reffed definitions, including schema
+     * overrides and generated definitions.
+     */
+    private reffedDefinitions;
+    /**
+     * This map only holds explicit schema overrides. This helps differentiate between
+     * user defined schema overrides and generated definitions.
+     */
+    private schemaOverrides;
+    /**
+     * This is a set of all the user-defined validation keywords.
+     */
+    private userValidationKeywords;
+    /**
+     * If true, this makes constants be defined as enums with a single value. This is useful
+     * for cases where constant values are not supported, such as OpenAPI.
+     */
+    private constAsEnum;
+    /**
+     * Types are assigned names which are looked up by their IDs.  This is the
+     * map from type IDs to type names.
+     */
+    private typeNamesById;
+    /**
+     * Whenever a type is assigned its name, its entry in this dictionary is set,
+     * so that we don't give the same name to two separate types.
+     */
+    private typeIdsByName;
+    constructor(symbols: SymbolRef[], allSymbols: {
+        [name: string]: ts.Type;
+    }, userSymbols: {
+        [name: string]: ts.Symbol;
+    }, inheritingTypes: {
+        [baseName: string]: string[];
+    }, tc: ts.TypeChecker, args?: Args);
+    get ReffedDefinitions(): {
+        [key: string]: Definition;
+    };
+    private isFromDefaultLib;
+    private resetSchemaSpecificProperties;
+    /**
+     * Parse the comments of a symbol into the definition and other annotations.
+     */
+    private parseCommentsIntoDefinition;
+    private getDefinitionForRootType;
+    private getReferencedTypeSymbol;
+    private getDefinitionForProperty;
+    private getEnumDefinition;
+    private getUnionDefinition;
+    private getIntersectionDefinition;
+    private getClassDefinition;
+    /**
+     * Gets/generates a globally unique type name for the given type
+     */
+    private getTypeName;
+    private makeTypeNameUnique;
+    private recursiveTypeRef;
+    private getTypeDefinition;
+    setSchemaOverride(symbolName: string, schema: Definition): void;
+    getSchemaForSymbol(symbolName: string, includeReffedDefinitions?: boolean, includeAllOverrides?: boolean): Definition;
+    getSchemaForSymbols(symbolNames: string[], includeReffedDefinitions?: boolean, includeAllOverrides?: boolean): Definition;
+    getSymbols(name?: string): SymbolRef[];
+    getUserSymbols(): string[];
+    getMainFileSymbols(program: ts.Program, onlyIncludeFiles?: string[]): string[];
+}
+export declare function buildGenerator(program: ts.Program, args?: PartialArgs): JsonSchemaGenerator | null;
+export {};