@player-lang/functional-dsl-generator 0.0.2-next.0

package/types/builder-class-generator.d.ts

@@ -0,0 +1,56 @@
+import type { ObjectType } from "@xlr-lib/xlr";
+import { type TypeRegistry } from "./utils";
+import type { TypeTransformer } from "./type-transformer";
+/**
+ * Information about a builder class to generate.
+ */
+export interface BuilderInfo {
+    /** Original type name from XLR */
+    name: string;
+    /** Generated class name (e.g., "TextAssetBuilder") */
+    className: string;
+    /** Factory function name (e.g., "text") */
+    factoryName: string;
+    /** The XLR ObjectType being generated */
+    objectType: ObjectType;
+    /** Asset type string if this is an Asset (e.g., "text") */
+    assetType?: string;
+    /** Generic parameters declaration if type is generic */
+    genericParams?: string;
+    /** Whether this type extends Asset */
+    isAsset: boolean;
+}
+/**
+ * Generates builder class code from BuilderInfo.
+ */
+export declare class BuilderClassGenerator {
+    private readonly typeTransformer;
+    private readonly defaultValueGenerator;
+    private readonly typeRegistry;
+    /** Track array properties for __arrayProperties__ */
+    private arrayProperties;
+    /** Track asset wrapper paths for __assetWrapperPaths__ */
+    private assetWrapperPaths;
+    constructor(typeTransformer: TypeTransformer, typeRegistry?: TypeRegistry);
+    /**
+     * Generate the builder class code.
+     */
+    generateBuilderClass(info: BuilderInfo): string;
+    /**
+     * Generate interface methods for the builder.
+     */
+    private generateInterfaceMethods;
+    /**
+     * Collect properties that need methods generated.
+     */
+    private collectPropertiesForMethods;
+    /**
+     * Generate class methods for the builder.
+     */
+    private generateClassMethods;
+    /**
+     * Generate default values object using DefaultValueGenerator.
+     */
+    private generateDefaults;
+}
+//# sourceMappingURL=builder-class-generator.d.ts.map

package/types/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for functional-generator
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/types/default-value-generator.d.ts

@@ -0,0 +1,74 @@
+import type { ObjectType } from "@xlr-lib/xlr";
+/**
+ * Configuration for default value generation
+ */
+export interface DefaultValueConfig {
+    /**
+     * Maximum depth for recursive object defaults.
+     * Prevents infinite recursion for deeply nested or circular types.
+     *
+     * The depth counter starts at 0 for the root object and increments
+     * for each nested object level. When depth equals maxDepth, nested
+     * objects are returned as empty `{}` instead of recursing further.
+     *
+     * Example with maxDepth=3:
+     * - Root object (depth 0): full defaults generated
+     * - level1.nested (depth 1): full defaults generated
+     * - level1.nested.child (depth 2): full defaults generated
+     * - level1.nested.child.deep (depth 3): returns {} (depth limit reached)
+     *
+     * Default: 3
+     */
+    maxDepth?: number;
+    /**
+     * Type names to skip (user must provide these values).
+     * Typically includes "Asset" and "AssetWrapper".
+     */
+    skipTypes?: Set<string>;
+}
+/**
+ * Generates smart default values for builder classes.
+ *
+ * This generator creates sensible defaults for required fields:
+ * - String → ""
+ * - Number → 0
+ * - Boolean → false
+ * - Array → []
+ * - Object → {} or recursive defaults for required properties
+ * - Expression/Binding → ""
+ * - Union types → uses the first non-null/undefined variant
+ * - AssetWrapper → SKIPPED (user must provide)
+ */
+export declare class DefaultValueGenerator {
+    private readonly config;
+    constructor(config?: DefaultValueConfig);
+    /**
+     * Generate default values for an ObjectType.
+     *
+     * @param objectType - The XLR ObjectType to generate defaults for
+     * @param assetType - Optional asset type string for Asset types
+     * @returns Record of property names to default values
+     */
+    generateDefaults(objectType: ObjectType, assetType?: string): Record<string, unknown>;
+    /**
+     * Get the default value for a specific type node.
+     *
+     * @param node - The type node
+     * @param context - Generation context for tracking depth
+     * @returns The default value, or undefined if the type should be skipped
+     */
+    private getDefaultForType;
+    /**
+     * Get default for a union type by picking the first non-null/undefined variant.
+     */
+    private getDefaultForUnion;
+    /**
+     * Get default for an intersection type by attempting to merge.
+     */
+    private getDefaultForIntersection;
+    /**
+     * Get default for an object type by processing required properties.
+     */
+    private getDefaultForObject;
+}
+//# sourceMappingURL=default-value-generator.d.ts.map

