@artel/artc 0.6.25191

package/build/types/ts-interop/TsInteropContext.d.ts

@@ -0,0 +1,179 @@
+import ts from 'typescript';
+import { Analyzer } from '../analysis/index.js';
+import { Name, PackageLocale } from '../common/index.js';
+import { EntityHidingLevel, EntityKind, InterfacePackageEntityInfo, TypeEntity, TypeEntityWithMembers } from '../entities/index.js';
+import { PackageEntity, PackageEntityDefinition } from '../entities/PackageEntity.js';
+import { OriginalPackageMembers } from '../entities/PackageMembers.js';
+import * as types from '../types/index.js';
+import { SourcePackageLoadedFromDtsEntity, TsPackageEntity } from './Entities.js';
+import { TsPackageContents } from './TsPackageContents.js';
+import { TsPackageMembersCreationResult } from './TsPackageMembersCreator.js';
+import { TsTypeMembersCreationResult } from './TsTypeMembersCreator.js';
+import { RequiredJsLibraryConfig } from './Utils.js';
+import { Tag } from '../analysis/Tags.js';
+import { JavaScriptImplementationConfig, PackageName, PlatformKind, ProgramPackage } from '../project/index.js';
+export declare class TsInteropContext {
+    readonly analyzer: Analyzer;
+    readonly tsProgramState: TsProgramState;
+    readonly type: TypeContext;
+    readonly packageForSymbolsWithUnknownOrigin: TsPackageEntityForSymbolsWithUnknownOrigin;
+    private readonly _config;
+    private readonly _packagesCreationResult;
+    private readonly _defaultExportTag;
+    get tsProgram(): ts.Program;
+    get tsChecker(): ts.TypeChecker;
+    get packageContentsByEntity(): ReadonlyMap<PackageEntity, TsPackageContents>;
+    constructor(analyzer: Analyzer, config: TsInteropConfig);
+    getPackageEntities(): readonly TsPackageEntity[];
+    getEntityOfSourcePackageLoadedFromDts(sourcePackage: ProgramPackage): SourcePackageLoadedFromDtsEntity | undefined;
+    isSignatureAsync(node: ts.SignatureDeclaration): boolean;
+    getSignatureReturnType(node: ts.SignatureDeclaration, replaceWithPromisedTypeIfPromise: boolean): types.Type;
+    getTypeMemberHiding(node: ts.Declaration | undefined, containingType: TypeEntity): EntityHidingLevel | undefined;
+    onPackageMembersCreated(pkg: PackageEntity, creationResult: TsPackageMembersCreationResult): void;
+    onTypeMembersCreated(type: TypeEntityWithMembers, creationResult: TsTypeMembersCreationResult): void;
+    ifTypeCanBeExpressedByMethodTypeThenCallSignature(symbol: ts.Symbol): ts.Symbol | undefined;
+    getName(original: string, ownerKind: 'type' | 'variable' | 'method'): Name;
+    createDefaultExportTag(): Tag;
+    private getPackagesCreationResult;
+    private createPackages;
+    private collectSubModulesInFilesRecursively;
+    private collectSubModulesOfModuleRecursively;
+    private collectGlobalLibraryFiles;
+    private collectReferencedFilePathsRecursively;
+}
+export declare class TsInteropConfig {
+    readonly programState: TsProgramState;
+    readonly implementationByConfig: ReadonlyMap<RequiredJsLibraryConfig, ResolvedJavaScriptImplementation>;
+    readonly namespacesOrSubModulesByOwningImplementation: ReadonlyMap<ResolvedJavaScriptImplementation, readonly NamespaceOrSubmodulePackageInfo[]>;
+    constructor(programState: TsProgramState, implementationByConfig: ReadonlyMap<RequiredJsLibraryConfig, ResolvedJavaScriptImplementation>, namespacesOrSubModulesByOwningImplementation: ReadonlyMap<ResolvedJavaScriptImplementation, readonly NamespaceOrSubmodulePackageInfo[]>);
+}
+export interface NamespaceOrSubmodulePackageInfo {
+    implementationConfig: JavaScriptImplementationConfig.NamespaceOfSubModule;
+    requiredLibraryConfig: RequiredJsLibraryConfig;
+}
+export type ResolvedJavaScriptImplementation = ResolvedJavaScriptImplementation.Globals | ResolvedJavaScriptImplementation.Module;
+export declare namespace ResolvedJavaScriptImplementation {
+    class Globals {
+        readonly rootFiles: readonly ts.SourceFile[];
+        readonly isStandardLibrary: boolean;
+        readonly kind = "globals";
+        constructor(rootFiles: readonly ts.SourceFile[], isStandardLibrary: boolean);
+    }
+    class Module {
+        /**
+         * (moduleSymbol.flags & ts.SymbolFlags.ValueModule) !== 0
+         */
+        readonly moduleSymbol: ts.Symbol;
+        readonly kind = "module";
+        constructor(
+        /**
+         * (moduleSymbol.flags & ts.SymbolFlags.ValueModule) !== 0
+         */
+        moduleSymbol: ts.Symbol);
+    }
+}
+/**
+ * Данный класс написан исходя из того, что сущности для символов типа всегда будут
+ * получаться после того, как были получены сущности, в которых они объявлены.
+ * Например, для класса `class MyClass<T> { }` запрос на получение сущности для параметра типа `T` не будет
+ * предшествовать запросу на получение сущности для класса `MyClass`.
+ *
+ * Такое предположение необходимо, поскольку сущности параметра типа требуют информацию о
+ * сущности, в которой они объявлены (containingEntity), а API компилятора TS не позволяет получить
+ * родительский символ. Поэтому параметры создаются не лениво, а в момент создания содержащий их сущностей.
+ */
+declare class TypeContext {
+    private readonly _tsctx;
+    private readonly _typeEntities;
+    private readonly _packagesWithCreatedMembers;
+    private readonly _esSymbolType;
+    private get checker();
+    private get standardTypes();
+    private get refObjectOrNone();
+    private get esSymbolType();
+    private get analyzer();
+    constructor(tsctx: TsInteropContext);
+    ofTypeNode(node: ts.TypeNode | undefined): types.Type;
+    ofTsType(type: ts.Type, ignoreAlias?: boolean): types.Type;
+    getUnderlyingTypeOfEnum(symbol: ts.Symbol): types.Type;
+    onPackageMembersCreated(_pkg: PackageEntity, creationResult: TsPackageMembersCreationResult): void;
+    onTypeMembersCreated(_type: TypeEntityWithMembers, creationResult: TsTypeMembersCreationResult): void;
+    private ofEnumType;
+    private ofEnumLiteralType;
+    private ofTypeAlias;
+    private ofObjectType;
+    private ofUnionType;
+    private ofTypeParameter;
+    private createTypeArguments;
+    private createTypeFromEntity;
+    /**
+     * @param symbol (symbol.flags & ts.SymbolFlags.Type) !== 0
+     */
+    private getEntityOfTypeSymbol;
+    private isSymbolSourceFileOrModuleChild;
+    /**
+     * Данный метод не нужно вызывать напрямую. Вместо этого необходимо вызвать метод `getEntityOfTypeSymbol`.
+     *
+     * @param symbol Символ, объявленный в корне исходного файла или в модуле.
+     */
+    private getEntityOfGlobalTypeSymbol;
+    private ensurePackageMembersAreCreated;
+    private addEntitiesFromPackageMembersCreationResult;
+    /**
+     * Данный метод не нужно вызывать напрямую. Вместо этого необходимо вызвать метод `getEntityOfTypeSymbol`.
+     *
+     * @param symbol (symbol.flags & ts.SymbolFlags.TypeLiteral) !== 0
+     */
+    private getEntityOfTypeLiteralSymbol;
+    private getContainingPackage;
+    private getContainingGlobalDeclaration;
+}
+export declare class TsUtils {
+    static isClassOrInterfaceType(type: ts.Type): type is ts.InterfaceType;
+    static isObjectType(type: ts.Type): type is ts.ObjectType;
+    static isTypeReference(type: ts.Type): type is ts.TypeReference;
+    static isSourceFileOrModuleDeclaration(node: ts.Node): node is ts.SourceFile | ts.ModuleDeclaration;
+    static isClassOrInterfaceDeclaration(node: ts.Node): node is ts.ClassDeclaration | ts.InterfaceDeclaration;
+    static isInterfaceAndVariableMergeSymbol(symbol: ts.Symbol): boolean;
+    static isNamespaceDeclaration(node: ts.Node): boolean;
+}
+export declare class TsProgramState {
+    readonly program: ts.Program;
+    readonly arraySymbol: ts.Symbol | undefined;
+    readonly readonlyArraySymbol: ts.Symbol | undefined;
+    readonly mapSymbol: ts.Symbol | undefined;
+    readonly readonlyMapSymbol: ts.Symbol | undefined;
+    readonly setSymbol: ts.Symbol | undefined;
+    readonly readonlySetSymbol: ts.Symbol | undefined;
+    readonly esSymbolSymbol: ts.Symbol | undefined;
+    private readonly _referencedFilesByFileWithReference;
+    get referencedFilesByFileWithReference(): ReadonlyMap<ts.Path, readonly TsFileReferenceInfo[]>;
+    constructor(program: ts.Program);
+    private createReferencedFilesByFileWithReference;
+}
+type TsFileReferenceInfo = {
+    path: ts.Path;
+    referenceKind: TsFileReferenceKind;
+};
+type TsFileReferenceKind = 'lib' | 'path-or-type';
+/**
+ * Данный пакет устанавливается в качестве `containingPackage` для сущностей, созданных из символов,
+ * для которых не удалось определить, в каком пакете они находятся.
+ *
+ * Такое может произойти в следующих случаях:
+ * - объявление не экспортируется, но используется в другом экспортируемом объявлении
+ *   (напр. не экспортируемый тип указан как тип параметра экспортируемой  функции.)
+ * - объявление экспортируется, используется в другом экспортируемом объявлении,
+ *   но не содержится в таблице экспорта ни одного загруженного модуля TS
+ */
+declare class TsPackageEntityForSymbolsWithUnknownOrigin implements PackageEntity {
+    readonly kind = EntityKind.Package;
+    getName(): PackageName;
+    getLocale(): PackageLocale;
+    getMembers(): OriginalPackageMembers;
+    isInterface(): InterfacePackageEntityInfo | undefined;
+    getImplementedInterfacePackage(): PackageEntity | undefined;
+    getSupportedPlatforms(): readonly PlatformKind[];
+    getDefinition(): PackageEntityDefinition;
+}
+export {};

