@artel/artc 0.6.25191

package/build/types/project/SourcePackage.d.ts

@@ -0,0 +1,151 @@
+import { Name, PackageDialect, PackageLocale, ReadonlyNonEmptyArray, Uri } from '../common/index.js';
+import { Compilation } from './Compilation.js';
+import { SourceFile } from './SourceFile.js';
+export type SourcePackage = ProgramPackage | TranslationPackage;
+declare abstract class SourcePackageBase {
+    readonly uri: Uri;
+    readonly name: PackageName;
+    readonly sourceFiles: readonly SourceFile[];
+    private _compilation;
+    get compilation(): Compilation;
+    protected abstract get asPackage(): SourcePackage;
+    abstract get locale(): PackageLocale;
+    abstract get dialect(): PackageDialect | undefined;
+    constructor(uri: Uri, name: PackageName, sourceFiles: readonly SourceFile[]);
+    /**
+     * Данный метод должен вызываться только из конструктора компиляции (Compilation).
+     */
+    setCompilation(compilation: Compilation): void;
+}
+export declare class ProgramPackage extends SourcePackageBase {
+    readonly kind = "program";
+    readonly configuration: ProgramPackageConfiguration;
+    protected get asPackage(): SourcePackage;
+    get locale(): PackageLocale;
+    get dialect(): PackageDialect | undefined;
+    constructor(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: readonly SourceFile[]);
+}
+export declare class TranslationPackage extends SourcePackageBase {
+    readonly kind = "translation";
+    readonly configuration: TranslationPackageConfiguration;
+    protected get asPackage(): SourcePackage;
+    get locale(): PackageLocale;
+    get dialect(): PackageDialect | undefined;
+    constructor(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: SourceFile[]);
+}
+export type PackageConfiguration = ProgramPackageConfiguration | TranslationPackageConfiguration;
+export declare class TranslationPackageConfiguration {
+    readonly targetPackageName: PackageName;
+    readonly translatedName: PackageName;
+    readonly translationLocale: PackageLocale;
+    constructor(targetPackageName: PackageName, translatedName: PackageName, translationLocale: PackageLocale);
+}
+export declare class ProgramPackageConfiguration {
+    readonly name: PackageName;
+    readonly locale: PackageLocale;
+    readonly dialect?: PackageDialect | undefined;
+    readonly version?: string | undefined;
+    readonly targetPlatform: TargetPlatformConfig;
+    readonly requiredPackages: readonly RequiredPackageConfig[];
+    readonly implementedInterfacePackageName?: PackageName | undefined;
+    readonly jsProjectRootUri?: Uri | undefined;
+    readonly packageImportLocales: readonly PackageImportLocaleConfig[];
+    readonly automaticallyImportedPackages?: readonly PackageName[] | undefined;
+    constructor(name: PackageName, locale: PackageLocale, dialect?: PackageDialect | undefined, version?: string | undefined, targetPlatform?: TargetPlatformConfig, requiredPackages?: readonly RequiredPackageConfig[], implementedInterfacePackageName?: PackageName | undefined, jsProjectRootUri?: Uri | undefined, packageImportLocales?: readonly PackageImportLocaleConfig[], automaticallyImportedPackages?: readonly PackageName[] | undefined);
+    isInterfacePackage(): boolean;
+}
+export declare class PackageName {
+    readonly segments: ReadonlyNonEmptyArray<Name>;
+    get lastSegment(): Name;
+    constructor(segments: ReadonlyNonEmptyArray<Name>);
+    static fromOriginalSegments(segments: ReadonlyNonEmptyArray<string>): PackageName;
+    universallyEquals(name: PackageName): boolean;
+    toString(original?: boolean): string;
+}
+export type RequiredPackageConfig = RequiredPackageConfig.Npm | RequiredPackageConfig.NuGet;
+export declare namespace RequiredPackageConfig {
+    class Npm {
+        readonly name: string;
+        readonly version: string;
+        readonly kind = "npm";
+        constructor(name: string, version: string);
+    }
+    class NuGet {
+        readonly name: string;
+        readonly version: string;
+        readonly kind = "nu-get";
+        constructor(name: string, version: string);
+    }
+}
+export type TargetPlatformConfig = TargetPlatformConfig.Any | TargetPlatformConfig.JavaScript | TargetPlatformConfig.DotNet;
+export declare namespace TargetPlatformConfig {
+    class Any {
+        readonly isInterfacePackage: boolean;
+        readonly kind = "any";
+        constructor(isInterfacePackage?: boolean);
+    }
+    class JavaScript {
+        readonly interfacePackageImplementation?: JavaScriptInterfacePackageImplementationConfig | undefined;
+        readonly packagesLoadedFromDts: readonly PackageFromDtsConfig[];
+        readonly kind = "javascript";
+        constructor(interfacePackageImplementation?: JavaScriptInterfacePackageImplementationConfig | undefined, packagesLoadedFromDts?: readonly PackageFromDtsConfig[]);
+    }
+    class DotNet {
+        readonly isInterfacePackage: boolean;
+        readonly kind = "dotnet";
+        constructor(isInterfacePackage?: boolean);
+    }
+}
+export declare class JavaScriptInterfacePackageImplementationConfig {
+    readonly value: JavaScriptImplementationConfig;
+    readonly loadFromDts: boolean;
+    constructor(value: JavaScriptImplementationConfig, loadFromDts?: boolean);
+}
+export type JavaScriptImplementationConfig = JavaScriptImplementationConfig.Module | JavaScriptImplementationConfig.Globals | JavaScriptImplementationConfig.NamespaceOfSubModule;
+export declare namespace JavaScriptImplementationConfig {
+    export class Module implements IJavaScriptImplementationConfig {
+        readonly moduleName: string;
+        readonly npmPackageName: string;
+        readonly moduleFormat: JavaScriptModuleFormat;
+        readonly kind = "module";
+        constructor(moduleName: string, npmPackageName: string, moduleFormat: JavaScriptModuleFormat);
+    }
+    export class Globals implements IJavaScriptImplementationConfig {
+        readonly npmPackageName: string;
+        readonly standardLibraryFiles: string[];
+        readonly kind = "globals";
+        constructor(npmPackageName: string, standardLibraryFiles?: string[]);
+    }
+    export class NamespaceOfSubModule implements IJavaScriptImplementationConfig {
+        readonly namespaceOrSubModuleName: string;
+        readonly owner: NamespaceOfSubModuleOwner;
+        readonly kind = "namespace-of-sub-module";
+        get npmPackageName(): string;
+        constructor(namespaceOrSubModuleName: string, owner: NamespaceOfSubModuleOwner);
+    }
+    export type NamespaceOfSubModuleOwner = Module | Globals;
+    interface IJavaScriptImplementationConfig {
+        npmPackageName: string;
+    }
+    export {};
+}
+export declare class PackageFromDtsConfig {
+    readonly artelPackageName: PackageName;
+    readonly implementation: JavaScriptImplementationConfig;
+    constructor(artelPackageName: PackageName, implementation: JavaScriptImplementationConfig);
+}
+export declare enum JavaScriptModuleFormat {
+    Esm = 0,
+    Cjs = 1
+}
+export declare class PackageImportLocaleConfig {
+    readonly packageName: PackageName;
+    readonly locale: PackageLocale;
+    constructor(packageName: PackageName, locale: PackageLocale);
+}
+export declare enum PlatformKind {
+    JavaScript = 0,
+    Browser = 1,
+    DotNet = 2
+}
+export {};