package/types/generator.d.ts

@@ -0,0 +1,102 @@
+import type { ObjectType, NamedType } from "@xlr-lib/xlr";
+import { type TypeRegistry } from "./utils";
+import { type TypeScriptContext, type UnexportedTypeInfo } from "./type-resolver";
+export type { TypeScriptContext, UnexportedTypeInfo } from "./type-resolver";
+export type { BuilderInfo } from "./builder-class-generator";
+/**
+ * Configuration for the generator
+ */
+export interface GeneratorConfig {
+    /** Import path for functional utilities (default: "@player-lang/functional-dsl") */
+    functionalImportPath?: string;
+    /** Import path for player-ui types (default: "@player-ui/types") */
+    typesImportPath?: string;
+    /**
+     * TypeScript context for automatic import resolution.
+     * When provided, the generator will automatically resolve import paths
+     * using TypeScript's module resolution.
+     */
+    tsContext?: TypeScriptContext;
+    /** Function to generate the type import path for a given type name */
+    typeImportPathGenerator?: (typeName: string) => string;
+    /**
+     * Set of type names that are defined in the same source file as the main type.
+     * Types not in this set will be imported from their own source files using typeImportPathGenerator.
+     * When tsContext is provided, this is computed automatically from the source file.
+     */
+    sameFileTypes?: Set<string>;
+    /**
+     * Explicitly maps type names to their package names for external imports.
+     * Types in this map will be imported from the specified package (e.g., "@player-lang/types").
+     * This takes precedence over typeImportPathGenerator for the specified types.
+     */
+    externalTypes?: Map<string, string>;
+    /**
+     * Type registry for resolving nested interface references.
+     * Maps type names to their XLR ObjectType definitions.
+     * Used to find AssetWrapper paths in nested interfaces.
+     */
+    typeRegistry?: TypeRegistry;
+}
+/**
+ * Result of builder generation including warnings
+ */
+export interface GeneratorResult {
+    /** Generated TypeScript code */
+    code: string;
+    /** Types that need to be exported in their source files */
+    unexportedTypes: UnexportedTypeInfo[];
+}
+/**
+ * Generates functional builder TypeScript code from XLR types.
+ * This class orchestrates the type collection, transformation, and code generation.
+ */
+export declare class FunctionalBuilderGenerator {
+    private readonly namedType;
+    private readonly config;
+    /** Import generator handles import tracking and generation */
+    private readonly importGenerator;
+    /** Type transformer handles XLR to TypeScript type conversion */
+    private readonly typeTransformer;
+    /** Type collector handles collecting type references */
+    private readonly typeCollector;
+    /** Builder class generator handles class code generation */
+    private readonly builderClassGenerator;
+    /** Map short type names to their full qualified names */
+    private readonly namespaceMemberMap;
+    constructor(namedType: NamedType<ObjectType>, config?: GeneratorConfig);
+    /**
+     * Get list of types that exist but need to be exported.
+     * Call this after generate() to get warnings for the user.
+     */
+    getUnexportedTypes(): UnexportedTypeInfo[];
+    /**
+     * Get list of types that couldn't be resolved at all.
+     * These types are used in the generated code but won't be imported,
+     * causing type errors. Often these are namespaced types (e.g., Validation.CrossfieldReference).
+     */
+    getUnresolvedTypes(): string[];
+    /**
+     * Generate the builder code
+     */
+    generate(): string;
+    private createBuilderInfo;
+}
+/**
+ * Generate functional builder code from a NamedType<ObjectType>
+ * @param namedType - The XLR NamedType to generate a builder for
+ * @param config - Optional generator configuration
+ * @returns Generated TypeScript code for the functional builder
+ */
+export declare function generateFunctionalBuilder(namedType: NamedType<ObjectType>, config?: GeneratorConfig): string;
+/**
+ * Generate functional builder code with warnings about unexported types.
+ * Use this when you want to get detailed information about types that need
+ * to be exported in their source files.
+ *
+ * @param namedType - The XLR NamedType to generate a builder for
+ * @param config - Optional generator configuration
+ * @returns Generated code and list of types that need to be exported
+ */
+export declare function generateFunctionalBuilderWithWarnings(namedType: NamedType<ObjectType>, config?: GeneratorConfig): GeneratorResult;
+//# sourceMappingURL=generator.d.ts.map