package/build/types/ts-interop/TsLibrariesProvider.d.ts

@@ -0,0 +1,12 @@
+import { Uri } from '../common/index.js';
+export interface TypeScriptLibrariesProvider {
+    /**
+     * Возвращает uri папки, содержащей файлы стандартной библиотеки TypeScript (файл `lib.es2023.d.ts` и др.).
+     * Обычно располагается в папке `node_modules/typescript/lib`.
+     */
+    getStandardLibraryUri(): Uri;
+    readFileSync(uri: Uri): string | undefined;
+    fileExistsSync(uri: Uri): boolean;
+    directoryExistsSync(uri: Uri): boolean;
+    isCaseSensitive(): boolean;
+}

package/build/types/ts-interop/TsPackageContents.d.ts

@@ -0,0 +1,64 @@
+import ts from 'typescript';
+import { OriginalPackageMembers } from '../entities/PackageMembers.js';
+import { PackageEntity } from '../entities/index.js';
+import { ProgramPackage } from '../project/SourcePackage.js';
+import { TsInteropContext } from './TsInteropContext.js';
+import { TsPackageMembersCreationResult } from './TsPackageMembersCreator.js';
+export declare class TsPackageContents {
+    private readonly _tsctx;
+    private readonly _symbols;
+    private readonly _packageEntity;
+    private readonly _sourcePackageToMergeWith;
+    readonly kind = "module";
+    private readonly _membersCreationResult;
+    private readonly _tsSymbols;
+    constructor(_tsctx: TsInteropContext, _symbols: TsPackageSymbols, _packageEntity: PackageEntity, _sourcePackageToMergeWith: ProgramPackage | undefined);
+    getMembers(): OriginalPackageMembers;
+    containsGlobalSymbol(symbol: ts.Symbol): boolean;
+    getMembersCreationResult(): TsPackageMembersCreationResult;
+}
+export type TsPackageSymbols = TsPackageSymbols.Module | TsPackageSymbols.GlobalLibrary;
+export declare namespace TsPackageSymbols {
+    /**
+     * Модулем является исходный файл, содержащий директивы экспорта, или объявление модуля (declare module 'module-name').
+     * https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html#modular-libraries
+     */
+    export class Module implements ITsPackageSymbols {
+        private readonly _tsctx;
+        /**
+         * (symbol.flags & ts.SymbolFlags.ValueModule) !== 0
+         */
+        private readonly _symbol;
+        readonly kind = "module";
+        private readonly _items;
+        constructor(_tsctx: TsInteropContext, 
+        /**
+         * (symbol.flags & ts.SymbolFlags.ValueModule) !== 0
+         */
+        _symbol: ts.Symbol);
+        getItems(): readonly SymbolFromTs[];
+    }
+    /**
+     * Библиотека, представленная одним или несколькими исходными файлами, содержащими объявления, доступные в глобальной
+     * области видимости. В TS такие библиотеки не нужно подключать с помощью директивы импорта.
+     * Все стандартные библиотеки TS (ES, DOM и др.) представлены такими библиотеками.
+     * https://www.typescriptlang.org/docs/handbook/declaration-files/library-structures.html#global-libraries
+     */
+    export class GlobalLibrary implements ITsPackageSymbols {
+        private readonly _tsctx;
+        private readonly _sourceFiles;
+        readonly kind = "global-library";
+        private readonly _items;
+        constructor(_tsctx: TsInteropContext, _sourceFiles: readonly ts.SourceFile[]);
+        getItems(): readonly SymbolFromTs[];
+    }
+    interface ITsPackageSymbols {
+        getItems(): readonly SymbolFromTs[];
+    }
+    export {};
+}
+export declare class SymbolFromTs {
+    readonly value: ts.Symbol;
+    readonly isDefaultExport: boolean;
+    constructor(value: ts.Symbol, isDefaultExport: boolean);
+}

