@abaplint/core/build/abaplint.d.ts

abaplint - Core API

import * as LServer from 'vscode-languageserver-types';
import { WorkspaceEdit } from 'vscode-languageserver-types';

export declare class ABAPFile extends AbstractFile {
    private readonly tokens;
    private readonly statements;
    private readonly structure;
    private readonly file;
    private readonly info;
    constructor(file: IFile, tokens: readonly Token[], statements: readonly StatementNode[], structure: StructureNode | undefined, info: IABAPFileInformation);
    getRaw(): string;
    getInfo(): IABAPFileInformation;
    getRawRows(): string[];
    getStructure(): StructureNode | undefined;
    getTokens(withPragmas?: boolean): readonly Token[];
    getStatements(): readonly StatementNode[];
}

export declare abstract class ABAPObject extends AbstractObject {
    private parsed;
    protected texts: ITextElements | undefined;
    syntaxResult: ISyntaxResult | undefined;
    abstract getSequencedFiles(): readonly ABAPFile[];
    abstract getDescription(): string | undefined;
    constructor(name: string);
    static is(x: any): x is ABAPObject;
    parse(version: Version, globalMacros?: readonly string[], reg?: IRegistry): IParseResult;
    setDirty(): void;
    getABAPFiles(): readonly ABAPFile[];
    getABAPFileByName(filename: string): ABAPFile | undefined;
    getMainABAPFile(): ABAPFile | undefined;
    getTexts(): ITextElements;
    protected findTexts(parsed: any): void;
}

declare class ABAPQueryFunctionalArea extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class ABAPQueryQuery extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class Abstract extends Expression {
    getRunnable(): IStatementRunnable;
}

export declare abstract class AbstractFile implements IFile {
    private readonly filename;
    constructor(filename: string);
    getFilename(): string;
    private baseName;
    getObjectType(): string | undefined;
    getObjectName(): string;
    abstract getRaw(): string;
    abstract getRawRows(): string[];
}

declare class AbstractMethods extends Expression {
    getRunnable(): IStatementRunnable;
}

declare abstract class AbstractNode<T extends INode> implements INode {
    protected children: T[];
    constructor();
    abstract get(): any;
    abstract getFirstToken(): Token;
    abstract getLastToken(): Token;
    addChild(n: T): void;
    setChildren(children: T[]): void;
    getChildren(): readonly T[];
    getFirstChild(): T | undefined;
    getLastChild(): T | undefined;
}

declare abstract class AbstractObject implements IObject {
    protected old: readonly Issue[];
    protected dirty: boolean;
    private files;
    private readonly name;
    abstract getType(): string;
    abstract getAllowedNaming(): IAllowedNaming;
    abstract getDescription(): string | undefined;
    constructor(name: string);
    getParsingIssues(): readonly Issue[];
    parse(_version?: Version, _globalMacros?: readonly string[], _reg?: IRegistry): IParseResult;
    getName(): string;
    setDirty(): void;
    addFile(file: IFile): void;
    getFiles(): readonly IFile[];
    containsFile(filename: string): boolean;
    removeFile(file: IFile): void;
    isDirty(): boolean;
    getIdentifier(): Identifier | undefined;
    getXMLFile(): IFile | undefined;
    getXML(): string | undefined;
    updateFile(file: IFile): void;
    protected parseRaw2(): any | undefined;
}

export declare abstract class AbstractType {
    protected readonly data: AbstractTypeData | undefined;
    constructor(input?: AbstractTypeData);
    getAbstractTypeData(): AbstractTypeData | undefined;
    /** fully qualified symbolic name of the type */
    getQualifiedName(): string | undefined;
    getRTTIName(): string | undefined;
    getDescription(): string | undefined;
    getConversionExit(): string | undefined;
    getDDICName(): string | undefined;
    abstract toText(level: number): string;
    abstract toABAP(): string;
    abstract toCDS(): string;
    abstract isGeneric(): boolean;
    abstract containsVoid(): boolean;
}

declare type AbstractTypeData = {
    qualifiedName?: string;
    conversionExit?: string;
    derivedFromConstant?: boolean;
    ddicName?: string;
    RTTIName?: string;
    description?: string;
};

declare class ActivationVariant extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class Add implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AddCorresponding implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Alias extends Identifier {
    private readonly visibility;
    private readonly component;
    constructor(token: Token, visibility: Visibility, component: string, filename: string);
    getComponent(): string;
    getVisibility(): Visibility;
}