package/types/import-generator.d.ts

@@ -0,0 +1,77 @@
+import type { RefType } from "@xlr-lib/xlr";
+import type { TypeScriptContext, UnexportedTypeInfo } from "./type-resolver";
+import { type TypeRegistry } from "./utils";
+import type { TypeTracker } from "./type-collector";
+import type { TypeTransformContext } from "./type-transformer";
+/**
+ * Configuration for import generation.
+ */
+export interface ImportGeneratorConfig {
+    /** Import path for functional utilities (default: "@player-lang/functional-dsl") */
+    functionalImportPath?: string;
+    /** Import path for player-ui types (default: "@player-ui/types") */
+    typesImportPath?: string;
+    /** TypeScript context for automatic import resolution */
+    tsContext?: TypeScriptContext;
+    /** Function to generate the type import path for a given type name */
+    typeImportPathGenerator?: (typeName: string) => string;
+    /** Types defined in the same source file as the main type */
+    sameFileTypes?: Set<string>;
+    /** External type mappings (type name -> package name) */
+    externalTypes?: Map<string, string>;
+    /** Type registry for resolving types that extend AssetWrapper */
+    typeRegistry?: TypeRegistry;
+}
+/**
+ * Generates import statements and tracks type references.
+ * Implements both TypeTracker and TypeTransformContext interfaces.
+ */
+export declare class ImportGenerator implements TypeTracker, TypeTransformContext {
+    private readonly config;
+    /** Track all type references that need to be imported, grouped by source file */
+    private referencedTypesBySource;
+    /** Track types that should be imported from the main type's source file */
+    private referencedTypes;
+    /** Track whether Asset type is needed for imports */
+    private needsAssetImport;
+    /** Track generic parameter symbols (e.g., T, U) that should not be imported */
+    private genericParamSymbols;
+    /** TypeScript resolver for automatic import path resolution */
+    private readonly tsResolver?;
+    /** Track types that couldn't be resolved - will cause errors if used */
+    private unresolvedTypes;
+    /** Track namespaces that need to be imported (e.g., "Validation" from @player-ui/types) */
+    private namespaceImports;
+    /** Map short type names to their full qualified names (e.g., "CrossfieldReference" -> "Validation.CrossfieldReference") */
+    private namespaceMemberMap;
+    /** Effective sameFileTypes - computed from tsContext or provided directly */
+    private readonly effectiveSameFileTypes?;
+    constructor(config?: ImportGeneratorConfig);
+    setNeedsAssetImport(value: boolean): void;
+    getNeedsAssetImport(): boolean;
+    getNamespaceMemberMap(): Map<string, string>;
+    getGenericParamSymbols(): Set<string>;
+    getAssetWrapperExtendsRef(typeName: string): RefType | undefined;
+    /**
+     * Get list of types that exist but need to be exported.
+     */
+    getUnexportedTypes(): UnexportedTypeInfo[];
+    /**
+     * Get list of types that couldn't be resolved at all.
+     */
+    getUnresolvedTypes(): string[];
+    /**
+     * Track a referenced type for import generation.
+     */
+    trackReferencedType(typeName: string): void;
+    /**
+     * Track a namespace that needs to be imported.
+     */
+    trackNamespaceImport(namespaceName: string): void;
+    /**
+     * Generate import statements.
+     */
+    generateImports(mainTypeName: string): string;
+    private getTypeFileName;
+}
+//# sourceMappingURL=import-generator.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @player-lang/functional-dsl-generator
+ *
+ * Generates functional builders from XLR types for Player-UI assets.
+ */
+export { generateFunctionalBuilder, generateFunctionalBuilderWithWarnings, type GeneratorConfig, type BuilderInfo, type GeneratorResult, type UnexportedTypeInfo, type TypeScriptContext, } from "./generator";
+export * from "./utils";
+export { TsMorphTypeDefinitionFinder, type UnexportedTypeLocation, } from "./ts-morph-type-finder";
+export { createTypeScriptResolver, isBuiltInDeclarationPath, isDeclarationExported, type TypeResolutionResult, } from "./type-resolver";
+export { isNodeModulesPath, extractPackageNameFromPath, createRelativeImportPath, resolveRelativeImportPath, } from "./path-utils";
+export { categorizeTypes, groupExternalTypesByPackage, type TypeCategories, type CategorizerOptions, } from "./type-categorizer";
+//# sourceMappingURL=index.d.ts.map