package/build/types/ts-interop/TsPackageMembersCreator.d.ts

@@ -0,0 +1,69 @@
+import ts from 'typescript';
+import { OriginalPackageMembers } from '../entities/PackageMembers.js';
+import { PackageEntity, PackageMemberEntity, TypeEntity } from '../entities/index.js';
+import { SourcePackage } from '../project/index.js';
+import * as tree from '../tree/index.js';
+import { TsInteropContext } from './TsInteropContext.js';
+import { SymbolFromTs } from './TsPackageContents.js';
+export declare class TsPackageMembersCreator {
+    private readonly _tsctx;
+    private readonly _symbols;
+    private readonly _packageEntity;
+    private readonly _sourcePackageToMergeWith;
+    private readonly _forceMembersAreHiddenInPackage;
+    private readonly _typeEntityBySymbol;
+    private readonly _owningNamedSymbolByTypeLiteralSymbol;
+    private readonly _namedDeclarationsByName;
+    private readonly _packageMemberEntityByNode;
+    constructor(_tsctx: TsInteropContext, _symbols: Iterable<SymbolFromTs>, _packageEntity: PackageEntity, _sourcePackageToMergeWith: SourcePackage | undefined, _forceMembersAreHiddenInPackage?: boolean);
+    create(): TsPackageMembersCreationResult;
+    private createAndRegisterPackageMemberEntity;
+    /**
+     * @param symbol (symbol.flags & (ts.SymbolFlags.Interface | ts.SymbolFlags.Class)) !== 0
+     */
+    private createClassOrInterface;
+    private createNamedFunctionTypeEntity;
+    private createGlobalClassOrInterfaceEntity;
+    /**
+     * Тип переменной может содержать объявления сигнатур конструктора, которые содержат параметры типа.
+     * Такие параметры типа заменяются на параметры типа соответствующего интерфейса.
+     *
+     * @example
+     * interface MyType<T1> {}
+     * var MyType: { new<T2>(): MyType }
+     *
+     * Параметр типа T2 будет заменён на Т1.
+     */
+    private registerTypeParametersOfSymbolWithImplicitStaticMembersConstructors;
+    /**
+     * @param symbol (symbol.flags & ts.SymbolFlags.TypeAlias) !== 0
+     */
+    private createTypeAlias;
+    private createNamedTypeLiteralEntity;
+    private createTypeAliasEntity;
+    /**
+     * @param symbol (symbol.flags & ts.SymbolFlags.Enum) !== 0
+     */
+    private createEnumEntity;
+    /**
+     * @param symbol (symbol.flags & ts.SymbolFlags.Variable) !== 0
+     */
+    private createVariableEntity;
+    /**
+     * @param symbol (symbol.flags & ts.SymbolFlags.Function) !== 0
+     */
+    private createFunctionEntities;
+    private createFunctionEntityNoReplacement;
+    private registerTypeParameters;
+    private getTypeDeclarationsToMergeWith;
+    private convertPackageMemberEntityToPackageMember;
+    private createReplacementSourceEntities;
+    private getSourceEntity;
+}
+export type NamedPackageMemberDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageMethodDeclaration | tree.PackageMethodTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariableDeclaration | tree.PackageVariableGetterDeclaration | tree.PackageVariableSetterDeclaration | tree.PackageVariantTypeDeclaration;
+export declare class TsPackageMembersCreationResult {
+    readonly members: OriginalPackageMembers;
+    readonly typeEntityBySymbol: ReadonlyMap<ts.Symbol, TypeEntity>;
+    readonly packageMemberEntityByNode: ReadonlyMap<tree.Node, PackageMemberEntity>;
+    constructor(members: OriginalPackageMembers, typeEntityBySymbol: ReadonlyMap<ts.Symbol, TypeEntity>, packageMemberEntityByNode: ReadonlyMap<tree.Node, PackageMemberEntity>);
+}