package/build/types/project/TextFile.d.ts

@@ -0,0 +1,11 @@
+import { Uri } from '../common/index.js';
+import { Position } from './Position.js';
+export declare class TextFile {
+    readonly text: string;
+    readonly uri: Uri;
+    readonly version: number;
+    private readonly _textDocument;
+    constructor(text: string, uri: Uri, version: number);
+    getPositionAt(offset: number): Position;
+    getOffsetAtPosition({ line, character }: Position): number;
+}

package/build/types/project/configuration/BuildPackageApi.d.ts

@@ -0,0 +1,75 @@
+export declare class Package {
+    name: string;
+    language?: Language | undefined;
+    dialect?: Dialect | undefined;
+    version?: string | undefined;
+    requiredPackages?: RequiredPackage[] | undefined;
+    externalImplementation?: ExternalImplementation | undefined;
+    implementedInterfacePackageName?: string | undefined;
+    supportedPlatforms?: TargetPlatform[] | undefined;
+    platformStorageFolder?: string | undefined;
+    jsProjectRootFolder?: string | undefined;
+    packageImportLanguages?: PackageImportLanguage[] | undefined;
+    constructor(name: string, language?: Language | undefined, dialect?: Dialect | undefined, version?: string | undefined, requiredPackages?: RequiredPackage[] | undefined, externalImplementation?: ExternalImplementation | undefined, implementedInterfacePackageName?: string | undefined, supportedPlatforms?: TargetPlatform[] | undefined, platformStorageFolder?: string | undefined, jsProjectRootFolder?: string | undefined, packageImportLanguages?: PackageImportLanguage[] | undefined);
+    onCreate(): void;
+}
+export declare enum Language {
+    Russian = 0,
+    English = 1
+}
+export declare enum Dialect {
+    Common = 0,
+    Special = 1
+}
+export declare enum TargetPlatform {
+    JavaScript = 0,
+    DotNet = 1
+}
+export type RequiredPackage = NpmPackage | NuGetPackage;
+export declare class NpmPackage {
+    name: string;
+    version: string;
+    format: JavaScriptModuleFormat;
+    modulesLoadingFromDts?: NpmPackageModuleFromDts[] | undefined;
+    readonly kind = "npm-package";
+    constructor(name: string, version: string, format: JavaScriptModuleFormat, modulesLoadingFromDts?: NpmPackageModuleFromDts[] | undefined);
+}
+export declare class NpmPackageModuleFromDts {
+    name: string;
+    artelName: string;
+    areNamesGlobal: boolean;
+    constructor(name: string, artelName: string, areNamesGlobal?: boolean);
+}
+export declare class NuGetPackage {
+    name: string;
+    version: string;
+    readonly kind = "nuget-package";
+    constructor(name: string, version: string);
+}
+export type ExternalImplementation = JavaScriptModule | DotNetAssembly | AnotherArtelPackage;
+export declare class JavaScriptModule {
+    moduleName: string;
+    packageName?: string | undefined;
+    areNamesGlobal: boolean;
+    loadFromDts: boolean;
+    standardLibraryFiles?: string[] | undefined;
+    readonly kind = "javascript-module";
+    constructor(moduleName: string, packageName?: string | undefined, areNamesGlobal?: boolean, loadFromDts?: boolean, standardLibraryFiles?: string[] | undefined);
+}
+export declare enum JavaScriptModuleFormat {
+    Esm = 0,
+    Cjs = 1
+}
+export declare class DotNetAssembly {
+    assembly: string;
+    readonly kind = "dotnet-assembly";
+    constructor(assembly: string);
+}
+export declare class AnotherArtelPackage {
+    readonly kind = "another-artel-package";
+}
+export declare class PackageImportLanguage {
+    packageName: string;
+    language: Language;
+    constructor(packageName: string, language: Language);
+}