package/types/path-utils.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Determines if a file path appears to be from a package (node_modules or pnpm store).
+ *
+ * @param filePath - The file path to analyze
+ * @returns True if the path looks like it belongs to a package
+ *
+ * @example
+ * ```ts
+ * isNodeModulesPath('/project/node_modules/react/index.d.ts') // true
+ * isNodeModulesPath('/project/src/components/Button.ts') // false
+ * isNodeModulesPath('/project/node_modules/.pnpm/react@18.0.0/...') // true
+ * ```
+ */
+export declare function isNodeModulesPath(filePath: string): boolean;
+/**
+ * Extracts the package name from a node_modules path.
+ * Handles npm, pnpm store, scoped packages, and various structures.
+ *
+ * @param filePath - The file path to extract package name from
+ * @returns The package name (e.g., 'lodash', '@player-lang/types') or null
+ *
+ * @example
+ * ```ts
+ * // Standard npm package
+ * extractPackageNameFromPath('/project/node_modules/lodash/index.d.ts')
+ * // Returns: 'lodash'
+ *
+ * // Scoped package
+ * extractPackageNameFromPath('/project/node_modules/@player-lang/types/index.d.ts')
+ * // Returns: '@player-lang/types'
+ *
+ * // pnpm store
+ * extractPackageNameFromPath('/project/node_modules/.pnpm/@player-lang+types@1.0.0/node_modules/@player-lang/types/index.d.ts')
+ * // Returns: '@player-lang/types'
+ * ```
+ */
+export declare function extractPackageNameFromPath(filePath: string): string | null;
+/**
+ * Creates a relative import path from one file to another.
+ * Converts TypeScript extensions to JavaScript for runtime imports.
+ *
+ * @param fromFile - The absolute path of the importing file
+ * @param toFile - The absolute path of the file being imported
+ * @returns Relative import path with .js extension
+ *
+ * @example
+ * ```ts
+ * createRelativeImportPath('/project/src/types/foo.ts', '/project/src/types/bar.ts')
+ * // Returns: './bar.js'
+ *
+ * createRelativeImportPath('/project/src/builders/foo.ts', '/project/src/types/bar.ts')
+ * // Returns: '../types/bar.js'
+ * ```
+ */
+export declare function createRelativeImportPath(fromFile: string, toFile: string): string;
+/**
+ * Resolves a relative import path to an absolute file path.
+ * Handles .js to .ts conversion for TypeScript resolution.
+ *
+ * @param fromFile - The absolute path of the file containing the import
+ * @param importSpecifier - The import specifier (e.g., './types', '../utils.js')
+ * @returns Absolute path with .ts extension
+ */
+export declare function resolveRelativeImportPath(fromFile: string, importSpecifier: string): string;
+//# sourceMappingURL=path-utils.d.ts.map