package/build/types/ts-interop/TsProgramLoader.d.ts

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+import { Uri } from '../common/index.js';
+import { TypeScriptLibrariesProvider } from './TsLibrariesProvider.js';
+export declare class TsProgramLoader {
+    private readonly _librariesProvider;
+    private readonly _rootDirectoryUri;
+    private readonly _standardLibraryFileNames;
+    private readonly _npmPackageNames;
+    private readonly _moduleNames;
+    private readonly _oldProgram?;
+    constructor(_librariesProvider: TypeScriptLibrariesProvider, _rootDirectoryUri: Uri, _standardLibraryFileNames: readonly string[], _npmPackageNames: readonly string[], _moduleNames: readonly string[], _oldProgram?: ts.Program | undefined);
+    load(): TsProgramLoadResult;
+    private createFileWithLibraryImportsText;
+    private createCompilerHost;
+    private getStandardLibraries;
+    private getUserLibraries;
+}
+export declare enum StandardTsLibraryKind {
+    JavaScript = 0,
+    Browser = 1,
+    WebWorker = 2,
+    ScriptHost = 3
+}
+export declare class TsProgramLoadResult {
+    readonly program: ts.Program;
+    readonly standardLibraryFileByName: ReadonlyMap<string, ts.SourceFile>;
+    readonly rootFileByGlobalLibraryName: ReadonlyMap<string, ts.SourceFile>;
+    readonly moduleSymbolByName: ReadonlyMap<string, ts.Symbol>;
+    readonly unresolvedStandardLibraryFileNames: readonly string[];
+    readonly unresolvedUserLibraryNames: readonly string[];
+    constructor(program: ts.Program, standardLibraryFileByName: ReadonlyMap<string, ts.SourceFile>, rootFileByGlobalLibraryName: ReadonlyMap<string, ts.SourceFile>, moduleSymbolByName: ReadonlyMap<string, ts.Symbol>, unresolvedStandardLibraryFileNames: readonly string[], unresolvedUserLibraryNames: readonly string[]);
+}
+export declare class TsUriExt {
+    static readonly scheme = "ts";
+    static readonly separator = "/";
+    static uriToPath(uri: Uri): string;
+    static pathToUri(path: string): Uri;
+}

