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

export declare class ABAPFile extends AbstractFile implements IABAPFile {
    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;
    getRawRows(): string[];
    getInfo(): IABAPFileInformation;
    getStructure(): StructureNode | undefined;
    getTokens(withPragmas?: boolean): readonly Token[];
    getStatements(): readonly StatementNode[];
}

export declare abstract class ABAPObject extends AbstractObject {
    private parsed;
    protected texts: {
        [id: string]: ITextElements;
    } | undefined;
    private textsTranslations;
    private rawXMLCache;
    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;
    private getParsedXML;
    getABAPFiles(): readonly ABAPFile[];
    getABAPFileByName(filename: string): ABAPFile | undefined;
    getMainABAPFile(): ABAPFile | undefined;
    getTextSymbols(): ITextElements;
    getTextElements(): ITextElements;
    getTextElementsTranslations(): ITranslationTextElements[];
    protected findTexts(parsed: any): void;
    private findTextsTranslations;
}

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;
    private readonly declaredInterfaces;
    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,
        EnumType,
        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;
}

/**
 * Arithmetic expression: one or more values joined by +, -, *, /.
 *
 * Parenthesized sub-expressions of any nesting depth are handled via the
 * separate CDSArithParen singleton (which wraps back to CDSArithmetics).
 * The mutual reference between two distinct singletons enables true n-level
 * nesting with no fixed limit and no infinite recursion.
 *
 * Grammar (simplified):
 *   CDSArithmetics  →  operand (op operand)+          -- with-operator form
 *                    | unary val                       -- unary form
 *                    | unary val (op operand)+         -- unary + continuation
 *                    | unary CDSArithParen             -- unary applied to paren, e.g. -(field)
 *                    | unary CDSArithParen (op op)+    -- unary paren + continuation
 *   operand         →  CDSArithParen | val
 *   CDSArithParen   →  "(" CDSArithmetics ")" | "(" CDSArithParen ")" | "(" val ")"
 */
declare class CDSArithmetics extends Expression {
    getRunnable(): IStatementRunnable;
}

/**
 * Parenthesized arithmetic sub-expression.
 *
 * Matches either:
 *   "(" CDSArithmetics ")"  — parenthesized expression with operators, e.g. (A + B), (A - B * C)
 *   "(" CDSArithParen ")"   — nested grouping parens, e.g. ((A + B)), (((A + B)))
 *   "(" val ")"             — parenthesized single value used for grouping, e.g. (field), (func(...))
 *
 * Mutual recursion with CDSArithmetics enables n-level deep nesting with no fixed limit:
 *   CDSArithmetics  →  operand (op operand)+
 *   CDSArithParen   →  "(" CDSArithmetics ")" | "(" CDSArithParen ")" | "(" val ")"
 */