package/build/types/project/configuration/ConfigurationConverter.d.ts

@@ -0,0 +1,25 @@
+import { PackageDialect } from '../../common/index.js';
+import { PackageLocale } from '../../common/PackageLocale.js';
+import { Uri } from '../../common/Uri.js';
+import * as origin from '../configuration/types/PackageConfigurationEn.js';
+import { PackageConfiguration, PackageName, ProgramPackageConfiguration, TranslationPackageConfiguration } from '../SourcePackage.js';
+export declare class ConfigurationConverter {
+    private static readonly _uriRegexp;
+    static convert(configurations: readonly origin.Configuration[], packageOrGroupUri?: Uri, defaultLocale?: PackageLocale, defaultDialect?: PackageDialect): ConvertedConfiguration;
+    static convertPackageConfiguration(configuration: origin.Package, packageOrGroupUri?: Uri, defaultLocale?: PackageLocale, defaultDialect?: PackageDialect): ProgramPackageConfiguration;
+    static convertPackageGroupConfiguration(configuration: origin.PackageGroup): PackageGroupConfiguration;
+    static convertTranslationsConfiguration(configuration: origin.Translations): TranslationPackageConfiguration | undefined;
+    private static convertJavaScriptImplementation;
+    private static convertLanguage;
+    private static convertDialect;
+    private static convertJavaScriptModuleFormat;
+    private static tryParseUri;
+}
+export interface ConvertedConfiguration {
+    packageConfiguration?: PackageConfiguration;
+    packageGroupConfiguration?: PackageGroupConfiguration;
+}
+export declare class PackageGroupConfiguration {
+}
+export declare function parsePackageName(text: string): PackageName | undefined;
+export declare function createDefaultPackageConfiguration(packageUri: Uri | undefined, locale?: PackageLocale, dialect?: PackageDialect): ProgramPackageConfiguration;