package/build/types/ts-interop/TsTypeMembersCreator.d.ts

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { TypeEntityWithMembers, TypeParameterEntity } from '../entities/index.js';
+import { OriginalTypeEntityMembers } from '../entities/TypeEntityMembers.js';
+import { TsInteropContext } from './TsInteropContext.js';
+export declare class TsTypeMembersCreator {
+    private readonly _tsctx;
+    private readonly _symbols;
+    private readonly _symbolsToForceStatic;
+    private readonly _typeSymbolDeclarations;
+    private readonly _typeEntity;
+    private readonly _symbolToTakeDefaultClassConstructorsFrom;
+    private readonly _membersOfTypeToMergeWith;
+    private readonly _typeParameterBySymbol;
+    constructor(_tsctx: TsInteropContext, _symbols: Iterable<ts.Symbol>, _symbolsToForceStatic: Iterable<ts.Symbol> | undefined, _typeSymbolDeclarations: readonly ts.Declaration[] | undefined, _typeEntity: TypeEntityWithMembers, _symbolToTakeDefaultClassConstructorsFrom: ts.Symbol | undefined, _membersOfTypeToMergeWith: OriginalTypeEntityMembers | undefined);
+    create(): TsTypeMembersCreationResult;
+    private createTypeMemberEntity;
+    /**
+     * @param symbol (symbol.flags & ts.SymbolFlags.Property) !== 0
+     */
+    private createProperty;
+    /**
+     * @param symbol (symbol.flags & ts.SymbolFlags.Accessor) !== 0
+     */
+    private createAccessor;
+    /**
+     * @returns Возвращает true, если symbol - это метод с именем [Symbol.iterator]
+     */
+    private isProbablyIteratorMethodSymbol;
+    /**
+     * @param symbol (symbol.flags & ts.SymbolFlags.Method) !== 0
+     */
+    private createMethods;
+    private createMethodEntityNoReplacement;
+    private createConstructors;
+    private createIndexerSignatures;
+    private registerTypeParameters;
+    private createEnumeratorMethodIfIteratorMethodExists;
+    private getNamedMembersFromTypeToMergeWith;
+    private createDefaultConstructorsFromSignatures;
+}
+export declare class TsTypeMembersCreationResult {
+    readonly members: OriginalTypeEntityMembers;
+    readonly typeParameterBySymbol: ReadonlyMap<ts.Symbol, TypeParameterEntity>;
+    constructor(members: OriginalTypeEntityMembers, typeParameterBySymbol: ReadonlyMap<ts.Symbol, TypeParameterEntity>);
+}