declare class Aliases implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AndReturn extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Any implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class AnyType extends AbstractType {
    private static readonly singletons;
    static get(input?: AbstractTypeData): AnyType;
    private constructor();
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class APIReleaseState extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class Append implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ApplicationDescriptorsFiori extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class ApplicationJobCatalogEntry extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class ApplicationJobTemplate extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class ApplicationLogObject extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

/** returns list of filenames which were changed */
declare function applyEditList(reg: IRegistry, edits: IEdit[]): string[];

declare function applyEditSingle(reg: IRegistry, edit: IEdit): void;

declare class ArithOperator extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Arrow extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ArrowOrDash extends Expression {
    getRunnable(): IStatementRunnable;
}

export declare class ArtifactsABAP {
    static getStructures(): IStructure[];
    static getExpressions(): (new () => Expression)[];
    static getStatements(): IStatement[];
    static getKeywords(): IKeyword[];
}

export declare class ArtifactsObjects {
    private static objectMap;
    static newObject(name: string, type: string): IObject;
    private static buildObjectMap;
}

export declare class ArtifactsRules {
    static getRules(): IRule[];
}

declare class Assert implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Assign implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AssignLocalCopy implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AssignmentServiceToAuthorizationGroup extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class AssignSource extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class AssociationName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class At implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class At_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class At_3 extends Token {
    static railroad(): string;
}

declare class ATCCheckCategory extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class ATCCheckObject extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class ATCCheckVariant extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class AtFirst implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class AtFirst_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AtLast implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class AtLast_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AtLineSelection implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AtPF implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AtSelectionScreen implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AttributeChain extends Expression {
    getRunnable(): IStatementRunnable;
}

declare enum AttributeLevel {
    Instance = "instance",
    Static = "static",
    Constant = "constant"
}

declare class AttributeName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Attributes implements IAttributes {
    private readonly static;
    private readonly instance;
    private readonly constants;
    private readonly types;
    private readonly tlist;
    private readonly filename;
    private readonly aliases;
    constructor(node: StructureNode, input: SyntaxInput);
    getTypes(): TypeDefinitions;
    getStatic(): ClassAttribute[];
    getAliases(): Alias[];
    getAll(): readonly ClassAttribute[];
    getStaticsByVisibility(visibility: Visibility): ClassAttribute[];
    getInstance(): ClassAttribute[];
    getInstancesByVisibility(visibility: Visibility): ClassAttribute[];
    getConstants(): ClassConstant[];
    getConstantsByVisibility(visibility: Visibility): ClassConstant[];
    findByName(name: string): ClassAttribute | ClassConstant | undefined;
    private parse;
    private parseSection;
    private parseAlias;
    private parseAttribute;
}

declare class AtUserCommand implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AtW extends Token {
    static railroad(): string;
}

declare class AuthorityCheck implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class AuthorizationCheckField extends AbstractObject {
    private parsedXML;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    getDescription(): string | undefined;
    getDataElementName(): string | undefined;
    parseType(reg: IRegistry): AbstractType;
    parse(): {
        updated: boolean;
        runtime: number;
    };
}

declare class AuthorizationGroup extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class AuthorizationObject extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class AuthorizationObjectClass extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class AuthorizationObjectExtension extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class Back implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class BADIDefinition extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare namespace BasicTypes {
    export {
        AnyType,
        CGenericType,
        CharacterType,
        CLikeType,
        CSequenceType,
        DataReference,
        DataType,
        DateType,
        DecFloatType,
        DecFloat16Type,
        DecFloat34Type,
        FloatType,
        FloatingPointType,
        GenericObjectReferenceType,
        HexType,
        IntegerType,
        Integer8Type,
        NumericGenericType,
        NumericType,
        ObjectReferenceType,
        PackedType,
        SimpleType,
        StringType,
        IStructureComponent,
        StructureType,
        TableAccessType,
        TableKeyType,
        ITableKey,
        ITableOptions,
        TableType_2 as TableType,
        TimeType,
        UnknownType,
        UTCLongType,
        VoidType,
        XGenericType,
        XSequenceType,
        XStringType
    }
}
export { BasicTypes }

declare class BehaviorDefinition extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BehaviorDefinitionName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class BlockName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Body implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class BracketLeft extends Token {
    static railroad(): string;
}

declare class BracketLeftW extends Token {
    static railroad(): string;
}

declare class BracketRight extends Token {
    static railroad(): string;
}

declare class BracketRightW extends Token {
    static railroad(): string;
}

declare class Break implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class BreakId implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class BRFPlusSystemApplication extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BSPApplication extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

export declare class BuiltIn {
    static readonly filename = "_builtin.prog.abap";
    private static counter;
    private static readonly getCache;
    static readonly methods: {
        [name: string]: IBuiltinMethod;
    };
    private row;
    private static buildDefinition;
    static searchBuiltin(name: string | undefined): IMethodDefinition | undefined;
    static isPredicate(name: string | undefined): boolean | undefined;
    getTypes(): TypedIdentifier[];
    get(extras: string[]): TypedIdentifier[];
    private buildVariable;
    private buildSY;
    private buildConstant;
}

declare class BuiltInMethod extends Identifier implements IMethodDefinition, IMethodParameters {
    private readonly method;
    private readonly row;
    constructor(token: Token, filename: string, method: IBuiltinMethod, row: number);
    getRequiredParameters(): readonly TypedIdentifier[];
    getOptional(): readonly string[];
    getAll(): readonly TypedIdentifier[];
    getEventName(): undefined;
    getEventClass(): undefined;
    getImporting(): readonly TypedIdentifier[];
    getDefaultImporting(): string | undefined;
    getExporting(): readonly TypedIdentifier[];
    getRaising(): readonly string[];
    getChanging(): readonly TypedIdentifier[];
    getReturning(): TypedIdentifier | undefined;
    getExceptions(): readonly string[];
    getVisibility(): Visibility;
    isRedefinition(): boolean;
    isAbstract(): boolean;
    isStatic(): boolean;
    isEventHandler(): boolean;
    getParameters(): IMethodParameters;
    getParameterDefault(_parameter: string): undefined;
}

declare class BusinessAddInImplementation extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BusinessCatalog extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BusinessCatalogAppAssignment extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BusinessConfigurationMaintenanceObject extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BusinessConfigurationSet extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BusinessFunctionAssignment extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BusinessFunctionSetAssignment extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BusinessObjectModel extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class BusinessObjectType extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class Call implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallBadi implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallDatabase implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallDialog implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallFunction implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallKernel implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallOLE implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallScreen implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallSelectionScreen implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallSubscreen implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallTransaction implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallTransformation implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CallTransformationOptions extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CallTransformationParameters extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Case implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class Case_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CaseType implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class CaseType_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Cast extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Catch implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class Catch_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CatchSystemExceptions implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class CatchSystemExceptions_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CDSAggregate extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSAnnotate extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSAnnotation extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSAnnotationArray extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSAnnotationObject extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSAnnotationSimple extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSArithmetics extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSAs extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSAssociation extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSCardinality extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSCase extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSCast extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSComposition extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSCondition extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSDefineAbstract extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSDefineCustom extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSDefineProjection extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSDefineTableFunction extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSDefineView extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSElement extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSExtendView extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSFunction extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSFunctionInput extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSGroupBy extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSHaving extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSInteger extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSJoin extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSMetadataExtension extends AbstractObject {
    private parserError;
    private parsedData;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    hasParserError(): boolean | undefined;
    parse(): IParseResult;
    getDescription(): string | undefined;
    findSourceFile(): IFile | undefined;
}

declare class CDSName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSParameters extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSParametersSelect extends Expression {
    getRunnable(): IStatementRunnable;
}

export declare class CDSParser {
    parse(file: IFile | undefined): ExpressionNode | undefined;
}

declare class CDSPrefixedName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSProviderContract extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSRelation extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSSelect extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSSource extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSString extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSType extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class CDSType_2 extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSWhere extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CDSWithParameters extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CGenericType extends AbstractType {
    private static readonly singleton;
    static get(): CGenericType;
    private constructor();
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class Chain implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class Chain_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ChangeDocument extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class ChapterOfBookStructure extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class CharacterType extends AbstractType {
    private readonly length;
    constructor(length: number, extra?: AbstractTypeData);
    cloneType(input: {
        qualifiedName?: string;
        ddicName?: string;
        derivedFromConstant?: boolean;
    }): CharacterType;
    getLength(): number;
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    getIdentifier(): undefined;
    toCDS(): string;
}

declare class Check implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CheckpointGroup extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class CheckSelectOptions implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Class extends ABAPObject {
    private def;
    private parsedXML;
    getType(): string;
    getSequencedFiles(): readonly ABAPFile[];
    setDefinition(def: IClassDefinition | undefined): void;
    getDefinition(): IClassDefinition | undefined;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    getClassDefinition(): InfoClassDefinition | undefined;
    getIdentifier(): Identifier | undefined;
    getDescription(): string | undefined;
    getNameFromXML(): string | undefined;
    getCategory(): string | undefined;
    getLocalsImpFile(): ABAPFile | undefined;
    getTestclassFile(): ABAPFile | undefined;
    private parseXML;
}

declare class ClassAttribute extends TypedIdentifier {
    private readonly visibility;
    constructor(id: TypedIdentifier, visibility: Visibility, meta: readonly IdentifierMeta[], value?: string | {
        [index: string]: string;
    });
    getVisibility(): Visibility;
}

declare enum ClassCategory {
    Test = "05",
    Persistent = "10",
    PersistentFactory = "11",
    Exception = "40",
    SharedObject = "45"
}

declare class ClassConstant extends TypedIdentifier {
    private readonly visibility;
    constructor(id: TypedIdentifier, visibility: Visibility, value: string | {
        [index: string]: string;
    } | undefined);
    getVisibility(): Visibility;
}

declare class ClassData implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class ClassData_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ClassDataBegin implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ClassDataEnd implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ClassDeferred implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ClassDefinition implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class ClassDefinition_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ClassDefinition_3 extends Identifier implements IClassDefinition {
    private readonly methodDefs;
    private readonly types;
    private readonly attributes;
    private readonly events;
    private readonly friends;
    private readonly superClass;
    private readonly implementing;
    private readonly testing;
    private readonly abstract;
    private readonly finalValue;
    private readonly globalValue;
    private readonly sharedMemory;
    private readonly aliases;
    constructor(node: StructureNode, input: SyntaxInput);
    getFriends(): string[];
    getEvents(): IEventDefinition[];
    getMethodDefinitions(): IMethodDefinitions;
    getTypeDefinitions(): TypeDefinitions;
    getSuperClass(): string | undefined;
    getAttributes(): Attributes;
    isGlobal(): boolean;
    isFinal(): boolean;
    getImplementing(): readonly IImplementing[];
    getAliases(): Alias[];
    isForTesting(): boolean;
    isAbstract(): boolean;
    isSharedMemory(): boolean;
    private findSuper;
    private checkMethodNameLength;
    private checkMethodsFromSuperClasses;
    private findFriends;
    private addReference;
    private parse;
}

declare class ClassDefinitionLoad implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ClassFinal extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ClassFriends extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ClassGlobal implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class ClassGlobal_2 extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Classification extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class ClassImplementation implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class ClassImplementation_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ClassImplementation_3 extends Identifier implements IClassImplementation {
    private readonly node;
    constructor(node: StructureNode, filename: string);
    getMethodImplementations(): MethodImplementation_2[];
    getMethodImplementation(name: string): MethodImplementation_2 | undefined;
}

declare class ClassLocalFriends implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ClassName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Cleanup implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class Cleanup_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Clear implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CLikeType extends AbstractType {
    private static readonly singleton;
    static get(): CLikeType;
    private constructor();
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class CloseCursor implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CloseDataset implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare type CodeLensSettings = {
    messageText: boolean;
    dynamicExceptions: boolean;
};

declare class Collect implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Colon extends Token {
}

declare class Color extends Expression {
    getRunnable(): IStatementRunnable;
}

export declare class Comment implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Comment_2 extends Token {
}

declare class Commit implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CommitEntities implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Communication implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CommunicationScenario extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class Compare extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CompareOperator extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ComponentChain extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ComponentChainSimple extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ComponentCompare extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ComponentCompareSimple extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ComponentCompareSingle extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ComponentCond extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ComponentCondSub extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ComponentName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CompositeEnhancementImplementation extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class CompositeEnhancementSpot extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class Compute implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Concatenate implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ConcatenatedConstant extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ConceptsOfPackage extends AbstractObject {
    getType(): string;
    getAllowedNaming(): IAllowedNaming;
    getDescription(): string | undefined;
}

declare class Cond extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CondBody extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Condense implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CondSub extends Expression {
    getRunnable(): IStatementRunnable;
}

export declare class Config implements IConfiguration {
    private readonly config;
    static getDefault(ver?: Version): Config;
    getEnabledRules(): IRule[];
    constructor(json: string);
    get(): IConfig;
    readByKey(rule: string, key: string): any;
    readByRule(rule: string): any;
    getGlobal(): IGlobalConfig;
    getSyntaxSetttings(): ISyntaxSettings;
    getVersion(): Version;
    private checkVersion;
}

declare class Constant implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Constant_2 extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class ConstantBegin implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ConstantEnd implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ConstantFieldLength extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Constants implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class ConstantString extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Contexts implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Continue implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class Controls implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ConvBody extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Convert implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class ConvertText implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CorrespondingBody extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CorrespondingBodyBase extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class CreateData implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CreateObject implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CreateOLE implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class CSequenceType extends AbstractType {
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

export declare class CurrentScope {
    protected readonly reg: IRegistry;
    protected current: SpaghettiScopeNode | undefined;
    protected allowHeaderUse: string | undefined;
    protected parentObj: IObject;
    static buildDefault(reg: IRegistry, obj: IObject): CurrentScope;
    private static addBuiltIn;
    private constructor();
    getVersion(): Version;
    getRegistry(): IRegistry;
    addType(type: TypedIdentifier | undefined): void;
    addTypeNamed(name: string, type: TypedIdentifier | undefined): void;
    addExtraLikeType(type: TypedIdentifier | undefined): void;
    addExtraLikeTypeNamed(name: string, type: TypedIdentifier | undefined): void;
    addClassDefinition(c: IClassDefinition): void;
    addFormDefinitions(f: readonly IFormDefinition[]): void;
    addInterfaceDefinition(i: IInterfaceDefinition): void;
    addNamedIdentifier(name: string, identifier: TypedIdentifier): void;
    addNamedIdentifierToParent(name: string, identifier: TypedIdentifier): void;
    addIdentifier(identifier: TypedIdentifier | undefined): void;
    addDeferred(token: Token | undefined, type: "CLAS" | "INTF"): void;
    addListPrefix(identifiers: readonly TypedIdentifier[], prefix: string): void;
    addList(identifiers: readonly TypedIdentifier[]): void;
    addReference(usage: Token | undefined, referencing: Identifier | undefined, type: ReferenceType | ReferenceType[] | undefined, filename: string, extra?: IReferenceExtras): void;
    addSQLConversion(fieldName: string, message: string, token: Token): void;
    findFunctionModule(name: string | undefined): FunctionModuleDefinition | undefined;
    findObjectDefinition(name: string | undefined): IClassDefinition | IInterfaceDefinition | undefined;
    isBadiDef(name: string): boolean;
    existsObject(name: string | undefined): {
        id: Identifier | undefined;
        ooType?: IReferenceExtras["ooType"];
        RTTIName?: string;
    } | undefined;
    /** Lookup class in local and global scope */
    findClassDefinition(name: string | undefined): IClassDefinition | undefined;
    findTypePoolConstant(name: string | undefined): TypedIdentifier | undefined;
    findTypePoolType(name: string): TypedIdentifier | undefined;
    /** Lookup interface in local and global scope */
    findInterfaceDefinition(name: string | undefined): IInterfaceDefinition | undefined;
    findFormDefinition(name: string): IFormDefinition | undefined;
    findType(name: string | undefined): TypedIdentifier | undefined;
    findExtraLikeType(name: string | undefined): TypedIdentifier | undefined;
    findVariable(name: string | undefined): TypedIdentifier | undefined;
    getDDIC(): DDIC;
    getDDICReferences(): IDDICReferences;
    getMSAGReferences(): IMSAGReferences;
    getParentObj(): IObject;
    getName(): string;
    getType(): ScopeType;
    push(stype: ScopeType, sname: string, start: Position, filename: string): void;
    isOO(): boolean;
    isAnyOO(): boolean;
    isGlobalOO(): boolean;
    isTypePool(): boolean;
    setAllowHeaderUse(name: string): void;
    isAllowHeaderUse(name: string): boolean;
    pop(end: Position): SpaghettiScope;
}

declare class CustomDataBrowserObject extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class CustomerEnhancementProject extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class CustomizingAttributes extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class CustomizingImgActivity extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class CustomizingTransaction extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

export declare class CyclomaticComplexityStats {
    static run(obj: IObject): ICyclomaticComplexityResult[];
}

declare class Dash extends Token {
    static railroad(): string;
}

declare class DashW extends Token {
    static railroad(): string;
}

declare class Data implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class Data_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class DatabaseConnection extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class DatabaseTable extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class DataBegin implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class DataControl extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

declare class DataDefinition extends AbstractObject {
    private parserError;
    private parsedData;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getSQLViewName(): string | undefined;
    getDefinitionName(): string | undefined;
    getDescription(): string | undefined;
    parseType(reg: IRegistry): AbstractType;
    getParsedData(): ParsedDataDefinition | undefined;
    listSources(): {
        name: string;
        as: string | undefined;
    }[] | undefined;
    setDirty(): void;
    findSourceFile(): IFile | undefined;
    hasParserError(): boolean | undefined;
    listKeys(): string[];
    parse(): IParseResult;
    getTree(): ExpressionNode | undefined;
    private findSQLViewName;
    private findDescription;
    private findFieldNames;
    private findSourcesAndRelations;
}

declare class DataDefinition_2 extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class DataElement extends AbstractObject {
    private parsedXML;
    private parsedType;
    getType(): string;
    getDescription(): string | undefined;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    getDomainName(): string | undefined;
    getTexts(): {
        short?: string;
        medium?: string;
        long?: string;
        heading?: string;
    } | undefined;
    parseType(reg: IRegistry): AbstractType;
    parse(): {
        updated: boolean;
        runtime: number;
    };
}

declare class DataEnd implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class DataReference extends AbstractType {
    private readonly type;
    constructor(type: AbstractType, qualifiedName?: string);
    toText(level: number): string;
    getType(): AbstractType;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class DataType extends AbstractType {
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class DateType extends AbstractType {
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class DDIC {
    private readonly reg;
    constructor(reg: IRegistry);
    isException(def: InfoClassDefinition | undefined, _obj: ABAPObject): boolean;
    lookupBuiltinType(name: string, length?: number, decimals?: number, qualifiedName?: string): AbstractType | undefined;
    inErrorNamespace(name: string | undefined): boolean;
    lookupObject(name: string): ILookupResult;
    lookupNoVoid(name: string): ILookupResult | undefined;
    lookupDDLS(name?: string): {
        type: AbstractType;
        object: DataDefinition;
    } | undefined;
    /** lookup with voiding and unknown types */
    lookup(name: string): ILookupResult;
    lookupDomain(name: string, dataElement?: string, description?: string): ILookupResult;
    lookupDataElement(name: string | undefined): ILookupResult;
    lookupTableOrView(name: string | undefined): ILookupResult;
    /** this method only looks up the object, does not parse the type */
    lookupTableOrView2(name: string | undefined): Table | DataDefinition | View | undefined;
    lookupTable(name: string | undefined): AbstractType;
    private lookupView;
    lookupTableType(name: string | undefined): ILookupResult;
    textToType(input: {
        text: string | undefined;
        length: string | undefined;
        decimals: string | undefined;
        infoText: string;
        qualifiedName?: string;
        conversionExit?: string;
        ddicName?: string;
        description?: string;
    }): AbstractType;
}

declare enum DDLKind {
    Structure = "structure",
    Table = "table"
}

export declare class DDLParser {
    parse(file: IFile): IDDLParserResult | undefined;
    private parsedToResult;
}

declare class DecFloat16Type extends AbstractType {
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class DecFloat34Type extends AbstractType {
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class DecFloatType extends AbstractType {
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class Decimals extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class Default extends Expression {
    getRunnable(): IStatementRunnable;
}

declare type DeferredInformation = {
    token: Token;
    ooType: "CLAS" | "INTF";
};

declare class Define implements IStructure {
    getMatcher(): IStructureRunnable;
}

declare class Define_2 implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class DefinitionName extends Expression {
    getRunnable(): IStatementRunnable;
}

declare class DeleteCluster implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class DeleteDatabase implements IStatement {
    getMatcher(): IStatementRunnable;
}

declare class DeleteDataset implements IStatement {
    getMatcher(): IState