package/build/types/project/configuration/ConfigurationFileParser.d.ts

@@ -0,0 +1,26 @@
+import { PackageLocale } from '../../common/PackageLocale.js';
+import { RangeDiagnosticAcceptor } from '../../diagnostic/RangeDiagnostic.js';
+import * as configEn from '../configuration/types/PackageConfigurationEn.js';
+export declare class ConfigurationFileParser {
+    private static _configurationValidator;
+    private static get configurationValidator();
+    /**
+     * Выполняет разбор и валидацию конфигурации (проверка соответствия JSON схеме), преобразует в конфигурацию на
+     * английском языке путём замены имён свойств.
+     *
+     * @returns Возвращает `ConfigurationArray`, если конфигурация была успешно разобрана, `undefined`, если содержала
+     * ошибки (ошибки в синтаксисе JSON, несоответствие JSON схеме).
+     *
+     * @example
+     * [{
+     *   "тип": "Пакет",
+     *   "имя": "МойПакет"
+     * }]
+     *  ->
+     * [{
+     *   "type": "Package",
+     *   "name": "МойПакет"
+     * }]
+     */
+    static parse(json: string, locale: PackageLocale, diagnostics: RangeDiagnosticAcceptor | undefined): Promise<configEn.ConfigurationArray | undefined>;
+}

package/build/types/project/configuration/PackageConfigurationInterpreter.d.ts