package/build/types/ts-interop/Utils.d.ts

@@ -0,0 +1,43 @@
+import { TsInteropInputs } from '../analysis/index.js';
+import { Compilation, JavaScriptImplementationConfig, JavaScriptInterfacePackageImplementationConfig, JavaScriptModuleFormat, PackageFromDtsConfig, ProgramPackage } from '../project/index.js';
+import { TypeScriptLibrariesProvider } from './TsLibrariesProvider.js';
+export declare function createTsInteropInputsForCompilation(compilation: Compilation, librariesProvider: TypeScriptLibrariesProvider): TsInteropInputs;
+export declare function collectRequiredJsLibraryConfigs(compilation: Compilation): RequiredJsLibraryConfigs;
+export declare class RequiredJsLibraryConfigs {
+    readonly values: readonly RequiredJsLibraryConfig[];
+    constructor(values: readonly RequiredJsLibraryConfig[]);
+    getJsModuleConfigs(): readonly JsModuleConfig[];
+    getStandardLibraryFileNames(): string[];
+    getNamesOfNpmPackagesToLoadFromDts(): string[];
+    getNamesOfModulesToLoadFromDts(): string[];
+}
+export type RequiredJsLibraryConfig = RequiredJsLibraryConfig.ExternalImplementation | RequiredJsLibraryConfig.PackageFromDts;
+export declare namespace RequiredJsLibraryConfig {
+    export class ExternalImplementation implements IRequiredJsLibraryConfig {
+        readonly pkg: ProgramPackage;
+        readonly value: JavaScriptInterfacePackageImplementationConfig;
+        readonly kind = "external-implementation";
+        get implementationConfig(): JavaScriptImplementationConfig;
+        get loadFromDts(): boolean;
+        constructor(pkg: ProgramPackage, value: JavaScriptInterfacePackageImplementationConfig);
+    }
+    export class PackageFromDts {
+        readonly value: PackageFromDtsConfig;
+        readonly kind = "package-from-dts";
+        get implementationConfig(): JavaScriptImplementationConfig;
+        get loadFromDts(): boolean;
+        constructor(value: PackageFromDtsConfig);
+    }
+    interface IRequiredJsLibraryConfig {
+        implementationConfig: JavaScriptImplementationConfig;
+        loadFromDts: boolean;
+    }
+    export {};
+}
+export declare class JsModuleConfig {
+    readonly name: string;
+    readonly format: JavaScriptModuleFormat;
+    readonly packageName: string;
+    readonly loadFromDts: boolean;
+    constructor(name: string, format: JavaScriptModuleFormat, packageName: string, loadFromDts: boolean);
+}

package/build/types/types/AliasType.d.ts