package/types/ts-morph-type-finder.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Information about an unexported type that was found
+ */
+export interface UnexportedTypeLocation {
+    /** The name of the type */
+    typeName: string;
+    /** The file where the type is declared (but not exported) */
+    filePath: string;
+}
+/**
+ * Finds type definitions by searching through TypeScript source files using ts-morph.
+ * Handles interfaces, type aliases, classes, and re-exported types.
+ * Supports both local files and types from node_modules.
+ *
+ * Note: This is the ts-morph based implementation. For the TypeScript API based
+ * implementation, see TypeScriptTypeDefinitionFinder in type-resolver.ts.
+ */
+export declare class TsMorphTypeDefinitionFinder {
+    private project;
+    private readonly typeLocationCache;
+    private readonly unexportedTypes;
+    /**
+     * Finds the source file for a type by searching the codebase.
+     * Recursively follows imports to find where a type is actually defined.
+     * Supports both relative imports and node_modules packages.
+     *
+     * @param typeName - The name of the type to find
+     * @param startingFile - The file to start searching from
+     * @returns The path to the file containing the type definition, or null if not found
+     */
+    findTypeSourceFile(typeName: string, startingFile: string): string | null;
+    /**
+     * Recursively searches for a type definition through imports.
+     * Handles both relative imports and node_modules packages.
+     */
+    private searchForType;
+    /**
+     * Checks if an import declaration imports a specific type.
+     * Handles named imports, default imports, and namespace imports.
+     */
+    private getImportedTypeFromDeclaration;
+    /**
+     * Checks if a source file defines and exports a specific type.
+     * Handles interfaces, type aliases, classes, and re-exported types.
+     * Only returns true if the type is publicly exported.
+     */
+    private fileDefinesType;
+    /**
+     * Resolves a relative import path to an actual file path.
+     * Handles TypeScript extensions and index files.
+     */
+    private resolveImportPath;
+    /**
+     * Get all types that were found to exist but are not exported.
+     * Call this after searching to get the list of types that need to be exported.
+     */
+    getUnexportedTypes(): UnexportedTypeLocation[];
+    /**
+     * Check if a file declares a type (regardless of export status).
+     * Used internally to track unexported types.
+     */
+    private fileHasTypeDeclaration;
+    /**
+     * Track an unexported type for later reporting.
+     */
+    private trackUnexportedType;
+    /**
+     * Disposes of internal resources and clears caches.
+     * Should be called when the finder is no longer needed.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=ts-morph-type-finder.d.ts.map

package/types/type-categorizer.d.ts

@@ -0,0 +1,46 @@
+import { TsMorphTypeDefinitionFinder } from "./ts-morph-type-finder";
+/**
+ * Categorized types for import generation.
+ * Types are split into three categories based on where they should be imported from.
+ */
+export interface TypeCategories {
+    /** Types defined in the same file as the main type (import from main source) */
+    localTypes: Set<string>;
+    /** Types from other local files, grouped by relative import path */
+    relativeImports: Map<string, Set<string>>;
+    /** Types from external packages (node_modules), mapped to package name */
+    externalTypes: Map<string, string>;
+}
+/**
+ * Options for type categorization.
+ */
+export interface CategorizerOptions {
+    /** The main source file being generated */
+    mainSourceFile: string;
+    /** Types known to be in the main source file (optional optimization) */
+    sameFileTypes?: Set<string>;
+}
+/**
+ * Categorizes referenced types into local, relative, and external imports.
+ *
+ * Uses TsMorphTypeDefinitionFinder to resolve where each type is defined, then
+ * categorizes based on the resolved path:
+ * - Same file as main → localTypes
+ * - Different local file → relativeImports
+ * - node_modules → externalTypes
+ *
+ * @param referencedTypes - Set of type names that need to be imported
+ * @param finder - TsMorphTypeDefinitionFinder instance for resolving type locations
+ * @param options - Categorization options including main source file
+ * @returns Categorized types for import generation
+ */
+export declare function categorizeTypes(referencedTypes: Set<string>, finder: TsMorphTypeDefinitionFinder, options: CategorizerOptions): TypeCategories;
+/**
+ * Groups external types by their package name for import generation.
+ * This allows generating single imports per package with multiple types.
+ *
+ * @param externalTypes - Map of typeName → packageName
+ * @returns Map of packageName → Set of typeNames
+ */
+export declare function groupExternalTypesByPackage(externalTypes: Map<string, string>): Map<string, Set<string>>;
+//# sourceMappingURL=type-categorizer.d.ts.map

package/types/type-collector.d.ts

@@ -0,0 +1,62 @@
+import type { NodeType, ObjectType, NamedType } from "@xlr-lib/xlr";
+import { type TypeRegistry } from "./utils";
+/**
+ * Interface for tracking type references.
+ * Implemented by the import generator to track types that need to be imported.
+ */
+export interface TypeTracker {
+    trackReferencedType(typeName: string): void;
+    trackNamespaceImport(namespaceName: string): void;
+}
+/**
+ * Collects type references from XLR types for import generation.
+ */
+export declare class TypeCollector {
+    private readonly typeTracker;
+    private readonly genericParamSymbols;
+    private readonly mainTypeName;
+    private readonly namespaceMemberMap;
+    private readonly typeRegistry?;
+    constructor(typeTracker: TypeTracker, genericParamSymbols: Set<string>, mainTypeName: string, namespaceMemberMap: Map<string, string>, typeRegistry?: TypeRegistry);
+    /**
+     * Collect generic parameter symbols (e.g., T, U) from the type definition.
+     * These should not be imported as they are type parameters, not concrete types.
+     *
+     * Also handles the case where a non-generic type extends a generic base without
+     * passing type arguments. In that scenario, XLR copies properties from the base
+     * (including references to the base's generic params like `AnyAsset`) but does
+     * NOT propagate `genericTokens` to the child type. We scan the type registry for
+     * generic parameter symbols that should be excluded from imports.
+     */
+    collectGenericParamSymbols(namedType: NamedType<ObjectType>): void;
+    /**
+     * Collect type references from generic parameter constraints and defaults.
+     * This ensures types used in generics like "T extends Foo = Bar<X>" have
+     * Foo, Bar, and X added to referencedTypes for import generation.
+     */
+    collectTypesFromGenericTokens(namedType: NamedType<ObjectType>): void;
+    /**
+     * Collect all referenced types from an object type for imports.
+     */
+    collectReferencedTypes(objType: ObjectType): void;
+    /**
+     * Collect referenced types from a node type.
+     */
+    collectReferencedTypesFromNode(node: NodeType): void;
+    /**
+     * Recursively collect type references from any NodeType.
+     * This handles refs, arrays, unions, intersections, and objects.
+     */
+    private collectTypeReferencesFromNode;
+    /**
+     * Check if a type name appears to be a generic type parameter of the referenced type.
+     * This detects cases like ref="Bar<AnyAsset>" where "AnyAsset" is Bar's type parameter,
+     * not a concrete type to import.
+     *
+     * @param argName - The name of the type argument being checked
+     * @param parentRef - The parent ref string that contains the generic usage
+     * @returns true if argName appears to be a type parameter in parentRef
+     */
+    private isTypeParamOfRef;
+}
+//# sourceMappingURL=type-collector.d.ts.map

package/types/type-resolver.d.ts

@@ -0,0 +1,49 @@
+import ts from "typescript";
+/**
+ * TypeScript context for automatic import resolution.
+ * When provided, the generator uses TypeScript's module resolution to determine
+ * where types should be imported from.
+ */
+export interface TypeScriptContext {
+    /** The TypeScript program */
+    program: ts.Program;
+    /** The source file containing the type being generated */
+    sourceFile: ts.SourceFile;
+    /** The output directory where generated files will be written */
+    outputDir: string;
+}
+/**
+ * Information about an unexported type that needs to be exported
+ */
+export interface UnexportedTypeInfo {
+    /** The type name that needs to be exported */
+    typeName: string;
+    /** The file path where the type is declared */
+    filePath: string;
+}
+/**
+ * Result from type resolution.
+ * - sameFile: type is defined in the same file as the main type
+ * - notFound: type couldn't be resolved anywhere
+ * - string: import path for the type (package name or relative path)
+ */
+export type TypeResolutionResult = "sameFile" | "notFound" | string;
+/**
+ * Check if a file path is a TypeScript lib/built-in declaration file.
+ * These are files like lib.dom.d.ts that contain built-in type definitions.
+ */
+export declare function isBuiltInDeclarationPath(filePath: string): boolean;
+/**
+ * Check if a declaration node is exported.
+ */
+export declare function isDeclarationExported(node: ts.Declaration, typescript: typeof ts): boolean;
+/**
+ * Creates an import resolver using TypeScript's type checker and
+ * TsMorphTypeDefinitionFinder for tracing types through imports.
+ * This handles cases where types come through extends, Pick, re-exports, etc.
+ */
+export declare function createTypeScriptResolver(tsContext: TypeScriptContext): {
+    resolveTypePath: (typeName: string) => TypeResolutionResult;
+    getUnexportedTypes: () => UnexportedTypeInfo[];
+};
+//# sourceMappingURL=type-resolver.d.ts.map