declare class CDSArithParen 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 CDSDefineHierarchy 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 CDSEntityBuffer extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

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;
    private readonly createVisibilityValue;
    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;
    getCreateVisibility(): Visibility;
    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 CorrespondingBodyMapping 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;
    private readonly localFriends;
    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;
    findReturningParameter(): 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;
    addLocalFriend(className: string, friendName: string): void;
    isLocalFriend(className: string, friendName: string): boolean;
    getEnclosingClassName(): string | undefined;
    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;
    getTextMaxLengths(): {
        short?: string;
        medium?: string;
        long?: string;
        heading?: string;
    } | undefined;
    getTextsTranslations(): {
        language: string;
        description?: string;
        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 DatastoreObject extends AbstractObject {
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

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(): IStatementRunnable;
}

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

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

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

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

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

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

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

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

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

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

export declare class Diagnostics {
    private readonly reg;
    constructor(reg: IRegistry);
    findIssues(textDocument: LServer.TextDocumentIdentifier): readonly Issue[];
    static mapDiagnostic(issue: Issue): LServer.Diagnostic;
    find(textDocument: LServer.TextDocumentIdentifier): LServer.Diagnostic[];
    private static mapSeverity;
}

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

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

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

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

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

declare class Domain extends AbstractObject {
    private parsedXML;
    getType(): string;
    getDescription(): string | undefined;
    getConversionExit(): string | undefined;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    parseType(reg: IRegistry, dataElement?: string, description?: string): AbstractType;
    parse(): {
        updated: boolean;
        runtime: number;
    };
    getFixedValues(): DomainValue[];
    getFixedValuesTranslations(): DomainValueTranslation[];
}

declare interface DomainValue {
    language: string;
    low: string;
    high: string;
    description: string;
}

declare interface DomainValueTranslation {
    language: string;
    description: string;
}

declare enum Duration {
    short = "SHORT",
    medium = "MEDIUM",
    long = "LONG"
}

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

declare type DynproField = {
    name: string;
    type: string;
    length: number;
    vislength: number;
    line: number;
    column: number;
    height: number;
};

declare type DynproHeader = {
    number: string;
    description: string;
    nextScreen: string;
    type: string;
    fields: DynproField[];
};

declare type DynproList = DynproHeader[];

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

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

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

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

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

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

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

export declare const Edits: {
    applyEditSingle: typeof applyEditSingle;
    applyEditList: typeof applyEditList;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare enum EnhancementCategory {
    NotClassified = "0",
    CannotBeEnhanced = "1",
    Character = "2",
    CharacterOrNumeric = "3",
    Deep = "4"
}

declare class EnhancementImplementation extends AbstractObject {
    private parsedXML;
    getType(): string;
    setDirty(): void;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getClassName(): string | undefined;
    getDescription(): string | undefined;
    parse(): {
        updated: boolean;
        runtime: number;
    };
}

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

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

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

declare class EnhancementSpot extends AbstractObject {
    private badis;
    getType(): string;
    getDescription(): string | undefined;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    listBadiDefinitions(): IBadiDefinition[];
    private parseXML;
}

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

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

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

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

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

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

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

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

/** non class based exception name */
declare class ExceptionName extends Expression {
    getRunnable(): IStatementRunnable;
}

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

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

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

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

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

declare abstract class Expression implements IStatementRunnable {
    private runnable;
    run(r: Result[]): Result[];
    abstract getRunnable(): IStatementRunnable;
    listKeywords(): string[];
    getUsing(): string[];
    getName(): string;
    railroad(): string;
    toStr(): string;
    first(): string[];
}

declare class ExpressionNode extends AbstractNode<ExpressionNode | TokenNode> {
    private readonly expression;
    constructor(expression: IStatementRunnable);
    get(): IStatementRunnable;
    countTokens(): number;
    getFirstToken(): Token;
    concatTokensWithLinebreaks(): string;
    concatTokens(): string;
    concatTokensWithoutStringsAndComments(): string;
    getTokens(): readonly Token[];
    private toTokens;
    getLastToken(): Token;
    getAllTokens(): Token[];
    getDirectTokens(): readonly Token[];
    findDirectExpression(type: new () => IStatementRunnable): ExpressionNode | undefined;
    findExpressionAfterToken(text: string): ExpressionNode | undefined;
    findDirectExpressions(type: new () => IStatementRunnable): readonly ExpressionNode[];
    findDirectExpressionsMulti(type: (new () => IStatementRunnable)[]): ExpressionNode[];
    findDirectTokenByText(text: string): Token | undefined;
    findAllExpressionsRecursive(type: new () => IStatementRunnable): readonly ExpressionNode[];
    findAllExpressions(type: new () => IStatementRunnable): readonly ExpressionNode[];
    findAllExpressionsMulti(type: (new () => IStatementRunnable)[], recursive?: boolean): ExpressionNode[];
    findFirstExpression(type: new () => IStatementRunnable): ExpressionNode | undefined;
}

declare namespace Expressions {
    export {
        AbstractMethods,
        Abstract,
        AndReturn,
        ArithOperator,
        ArrowOrDash,
        Arrow,
        AssignSource,
        AssociationName,
        AttributeChain,
        AttributeName,
        BehaviorDefinitionName,
        BlockName,
        CallTransformationOptions,
        CallTransformationParameters,
        Cast,
        ClassFinal,
        ClassFriends,
        ClassGlobal_2 as ClassGlobal,
        ClassName,
        Color,
        CompareOperator,
        Compare,
        ComponentChainSimple,
        ComponentChain,
        ComponentCompareSimple,
        ComponentCompareSingle,
        ComponentCompare,
        ComponentCondSub,
        ComponentCond,
        ComponentName,
        ConcatenatedConstant,
        CondBody,
        CondSub,
        Cond,
        ConstantFieldLength,
        ConstantString,
        Constant_2 as Constant,
        ConvBody,
        CorrespondingBodyBase,
        CorrespondingBodyMapping,
        CorrespondingBody,
        DataDefinition_2 as DataDefinition,
        DatabaseConnection,
        DatabaseTable,
        Decimals,
        Default,
        DefinitionName,
        Dereference,
        Destination,
        Dynamic,
        EntityAssociation,
        EventHandler,
        EventName,
        ExceptionName,
        FieldAll,
        FieldAssignment,
        FieldChain,
        FieldLength,
        FieldOffset,
        FieldSub,
        FieldSymbol_2 as FieldSymbol,
        Field_2 as Field,
        FilterBody,
        FinalMethods,
        FindType,
        For,
        FormChanging,
        FormName,
        FormParamName,
        FormParamType,
        FormParam,
        FormRaising,
        FormTables,
        FormUsing,
        FSTarget,
        FunctionExportingParameter,
        FunctionExporting,
        FunctionName,
        FunctionParameters,
        IncludeName,
        InlineFieldDefinition,
        InlineField,
        InlineLoopDefinition,
        InlineData,
        InlineFS,
        Integer,
        InterfaceName,
        KernelId,
        Language,
        Length,
        Let,
        LOBHandle,
        LoopGroupByComponent,
        LoopGroupByTarget,
        LoopGroupBy,
        LoopSource,
        LoopTarget,
        MacroName,
        MessageClass_2 as MessageClass,
        MessageNumber,
        MessageSourceSource,
        MessageSource,
        MessageTypeAndNumber,
        MethodCallBody,
        MethodCallChain,
        MethodCallParam,
        MethodCall,
        MethodDefChanging,
        MethodDefExceptions,
        MethodDefExporting,
        MethodDefImporting,
        MethodDefRaising,
        MethodDefReturning,
        MethodName,
        MethodParamName,
        MethodParamOptional,
        MethodParam,
        MethodParameters,
        MethodSource,
        Modif,
        NamespaceSimpleName,
        NewObject,
        OLEExporting,
        Or,
        ParameterException,
        ParameterListExceptions,
        ParameterListS,
        ParameterListT,
        ParameterName,
        ParameterS,
        ParameterT,
        PassByValue,
        PerformChanging,
        PerformTables,
        PerformUsing,
        ProvideFieldName,
        RadioGroupName,
        RaiseWith,
        ReadTableTarget,
        ReceiveParameters,
        Redefinition,
        ReduceBody,
        ReduceNext,
        ReportName,
        SelectLoop_2 as SelectLoop,
        Select_3 as Select,
        SimpleFieldChain,
        SimpleFieldChain2,
        SimpleName,
        SimpleSource1,
        SimpleSource2,
        SimpleSource3,
        SimpleSource4,
        SimpleTarget,
        SourceFieldSymbolChain,
        SourceFieldSymbol,
        SourceField,
        Source,
        SQLAggregation,
        SQLAliasField,
        SQLArithmeticOperator,
        SQLArithmetics,
        SQLAsName,
        SQLCase,
        SQLCDSParameters,
        SQLClient,
        SQLCompareOperator,
        SQLCompare,
        SQLCond,
        SQLFieldAndValue,
        SQLFieldListLoop,
        SQLFieldList,
        SQLFieldName,
        SQLField,
        SQLFieldsLoop,
        SQLFields,
        SQLForAllEntries,
        SQLFromSource,
        SQLFrom,
        SQLFunctionInput,
        SQLFunction,
        SQLGroupBy,
        SQLHaving,
        SQLHints,
        SQLIn,
        SQLIntoList,
        SQLIntoStructure,
        SQLIntoTable,
        SQLJoin,
        SQLOrderBy,
        SQLPath,
        SQLSourceNoSpace,
        SQLSourceSimple,
        SQLSource,
        SQLTarget,
        SQLUpTo,
        StringTemplateFormatting,
        StringTemplateSource,
        StringTemplate,
        SuperClassName,
        SwitchBody,
        TableBody,
        TableExpression,
        TargetFieldSymbol,
        TargetField,
        Target,
        TestSeamName,
        TextElementKey,
        TextElementString,
        TextElement,
        Throw,
        TransportingFields,
        TypeNameOrInfer,
        TypeName,
        TypeParam,
        TypeStructure,
        TypeTableKey,
        TypeTable,
        Type_2 as Type,
        ValueBase,
        ValueBodyLine,
        ValueBodyLines,
        ValueBody,
        Value,
        WithName,
        WriteOffsetLength
    }
}
export { Expressions }

declare namespace ExpressionsCDS {
    export {
        CDSAggregate,
        CDSAnnotate,
        CDSAnnotationArray,
        CDSAnnotationObject,
        CDSAnnotationSimple,
        CDSAnnotation,
        CDSArithParen,
        CDSArithmetics,
        CDSAs,
        CDSAssociation,
        CDSCardinality,
        CDSCase,
        CDSCast,
        CDSComposition,
        CDSCondition,
        CDSDefineAbstract,
        CDSDefineCustom,
        CDSDefineHierarchy,
        CDSDefineProjection,
        CDSDefineTableFunction,
        CDSDefineView,
        CDSElement,
        CDSExtendView,
        CDSFunctionInput,
        CDSFunction,
        CDSGroupBy,
        CDSHaving,
        CDSInteger,
        CDSJoin,
        CDSName,
        CDSParametersSelect,
        CDSParameters,
        CDSPrefixedName,
        CDSProviderContract,
        CDSRelation,
        CDSSelect,
        CDSSource,
        CDSString,
        CDSType_2 as CDSType,
        CDSWhere,
        CDSWithParameters
    }
}
export { ExpressionsCDS }

declare class ExtensionIndex extends AbstractObject {
    private parsedXML;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    getDescription(): string | undefined;
    getTableName(): string | undefined;
    parse(): {
        updated: boolean;
        runtime: number;
    };
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare type Fix = {
    description: string;
    edit: IEdit;
};

declare class FloatingPointType extends AbstractType {
    private readonly length;
    constructor(length: number, qualifiedName?: string);
    getLength(): number;
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

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

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

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

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

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

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

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

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

declare class FormDefinition_2 extends Identifier implements IFormDefinition {
    private readonly node;
    private readonly tableParameters;
    private readonly usingParameters;
    private readonly changingParameters;
    constructor(node: StructureNode | StatementNode, input: SyntaxInput);
    getTablesParameters(): TypedIdentifier[];
    getUsingParameters(): TypedIdentifier[];
    getChangingParameters(): TypedIdentifier[];
    private findTables;
    private findType;
    private findParams;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class FunctionGroup extends ABAPObject {
    private includes;
    private modules;
    private description;
    private dynpros;
    getType(): string;
    getDescription(): string | undefined;
    setDirty(): void;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDynpros(): DynproList;
    getSequencedFiles(): readonly ABAPFile[];
    getModules(): FunctionModuleDefinition[];
    getIncludeFiles(): {
        file: ABAPFile;
        name: string;
    }[];
    getInclude(name: string): ABAPFile | undefined;
    getMainABAPFile(): ABAPFile | undefined;
    getIncludes(): string[];
    getModule(name: string): FunctionModuleDefinition | undefined;
    getTextSymbols(): ITextElements;
    private parseXML;
    private findTextFile;
}

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

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

declare class FunctionModuleDefinition {
    private name;
    private description;
    private parameters;
    private globalParameters;
    private moduleType;
    constructor(data: any);
    getParameters(): readonly IFunctionModuleParameter[];
    getModuleType(): FunctionModuleType | undefined;
    getDescription(): string | undefined;
    getName(): string;
    isGlobalParameters(): boolean;
    private parse;
}

declare enum FunctionModuleParameterDirection {
    importing = "importing",
    exporting = "exporting",
    changing = "changing",
    tables = "tables"
}

declare enum FunctionModuleType {
    regular = "regular",
    remote = "remoteEnabled",
    update = "update"
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class HexType extends AbstractType {
    private readonly length;
    constructor(length: number, qualifiedName?: string);
    getLength(): number;
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

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

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

export declare interface IABAPFile {
    getInfo(): IABAPFileInformation;
    getStructure(): StructureNode | undefined;
    getTokens(withPragmas?: boolean): readonly Token[];
    getStatements(): readonly StatementNode[];
}

declare interface IABAPFileInformation {
    listInterfaceDefinitions(): readonly InfoInterfaceDefinition[];
    getInterfaceDefinitionByName(name: string): InfoInterfaceDefinition | undefined;
    listClassDefinitions(): readonly InfoClassDefinition[];
    getClassDefinitionByName(name: string): InfoClassDefinition | undefined;
    listFormDefinitions(): readonly InfoFormDefinition[];
    listClassImplementations(): readonly InfoClassImplementation[];
    getClassImplementationByName(name: string): InfoClassImplementation | undefined;
}

declare interface IAbaplintAppSettings {
    /** Enable or disable observations, enabled by default */
    observations?: boolean;
}

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

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

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

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

declare interface IAllowedNaming {
    maxLength: number;
    allowNamespace: boolean;
    customRegex?: RegExp;
}

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

declare interface IArtifact {
    getType(): string;
    getAllowedNaming(): IAllowedNaming;
}

declare interface IAttributes {
    getStatic(): readonly ClassAttribute[];
    getStaticsByVisibility(visibility: Visibility): readonly ClassAttribute[];
    getInstance(): readonly ClassAttribute[];
    getInstancesByVisibility(visibility: Visibility): readonly ClassAttribute[];
    getConstantsByVisibility(visibility: Visibility): readonly ClassConstant[];
    findByName(name: string): ClassAttribute | ClassConstant | undefined;
    getConstants(): readonly ClassConstant[];
    getAll(): readonly ClassAttribute[];
    getAliases(): readonly Alias[];
    getTypes(): ITypeDefinitions;
}

declare interface IBadiDefinition {
    name: string;
    interface: string;
}

declare interface IBuiltinMethod {
    counter: number;
    mandatory?: {
        [key: string]: AbstractType;
    };
    optional?: {
        [key: string]: AbstractType;
    };
    version?: Version;
    predicate?: boolean;
    return: AbstractType;
    cache?: BuiltInMethod | undefined;
}

declare class ICFService extends AbstractObject {
    private parsedXML;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    getDescription(): string | undefined;
    getURL(): string | undefined;
    getHandlerList(): string[] | undefined;
    parse(): {
        updated: boolean;
        runtime: number;
    };
}

export declare interface IClassDefinition extends IInterfaceDefinition {
    isFinal(): boolean;
    isForTesting(): boolean;
    isAbstract(): boolean;
    isSharedMemory(): boolean;
    getFriends(): string[];
    getCreateVisibility(): Visibility;
}

declare interface IClassImplementation extends Identifier {
    getMethodImplementations(): MethodImplementation_2[];
    getMethodImplementation(name: string): MethodImplementation_2 | undefined;
}

declare interface ICodeActionParams {
    textDocument: LServer.TextDocumentIdentifier;
    range: LServer.Range;
    context: LServer.CodeActionContext;
}

export declare interface IConfig {
    /** Global settings */
    global: IGlobalConfig;
    /** External git dependencies used for syntax checks */
    dependencies?: IDependency[];
    /** Syntax settings */
    syntax: ISyntaxSettings;
    /** Automatic object rename settings, use with command line paramter "--rename" */
    rename?: IRenameSettings;
    /** abaplint.app settings, see https://docs.abaplint.app */
    app?: IAbaplintAppSettings;
    /** Settings for each rule, see https://rules.abaplint.org */
    rules: any;
    /** see https://abaplint.app */
    targetRules?: any;
}

export declare interface IConfiguration {
    getEnabledRules(): IRule[];
    get(): IConfig;
    getGlobal(): IGlobalConfig;
    getVersion(): Version;
    getSyntaxSetttings(): ISyntaxSettings;
    readByRule(rule: string): any;
    readByKey(rule: string, key: string): any;
}

declare interface ICyclomaticComplexityResult {
    file: IFile;
    pos: Position;
    name: string;
    count: number;
}

declare interface IDDICReferences {
    setUsing(obj: IObject, using: readonly IObjectAndToken[]): void;
    addUsing(obj: IObject, using: IObjectAndToken | undefined): void;
    clear(obj: IObject): void;
    listUsing(obj: IObject): readonly IObjectAndToken[];
    listByFilename(filename: string, line: number): readonly IObjectAndToken[];
    listWhereUsed(obj: IObject): {
        type: string;
        name: string;
        token?: Token;
        filename?: string;
    }[];
}

declare interface IDDLParserResult {
    name: string;
    kind: DDLKind;
    fields: IDDLParserResultField[];
}

declare interface IDDLParserResultField {
    key: boolean;
    name: string;
    type: string;
    notNull: boolean;
}

export declare class Identifier {
    private readonly token;
    protected readonly filename: string;
    constructor(token: Token, filename: string);
    getName(): string;
    equals(id: Identifier): boolean;
    getToken(): Token;
    getFilename(): string;
    getStart(): Position;
    getEnd(): Position;
}

declare class Identifier_2 extends Token {
}

export declare const enum IdentifierMeta {
    MethodImporting = "importing",
    MethodExporting = "exporting",
    MethodChanging = "changing",
    MethodReturning = "returning",
    EventParameter = "event_parameter",
    FormParameter = "form_parameter",
    ReadOnly = "read_only",
    Tables = "tables",
    Abstract = "abstract",
    PassByValue = "pass_by_value",
    InlineDefinition = "inline",
    BuiltIn = "built-in",
    DDIC = "ddic",
    Static = "static",
    Enum = "enum",
    SelectionScreenTab = "selection_screen_tab"
}

export declare interface IDependency {
    /** Url of a git repository */
    url?: string;
    /** Git branch */
    branch?: string;
    /** Name of local folder with dependencies */
    folder?: string;
    /** File search, glob pattern */
    files: string;
}

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

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

declare interface IDocumentSymbolParams {
    textDocument: LServer.TextDocumentIdentifier;
}

export declare interface IEdit {
    [filename: string]: ITextEdit[];
}

declare interface IEventDefinition {
    getName(): string;
    getParameters(): readonly TypedIdentifier[];
    isStatic(): boolean;
}

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

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

export declare interface IFile {
    getFilename(): string;
    getObjectType(): string | undefined;
    getObjectName(): string;
    getRaw(): string;
    getRawRows(): string[];
}

declare interface IFilenameAndToken {
    filename: string;
    token: Token;
}

declare interface IFormDefinition extends Identifier {
    getTablesParameters(): readonly TypedIdentifier[];
    getUsingParameters(): readonly TypedIdentifier[];
    getChangingParameters(): readonly TypedIdentifier[];
}

declare interface IFunctionModuleParameter {
    name: string;
    direction: FunctionModuleParameterDirection;
    type: string | undefined;
    optional: boolean;
    defaultValue: string | undefined;
}

declare interface IGlobalConfig {
    /** input files, glob format
     * @uniqueItems true
     */
    files: string | string[];
    skipGeneratedBOPFInterfaces?: boolean;
    /** Skips generated table maintenances, determined via TOBJ object */
    skipGeneratedFunctionGroups?: boolean;
    skipGeneratedGatewayClasses?: boolean;
    skipGeneratedPersistentClasses?: boolean;
    skipGeneratedProxyClasses?: boolean;
    skipGeneratedProxyInterfaces?: boolean;
    /** Clone and parse dependencies specified in .apack-manifest.xml if it is present */
    useApackDependencies?: boolean;
    /** Do not report any issues for includes without main programs */
    skipIncludesWithoutMain?: boolean;
    /** Throw an error if multiple files with the same filename are added to the registry, ignores package.devc.xml */
    errorOnDuplicateFilenames?: boolean;
    /** list of files to exclude, these files are not added when running syntax check or any other rules, case insensitive regex
     * @uniqueItems true
     */
    exclude?: string[];
    /** list of files to not report any issues for, case insensitive regex
     * @uniqueItems true
     */
    noIssues?: string[];
}

declare interface IImplementing {
    name: string;
    partial: boolean;
}

export declare interface IInterfaceDefinition extends Identifier {
    getAttributes(): IAttributes;
    getTypeDefinitions(): ITypeDefinitions;
    getMethodDefinitions(): IMethodDefinitions;
    getEvents(): readonly IEventDefinition[];
    isGlobal(): boolean;
    getSuperClass(): string | undefined;
    getAliases(): readonly Alias[];
    getImplementing(): readonly IImplementing[];
}

declare interface IIssueData {
    filename: string;
    message: string;
    key: string;
    start: Position;
    end: Position;
    severity: Severity;
    /** The default fix for the issue, it always makes sense to apply this fix
     *  These are applied by "abaplint --fix" and in the document formatter in vscode extension
     */
    defaultFix?: IEdit;
    /** Alternative quick fixes, the developer must choose which to apply */
    alternativeFixes?: Fix[];
}

declare interface IKeyword {
    word: string;
    source: string[];
}

declare interface ILookupResult {
    type: AbstractType;
    object?: IObject;
}

declare interface IMacroReferences {
    addDefinition(ref: IFilenameAndToken, start: Position, end: Position): void;
    addReference(ref: IFilenameAndToken): void;
    listDefinitionsByFile(filename: string): Token[];
    listUsagesbyMacro(filename: string, token: Token): IFilenameAndToken[];
    getDefinitionRange(filename: string, token: Token): {
        start: Position;
        end: Position;
    } | undefined;
    findDefinitionByUsage(filename: string, token: Token): {
        filename: string;
        token: Token;
    } | undefined;
    clear(filename: string): void;
}

declare interface IMatch {
    matched: StatementNode[];
    unmatched: StatementNode[];
    error: boolean;
    errorDescription: string;
    errorMatched: number;
}

export declare interface IMethodDefinition extends Identifier {
    getVisibility(): Visibility;
    isRedefinition(): boolean;
    isAbstract(): boolean;
    isStatic(): boolean;
    isEventHandler(): boolean;
    getEventName(): string | undefined;
    getEventClass(): string | undefined;
    getParameters(): IMethodParameters;
    getRaising(): readonly string[];
    getExceptions(): readonly string[];
}

declare interface IMethodDefinitions {
    getAll(): Generator<IMethodDefinition, void, undefined>;
    getByName(name: string | undefined): IMethodDefinition | undefined;
}

export declare interface IMethodLengthResult {
    className: string;
    name: string;
    count: number;
    file: ABAPFile;
    pos: Position;
}

declare interface IMethodParameters {
    getAll(): readonly TypedIdentifier[];
    getImporting(): readonly TypedIdentifier[];
    getRequiredParameters(): readonly TypedIdentifier[];
    getExporting(): readonly TypedIdentifier[];
    getChanging(): readonly TypedIdentifier[];
    getOptional(): readonly string[];
    getReturning(): TypedIdentifier | undefined;
    getExceptions(): readonly string[];
    getFilename(): string;
    getDefaultImporting(): string | undefined;
    getParameterDefault(parameter: string): ExpressionNode | undefined;
}

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

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

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

declare interface IMSAGReferences {
    clear(obj: IObject): void;
    addUsing(filename: string, token: Token, messageClass: string, number: string): void;
    listByFilename(filename: string): {
        token: Token;
        messageClass: string;
        number: string;
    }[];
    listByMessage(messageClass: string, number: string): {
        filename: string;
        token: Token;
    }[];
}

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

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

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

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

declare namespace Info {
    export {
        AttributeLevel,
        MethodParameterDirection,
        InfoAttribute,
        InfoMethodParameter,
        InfoMethodDefinition,
        InfoInterfaceDefinition,
        InfoConstant,
        InfoAlias,
        InfoImplementing,
        Duration,
        RiskLevel,
        InfoClassDefinition,
        InfoClassImplementation,
        InfoFormDefinition,
        IABAPFileInformation
    }
}
export { Info }

declare interface InfoAlias {
    name: string;
    identifier: Identifier;
    visibility: Visibility;
    component: string;
}

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

declare interface InfoAttribute {
    name: string;
    identifier: Identifier;
    level: AttributeLevel;
    readOnly: boolean;
    visibility: Visibility;
}

declare interface InfoClassDefinition extends InfoInterfaceDefinition {
    superClassName: string | undefined;
    isAbstract: boolean;
    isFinal: boolean;
    interfaces: readonly InfoImplementing[];
    isForTesting: boolean;
    duration: Duration | undefined;
    riskLevel: RiskLevel | undefined;
    isSharedMemory: boolean;
}

declare interface InfoClassImplementation {
    name: string;
    identifier: Identifier;
    methods: readonly Identifier[];
}

declare interface InfoConstant {
    identifier: Identifier;
    name: string;
    typeName: string;
    visibility: Visibility;
    value: string;
}

declare interface InfoFormDefinition {
    name: string;
    identifier: Identifier;
}

declare interface InfoImplementing {
    name: string;
    partial: boolean;
    allAbstract: boolean;
    abstractMethods: string[];
    finalMethods: string[];
}

declare interface InfoInterfaceDefinition {
    name: string;
    identifier: Identifier;
    isLocal: boolean;
    isGlobal: boolean;
    interfaces: readonly InfoImplementing[];
    methods: readonly InfoMethodDefinition[];
    aliases: readonly InfoAlias[];
    constants: readonly InfoConstant[];
    attributes: readonly InfoAttribute[];
}

declare interface InfoMethodDefinition {
    name: string;
    identifier: Identifier;
    isRedefinition: boolean;
    isEventHandler: boolean;
    isForTesting: boolean;
    isAbstract: boolean;
    isFinal: boolean;
    visibility: Visibility;
    parameters: InfoMethodParameter[];
    exceptions: string[];
}

declare interface InfoMethodParameter {
    name: string;
    identifier: Identifier;
    direction: MethodParameterDirection;
}

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

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

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

declare type InlayHintsSettings = {
    inferredTypes: boolean;
};

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

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

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

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

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

export declare interface INode {
    addChild(n: INode): void;
    setChildren(children: INode[]): void;
    getChildren(): readonly INode[];
    get(): object;
    getFirstToken(): Token;
    getLastToken(): Token;
}

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

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

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

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

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

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

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

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

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

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

declare class IntegerType extends AbstractType {
    private static readonly singletons;
    static get(input?: AbstractTypeData): IntegerType;
    private constructor();
    /** fully qualified symbolic name of the type */
    getQualifiedName(): string | undefined;
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class Interface extends ABAPObject {
    private def;
    private parsedXML;
    getType(): string;
    setDefinition(def: IInterfaceDefinition | undefined): void;
    getSequencedFiles(): readonly ABAPFile[];
    getDefinition(): IInterfaceDefinition | undefined;
    getInterface(): InfoInterfaceDefinition | undefined;
    getIdentifier(): Identifier | undefined;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    getNameFromXML(): string | undefined;
    getDescription(): string | undefined;
    private parseXML;
}

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

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

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

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

declare class InterfaceDefinition extends Identifier implements IInterfaceDefinition {
    private attributes;
    private readonly implementing;
    private typeDefinitions;
    private methodDefinitions;
    private readonly events;
    private readonly globalValue;
    private aliases;
    constructor(node: StructureNode, input: SyntaxInput);
    getSuperClass(): undefined;
    getImplementing(): readonly IImplementing[];
    getAliases(): readonly Alias[];
    getEvents(): IEventDefinition[];
    getAttributes(): IAttributes;
    getTypeDefinitions(): ITypeDefinitions;
    isLocal(): boolean;
    isGlobal(): boolean;
    getMethodDefinitions(): IMethodDefinitions;
    private checkMethodNameLength;
    private checkInterfacesExists;
    private parse;
}

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

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

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

export declare interface IObject extends IArtifact {
    /** the main place identifying the object, used for go-to */
    getIdentifier(): Identifier | undefined;
    getName(): string;
    getDescription(): string | undefined;
    setDirty(): void;
    isDirty(): boolean;
    /** returns true if the object was parsed, false if no changes since last parse
     * registry for global cross object macros
     */
    parse(version?: Version, globalMacros?: readonly string[], reg?: IRegistry): IParseResult;
    getParsingIssues(): readonly Issue[];
    getFiles(): readonly IFile[];
    addFile(file: IFile): void;
    updateFile(file: IFile): void;
    removeFile(file: IFile): void;
    getXMLFile(): IFile | undefined;
    getXML(): string | undefined;
}

declare interface IObjectAndToken {
    object?: IObject;
    token?: Token;
    filename?: string;
}

declare interface IParseResult {
    updated: boolean;
    runtime: number;
    runtimeExtra?: {
        lexing: number;
        statements: number;
        structure: number;
    };
}

export declare interface IProgress {
    set(total: number, text: string): void;
    tick(text: string): Promise<void>;
    tickSync(text: string): void;
}

declare interface IRange {
    start: Position;
    end: Position;
}

declare interface IReference {
    position: Identifier;
    resolved: Identifier | undefined;
    referenceType: ReferenceType;
    extra?: IReferenceExtras;
}

declare interface IReferenceExtras {
    ooName?: string;
    ooType?: "CLAS" | "INTF" | "Void";
    foundQualified?: boolean;
}

export declare interface IRegistry {
    parse(): IRegistry;
    parseAsync(input?: IRunInput): Promise<IRegistry>;
    clear(): void;
    addDependencies(files: readonly IFile[]): IRegistry;
    addDependency(file: IFile): IRegistry;
    removeDependency(obj: IObject): void;
    isDependency(obj: IObject): boolean;
    isFileDependency(filename: string): boolean;
    findIssues(input?: IRunInput): readonly Issue[];
    findIssuesObject(iobj: IObject): readonly Issue[];
    inErrorNamespace(name: string): boolean;
    getDDICReferences(): IDDICReferences;
    getMSAGReferences(): IMSAGReferences;
    getMacroReferences(): IMacroReferences;
    getConfig(): IConfiguration;
    setConfig(conf: IConfiguration): IRegistry;
    /** Get all objects, including dependencies */
    getObjects(): Generator<IObject, void, undefined>;
    /** Get objects by type, including dependencies */
    getObjectsByType(type: string): Generator<IObject, void, undefined>;
    /** Get number of objects in the registry */
    getObjectCount(): {
        total: number;
        normal: number;
        dependencies: number;
    };
    getFirstObject(): IObject | undefined;
    getObject(type: string | undefined, name: string | undefined): IObject | undefined;
    findObjectForFile(file: IFile): IObject | undefined;
    addFile(file: IFile): IRegistry;
    updateFile(file: IFile): IRegistry;
    removeFile(file: IFile): IRegistry;
    addFiles(files: readonly IFile[]): IRegistry;
    getFileByName(filename: string): IFile | undefined;
    getFiles(): Generator<IFile, void, undefined>;
}

declare interface IRenameParams {
    textDocument: LServer.TextDocumentIdentifier;
    position: LServer.Position;
    newName: string;
}

declare interface IRenameResult {
    deletedFiles: Set<string>;
    addedFiles: Set<string>;
    updatedFiles: Set<string>;
}

export declare interface IRenameSettings {
    /** output folder, if value is empty or undefined the changes are written inline in the input folders */
    output?: string;
    /** list of regex, matches filenames to be skipped, case insensitive
     * @uniqueItems true
     */
    skip?: string[];
    /** List of rename patterns
     * @uniqueItems true
     */
    patterns: {
        /** Object type, example "CLAS", regex, case insensitive */
        type: string;
        /** Matches object name, regex, case insensitive */
        oldName: string;
        /** new name, match groups from oldName regex can be used */
        newName: string;
    }[];
}

/** Rule Interface */
declare interface IRule {
    getMetadata(): IRuleMetadata;
    getConfig(): void;
    setConfig(conf: any): void;
    /** called one time before run() */
    initialize(reg: IRegistry): IRule;
    /** called for each object */
    run(obj: IObject): readonly Issue[];
}

/** Rule Metadata */
declare interface IRuleMetadata {
    /** Rule key, no whitespace allowed, always lower case, words separated by underscore
     * Used in abaplint.json configuration files */
    key: string;
    /** Rule title */
    title: string;
    /** Short description in markdown, can be shown in editors */
    shortDescription: string;
    /** ABAP code with bad example, shown on rules.abaplint.org */
    badExample?: string;
    /** ABAP code with good example, shown on rules.abaplint.org */
    goodExample?: string;
    /** Extended information, markdown, only shown on rules.abaplint.org */
    extendedInformation?: string;
    /** Various tags with additional usage information */
    tags?: RuleTag[];
    /** Pragma that can be used to suppress the issue */
    pragma?: string;
    /** Pseudo comment that can be used to suppress the issue */
    pseudoComment?: string;
}

declare interface IRunInput {
    progress?: IProgress;
    outputPerformance?: boolean;
}

declare interface IScopeData {
    vars: {
        [name: string]: TypedIdentifier;
    };
    types: {
        [name: string]: TypedIdentifier;
    };
    extraLikeTypes: {
        [name: string]: TypedIdentifier;
    };
    deferred: {
        [name: string]: DeferredInformation;
    };
    cdefs: {
        [name: string]: IClassDefinition;
    };
    idefs: {
        [name: string]: IInterfaceDefinition;
    };
    forms: IFormDefinition[];
    references: IReference[];
    sqlConversion: {
        fieldName: string;
        message: string;
        token: Token;
    }[];
}

declare interface IScopeIdentifier {
    stype: ScopeType;
    sname: string;
    filename: string;
    start: Position;
    end: Position | undefined;
}

declare interface IScopeVariable {
    name: string;
    identifier: TypedIdentifier;
}

export declare interface ISpaghettiScope {
    listDefinitions(filename: string): IScopeVariable[];
    listReadPositions(filename: string): Identifier[];
    listWritePositions(filename: string): Identifier[];
    lookupPosition(p: Position | undefined, filename: string | undefined): ISpaghettiScopeNode | undefined;
    getTop(): ISpaghettiScopeNode;
    getFirstChild(): ISpaghettiScopeNode | undefined;
}

export declare interface ISpaghettiScopeNode {
    getParent(): ISpaghettiScopeNode | undefined;
    addChild(node: ISpaghettiScopeNode): void;
    getChildren(): ISpaghettiScopeNode[];
    getFirstChild(): ISpaghettiScopeNode | undefined;
    getIdentifier(): IScopeIdentifier;
    getData(): IScopeData;
    calcCoverage(): {
        start: Position;
        end: Position;
    };
    findClassDefinition(name: string): IClassDefinition | undefined;
    listClassDefinitions(): IClassDefinition[];
    listInterfaceDefinitions(): IInterfaceDefinition[];
    findFormDefinition(name: string): IFormDefinition | undefined;
    findInterfaceDefinition(name: string): IInterfaceDefinition | undefined;
    findType(name: string): TypedIdentifier | undefined;
    findVariable(name: string): TypedIdentifier | undefined;
    findScopeForVariable(name: string): IScopeIdentifier | undefined;
    findWriteReference(pos: Position): TypedIdentifier | undefined;
    findTableReference(pos: Position): string | undefined;
    findTableVoidReference(pos: Position): boolean;
}

export declare class Issue {
    private readonly data;
    static atRow(file: IFile, row: number, message: string, key: string, severity?: Severity): Issue;
    static atStatement(file: IFile, statement: StatementNode, message: string, key: string, severity?: Severity, fix?: IEdit, alternativeFixes?: Fix[]): Issue;
    static atPosition(file: IFile, start: Position, message: string, key: string, severity?: Severity, fix?: IEdit): Issue;
    static atRowRange(file: IFile, row: number, startCol: number, endCol: number, message: string, key: string, severity?: Severity, fix?: IEdit): Issue;
    static atRange(file: IFile, start: Position, end: Position, message: string, key: string, severity?: Severity, fix?: IEdit, alternativeFixes?: Fix[]): Issue;
    static atToken(file: IFile, token: Token, message: string, key: string, severity?: Severity, fix?: IEdit): Issue;
    static atTokenFilename(filename: string, token: Token, message: string, key: string, severity?: Severity, fix?: IEdit): Issue;
    static atIdentifier(identifier: Identifier, message: string, key: string, severity?: Severity, fix?: IEdit): Issue;
    constructor(data: IIssueData);
    getData(): IIssueData;
    getMessage(): string;
    getKey(): string;
    getStart(): Position;
    getEnd(): Position;
    getFilename(): string;
    getDefaultFix(): IEdit | undefined;
    getAlternativeFixes(): Fix[] | undefined;
    getSeverity(): Severity;
}

declare interface IStatement {
    getMatcher(): IStatementRunnable;
}

declare interface IStatementRunnable {
    run(r: Result[]): Result[];
    railroad(): string;
    toStr(): string;
    getUsing(): string[];
    listKeywords(): string[];
    first(): string[];
}

declare interface IStructure {
    getMatcher(): IStructureRunnable;
}

declare interface IStructureComponent {
    name: string;
    type: AbstractType;
    asInclude?: boolean;
    suffix?: string;
}

declare interface IStructureRunnable {
    toRailroad(): string;
    getUsing(): string[];
    run(statements: StatementNode[], parent: INode): IMatch;
    first(): string[];
}

declare interface ISyntaxResult {
    readonly issues: Issue[];
    readonly spaghetti: ISpaghettiScope;
}

declare interface ISyntaxSettings {
    /** ABAP language version */
    version?: Version;
    /** Report error for objects in this regex namespace. Types not in namespace will be void. Case insensitive */
    errorNamespace: string;
    /** List of full named global constants (regex not possible)
     * @uniqueItems true
     */
    globalConstants?: string[];
    /** List of full named global macros (regex not possible)
     * @uniqueItems true
     */
    globalMacros?: string[];
}

declare type ITableKey = {
    name: string;
    type: TableAccessType;
    keyFields: string[];
    isUnique: boolean;
};

declare type ITableOptions = {
    withHeader: boolean;
    keyType: TableKeyType;
    primaryKey?: ITableKey;
    secondary?: ITableKey[];
};

declare interface ITextDocumentPositionParams {
    textDocument: LServer.TextDocumentIdentifier;
    position: LServer.Position;
}

declare interface ITextDocumentRange {
    textDocument: LServer.TextDocumentIdentifier;
    start: LServer.Position;
    end: LServer.Position;
}

declare interface ITextEdit {
    range: IRange;
    newText: string;
}

declare interface ITextElements {
    [key: string]: {
        entry: string;
        maxLength: number;
    };
}

declare interface ITranslationTextElements {
    language: string;
    textElements: ITextElements;
}

declare interface ITypeDefinitions {
    getAll(): readonly TypeDefinitionsEntry[];
    getByName(name: string): TypedIdentifier | undefined;
}

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

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

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

export declare class LanguageServer {
    private readonly reg;
    constructor(reg: IRegistry);
    documentSymbol(params: IDocumentSymbolParams): LServer.DocumentSymbol[];
    hover(params: ITextDocumentPositionParams): LServer.Hover | undefined;
    gotoDefinition(params: ITextDocumentPositionParams): LServer.Location | undefined;
    documentFormatting(params: {
        textDocument: LServer.TextDocumentIdentifier;
        options?: LServer.FormattingOptions;
    }): LServer.TextEdit[];
    diagnostics(textDocument: LServer.TextDocumentIdentifier): LServer.Diagnostic[];
    prepareRename(params: ITextDocumentPositionParams): {
        range: LServer.Range;
        placeholder: string;
    } | undefined;
    rename(params: IRenameParams): LServer.WorkspaceEdit | undefined;
    codeActions(params: ICodeActionParams): LServer.CodeAction[];
    documentHighlight(_params: ITextDocumentPositionParams): LServer.DocumentHighlight[];
    implementation(params: ITextDocumentPositionParams): LServer.Location[];
    references(params: ITextDocumentPositionParams): LServer.Location[];
    static semanticTokensLegend(): LServer.SemanticTokensLegend;
    semanticTokensRange(range: ITextDocumentRange): LServer.SemanticTokens;
    codeLens(textDocument: LServer.TextDocumentIdentifier, settings?: CodeLensSettings): LServer.CodeLens[];
    inlayHints(textDocument: LServer.TextDocumentIdentifier, settings?: InlayHintsSettings): LServer.InlayHint[];
    help(textDocument: LServer.TextDocumentIdentifier, position: LServer.Position): string;
    listDefinitionPositions(textDocument: LServer.TextDocumentIdentifier): LServer.Range[];
    listReadPositions(textDocument: LServer.TextDocumentIdentifier): LServer.Range[];
    listWritePositions(textDocument: LServer.TextDocumentIdentifier): LServer.Range[];
}

declare namespace LanguageServerTypes {
    export {
        ITextDocumentPositionParams,
        IRenameParams,
        ICodeActionParams,
        IDocumentSymbolParams,
        ITextDocumentRange
    }
}
export { LanguageServerTypes }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export declare class LSPEdit {
    static mapEdits(edits: IEdit[]): LServer.WorkspaceEdit;
    static mapEdit(edit: IEdit): LServer.WorkspaceEdit;
    private static mapText;
}

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

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

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

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

export declare class MemoryFile extends AbstractFile {
    private readonly raw;
    constructor(filename: string, raw: string);
    getRaw(): string;
    getRawRows(): string[];
}

declare class Message {
    private readonly number;
    private readonly message;
    private readonly className;
    constructor(number: string, message: string, className: string);
    getMessageClass(): string;
    getNumber(): string;
    getMessage(): string;
    getPlaceholderCount(): number;
}

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

declare class MessageClass extends AbstractObject {
    private xml;
    getType(): string;
    getDescription(): string | undefined;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getParsed(): parsedMessageClass | undefined;
    getTextsTranslations(): {
        language: string;
        number: string;
        text?: string;
    }[] | undefined;
    setDirty(): void;
    getMessages(): readonly Message[];
    getByNumber(num: string): Message | undefined;
    private parseXML;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class MethodDefinition extends Identifier implements IMethodDefinition {
    private readonly visibility;
    private readonly parameters;
    private readonly redefinition;
    private readonly eventHandler;
    private readonly eventName;
    private readonly eventClass;
    private readonly abstract;
    private readonly static;
    private readonly raising;
    private readonly exceptions;
    private readonly className;
    constructor(node: StatementNode, visibility: Visibility, input: SyntaxInput);
    getVisibility(): Visibility;
    getClassName(): string;
    isRedefinition(): boolean;
    isAbstract(): boolean;
    isStatic(): boolean;
    isEventHandler(): boolean;
    getEventName(): string | undefined;
    getEventClass(): string | undefined;
    getParameters(): MethodParameters_2;
    getRaising(): readonly string[];
    getExceptions(): readonly string[];
}

declare class MethodDefinitions implements IMethodDefinitions {
    private readonly all;
    constructor(node: StructureNode, input: SyntaxInput);
    getAll(): Generator<IMethodDefinition, void, undefined>;
    getByName(name: string | undefined): IMethodDefinition | undefined;
    private parseInterface;
    private parse;
    private add;
}

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

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

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

declare class MethodImplementation_2 extends Identifier {
    constructor(node: StructureNode, filename: string);
}

export declare class MethodLengthStats {
    static run(obj: IObject): IMethodLengthResult[];
    private static findName;
}

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

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

declare enum MethodParameterDirection {
    Importing = "importing",
    Exporting = "exporting",
    Changing = "changing",
    Returning = "returning"
}

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

declare class MethodParameters_2 implements IMethodParameters {
    private preferred;
    private returning;
    private readonly importing;
    private readonly optional;
    private readonly exporting;
    private readonly changing;
    private readonly exceptions;
    private readonly defaults;
    private readonly filename;
    constructor(node: StatementNode, input: SyntaxInput, abstractMethod: boolean);
    getFilename(): string;
    getOptional(): string[];
    getAll(): TypedIdentifier[];
    getDefaultImporting(): string | undefined;
    getImporting(): TypedIdentifier[];
    getRequiredParameters(): TypedIdentifier[];
    getExporting(): TypedIdentifier[];
    getChanging(): TypedIdentifier[];
    getReturning(): TypedIdentifier | undefined;
    getExceptions(): string[];
    getParameterDefault(parameter: string): ExpressionNode;
    private parse;
    private checkDuplicateNames;
    private workaroundRAP;
    private add;
}

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

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

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

declare class MIMEObject extends AbstractObject {
    private parsedXML;
    getType(): string;
    getURL(): string | undefined;
    getClass(): string | undefined;
    isFolder(): boolean;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDataFile(): IFile | undefined;
    setDirty(): void;
    getDescription(): string | undefined;
    parse(): {
        updated: boolean;
        runtime: number;
    };
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare namespace Nodes {
    export {
        ExpressionNode,
        StatementNode,
        StructureNode,
        TokenNode,
        TokenNodeRegex
    }
}
export { Nodes }

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

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

declare class NumberRange extends AbstractObject {
    private parsedXML;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDomain(): string | undefined;
    getPercentage(): number | undefined;
    setDirty(): void;
    parse(): {
        updated: boolean;
        runtime: number;
    };
    getDescription(): string | undefined;
}

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

declare class NumericType extends AbstractType {
    private readonly length;
    constructor(length: number, qualifiedName?: string);
    getLength(): number;
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

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

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

declare class ObjectReferenceType extends AbstractType {
    private readonly identifier;
    constructor(id: Identifier, extra?: AbstractTypeData);
    getIdentifierName(): string;
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    getIdentifier(): Identifier;
    toCDS(): string;
}

declare namespace Objects {
    export {
        ABAPQueryFunctionalArea,
        ABAPQueryQuery,
        ActivationVariant,
        APIReleaseState,
        ApplicationDescriptorsFiori,
        ApplicationJobCatalogEntry,
        ApplicationJobTemplate,
        ApplicationLogObject,
        AssignmentServiceToAuthorizationGroup,
        ATCCheckCategory,
        ATCCheckObject,
        ATCCheckVariant,
        AuthorizationCheckField,
        AuthorizationGroup,
        AuthorizationObjectClass,
        AuthorizationObjectExtension,
        AuthorizationObject,
        BADIDefinition,
        BehaviorDefinition,
        BRFPlusSystemApplication,
        BSPApplication,
        BusinessAddInImplementation,
        BusinessCatalogAppAssignment,
        BusinessCatalog,
        BusinessConfigurationMaintenanceObject,
        BusinessConfigurationSet,
        BusinessFunctionAssignment,
        BusinessFunctionSetAssignment,
        BusinessObjectModel,
        BusinessObjectType,
        CDSEntityBuffer,
        ParsedMetadataExtension,
        CDSMetadataExtension,
        CDSType,
        ChangeDocument,
        ChapterOfBookStructure,
        CheckpointGroup,
        ClassCategory,
        Class,
        Classification,
        CommunicationScenario,
        CompositeEnhancementImplementation,
        CompositeEnhancementSpot,
        ConceptsOfPackage,
        CustomDataBrowserObject,
        CustomerEnhancementProject,
        CustomizingAttributes,
        CustomizingImgActivity,
        CustomizingTransaction,
        DataControl,
        ParsedDataDefinition,
        DataDefinition,
        DataElement,
        DatastoreObject,
        DialogModule,
        Documentation,
        DomainValue,
        DomainValueTranslation,
        Domain,
        EcattTestConfiguration,
        EcattTestDataContainer,
        EcattTestScript,
        EmailTemplate,
        EnhancementImplementation,
        IBadiDefinition,
        EnhancementSpot,
        EntityType,
        EventBinding,
        EventConsumer,
        ExtensionIndex,
        FieldCatalog,
        FormObjectForm,
        FormObjectInterface,
        FormatType,
        FunctionGroup,
        GatewayModelMetadata,
        GatewayModel,
        GatewayODataGroupAndAssignment,
        GatewayProject,
        GatewayServiceGroupsMetadata,
        GatewayService,
        GatewayVocabularyAnnotation,
        GeneralHierarchyStorageExtrensionName,
        GeneralStorageStructure,
        GeneralText,
        HttpService,
        IACBinaryData,
        IACLanguageResource,
        IACService,
        IACTemplate,
        IAMApp,
        ICFService,
        IdocExtension,
        Idoc,
        InboundService,
        InfoArea,
        InfoObject,
        Interface,
        KnowledgeTransferDocument,
        LockObject,
        MaintenanceAndTransportObject,
        parsedMessageClass,
        MessageClass,
        MessagingChannel,
        MIMEObject,
        Namespace,
        NeptuneAPI,
        NeptuneApp,
        NeptuneCustomColor,
        NeptuneCustomJSHelper,
        NeptuneDocumentation,
        NeptuneEnhancement,
        NeptuneLaunchpadLayout,
        NeptuneLaunchpad,
        NeptuneLoginPage,
        NeptuneMediaLibrary,
        NeptuneMediaPack,
        NeptuneMetadata,
        NeptuneMobileClient,
        NeptuneOData,
        NeptunePolicy,
        NeptuneRFCMapping,
        NeptuneRichTextTemplate,
        NeptuneSplashScreen,
        NeptuneStickyBanner,
        NeptuneTileGroup,
        NeptuneTileLayout,
        NeptuneTile,
        NeptuneURLAlias,
        NumberRange,
        Oauth2Profile,
        ObjectCharacteristic,
        OutboundService,
        PackageInterface,
        Package,
        PageFormat,
        Parameter,
        PersonalizationObject,
        Program,
        ProxyObject,
        PushChannel,
        QueryUserGroup,
        RestrictionField,
        RestrictionType,
        RFCService,
        SAPScriptStyle,
        SAPScript,
        ScreenVariant,
        SearchHelp,
        ServiceBinding,
        ServiceDefinition,
        SharedMemory,
        SmartForm,
        SmartStyle,
        StandardTask,
        SwitchAssignmentHierarchy,
        SwitchAssignments,
        TableType,
        EnhancementCategory,
        TableCategory,
        SecondaryIndex,
        Table,
        TechnicalJobDefinition,
        TransactionVariant,
        Transaction,
        Transformation,
        TypePool,
        ViewCluster,
        View,
        VirtualEndPoint,
        WebDynproApplicationConfiguration,
        WebDynproApplication,
        WebDynproComponentConfiguration,
        WebDynproComponent,
        WebMIME,
        WebReportingTemplate
    }
}
export { Objects }

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

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

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

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

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

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

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

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

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

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

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

declare class PackedType extends AbstractType {
    private readonly length;
    private readonly decimals;
    constructor(length: number, decimals: number, extra?: AbstractTypeData);
    getLength(): number;
    getDecimals(): number;
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare type ParsedDataDefinition = {
    sqlViewName: string | undefined;
    definitionName: string | undefined;
    description: string | undefined;
    fields: {
        key: boolean;
        name: string;
        prefix: string;
        annotations: string[];
    }[];
    sources: {
        name: string;
        as: string | undefined;
    }[];
    associations: {
        name: string;
        as: string | undefined;
    }[];
    relations: {
        name: string;
        as: string | undefined;
    }[];
    tree: ExpressionNode | undefined;
};

declare type parsedMessageClass = {
    topName: string | undefined;
    description: string | undefined;
    parsedMessages: Message[] | undefined;
    textsTranslations: {
        language: string;
        number: string;
        text?: string;
    }[] | undefined;
};

declare type ParsedMetadataExtension = {
    tree: ExpressionNode | undefined;
};

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

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

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

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

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

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

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

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

export declare class Position {
    private readonly row;
    private readonly col;
    constructor(row: number, col: number);
    getCol(): number;
    getRow(): number;
    isAfter(p: Position): boolean;
    equals(p: Position): boolean;
    isBefore(p: Position): boolean;
    isBetween(p1: Position, p2: Position): boolean;
}

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

declare class Pragma extends Token {
}

export declare class PrettyPrinter {
    private result;
    private readonly file;
    private readonly options;
    private readonly config;
    constructor(file: ABAPFile, config: IConfiguration);
    run(): string;
}

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

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

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

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

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

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

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

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

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

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

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

declare class Program extends ABAPObject {
    private parsedXML;
    getType(): string;
    getSequencedFiles(): readonly ABAPFile[];
    getDescription(): string | undefined;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    setDirty(): void;
    isInclude(): boolean;
    isModulePool(): boolean;
    getDynpros(): DynproList;
    getSelectionTexts(): ITextElements;
    private parseXML;
}

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

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

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

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

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

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

declare class ProxyObject extends AbstractObject {
    private parsedXML;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
    setDirty(): void;
    parse(_version?: Version, _globalMacros?: readonly string[], reg?: IRegistry): {
        updated: boolean;
        runtime: number;
    };
    private parseXML;
    generateABAPObjects(): AbstractObject[];
}

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

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

declare class Punctuation extends Token {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export declare enum ReferenceType {
    /** for classes and interface references */
    ObjectOrientedReference = "Object",
    ObjectOrientedVoidReference = "Object (Void)",
    ObjectOrientedUnknownReference = "Object (Unknown)",
    TableReference = "Table",
    TableVoidReference = "Table (Void)",
    MethodReference = "Method",
    BuiltinMethodReference = "Builtin Method",
    ConstructorReference = "Constructor Reference",
    MethodImplementationReference = "Method Implementation",
    TypeReference = "Type",
    BuiltinTypeReference = "Builtin Type",
    VoidType = "Type (Void)",
    InferredType = "Inferred Type",
    FormReference = "Form",
    DataReadReference = "Read From",
    DataWriteReference = "Write To"
}

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

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

export declare class Registry implements IRegistry {
    private objects;
    private objectsByType;
    private dependencies;
    private ddicReferences;
    private msagReferences;
    private macroReferences;
    private errorNamespace;
    private conf;
    constructor(conf?: IConfiguration);
    /** clears all objects, keeping the configuration */
    clear(): void;
    static abaplintVersion(): string;
    getDDICReferences(): IDDICReferences;
    getMSAGReferences(): IMSAGReferences;
    getMacroReferences(): IMacroReferences;
    getObjects(): Generator<IObject, void, undefined>;
    getObjectsByType(type: string): Generator<IObject, void, undefined>;
    getFiles(): Generator<IFile, void, undefined>;
    getFirstObject(): IObject | undefined;
    getObjectCount(): {
        total: number;
        normal: number;
        dependencies: number;
    };
    getFileByName(filename: string): IFile | undefined;
    getObject(type: string | undefined, name: string | undefined): IObject | undefined;
    getConfig(): IConfiguration;
    setConfig(conf: IConfiguration): IRegistry;
    inErrorNamespace(name: string): boolean;
    addFile(file: IFile): IRegistry;
    updateFile(file: IFile): IRegistry;
    removeFile(file: IFile): IRegistry;
    private _addFiles;
    private checkDuplicateFilename;
    private static filenameBasename;
    addFiles(files: readonly IFile[]): IRegistry;
    addDependencies(files: readonly IFile[]): IRegistry;
    addDependency(file: IFile): IRegistry;
    removeDependency(obj: IObject): void;
    isDependency(obj: IObject): boolean;
    isFileDependency(filename: string): boolean;
    findObjectForFile(file: IFile): IObject | undefined;
    findIssues(input?: IRunInput): readonly Issue[];
    findIssuesObject(iobj: IObject): readonly Issue[];
    parse(): this;
    parseAsync(input?: IRunInput): Promise<this>;
    private parsePrivate;
    private isDirty;
    private findOrCreate;
    private removeObject;
    private find;
}

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

export declare class Rename {
    private readonly reg;
    constructor(reg: IRegistry);
    /** Applies the renaming to the objects and files in the registry,
     *  after renaming the registry is not parsed */
    rename(type: string, oldName: string, newName: string): IRenameResult;
    /** Builds edits, but does not apply to registry, used by LSP */
    buildEdits(type: string, oldName: string, newName: string): WorkspaceEdit | undefined;
    private factory;
    private apply;
    private applyEdit;
    private applyRenames;
}

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

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

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

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

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

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

declare class Result {
    private readonly tokens;
    private readonly tokenIndex;
    private nodes;
    constructor(tokens: readonly Token[], tokenIndex: number, nodes?: (ExpressionNode | TokenNode)[]);
    peek(): Token;
    shift(node: ExpressionNode | TokenNode): Result;
    popNode(): ExpressionNode | TokenNode | undefined;
    getNodes(): (ExpressionNode | TokenNode)[];
    setNodes(n: (ExpressionNode | TokenNode)[]): void;
    remainingLength(): number;
}

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

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

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

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

declare enum RiskLevel {
    harmless = "HARMLESS",
    critical = "CRITICAL",
    dangerous = "DANGEROUS"
}

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

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

export declare class RulesRunner {
    private readonly reg;
    private readonly syntaxPerformance;
    constructor(reg: IRegistry);
    objectsToCheck(objects: Iterable<IObject>): readonly IObject[];
    runRules(objects: Iterable<IObject>, input?: IRunInput): readonly Issue[];
    excludeIssues(issues: Issue[]): Issue[];
}

export declare enum RuleTag {
    Experimental = "Experimental",
    DeprecationCandidate = "DeprecationCandidate",
    Upport = "Upport",
    Downport = "Downport",
    Whitespace = "Whitespace",
    Naming = "Naming",
    Quickfix = "Quickfix",
    Performance = "Performance",
    Syntax = "Syntax",
    Security = "Security",
    /** Relevant wrt the official SAP ABAP style guide*/
    Styleguide = "Styleguide",
    /** Single file compatible, the rule gives correct results when having only information about the single file */
    SingleFile = "SingleFile"
}

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

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

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

declare abstract class ScopeData {
    private readonly data;
    constructor();
    getData(): IScopeData;
}

export declare enum ScopeType {
    BuiltIn = "_builtin",
    Dummy = "_dummy",
    SelectionEvent = "selection_event",
    Global = "_global",
    Program = "_program",
    TypePool = "_type_pool",
    FunctionGroup = "_function_group",
    ClassDefinition = "class_definition",
    Interface = "interface",
    ClassImplementation = "class_implementation",
    Form = "form",
    FunctionModule = "function",
    Method = "method",
    MethodInstance = "method_instance",
    MethodDefinition = "method_definition",
    For = "for",
    Let = "let",
    OpenSQL = "open_sql"
}

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

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

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

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

declare type SecondaryIndex = {
    name: string;
    fields: string[];
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export declare enum Severity {
    Error = "Error",
    Warning = "Warning",
    Info = "Info"
}

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

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

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

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

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

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

/** Reduced version of SimpleSource, omits MethodCallChains. */
declare class SimpleSource2 extends Expression {
    getRunnable(): IStatementRunnable;
}

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

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

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

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

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

export declare class SkipLogic {
    private readonly reg;
    /** TOBJ cache hashmap */
    private tobj;
    constructor(reg: IRegistry);
    skip(obj: IObject): boolean;
    private isGeneratedBOPFInterface;
    private isGeneratedProxyInterface;
    private isGeneratedProxyClass;
    isGeneratedFunctionGroup(group: FunctionGroup): boolean;
    private isGeneratedGatewayClass;
    private isGeneratedPersistentClass;
}

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

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

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

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

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

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

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

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

export declare class SpaghettiScope implements ISpaghettiScope {
    private readonly node;
    constructor(top: SpaghettiScopeNode);
    listDefinitions(filename: string): IScopeVariable[];
    listReadPositions(filename: string): Identifier[];
    listWritePositions(filename: string): Identifier[];
    lookupPosition(p: Position | undefined, filename: string | undefined): SpaghettiScopeNode | undefined;
    getFirstChild(): SpaghettiScopeNode | undefined;
    getTop(): SpaghettiScopeNode;
    private allNodes;
    private lookupPositionTraverse;
}

export declare class SpaghettiScopeNode extends ScopeData implements ISpaghettiScopeNode {
    private readonly identifier;
    private readonly children;
    private readonly parent;
    constructor(identifier: IScopeIdentifier, parent: SpaghettiScopeNode | undefined);
    getParent(): SpaghettiScopeNode | undefined;
    addChild(node: SpaghettiScopeNode): void;
    getChildren(): SpaghettiScopeNode[];
    getFirstChild(): SpaghettiScopeNode | undefined;
    getIdentifier(): IScopeIdentifier;
    calcCoverage(): {
        start: Position;
        end: Position;
    };
    setEnd(end: Position): void;
    findDeferred(name: string): {
        id: Identifier | undefined;
        ooType: "CLAS" | "INTF";
    } | undefined;
    findClassDefinition(name: string): IClassDefinition | undefined;
    listClassDefinitions(): IClassDefinition[];
    listInterfaceDefinitions(): IInterfaceDefinition[];
    findFormDefinition(name: string): IFormDefinition | undefined;
    findInterfaceDefinition(name: string): IInterfaceDefinition | undefined;
    findType(name: string): TypedIdentifier | undefined;
    findExtraLikeType(name: string): TypedIdentifier | undefined;
    findVariable(name: string): TypedIdentifier | undefined;
    findWriteReference(pos: Position): TypedIdentifier | undefined;
    findTableReference(pos: Position): string | undefined;
    findTableVoidReference(pos: Position): boolean;
    findScopeForVariable(name: string): IScopeIdentifier | undefined;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class StatementNode extends AbstractNode<ExpressionNode | TokenNode> {
    private readonly statement;
    private readonly colon;
    private readonly pragmas;
    constructor(statement: IStatement, colon?: Token | undefined, pragmas?: readonly Token[]);
    get(): IStatement;
    getColon(): Token | undefined;
    getPragmas(): readonly Token[];
    setChildren(children: (ExpressionNode | TokenNode)[]): StatementNode;
    getStart(): Position;
    getEnd(): Position;
    getTokens(): readonly Token[];
    includesToken(search: Token): boolean;
    getTokenNodes(): readonly TokenNode[];
    concatTokens(): string;
    concatTokensVirtual(): string;
    concatTokensWithoutStringsAndComments(): string;
    getTerminator(): string;
    getFirstToken(): Token;
    getLastToken(): Token;
    findDirectExpression(type: new () => IStatementRunnable): ExpressionNode | undefined;
    findDirectExpressions(type: new () => IStatementRunnable): readonly ExpressionNode[];
    findDirectExpressionsMulti(type: (new () => IStatementRunnable)[]): readonly ExpressionNode[];
    findDirectTokenByText(text: string): Token | undefined;
    findFirstExpression(type: new () => IStatementRunnable): ExpressionNode | undefined;
    findAllExpressions(type: new () => IStatementRunnable): readonly ExpressionNode[];
    findAllExpressionsRecursive(type: new () => IStatementRunnable): readonly ExpressionNode[];
    findAllExpressionsMulti(type: (new () => IStatementRunnable)[], recursive?: boolean): ExpressionNode[];
    /**
     * Returns the Position of the first token if the sequence is found,
     * otherwise undefined. Strings and Comments are ignored in this search.
     * @param first - Text of the first Token
     * @param second - Text of the second Token
     */
    findTokenSequencePosition(first: string, second: string): Position | undefined;
    findExpressionAfterToken(text: string): ExpressionNode | undefined;
    findExpressionsAfterToken(text: string): ExpressionNode[];
    private toTokens;
    private toTokenNodess;
}

declare namespace Statements {
    export {
        Data_2 as Data,
        Report,
        Write,
        EndMethod,
        MethodImplementation,
        EndForm,
        Form_2 as Form,
        ImportNametab,
        CheckSelectOptions,
        CallBadi,
        ClassData_2 as ClassData,
        ClassDataBegin,
        ClassDataEnd,
        SelectLoop,
        Do_2 as Do,
        BreakId,
        InterfaceDeferred,
        While_2 as While,
        LoopAtScreen_2 as LoopAtScreen,
        Loop_2 as Loop,
        Check,
        EndProvide,
        If_2 as If,
        ConvertText,
        LogPoint,
        Window_2 as Window,
        EndIf,
        TypeEnum_2 as TypeEnum,
        TypeEnumBegin,
        TypeEnumEnd,
        SetRunTime,
        FieldGroup,
        PrintControl,
        Extract_2 as Extract,
        Sum,
        EndOfPage,
        GenerateReport,
        ElseIf_2 as ElseIf,
        Else_2 as Else,
        Perform,
        Append,
        Clear,
        Concatenate,
        EndDo,
        EndClass,
        Try_2 as Try,
        EndTry,
        Assert,
        Return,
        EndWhile,
        Constant,
        Catch_2 as Catch,
        Infotypes,
        Message_2 as Message,
        ReadTable,
        EndLoop,
        Case_2 as Case,
        CreateObject,
        Select_2 as Select,
        Call,
        ClassLocalFriends,
        ClassDeferred,
        FieldSymbol,
        ClassDefinition_2 as ClassDefinition,
        ClassImplementation_2 as ClassImplementation,
        Translate,
        Exit,
        EndCase,
        ConstantBegin,
        ConstantEnd,
        WhenOthers,
        When_2 as When,
        Continue,
        Assign,
        GetBadi,
        SuppressDialog,
        Type,
        Hide,
        GetLocale,
        SetLocale,
        Commit,
        ModifyScreen,
        CommitEntities,
        ModifyEntities,
        ReadEntities,
        RollbackEntities,
        Summary,
        Input,
        OnChange_2 as OnChange,
        AtUserCommand,
        Position_2 as Position,
        Resume,
        Stop,
        GetPFStatus,
        DeleteReport,
        Controls,
        AtLineSelection,
        NewPage,
        SetDataset,
        GetProperty,
        ScrollList,
        LoadOfProgram,
        TopOfPage,
        TruncateDataset,
        SetUpdateTask,
        SetUserCommand,
        Rollback,
        DeleteInternal,
        DeleteDatabase,
        DeleteDataset,
        FreeMemory,
        CatchSystemExceptions_2 as CatchSystemExceptions,
        EndCatch,
        AssignLocalCopy,
        SetExtendedCheck,
        Split,
        NewLine,
        FreeObject,
        Sort,
        Replace,
        WithLoop,
        With_2 as With,
        EndWith,
        Condense,
        InsertInternal,
        InsertDatabase,
        InsertFieldGroup,
        UpdateDatabase,
        ModifyDatabase,
        ModifyInternal,
        Raise,
        Define_2 as Define,
        EndOfDefinition,
        Find,
        Move,
        MoveCorresponding,
        GetTime,
        EnhancementPoint,
        EnhancementSection_2 as EnhancementSection,
        EndEnhancementSection,
        SetHandler,
        SetLeft,
        Pack,
        CaseType_2 as CaseType,
        WhenType_2 as WhenType,
        ExecSQL_2 as ExecSQL,
        OpenCursor,
        Communication,
        GenerateSubroutine,
        Reject,
        LoadReport,
        Private,
        SystemCall,
        SetLanguage,
        CallDialog,
        Protected,
        Public,
        Nodes_2 as Nodes,
        Demand,
        Supply,
        Fields,
        DeleteCluster,
        SetMargin,
        CallDatabase,
        Contexts,
        Interface_3 as Interface,
        EndInterface,
        Parameter_2 as Parameter,
        Include,
        Collect,
        Ranges,
        Events,
        Receive,
        Back,
        AddCorresponding,
        SubtractCorresponding,
        StaticBegin,
        StaticEnd,
        GetDataset,
        Tables,
        Local,
        Add,
        Describe,
        Submit,
        Scan,
        Export,
        Import,
        AtFirst_2 as AtFirst,
        AtLast_2 as AtLast,
        AtPF,
        At_2 as At,
        Put,
        EndAt,
        EndSelect,
        Refresh,
        Shift,
        TypeMesh_2 as TypeMesh,
        Transfer,
        Subtract,
        Unassign,
        OpenDataset,
        CloseDataset,
        InterfaceLoad,
        CloseCursor,
        Leave,
        ClassDefinitionLoad,
        Initialization,
        StartOfSelection,
        SetBlank,
        ExportDynpro,
        EndOfSelection,
        Search,
        ModifyLine,
        SelectionScreen,
        Free,
        EndOn,
        FetchNextCursor,
        Reserve,
        RaiseEntityEvent,
        RefreshControl,
        DeleteDynpro,
        GenerateDynpro,
        ProcessOnHelpRequest_2 as ProcessOnHelpRequest,
        Detail,
        EditorCall,
        Break,
        DeleteTextpool,
        Get,
        LoopExtract_2 as LoopExtract,
        SelectOption,
        Convert,
        Static,
        Compute,
        Multiply,
        Divide,
        Format,
        SyntaxCheck,
        Aliases,
        MethodDef,
        TypeMeshBegin,
        TypeMeshEnd,
        InterfaceDef,
        AtSelectionScreen,
        IncludeType,
        ImportDynpro,
        CallFunction,
        CallSelectionScreen,
        CallTransformation,
        ReadLine,
        ReadTextpool,
        ReadReport,
        ReadDataset,
        GetBit,
        GetReference,
        InsertReport,
        InsertTextpool,
        SetBit,
        GetRunTime,
        GetParameter,
        CreateData,
        SetCountry,
        FunctionModule_2 as FunctionModule,
        DynproLoop_2 as DynproLoop,
        TypePools,
        TypePool_2 as TypePool,
        Wait,
        Overlay,
        SetScreen,
        SetCursor,
        CallScreen,
        SetPFStatus,
        SetTitlebar,
        Program_2 as Program,
        FunctionPool,
        Module_2 as Module,
        EndModule,
        EndFunction,
        Retry,
        AuthorityCheck,
        SetParameter,
        Field,
        GetCursor,
        CallKernel,
        CallTransaction,
        Unpack,
        Skip,
        Uline,
        DataBegin,
        DataEnd,
        TypeBegin,
        ProcessAfterInput_2 as ProcessAfterInput,
        ProcessBeforeOutput_2 as ProcessBeforeOutput,
        ProcessOnValueRequest_2 as ProcessOnValueRequest,
        TypeEnd,
        RaiseEvent,
        Cleanup_2 as Cleanup,
        CreateOLE,
        CallOLE,
        SetProperty,
        TestInjection_2 as TestInjection,
        EndTestInjection,
        TestSeam_2 as TestSeam,
        EndTestSeam,
        DeleteMemory,
        Provide_2 as Provide,
        EndExec,
        Chain_2 as Chain,
        EndChain,
        CallSubscreen,
        SortDataset,
        GetPermissions,
        SetLocks,
        Enhancement_2 as Enhancement,
        EndEnhancement,
        FormDefinition,
        VerificationMessage
    }
}
export { Statements }

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

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

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

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

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

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

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

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

declare class StringTemplate_2 extends Token {
}

declare class StringTemplateBegin extends Token {
}

declare class StringTemplateEnd extends Token {
}

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

declare class StringTemplateMiddle extends Token {
}

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

declare class StringToken extends Token {
}

declare class StringType extends AbstractType {
    private static readonly singletons;
    static get(input?: AbstractTypeData): StringType;
    private constructor();
    /** fully qualified symbolic name of the type */
    getQualifiedName(): string | undefined;
    toText(): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

declare class StructureNode extends AbstractNode<StructureNode | StatementNode> {
    private readonly structure;
    constructor(structure: IStructure);
    get(): IStructure;
    findParent(node: StatementNode): StructureNode | undefined;
    concatTokens(): string;
    findDirectStatement(type: new () => IStatement): StatementNode | undefined;
    findDirectStatements(type: new () => IStatement): StatementNode[];
    findDirectStructures(type: new () => IStructure): StructureNode[];
    findFirstStatement(type: new () => IStatement): StatementNode | undefined;
    findFirstExpression(type: new () => IStatementRunnable): ExpressionNode | undefined;
    getFirstStatement(): StatementNode | undefined;
    getFirstToken(): Token;
    getLastToken(): Token;
    findAllExpressions(type: new () => IStatementRunnable): ExpressionNode[];
    findAllExpressionsRecursive(type: new () => IStatementRunnable): ExpressionNode[];
    findAllExpressionsMulti(type: (new () => IStatementRunnable)[]): ExpressionNode[];
    findAllStatements(type: new () => IStatement): StatementNode[];
    findAllStatementNodes(): StatementNode[];
    findAllStructuresRecursive(type: new () => IStructure): StructureNode[];
    findAllStructuresMulti(type: (new () => IStructure)[]): StructureNode[];
    findAllStructures(type: new () => IStructure): StructureNode[];
    findDirectStructure(type: new () => IStructure): StructureNode | undefined;
    findFirstStructure(type: new () => IStructure): StructureNode | undefined;
}

declare namespace Structures {
    export {
        Any,
        AtFirst,
        AtLast,
        At,
        Body,
        CaseType,
        Case,
        CatchSystemExceptions,
        Catch,
        Chain,
        ClassData,
        ClassDefinition,
        ClassGlobal,
        ClassImplementation,
        Cleanup,
        Constants,
        Data,
        Define,
        Do,
        DynproLogic,
        Else,
        ElseIf,
        EnhancementSection,
        Enhancement,
        ExecSQL,
        Form,
        FunctionModule,
        If,
        InterfaceGlobal,
        Interface_2 as Interface,
        LoopAtScreen,
        Loop,
        Method,
        Module,
        Normal,
        OnChange,
        PrivateSection,
        ProcessAfterInput,
        ProcessBeforeOutput,
        ProcessOnValueRequest,
        ProtectedSection,
        Provide,
        PublicSection,
        SectionContents,
        Select,
        ProcessOnHelpRequest,
        DynproLoop,
        Statics,
        TestInjection,
        TestSeam,
        LoopExtract,
        Try,
        TypeEnum,
        TypeMesh,
        Types_2 as Types,
        WhenType,
        When,
        While,
        With
    }
}
export { Structures }

declare class StructureType extends AbstractType {
    private readonly indexed;
    private readonly components;
    constructor(components: IStructureComponent[], qualifiedName?: string, ddicName?: string, description?: string);
    getComponents(): readonly IStructureComponent[];
    getComponentByName(name: string): AbstractType | undefined;
    toText(level: number): string;
    isGeneric(): boolean;
    toABAP(): string;
    containsVoid(): boolean;
    toCDS(): string;
}

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

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

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

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

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

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

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

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

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

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

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

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

declare type SyntaxInput = {
    scope: CurrentScope;
    filename: string;
    issues: Issue[];
};

export declare class SyntaxLogic {
    private currentFile;
    private issues;
    private readonly object;
    private readonly reg;
    private readonly scope;
    private readonly helpers;
    constructor(reg: IRegistry, object: ABAPObject);
    run(): ISyntaxResult;
    private traverseObject;
    private newIssue;
    private traverse;
    /**
     * if this returns true, then the traversal should continue with next child
     */
    private updateScopeStructure;
    private updateScopeStatement;
    private updateSelectionEventScope;
    private opensSelectionEventScope;
    private isSelectionEventBoundary;
    private isSelectionEventBoundaryStructure;
}

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

declare class Table extends AbstractObject {
    private parsedData;
    private parsedType;
    getType(): string;
    getDescription(): string | undefined;
    getSecondaryIndexes(): SecondaryIndex[] | undefined;
    getAllowedNaming(): IAllowedNaming;
    setDirty(): void;
    listKeys(reg: IRegistry): string[];
    parseType(reg: IRegistry): AbstractType;
    getTableCategory(): TableCategory | undefined;
    getEnhancementCategory(): EnhancementCategory;
    private parseXML;
}

declare enum TableAccessType {
    standard = "STANDARD",
    sorted = "SORTED",
    hashed = "HASHED",
    index = "INDEX",
    any = "ANY"
}

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

declare enum TableCategory {
    Transparent = "TRANSP",
    Structure = "INTTAB",
    Cluster = "CLUSTER",
    Pooled = "POOL",
    View = "VIEW",
    Append = "APPEND"
}

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

declare enum TableKeyType {
    default = "DEFAULT",
    user = "USER",
    empty = "EMPTY"
}

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

declare class TableType extends AbstractObject {
    private parsedXML;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
    getRowType(): string | undefined;
    setDirty(): void;
    private buildPrimaryKey;
    private buildTableOptions;
    parseType(reg: IRegistry): AbstractType;
    private parseXML;
}

declare class TableType_2 extends AbstractType {
    private readonly rowType;
    private readonly options;
    constructor(rowType: AbstractType, options: ITableOptions, qualifiedName?: string, description?: string);
    getOptions(): ITableOptions;
    isWithHeader(): boolean;
    getAccessType(): TableAccessType | undefined;
    getRowType(): AbstractType;
    toABAP(): string;
    toText(level: number): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export declare abstract class Token {
    private readonly start;
    private readonly str;
    private readonly strUpper;
    constructor(start: Position, str: string);
    getStr(): string;
    getUpperStr(): string;
    getRow(): number;
    getCol(): number;
    getStart(): Position;
    getEnd(): Position;
}

declare class TokenNode implements INode {
    private readonly token;
    constructor(token: Token);
    addChild(_n: INode): void;
    setChildren(_children: INode[]): void;
    getChildren(): readonly INode[];
    concatTokens(): string;
    get(): Token;
    countTokens(): number;
    getFirstToken(): Token;
    getLastToken(): Token;
}

declare class TokenNodeRegex extends TokenNode {
}

declare namespace Tokens {
    export {
        At_3 as At,
        AtW,
        WAt,
        WAtW,
        BracketLeft,
        WBracketLeft,
        BracketLeftW,
        WBracketLeftW,
        BracketRight,
        WBracketRight,
        BracketRightW,
        WBracketRightW,
        InstanceArrow,
        WInstanceArrow,
        InstanceArrowW,
        WInstanceArrowW,
        ParenLeft,
        WParenLeft,
        ParenLeftW,
        WParenLeftW,
        ParenRight,
        WParenRight,
        ParenRightW,
        WParenRightW,
        Dash,
        WDash,
        DashW,
        WDashW,
        Plus,
        WPlus,
        PlusW,
        WPlusW,
        StaticArrow,
        WStaticArrow,
        StaticArrowW,
        WStaticArrowW,
        StringToken,
        StringTemplate_2 as StringTemplate,
        StringTemplateBegin,
        StringTemplateEnd,
        StringTemplateMiddle,
        Colon,
        Comment_2 as Comment,
        Identifier_2 as Identifier,
        Pragma,
        Punctuation
    }
}
export { Tokens }

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

declare class Transaction extends AbstractObject {
    private parsedXML;
    getType(): string;
    setDirty(): void;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getCInfo(): string | undefined;
    getProgramName(): string | undefined;
    getDescription(): string | undefined;
    getTextsTranslations(): {
        language: string;
        description?: string;
    }[] | undefined;
    parse(): {
        updated: boolean;
        runtime: number;
    };
}

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

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

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

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

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

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

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

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

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

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

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

declare class TypeDefinitions implements ITypeDefinitions {
    private readonly list;
    private readonly map;
    constructor(list: TypeDefinitionsEntry[]);
    getAll(): TypeDefinitionsEntry[];
    getByName(name: string): TypedIdentifier | undefined;
}

declare type TypeDefinitionsEntry = {
    type: TypedIdentifier;
    visibility: Visibility;
};

export declare class TypedIdentifier extends Identifier {
    private readonly type;
    private readonly meta;
    private readonly value;
    static from(id: Identifier, type: TypedIdentifier | AbstractType, meta?: readonly IdentifierMeta[]): TypedIdentifier;
    constructor(token: Token, filename: string, type: TypedIdentifier | AbstractType, meta?: readonly IdentifierMeta[], value?: string | {
        [index: string]: string;
    });
    toText(): string;
    getType(): AbstractType;
    getMeta(): readonly IdentifierMeta[];
    getValue(): string | {
        [index: string]: string;
    } | undefined;
}

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

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

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

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

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

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

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

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

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

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

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

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

declare class TypePool extends ABAPObject {
    getType(): string;
    getSequencedFiles(): readonly ABAPFile[];
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getDescription(): string | undefined;
}

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

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

declare namespace Types {
    export {
        ClassAttribute,
        Attributes,
        ClassConstant,
        ClassDefinition_3 as ClassDefinition,
        ClassImplementation_3 as ClassImplementation,
        FormDefinition_2 as FormDefinition,
        FunctionModuleParameterDirection,
        IFunctionModuleParameter,
        FunctionModuleType,
        FunctionModuleDefinition,
        InterfaceDefinition,
        MethodDefinition,
        MethodDefinitions,
        MethodImplementation_2 as MethodImplementation,
        MethodParameters_2 as MethodParameters,
        TypeDefinitions
    }
}
export { Types }

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

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

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

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

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

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

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

declare class UnknownType extends AbstractType {
    private readonly error;
    constructor(error: string, qualifiedName?: string);
    getError(): string;
    toText(): string;
    toABAP(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

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

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

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

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

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

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

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

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

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

export declare enum Version {
    OpenABAP = "open-abap",// as 702, but with some extra new language features
    v700 = "v700",
    v702 = "v702",
    v740sp02 = "v740sp02",
    v740sp05 = "v740sp05",
    v740sp08 = "v740sp08",
    v750 = "v750",
    v751 = "v751",
    v752 = "v752",
    v753 = "v753",
    v754 = "v754",
    v755 = "v755",
    v756 = "v756",
    v757 = "v757",
    v758 = "v758",
    Cloud = "Cloud"
}

declare class View extends AbstractObject {
    private parsedData;
    getType(): string;
    getAllowedNaming(): {
        maxLength: number;
        allowNamespace: boolean;
    };
    getFields(): {
        VIEWFIELD: string;
        TABNAME: string;
        FIELDNAME: string;
        KEYFLAG: string;
    }[] | undefined;
    getJoin(): {
        LTAB: string;
        LFIELD: string;
        OPERATOR: string;
        RTAB: string;
        RFIELD: string;
    }[] | undefined;
    setDirty(): void;
    parseType(reg: IRegistry): AbstractType;
    listKeys(): string[];
    getDescription(): string | undefined;
    private parseXML;
}

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

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

/** used for macro calls */
export declare class VirtualPosition extends Position {
    readonly vrow: number;
    readonly vcol: number;
    constructor(virtual: Position, row: number, col: number);
    equals(p: Position): boolean;
    isAfter(p: Position | VirtualPosition): boolean;
}

export declare enum Visibility {
    Private = 1,
    Protected = 2,
    Public = 3
}

declare class VoidType extends AbstractType {
    private static readonly singletons;
    static get(voided: string | undefined, qualifiedName?: string): VoidType;
    private readonly voided;
    private constructor();
    getVoided(): string | undefined;
    toABAP(): string;
    toText(): string;
    isGeneric(): boolean;
    containsVoid(): boolean;
    toCDS(): string;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class WebMIME extends AbstractObject {
    private parsedXML;
    getType(): string;
    getAllowedNaming(): IAllowedNaming;
    getDescription(): string | undefined;
    getParameter(name: string): string | undefined;
    getParameters(): {
        [key: string]: string;
    };
    setDirty(): void;
    getDataFile(): IFile | undefined;
    parse(): {
        updated: boolean;
        runtime: number;
    };
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export { }