@@ -0,0 +1,20 @@
+import { Analyzer } from '../analysis/index.js';
+import { AliasTypeEntity, TypeParameterEntity } from '../entities/index.js';
+import { IType, SubstitutionMap, Substitutions, Type } from './index.js';
+export declare class AliasType implements IType {
+    private readonly _analyzer;
+    private readonly _entity;
+    private readonly _substitutions;
+    readonly kind = "alias";
+    private readonly _aliasedType;
+    get debuggerDisplay(): string;
+    constructor(_analyzer: Analyzer, _entity: AliasTypeEntity, _substitutions: Substitutions);
+    getAliasedType(): Type;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getSubstitutions(): Substitutions;
+    applySubstitutions(map: SubstitutionMap): Type;
+    equals(other: Type): boolean;
+    getEntity(): AliasTypeEntity;
+    getBaseObjectTypeOrAliasedType(): Type | undefined;
+    toString(): string;
+}

package/build/types/types/Internal.d.ts

@@ -0,0 +1 @@
+export * from './StandardTypes.js';

package/build/types/types/MethodType.d.ts

@@ -0,0 +1,23 @@
+import { Analyzer } from '../analysis/index.js';
+import { MethodTypeEntity, TypeParameterEntity } from '../entities/index.js';
+import { IType, StructuredType, SubstitutionMap, Substitutions, Type, ValueParameter } from './index.js';
+export declare class MethodType implements IType {
+    private readonly _analyzer;
+    private readonly _entity;
+    private readonly _substitutions;
+    readonly kind = "method";
+    private readonly _valueParameters;
+    get debuggerDisplay(): string;
+    constructor(_analyzer: Analyzer, _entity: MethodTypeEntity, _substitutions: Substitutions);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getSubstitutions(): Substitutions;
+    applySubstitutions(map: SubstitutionMap): MethodType;
+    equals(other: Type): boolean;
+    getEntity(): MethodTypeEntity;
+    isAsync(): boolean;
+    getReturnType(): Type;
+    getValueParameters(): readonly ValueParameter[];
+    getBaseType(): StructuredType;
+    getBaseObjectTypeOrAliasedType(): Type | undefined;
+    toString(): string;
+}

package/build/types/types/ParameterType.d.ts

@@ -0,0 +1,19 @@
+import { Analyzer } from '../analysis/index.js';
+import { TypeParameterEntity } from '../entities/index.js';
+import { IType, SubstitutionMap, Substitutions, Type } from './index.js';
+export declare class ParameterType implements IType {
+    private readonly _analyzer;
+    private readonly _entity;
+    private readonly _excludeNone;
+    readonly kind = "parameter";
+    get isNoneExcluded(): boolean;
+    get constraint(): Type | undefined;
+    get debuggerDisplay(): string;
+    constructor(_analyzer: Analyzer, _entity: TypeParameterEntity, _excludeNone: boolean);
+    getSubstitutions(): Substitutions;
+    getEntity(): TypeParameterEntity;
+    applySubstitutions(map: SubstitutionMap): Type;
+    equals(other: Type): boolean;
+    getBaseObjectTypeOrAliasedType(): Type | undefined;
+    toString(): string;
+}

package/build/types/types/StandardTypes.d.ts

@@ -0,0 +1,42 @@
+import { Analyzer } from '../analysis/index.js';
+import { StructuredType, UnresolvedType, VariantType } from './index.js';
+export declare class StandardTypes {
+    private readonly _analyzer;
+    private _refObject;
+    private _plainObject;
+    private _number;
+    private _integer;
+    private _text;
+    private _textTemplate;
+    private _char;
+    private _unresolved;
+    private _yesNo;
+    private _none;
+    private _measure;
+    private _enumerator;
+    private _enumerable;
+    private _array;
+    private _reference;
+    private _task;
+    private _error;
+    private _method;
+    constructor(_analyzer: Analyzer);
+    get refObject(): StructuredType;
+    get plainObject(): StructuredType;
+    get number(): StructuredType;
+    get integer(): StructuredType;
+    get text(): StructuredType;
+    get textTemplate(): StructuredType;
+    get char(): StructuredType;
+    get unresolved(): UnresolvedType;
+    get yesNo(): VariantType;
+    get none(): StructuredType;
+    get measure(): StructuredType;
+    get enumerator(): StructuredType;
+    get enumerable(): StructuredType;
+    get array(): StructuredType;
+    get reference(): StructuredType;
+    get task(): StructuredType;
+    get error(): StructuredType;
+    get method(): StructuredType;
+}

package/build/types/types/StructuredType.d.ts

