@artel/artc 0.6.26017 → 0.6.26019

package/build/types/entities/translated/source/a/SourceTranslatedReducedTypeEntity.d.ts

@@ -0,0 +1,14 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Name } from '../../../../common/index.js';
+import * as tree from '../../../../tree/a/index.js';
+import { ReducedTypeEntity, Translation, TypeEntityMembers, TypeParameterEntity } from '../../../index.js';
+import { TranslatedReducedTypeEntity } from '../../TranslatedReducedTypeEntity.js';
+export declare class SourceTranslatedReducedTypeEntity extends TranslatedReducedTypeEntity {
+    private readonly translationPackage;
+    private readonly node;
+    private readonly typeParameters;
+    private readonly members;
+    constructor(originalEntity: ReducedTypeEntity, translation: Translation, name: Name, translationPackage: ResolvedTranslationPackage, node: tree.TypeTranslationDeclaration | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/a/SourceTranslatedTypeExtensionEntity.d.ts

@@ -0,0 +1,9 @@
+import { ResolvedTranslationPackage } from '../../../../analysis/a/ResolvedTranslationPackage.js';
+import { Translation, TypeEntityMembers, TypeExtensionEntity } from '../../../index.js';
+import { TranslatedTypeExtensionEntity } from '../../index.js';
+export declare class SourceTranslatedTypeExtensionEntity extends TranslatedTypeExtensionEntity {
+    private readonly translationPackage;
+    private readonly members;
+    constructor(originalEntity: TypeExtensionEntity, translation: Translation, translationPackage: ResolvedTranslationPackage);
+    getMembers(): TypeEntityMembers;
+}

package/build/types/entities/translated/source/a/index.d.ts

@@ -0,0 +1,11 @@
+export * from './SourceTranslatedAliasTypeEntity.js';
+export * from './SourceTranslatedConstructorEntity.js';
+export * from './SourceTranslatedDestructorEntity.js';
+export * from './SourceTranslatedFunctionEntity.js';
+export * from './SourceTranslatedFunctionTypeEntity.js';
+export * from './SourceTranslatedIndexerEntity.js';
+export * from './SourceTranslatedPackageEntity.js';
+export * from './SourceTranslatedPackageStructuredTypeEntity.js';
+export * from './SourceTranslatedPackageVariantTypeEntity.js';
+export * from './SourceTranslatedReducedTypeEntity.js';
+export * from './SourceTranslatedTypeExtensionEntity.js';

package/build/types/executor/NodeCompiler.d.ts

@@ -1,4 +1,4 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer } from '../analysis/Analyzer.js';
 import { TaskController, Uri } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { EmitOptions } from '../emitter/index.js';

package/build/types/parser/{ConvertTokenKind.d.ts → a/ConvertTokenKind.d.ts}

@@ -1,3 +1,3 @@
-import { TokenKind as TreeTokenKind } from '../tree/index.js';
+import { TokenKind as TreeTokenKind } from '../../tree/a/index.js';
 import { TokenKind as ScannerTokenKind } from './TokenKind.js';
 export declare function scannerTokenKindToTreeTokenKind(kind: ScannerTokenKind): TreeTokenKind;

package/build/types/parser/{KeywordDictionary.d.ts → a/KeywordDictionary.d.ts}

@@ -1,6 +1,7 @@
-import { PackageDialect, PackageLocale } from '../common/index.js';
-import { KeywordFlags } from '../tree/KeywordFlags.js';
-import { KeywordKind } from '../tree/KeywordKind.js';
+import { PackageDialect } from '../../common/PackageDialect.js';
+import { PackageLocale } from '../../common/PackageLocale.js';
+import { KeywordFlags } from '../../tree/a/KeywordFlags.js';
+import { KeywordKind } from '../../tree/a/KeywordKind.js';
 export type KeywordDictionary = Map<string, Array<KeywordPart>>;
 export type KeywordKindDictionary = Map<KeywordKind, Array<Keyword>>;
 export declare enum KeywordPartKind {

package/build/types/parser/{Parser.d.ts → a/Parser.d.ts}

@@ -1,5 +1,5 @@
-import { PackageDialect, PackageLocale } from '../common/index.js';
-import * as tree from '../tree/index.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
+import * as tree from '../../tree/a/index.js';
 export declare class Parser {
     private readonly parser;
     constructor(text: string, locale?: PackageLocale, dialect?: PackageDialect);

package/build/types/parser/a/TokenKind.d.ts

@@ -0,0 +1,80 @@
+export declare enum TokenKind {
+    Unknown = 0,
+    EndOfFile = 1,
+    Whitespace = 2,
+    NewLine = 3,
+    SingleLineComment = 4,
+    MultiLineComment = 5,
+    IntegerLiteral = 6,
+    RealLiteral = 7,
+    MeasureLiteral = 8,
+    CharLiteral = 9,
+    TextLiteral = 10,
+    TextTemplateHead = 11,
+    TextTemplatePart = 12,
+    TextTemplateTail = 13,
+    LocalizableTextLiteral = 14,
+    LocalizableTextTemplateHead = 15,
+    LocalizableTextTemplateTail = 16,
+    Identifier = 17,
+    QuotedIdentifier = 18,
+    Ampersand = 19,
+    AmpersandAmpersand = 20,
+    AmpersandEquals = 21,
+    Asterisk = 22,
+    AsteriskAsterisk = 23,
+    AsteriskEquals = 24,
+    BackQuote = 25,
+    Bar = 26,
+    BarBar = 27,
+    BarEquals = 28,
+    BarBarEquals = 29,
+    BarLeftAngle = 30,
+    BarLeftAngleEquals = 31,
+    BarRightAngle = 32,
+    BarRightAngleEquals = 33,
+    BarRightAngleRightAngle = 34,
+    BarRightAngleRightAngleEquals = 35,
+    Caret = 36,
+    RightBrace = 37,
+    RightParenthesis = 38,
+    RightSquareBracket = 39,
+    Colon = 40,
+    Comma = 41,
+    CommercialAt = 42,
+    Dot = 43,
+    DoublePeriod = 44,
+    Ellipsis = 45,
+    EqualsEquals = 46,
+    Exclamation = 47,
+    ExclamationEquals = 48,
+    RightAngle = 49,
+    RightAngleEquals = 50,
+    HashSign = 51,
+    LeftAngle = 52,
+    LeftAngleEquals = 53,
+    LeftAngleMinus = 54,
+    Minus = 55,
+    MinusMinus = 56,
+    MinusEquals = 57,
+    MinusRightAngle = 58,
+    LeftBrace = 59,
+    LeftParenthesis = 60,
+    LeftSquareBracket = 61,
+    Plus = 62,
+    PlusPlus = 63,
+    PlusEquals = 64,
+    Question = 65,
+    QuestionQuestion = 66,
+    Semicolon = 67,
+    Slash = 68,
+    SlashEquals = 69,
+    Tilde = 70,
+    TildeTilde = 71,
+    Underscore = 72,
+    Equals = 73,
+    Percent = 74,
+    PercentEquals = 75,
+    PercentPercent = 76,
+    BackSlash = 77
+}

package/build/types/parser/{TriviaInterner.d.ts → a/TriviaInterner.d.ts}

@@ -1,4 +1,4 @@
-import { Trivia } from '../tree/index.js';
+import { Trivia } from '../../tree/a/index.js';
 export declare class TriviaInterner {
     private readonly triviaCache;
     private readonly triviaArrayCache;

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

@@ -1,7 +1,7 @@
 import { TaskController, Uri } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { Compilation } from './Compilation.js';
-import { ConvertedConfiguration } from './configuration/ConfigurationConverter.js';
+import { PackageOrGroupConfiguration } from './configuration/ConfigurationConverter.js';
 import * as fsTree from './FileSystemTree.js';
 import * as packageContent from './PackageContent.js';
 import { PackageName, ProgramPackageConfiguration } from './SourcePackage.js';
@@ -92,10 +92,10 @@ export declare class CompilationLoadResult {
     constructor(compilation: Compilation | undefined, configurationsByPackageOrGroupUri: ReadonlyMap<string, ProcessedConfigurationInfo>);
 }
 interface ProcessedConfigurationInfo {
-    processedConfiguration: ConvertedConfiguration | undefined;
+    processedConfiguration: PackageOrGroupConfiguration | undefined;
     diagnostics: readonly Diagnostic[];
     configurationFileVersion: number;
 }
 export type MainPackageConfigurationProvider = () => Promise<ProgramPackageConfiguration>;
-export type ConfigurationProvider = (configurationDirectory: ConfigurationDirectoryInfo, isLoadedFromNodeModules: boolean, process: (configurationDirectory: ConfigurationDirectoryInfo) => Promise<ConvertedConfiguration | undefined>) => Promise<ConvertedConfiguration | undefined>;
+export type ConfigurationProvider = (configurationDirectory: ConfigurationDirectoryInfo, isLoadedFromNodeModules: boolean, process: (configurationDirectory: ConfigurationDirectoryInfo) => Promise<PackageOrGroupConfiguration | undefined>) => Promise<PackageOrGroupConfiguration | undefined>;
 export {};

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

@@ -1,23 +1,47 @@
 import { PackageDialect, PackageLocale, Uri } from '../common/index.js';
+import * as treeA from '../tree/a/index.js';
 import * as tree from '../tree/index.js';
-import { SourcePackage } from './SourcePackage.js';
+import * as treeM from '../tree/m/index.js';
+import { SourcePackage, SourcePackageA, SourcePackageM } from './SourcePackage.js';
 import { TextFile } from './TextFile.js';
-export declare class SourceFile extends TextFile {
+export declare abstract class BaseSourceFile extends TextFile {
     readonly name: string;
     private package_;
-    private readonly node;
     get package(): SourcePackage;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
-    private constructor();
-    static create(text: string, uri: Uri, version: number): SourceFile;
+    protected constructor(text: string, uri: Uri, version: number);
+    abstract getSyntaxNode(): tree.SourceFile;
+    abstract parse(): tree.SourceFile;
+    abstract getSyntaxNodeIfParsed(): tree.SourceFile | undefined;
     /**
      * Данный метод должен вызываться только пакетом этого исходного файла.
      */
     setPackage(package_: SourcePackage): void;
-    createCopy(): SourceFile;
     getSourceText(): string;
-    getSyntaxNode(): tree.SourceFile;
-    parse(): tree.SourceFile;
-    getSyntaxNodeIfParsed(): tree.SourceFile | undefined;
+}
+export declare class SourceFileA extends BaseSourceFile {
+    readonly dialect = PackageDialect.ArtelA;
+    private readonly node;
+    get package(): SourcePackageA;
+    protected constructor(text: string, uri: Uri, version: number, node: treeA.SourceFile | undefined);
+    getSyntaxNode(): treeA.SourceFile;
+    parse(): treeA.SourceFile;
+    getSyntaxNodeIfParsed(): treeA.SourceFile | undefined;
+    static create(text: string, uri: Uri, version: number): SourceFileA;
+    createCopy(): SourceFileA;
+}
+export declare class SourceFileM extends BaseSourceFile {
+    readonly dialect = PackageDialect.ArtelM;
+    private readonly node;
+    get package(): SourcePackageM;
+    protected constructor(text: string, uri: Uri, version: number, node: treeM.SourceFile | undefined);
+    getSyntaxNode(): treeM.SourceFile;
+    parse(): treeM.SourceFile;
+    getSyntaxNodeIfParsed(): treeM.SourceFile | undefined;
+    static create(text: string, uri: Uri, version: number): SourceFileM;
+    createCopy(): SourceFileM;
+}
+export type SourceFile = SourceFileA | SourceFileM;
+export declare namespace SourceFile {
+    function create(text: string, uri: Uri, version: number, dialect: PackageDialect): SourceFile;
 }

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

@@ -1,49 +1,95 @@
 import { Name, PackageDialect, PackageLocale, ReadonlyNonEmptyArray, Uri } from '../common/index.js';
 import { Compilation } from './Compilation.js';
-import { SourceFile } from './SourceFile.js';
+import { SourceFile, SourceFileA, SourceFileM } from './SourceFile.js';
 export type SourcePackage = ProgramPackage | TranslationPackage | TextTranslationPackage;
+export type SourcePackageA = ProgramPackageA | TranslationPackageA | TextTranslationPackageA;
+export type SourcePackageM = ProgramPackageM | TranslationPackageM | TextTranslationPackageM;
 export type ProgramOrTextTranslationPackage = ProgramPackage | TextTranslationPackage;
-declare abstract class SourcePackageBase {
+export type ProgramOrTextTranslationPackageA = ProgramOrTextTranslationPackage & SourcePackageA;
+export type ProgramOrTextTranslationPackageM = ProgramOrTextTranslationPackage & SourcePackageM;
+declare abstract class BaseSourcePackage {
     readonly uri: Uri;
     readonly name: PackageName;
-    readonly sourceFiles: readonly SourceFile[];
     private compilation_;
+    abstract readonly sourceFiles: SourceFiles;
     get compilation(): Compilation;
-    protected abstract get asPackage(): SourcePackage;
-    abstract get locale(): PackageLocale;
-    abstract get dialect(): PackageDialect;
-    constructor(uri: Uri, name: PackageName, sourceFiles: readonly SourceFile[]);
+    protected abstract readonly asPackage: SourcePackage;
+    abstract readonly locale: PackageLocale;
+    abstract readonly dialect: PackageDialect;
+    constructor(uri: Uri, name: PackageName);
     /**
      * Данный метод должен вызываться только из конструктора компиляции (Compilation).
      */
     setCompilation(compilation: Compilation): void;
 }
-export declare class ProgramPackage extends SourcePackageBase {
+export declare abstract class BaseProgramPackage extends BaseSourcePackage {
     readonly kind = "program";
     readonly configuration: ProgramPackageConfiguration;
-    protected get asPackage(): SourcePackage;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
-    constructor(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: readonly SourceFile[]);
+    constructor(uri: Uri, configuration: ProgramPackageConfiguration);
+}
+export declare class ProgramPackageA extends BaseProgramPackage {
+    readonly dialect = PackageDialect.ArtelA;
+    readonly sourceFiles: SourceFilesA;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: SourceFilesA);
+}
+export declare class ProgramPackageM extends BaseProgramPackage {
+    readonly dialect = PackageDialect.ArtelM;
+    readonly sourceFiles: SourceFilesM;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: SourceFilesM);
 }
-export declare class TranslationPackage extends SourcePackageBase {
+export type ProgramPackage = ProgramPackageA | ProgramPackageM;
+export declare namespace ProgramPackage {
+    function create(uri: Uri, configuration: ProgramPackageConfiguration, sourceFiles: readonly SourceFile[]): ProgramPackage;
+}
+export declare abstract class BaseTranslationPackage extends BaseSourcePackage {
     readonly kind = "translation";
     readonly configuration: TranslationPackageConfiguration;
-    protected get asPackage(): SourcePackage;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
-    constructor(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: SourceFile[]);
+    constructor(uri: Uri, configuration: TranslationPackageConfiguration);
+}
+export declare class TranslationPackageA extends BaseTranslationPackage {
+    readonly dialect = PackageDialect.ArtelA;
+    readonly sourceFiles: SourceFilesA;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: SourceFilesA);
 }
-export declare class TextTranslationPackage extends SourcePackageBase {
+export declare class TranslationPackageM extends BaseTranslationPackage {
+    readonly dialect = PackageDialect.ArtelM;
+    readonly sourceFiles: SourceFilesM;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: SourceFilesM);
+}
+export type TranslationPackage = TranslationPackageA | TranslationPackageM;
+export declare namespace TranslationPackage {
+    function create(uri: Uri, configuration: TranslationPackageConfiguration, sourceFiles: readonly SourceFile[]): TranslationPackage;
+}
+export declare abstract class BaseTextTranslationPackage extends BaseSourcePackage {
     readonly kind = "text-translation";
     readonly configuration: TextTranslationPackageConfiguration;
-    protected get asPackage(): SourcePackage;
     get locale(): PackageLocale;
-    get dialect(): PackageDialect;
     get translationLocale(): string;
     get targetPackageName(): PackageName;
     get isPrimary(): boolean;
-    constructor(uri: Uri, configuration: TextTranslationPackageConfiguration, sourceFiles: SourceFile[]);
+    constructor(uri: Uri, configuration: TextTranslationPackageConfiguration);
+}
+export declare class TextTranslationPackageA extends BaseTextTranslationPackage {
+    readonly dialect = PackageDialect.ArtelA;
+    readonly sourceFiles: SourceFilesA;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: TextTranslationPackageConfiguration, sourceFiles: SourceFilesA);
+}
+export declare class TextTranslationPackageM extends BaseTextTranslationPackage {
+    readonly dialect = PackageDialect.ArtelM;
+    readonly sourceFiles: SourceFilesM;
+    protected get asPackage(): SourcePackage;
+    constructor(uri: Uri, configuration: TextTranslationPackageConfiguration, sourceFiles: SourceFilesM);
+}
+export type TextTranslationPackage = TextTranslationPackageA | TextTranslationPackageM;
+export declare namespace TextTranslationPackage {
+    function create(uri: Uri, configuration: TextTranslationPackageConfiguration, sourceFiles: readonly SourceFile[]): TextTranslationPackage;
 }
 export type PackageConfiguration = ProgramPackageConfiguration | TranslationPackageConfiguration | TextTranslationPackageConfiguration;
 export declare class TranslationPackageConfiguration {
@@ -52,6 +98,7 @@ export declare class TranslationPackageConfiguration {
     readonly translationLocale: PackageLocale;
     readonly locale: PackageLocale;
     readonly dialect: PackageDialect;
+    readonly kind = "name-translation-package";
     readonly name: PackageName;
     constructor(targetPackageName: PackageName, translatedName: PackageName, translationLocale: PackageLocale, locale: PackageLocale, dialect?: PackageDialect);
 }
@@ -65,6 +112,7 @@ export declare class TextTranslationPackageConfiguration {
     readonly targetPlatform: TargetPlatformConfig;
     readonly packageImportLocales: readonly PackageImportLocaleConfig[];
     readonly automaticallyImportedPackages?: readonly PackageName[] | undefined;
+    readonly kind = "text-translation-package";
     readonly name: PackageName;
     constructor(targetPackageName: PackageName, translationLocale: string, isPrimaryTranslation: boolean | undefined, locale: PackageLocale, dialect?: PackageDialect, version?: string | undefined, targetPlatform?: TargetPlatformConfig, packageImportLocales?: readonly PackageImportLocaleConfig[], automaticallyImportedPackages?: readonly PackageName[] | undefined);
 }
@@ -79,6 +127,7 @@ export declare class ProgramPackageConfiguration {
     readonly jsProjectRootUri?: Uri | undefined;
     readonly packageImportLocales: readonly PackageImportLocaleConfig[];
     readonly automaticallyImportedPackages?: readonly PackageName[] | undefined;
+    readonly kind = "program-package";
     constructor(name: PackageName, locale: PackageLocale, dialect?: PackageDialect, version?: string | undefined, targetPlatform?: TargetPlatformConfig, requiredPackages?: readonly RequiredPackageConfig[], implementedInterfacePackageName?: PackageName | undefined, jsProjectRootUri?: Uri | undefined, packageImportLocales?: readonly PackageImportLocaleConfig[], automaticallyImportedPackages?: readonly PackageName[] | undefined);
     isInterfacePackage(): boolean;
 }
@@ -90,6 +139,9 @@ export declare class PackageName {
     considerEqual(name: PackageName): boolean;
     toString(original?: boolean): string;
 }
+export type SourceFilesA = readonly SourceFileA[];
+export type SourceFilesM = readonly SourceFileM[];
+export type SourceFiles = SourceFilesA | SourceFilesM;
 export type RequiredPackageConfig = RequiredPackageConfig.Npm | RequiredPackageConfig.NuGet;
 export declare namespace RequiredPackageConfig {
     class Npm {

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

@@ -5,7 +5,7 @@ import * as origin from '../configuration/types/PackageConfigurationEn.js';
 import { PackageConfiguration, ProgramPackageConfiguration, TextTranslationPackageConfiguration, 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 convert(configuration: origin.Configuration | undefined, packageOrGroupUri?: Uri, defaultLocale?: PackageLocale, defaultDialect?: PackageDialect): PackageOrGroupConfiguration;
     static convertPackageConfiguration(configuration: origin.Package, packageOrGroupUri?: Uri, defaultLocale?: PackageLocale, defaultDialect?: PackageDialect): ProgramPackageConfiguration;
     static convertPackageGroupConfiguration(configuration: origin.PackageGroup): PackageGroupConfiguration;
     static convertNameTranslationsConfiguration(configuration: origin.NameTranslations, defaultLocale?: PackageLocale, defaultDialect?: PackageDialect): TranslationPackageConfiguration;
@@ -19,10 +19,8 @@ export declare class ConfigurationConverter {
     private static convertJavaScriptModuleFormat;
     private static tryParseUri;
 }
-export interface ConvertedConfiguration {
-    packageConfiguration?: PackageConfiguration;
-    packageGroupConfiguration?: PackageGroupConfiguration;
-}
+export type PackageOrGroupConfiguration = PackageConfiguration | PackageGroupConfiguration;
 export declare class PackageGroupConfiguration {
+    readonly kind = "package-group";
 }
 export declare function createDefaultPackageConfiguration(packageUri: Uri | undefined, locale?: PackageLocale, dialect?: PackageDialect): ProgramPackageConfiguration;

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

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

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

@@ -1,7 +1,6 @@
 import { PackageLocale } from '../../common/PackageLocale.js';
 import * as configEn from '../configuration/types/PackageConfigurationEn.js';
 import * as configRu from '../configuration/types/PackageConfigurationRu.js';
-export type ConfigurationArray = configEn.ConfigurationArray | configRu.МассивКонфигураций;
 export type Configuration = configEn.Configuration | configRu.Конфигурация;
 /**
  * Заменяет ключи объектов конфигурации на ключи на английском языке.
@@ -18,6 +17,5 @@ export type Configuration = configEn.Configuration | configRu.Конфигура
  * }]
  */
 export declare class ConfigurationTranslator {
-    static translate(configuration: ConfigurationArray, locale: PackageLocale): configEn.ConfigurationArray;
-    static translateConfiguration(configuration: Configuration, locale: PackageLocale): configEn.Configuration;
+    static translate(configuration: Configuration, locale: PackageLocale): configEn.Configuration;
 }

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

@@ -1,7 +1,6 @@
-export type ConfigurationArray = Configuration[];
 export type Configuration = Package | PackageGroup | NameTranslations | TextTranslations;
 export interface Package {
-    type: 'Package';
+    type?: 'Package';
     name: string;
     language?: Language;
     dialect?: Dialect;

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

@@ -1,7 +1,6 @@
-export type МассивКонфигураций = Конфигурация[];
 export type Конфигурация = Пакет | ГруппаПакетов | ПереводыИмён | ПереводыТекстов;
 export interface Пакет {
-    тип: 'Пакет';
+    тип?: 'Пакет';
     имя: string;
     язык?: Язык;
     диалект?: Диалект;

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

@@ -18,22 +18,22 @@ export declare class LanguageServer {
     private manuallyUpdatedFileSystemTreeProvider;
     private readonly sourceFileItemsService;
     private readonly workspaceItemsService;
-    private definitionService;
+    private definitionServiceA;
     private sourceGenerationService;
     private readonly referencesService;
     private readonly documentHighlightService;
-    private readonly renameService;
-    private readonly hoverService;
-    private readonly evaluatableExpressionService;
-    private readonly completionService;
-    private readonly semanticTokensService;
+    private readonly renameServiceA;
+    private readonly hoverServiceA;
+    private readonly evaluatableExpressionServiceA;
+    private readonly completionServiceA;
+    private readonly semanticTokensServiceA;
     private readonly semanticTokenTypeIndexBySemanticTokenKind;
     private readonly protocolSemanticTokenModifierFlagByIndex;
-    private readonly signatureHelpService;
+    private readonly signatureHelpServiceA;
     private readonly fileSystemTreeDisplayService;
-    private readonly selectionRangeService;
-    private readonly scriptEditingService;
-    private readonly codeActionsService;
+    private readonly selectionRangeServiceA;
+    private readonly scriptEditingServiceA;
+    private readonly codeActionsServiceA;
     constructor(config: LanguageServerConfig);
     start(): void;
     dispose(): void;

package/build/types/services/a/CodeActionsService.d.ts

@@ -0,0 +1,10 @@
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import { DiagnosticCode } from '../../diagnostic/DiagnosticCode.js';
+import { SourceFileA } from '../../project/SourceFile.js';
+import { CodeAction } from '../common/code-action/Types.js';
+import { SourceFileEdit } from '../common/Types.js';
+export declare class CodeActionsServiceA {
+    private readonly translationsGeneratorService;
+    getCodeActions(analyzer: Analyzer, sourceFile: SourceFileA, offset: number, diagnosticCodes: readonly DiagnosticCode[] | undefined): CodeAction[] | undefined;
+    resolveEdits(analyzer: Analyzer, sourceFile: SourceFileA, offset: number, name: string, data: any): SourceFileEdit[] | undefined;
+}

package/build/types/services/{CompletionService.d.ts → a/CompletionService.d.ts}

@@ -1,7 +1,7 @@
-import { Analyzer } from '../analysis/index.js';
-import { Range } from '../common/index.js';
-import { SourceFile } from '../project/index.js';
-export declare class CompletionService {
+import { Analyzer } from '../../analysis/a/Analyzer.js';
+import { SourceFileA } from '../../project/index.js';
+import { CompletionItem, ResolutionResult } from '../common/completion/Types.js';
+export declare class CompletionServiceA {
     private readonly cache;
     private sourceFile;
     private analyzer;
@@ -9,7 +9,7 @@ export declare class CompletionService {
     private dialect;
     private readonly completionItemInfoContext_;
     private get completionItemInfoContext();
-    getCompletions(analyzer: Analyzer, sourceFile: SourceFile, offset: number): readonly CompletionItem[];
+    getCompletions(analyzer: Analyzer, sourceFile: SourceFileA, offset: number): readonly CompletionItem[];
     resolveCompletionItem(cacheId: number, indexInCache: number): ResolutionResult;
     private createSemanticContextAtPosition;
     private createPositionDescription;
@@ -57,50 +57,3 @@ export declare class CompletionService {
     private convertCompletionItemInfos;
     private convertCompletionItemInfo;
 }
-export declare class CompletionItem {
-    readonly label: string;
-    readonly kind: CompletionItemKind;
-    readonly details: string | undefined;
-    readonly insertText: string | undefined;
-    readonly editRange: Range | undefined;
-    readonly sortText: string | undefined;
-    readonly cacheId: number;
-    readonly indexInCache: number;
-    constructor(label: string, kind: CompletionItemKind, details: string | undefined, insertText: string | undefined, editRange: Range | undefined, sortText: string | undefined, cacheId: number, indexInCache: number);
-}
-export declare const enum CompletionItemKind {
-    PackageNameSegment = 0,
-    PackageAlias = 1,
-    Field = 2,
-    Method = 3,
-    Operator = 4,
-    Indexer = 5,
-    Constructor = 6,
-    PackageVariable = 7,
-    PackageFunction = 8,
-    LocalVariable = 9,
-    Parameter = 10,
-    NestedFunction = 11,
-    VariantValue = 12,
-    Class = 13,
-    Structure = 14,
-    Aspect = 15,
-    Variant = 16,
-    TypeParameter = 17,
-    AliasType = 18,
-    ReducedType = 19,
-    InvalidType = 20,
-    Keyword = 21,
-    TargetSignatureParameter = 22,
-    OperatorName = 23
-}
-export type ResolutionResult = ResolutionResult_item | ResolutionResult_notInCache;
-export declare class ResolutionResult_item {
-    readonly value: CompletionItem;
-    readonly sourceFile: SourceFile;
-    readonly kind = "item";
-    constructor(value: CompletionItem, sourceFile: SourceFile);
-}
-export declare class ResolutionResult_notInCache {
-    readonly kind = "not-in-cache";
-}

package/build/types/services/a/DefinitionService.d.ts

@@ -0,0 +1,11 @@
+import { Analyzer } from '../../analysis/Analyzer.js';
+import { Range } from '../../common/index.js';
+import { SourceFileA } from '../../project/index.js';
+import { DefinitionService } from '../common/definition/DefinitionService.js';
+import { NodeSemanticInfo } from '../common/node-semantic-info/Types.js';
+export declare class DefinitionServiceA extends DefinitionService<SourceFileA> {
+    protected getSemanticInfoAndRangeAtOffset(analyzer: Analyzer, sourceFile: SourceFileA, offset: number): {
+        semanticInfo: NodeSemanticInfo;
+        range: Range;
+    } | undefined;
+}