@@ -0,0 +1,27 @@
+import { Analyzer, TsInteropInputs } from '../../analysis/index.js';
+import { CancellationToken, Result, Uri } from '../../common/index.js';
+import { Diagnostic, DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { TypeScriptLibrariesProvider } from '../../ts-interop/TsLibrariesProvider.js';
+import { Compilation } from '../Compilation.js';
+import { CompilationLoadResult } from '../CompilationLoader.js';
+import * as fsTree from '../FileSystemTree.js';
+import * as buildScript from './BuildPackageApi.js';
+export declare class PackageConfigurationInterpreter {
+    static readonly artelPackageUri: Uri;
+    static readonly buildPackageUri: Uri;
+    static readonly platformJavaScriptPackageUri: Uri;
+    static readonly availablePackageUris: Uri[];
+    static readonly asyncFunctionConstructor: any;
+    static interpret(configurationDirectory: fsTree.Directory, tsInteropInputs: TsInteropInputs, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<Result<buildScript.Package | undefined, undefined>>;
+    static createTsInteropInputsForInterpretation(librariesProvider: TypeScriptLibrariesProvider): TsInteropInputs;
+    static loadConfigurationCompilation(configurationDirectory: fsTree.Directory, diagnostics: DiagnosticAcceptor | undefined, previousLoadResult?: CompilationLoadResult, cancellationToken?: CancellationToken): Promise<Compilation | undefined>;
+    static compileAndExecuteConfiguration(analyzer: Analyzer, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<Result<buildScript.Package | undefined, undefined>>;
+    private static analyze;
+    private static executeConfigurationCode;
+}
+export declare class RawInterpretationResult {
+    readonly configuration: buildScript.Package | undefined;
+    readonly isSuccessful: boolean;
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(configuration: buildScript.Package | undefined, isSuccessful: boolean, diagnostics: readonly Diagnostic[]);
+}

package/build/types/project/configuration/types/PackageConfigurationEn.d.ts

@@ -0,0 +1,90 @@
+export type ConfigurationArray = Configuration[];
+export type Configuration = Package | PackageGroup | Translations;
+export interface Package {
+    type: 'Package';
+    name: string;
+    language?: Language;
+    dialect?: Dialect;
+    version?: string;
+    targetPlatform?: TargetPlatform;
+    requiredPackages?: RequiredPackage[];
+    implementedInterfacePackageName?: string;
+    jsProjectRootFolder?: string;
+    packageImportLanguages?: PackageImportLanguage[];
+    automaticallyImportedPackages?: string[];
+}
+export interface PackageGroup {
+    type: 'PackageGroup';
+}
+export interface Translations {
+    type: 'Translations';
+    originalPackageName: string;
+    translatedPackageName: string;
+    translationLanguage: Language;
+}
+export declare enum Language {
+    Russian = "russian",
+    English = "english"
+}
+export declare enum Dialect {
+    Mixed = "mixed",
+    Usual = "usual",
+    Special = "special"
+}
+export type TargetPlatform = JavaScriptPlatform | DotNetPlatform | AnyPlatform;
+export interface JavaScriptPlatform {
+    type: 'JavaScriptPlatform';
+    interfacePackageImplementation?: JavaScriptInterfacePackageImplementation;
+    packagesLoadedFromDts?: PackageFromDts[];
+}
+export type JavaScriptInterfacePackageImplementation = JavaScriptImplementation & {
+    loadFromDts?: boolean;
+};
+export type JavaScriptImplementation = JavaScriptModule | JavaScriptGlobals | JavaScriptNamespaceOrSubModule;
+export interface JavaScriptModule {
+    type: 'JavaScriptModule';
+    moduleName: string;
+    npmPackageName: string;
+    moduleFormat: JavaScriptModuleFormat;
+}
+export declare enum JavaScriptModuleFormat {
+    Esm = "esm",
+    Cjs = "cjs"
+}
+export interface JavaScriptGlobals {
+    type: 'JavaScriptGlobals';
+    npmPackageName: string;
+    standardLibraryFiles?: string[];
+}
+export interface JavaScriptNamespaceOrSubModule {
+    type: 'JavaScriptNamespaceOrSubModule';
+    namespaceOrSubModule: string;
+    owningImplementation: JavaScriptNamespaceOrSubModuleOwner;
+}
+export type JavaScriptNamespaceOrSubModuleOwner = JavaScriptModule | JavaScriptGlobals;
+export interface PackageFromDts {
+    artelPackageName: string;
+    implementation: JavaScriptImplementation;
+}
+export interface DotNetPlatform {
+    type: 'DotNetPlatform';
+}
+export interface AnyPlatform {
+    type: 'AnyPlatform';
+    isInterfacePackage?: boolean;
+}
+export type RequiredPackage = NpmPackage | NuGetPackage;
+export interface NpmPackage {
+    type: 'NpmPackage';
+    name: string;
+    version: string;
+}
+export interface NuGetPackage {
+    type: 'NuGetPackage';
+    name: string;
+    version: string;
+}
+export interface PackageImportLanguage {
+    packageName: string;
+    language: Language;
+}

package/build/types/project/configuration/types/PackageConfigurationRu.d.ts

@@ -0,0 +1,91 @@
+export type МассивКонфигураций = Конфигурация[];
+export type Конфигурация = Пакет | ГруппаПакетов | Переводы;
+export interface Пакет {
+    тип: 'Пакет';
+    имя: string;
+    язык?: Язык;
+    диалект?: Диалект;
+    версия?: string;
+    целеваяПлатформа?: ЦелеваяПлатформа;
+    требуемыеПакеты?: ТребуемыйПакет[];
+    имяРеализуемогоИнтерфейсногоПакета?: string;
+    папкаПроектаJs?: string;
+    языкиПакетовПриПодключении?: ЯзыкПодключенияПакета[];
+    автоматическиПодключаемыеПакеты?: string[];
+}
+export interface ГруппаПакетов {
+    тип: 'ГруппаПакетов';
+}
+export interface Переводы {
+    тип: 'Переводы';
+    имяПакетаИсходное: string;
+    имяПакетаПереведённое: string;
+    языкПеревода: Язык;
+}
+export declare enum Язык {
+    Русский = "\u0440\u0443\u0441\u0441\u043A\u0438\u0439",
+    Английский = "\u0430\u043D\u0433\u043B\u0438\u0439\u0441\u043A\u0438\u0439"
+}
+export declare enum Диалект {
+    Смешанный = "\u0441\u043C\u0435\u0448\u0430\u043D\u043D\u044B\u0439",
+    Привычный = "\u043F\u0440\u0438\u0432\u044B\u0447\u043D\u044B\u0439",
+    Особый = "\u043E\u0441\u043E\u0431\u044B\u0439"
+}
+export type ЦелеваяПлатформа = ПлатформаJavaScript | ПлатформаDotNet | ПлатформаЛюбая;
+export interface ПлатформаJavaScript {
+    тип: 'ПлатформаJavaScript';
+    реализацияИнтерфейсногоПакета?: РеализацияИнтерфейсногоПакетаНаJavaScript;
+    пакетыЗагружаемыеИзDts?: ПакетИзDts[];
+}
+export type РеализацияИнтерфейсногоПакетаНаJavaScript = РеализацияНаJavaScript & {
+    загрузитьИзDts?: ДаНет;
+};
+export type РеализацияНаJavaScript = МодульJavaScript | ГлобальныеОбъявленияJavaScript | ОбластьИмёнИлиВложенныйМодульJavaScript;
+export interface МодульJavaScript {
+    тип: 'МодульJavaScript';
+    имяМодуля: string;
+    имяПакетаNpm: string;
+    форматМодуля: ФорматМодуляJavaScript;
+}
+export declare enum ФорматМодуляJavaScript {
+    Esm = "esm",
+    Cjs = "cjs"
+}
+export interface ГлобальныеОбъявленияJavaScript {
+    тип: 'ГлобальныеОбъявленияJavaScript';
+    имяПакетаNpm: string;
+    файлыСтандартнойБиблиотеки?: string[];
+}
+export interface ОбластьИмёнИлиВложенныйМодульJavaScript {
+    тип: 'ОбластьИмёнИлиВложенныйМодульJavaScript';
+    областьИмёнИлиВложенныйМодуль: string;
+    реализацияВладельца: ВладелецОбластиИмёнИлиВложенногоМодуляJavaScript;
+}
+export type ВладелецОбластиИмёнИлиВложенногоМодуляJavaScript = МодульJavaScript | ГлобальныеОбъявленияJavaScript;
+export interface ПакетИзDts {
+    имяПакетаАртель: string;
+    реализация: РеализацияНаJavaScript;
+}
+export interface ПлатформаDotNet {
+    тип: 'ПлатформаDotNet';
+}
+export interface ПлатформаЛюбая {
+    тип: 'ПлатформаЛюбая';
+    интерфейсныйПакет?: ДаНет;
+}
+export type ТребуемыйПакет = ПакетNpm | ПакетNuGet;
+export interface ПакетNpm {
+    тип: 'ПакетNpm';
+    имя: string;
+    версия: string;
+}
+export interface ПакетNuGet {
+    тип: 'ПакетNuGet';
+    имя: string;
+    версия: string;
+}
+export interface ЯзыкПодключенияПакета {
+    имяПакета: string;
+    язык: Язык;
+}
+export type ДаНет = 'да' | 'нет';

package/build/types/project/index.d.ts

@@ -0,0 +1,12 @@
+export * from './Compilation.js';
+export * from './CompilationLoader.js';
+export * from './configuration/ConfigurationFileParser.js';
+export * from './configuration/PackageConfigurationInterpreter.js';
+export * from './configuration/ConfigurationConverter.js';
+export * as config from './configuration/types/PackageConfigurationEn.js';
+export * as configRu from './configuration/types/PackageConfigurationRu.js';
+export * as fsTree from './FileSystemTree.js';
+export * from './Position.js';
+export * from './SourceFile.js';
+export * from './SourcePackage.js';
+export * from './TextFile.js';

package/build/types/services/AddPropertyAssignmentService.d.ts

@@ -0,0 +1,15 @@
+import { SourceFile } from '../project/index.js';
+import * as tree from '../tree/index.js';
+import { SourceFileEdit } from './Types.js';
+export declare class AddPropertyAssignmentService {
+    createEditWithAssignment(sourceFile: SourceFile, assignmentNode: tree.AssignmentStatement, value: string, propertyName: string | undefined): SourceFileEdit | undefined;
+    /**
+     * Метод определяет, где нужно расположить присваивание нового значение: сразу после присваивания предыдущего
+     * значения, или в конце подпрограммы.
+     * Если предыдущее присваивание не вложено ни в какие конструкции ветвления, присваивание нового значение можно
+     * расположить сразу после. Иначе присваивание необходимо расположить в конце подпрограммы (после всех ветвлений).
+     */
+    private ifShouldBeAssignedAtTheEndOfSubProgramThenBody;
+    private getContainingSubProgram;
+    private detectNewLine;
+}

package/build/types/services/CompletionService.d.ts

@@ -0,0 +1,95 @@
+import { Analyzer } from '../analysis/index.js';
+import { SourceFile } from '../project/index.js';
+export declare class CompletionService {
+    private readonly _cache;
+    private _sourceFile;
+    private _analyzer;
+    private _locale;
+    private _dialect;
+    private readonly _completionItemInfoContext;
+    private get completionItemInfoContext();
+    getCompletions(analyzer: Analyzer, sourceFile: SourceFile, offset: number): readonly CompletionItem[];
+    resolveCompletionItem(cacheId: number, indexInCache: number): ResolutionResult;
+    private createSemanticContextAtPosition;
+    private createPositionDescription;
+    private getCompletionContext;
+    private tryGetTopLevelTranslationCompletionContext;
+    private tryGetTypeMemberTranslationCompletionContext;
+    private getTargetTypesAndTargetSignaturesParameters;
+    private getTargetTypesAndTargetSignaturesParametersFromSignatures;
+    private tokenOrKeywordIsPackageImportListChild;
+    private getCompletionItemInfos;
+    private getKeywordCompletionItemInfos;
+    private isRepeatWhileKeywordContext;
+    private isModifierLevelContext;
+    private isElseOrElseIfKeywordContext;
+    private isRunStatementAccessorListContext;
+    private isTypeKindCompletionContext;
+    private isFromKeywordContext;
+    private isCaseKeywordContext;
+    private getExpressionCompletionItemInfos;
+    private prioritizeItemsFromUnionType;
+    private getTargetVariantType;
+    private getCompletionItemInfosForTargetSignaturesValueParameters;
+    private getScopeCompletionItemInfos;
+    private getTypeCompletionItemInfos;
+    private getEntityFromType;
+    private getTypeCompletionItemInfosFromPackage;
+    private getTypeCompletionItemInfosFromPackageNameSegment;
+    private getTypeCompletionItemInfosFromScope;
+    private getPackageAliasMemberCompletionItemInfos;
+    private getPackageNameSegmentCompletionItemInfos;
+    private packageMemberToCompletionItemInfo;
+    private createTypeEntityCompletionItemInfo;
+    private getTypeMemberCompletionItemInfos;
+    private getPackageImportCompletionItemInfos;
+    private getTopLevelAliasListCompletionItemInfos;
+    private getTypeAliasMemberListItemInfos;
+    private mergeOverloadedMethods;
+    private removeCompletionItemsWithDuplicateLabels;
+    private convertCompletionItemInfos;
+    private convertCompletionItemInfo;
+}
+export declare class CompletionItem {
+    readonly label: string;
+    readonly kind: CompletionItemKind;
+    readonly details: string | undefined;
+    readonly insertText: string | undefined;
+    readonly sortText: string | undefined;
+    readonly cacheId: number;
+    readonly indexInCache: number;
+    constructor(label: string, kind: CompletionItemKind, details: string | undefined, insertText: string | undefined, sortText: string | undefined, cacheId: number, indexInCache: number);
+}
+export declare const enum CompletionItemKind {
+    PackageNameSegment = 0,
+    PackageAlias = 1,
+    TypeVariable = 2,
+    TypeMethod = 3,
+    TypeIndexer = 4,
+    TypeConstructor = 5,
+    PackageVariable = 6,
+    PackageMethod = 7,
+    LocalVariable = 8,
+    ParameterVariable = 9,
+    NestedMethod = 10,
+    Variant = 11,
+    RefObjectType = 12,
+    PlainObjectType = 13,
+    AspectType = 14,
+    VariantType = 15,
+    TypeParameter = 16,
+    MethodType = 17,
+    AliasType = 18,
+    InvalidType = 19,
+    Keyword = 20,
+    TargetSignatureParameter = 21
+}
+export type ResolutionResult = ResolutionResult_item | ResolutionResult_notInCache;
+export declare class ResolutionResult_item {
+    readonly value: CompletionItem;
+    readonly kind = "item";
+    constructor(value: CompletionItem);
+}
+export declare class ResolutionResult_notInCache {
+    readonly kind = "not-in-cache";
+}