@@ -0,0 +1,25 @@
+import { Analyzer } from '../analysis/index.js';
+import { StructuredTypeEntity, TypeParameterEntity } from '../entities/index.js';
+import { IType, SubstitutionMap, Substitutions, Type } from './index.js';
+export declare class StructuredType implements IType {
+    private readonly _analyzer;
+    private readonly _entity;
+    private readonly _substitutions;
+    readonly kind = "structured";
+    private readonly _baseObjectType;
+    private readonly _baseAspectTypes;
+    get debuggerDisplay(): string;
+    constructor(_analyzer: Analyzer, _entity: StructuredTypeEntity, _substitutions: Substitutions);
+    getSubstitutions(): Substitutions;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    applySubstitutions(map: SubstitutionMap): StructuredType;
+    isAspect(): boolean;
+    isRefObject(): boolean;
+    isPlainObject(): boolean;
+    equals(other: Type): boolean;
+    getEntity(): StructuredTypeEntity;
+    getBaseObjectType(): Type | undefined;
+    getBaseAspectTypes(): readonly Type[];
+    getBaseObjectTypeOrAliasedType(): Type | undefined;
+    toString(): string;
+}

package/build/types/types/Substitutions.d.ts

@@ -0,0 +1,18 @@
+import { Analyzer } from '../analysis/index.js';
+import { TypeParameterEntity } from '../entities/index.js';
+import { Type } from './index.js';
+export declare class Substitutions {
+    readonly map: SubstitutionMap;
+    private readonly _analyzer;
+    get size(): number;
+    constructor(analyzer: Analyzer, parameters: readonly TypeParameterEntity[], types: readonly Type[]);
+    constructor(analyzer: Analyzer, map: SubstitutionMap);
+    static identity(analyzer: Analyzer, parameters: readonly TypeParameterEntity[]): Substitutions;
+    static empty(analyzer: Analyzer): Substitutions;
+    getParameters(): Iterable<TypeParameterEntity>;
+    getTypes(): Iterable<Type>;
+    substituteTypes(map: SubstitutionMap): Substitutions;
+    substituteTypesAndMerge(map: SubstitutionMap): Substitutions;
+    equals(other: Substitutions): boolean;
+}
+export type SubstitutionMap = ReadonlyMap<TypeParameterEntity, Type>;

package/build/types/types/Type.d.ts

@@ -0,0 +1,16 @@
+import { TypeEntity } from '../entities/index.js';
+import { AliasType } from './AliasType.js';
+import { MethodType } from './MethodType.js';
+import { ParameterType } from './ParameterType.js';
+import { StructuredType } from './StructuredType.js';
+import { UnresolvedType } from './UnresolvedType.js';
+import { VariantType } from './VariantType.js';
+import { SubstitutionMap, Substitutions, UnionType } from './index.js';
+export type Type = StructuredType | VariantType | MethodType | AliasType | UnresolvedType | ParameterType | UnionType;
+export interface IType {
+    getSubstitutions(): Substitutions;
+    applySubstitutions(map: SubstitutionMap): Type;
+    equals(other: Type): boolean;
+    getEntity(): TypeEntity | undefined;
+    getBaseObjectTypeOrAliasedType(): Type | undefined;
+}

package/build/types/types/TypeFactory.d.ts

@@ -0,0 +1,15 @@
+import { Analyzer } from '../analysis/index.js';
+import { AliasTypeEntity, MethodTypeEntity, StructuredTypeEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
+import { AliasType, MethodType, ParameterType, StructuredType, Substitutions, Type, UnresolvedType, VariantType } from './index.js';
+export declare class TypeFactory {
+    readonly analyzer: Analyzer;
+    constructor(analyzer: Analyzer);
+    getStructuredType(entity: StructuredTypeEntity, substitutions: Substitutions): StructuredType;
+    getParameterType(entity: TypeParameterEntity, excludeNone: boolean): ParameterType;
+    getVariantType(entity: VariantTypeEntity, substitutions: Substitutions): VariantType;
+    getMethodType(entity: MethodTypeEntity, substitutions: Substitutions): MethodType;
+    getAliasType(entity: AliasTypeEntity, substitutions: Substitutions): AliasType;
+    getUnionType(types: readonly Type[]): Type;
+    getUnresolvedType(): UnresolvedType;
+    private getUniqueFlattenedConstituentTypes;
+}