@abaplint/runtime 2.7.90 → 2.7.92

package/build/src/statements/insert_database.d.ts

@@ -0,0 +1,13 @@
+import { Context } from "../context";
+import { Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+export declare function toValue(value: any): any;
+export interface IInsertDatabaseOptions {
+    values?: Structure;
+    table?: Table;
+}
+export declare class InsertDatabase {
+    private readonly context;
+    constructor(context: Context);
+    insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): Promise<number | undefined>;
+}

package/build/src/statements/insert_internal.d.ts

@@ -0,0 +1,14 @@
+import { ABAPObject, DataReference, FieldSymbol, HashedTable, Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IInsertInternalOptions {
+    index?: INumeric;
+    initial?: boolean;
+    data?: INumeric | ICharacter | Structure | ABAPObject | Table | FieldSymbol | string;
+    table: Table | HashedTable | FieldSymbol;
+    referenceInto?: DataReference;
+    assigning?: FieldSymbol;
+    noClone?: boolean;
+    lines?: boolean;
+}
+export declare function insertInternal(options: IInsertInternalOptions): void;

package/build/src/statements/loop.d.ts

@@ -0,0 +1,15 @@
+import { FieldSymbol, HashedTable, Integer, Table } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+type topType = {
+    [name: string]: INumeric | ICharacter;
+};
+export interface ILoopOptions {
+    where?: (i: any) => Promise<boolean>;
+    usingKey?: string;
+    from?: Integer;
+    to?: Integer;
+    topEquals?: topType;
+}
+export declare function loop(table: Table | HashedTable | FieldSymbol | undefined, options?: ILoopOptions): AsyncGenerator<any, void, unknown>;
+export {};

package/build/src/statements/message.d.ts

@@ -0,0 +1,17 @@
+import { Context } from "../context";
+import { ABAPObject } from "../types";
+import { ICharacter } from "../types/_character";
+export interface IMessageOptions {
+    id?: ICharacter | string;
+    number?: ICharacter | string;
+    type?: ICharacter | string;
+    displayLike?: ICharacter | string;
+    exception?: ABAPObject;
+    with?: (ICharacter | string)[];
+    into?: ICharacter;
+}
+export declare class MessageStatement {
+    private readonly context;
+    constructor(context: Context);
+    message(options: IMessageOptions): Promise<void>;
+}

package/build/src/statements/modify_database.d.ts

@@ -0,0 +1,12 @@
+import { Context } from "../context";
+import { FieldSymbol, Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+export interface IModifyDatabaseOptions {
+    values?: Structure | FieldSymbol;
+    table?: Table | FieldSymbol;
+}
+export declare class ModifyDatabase {
+    private readonly context;
+    constructor(context: Context);
+    modifyDatabase(table: string | ICharacter, options: IModifyDatabaseOptions): Promise<void>;
+}

package/build/src/statements/modify_internal.d.ts

@@ -0,0 +1,9 @@
+import { Table } from "../types";
+import { INumeric } from "../types/_numeric";
+export interface IModifyInternalOptions {
+    index: INumeric;
+    from: any;
+    where?: (i: any) => boolean;
+    transporting?: string[];
+}
+export declare function modifyInternal(table: Table, options: IModifyInternalOptions): void;

package/build/src/statements/move_corresponding.d.ts

@@ -0,0 +1,2 @@
+import { Structure } from "../types";
+export declare function moveCorresponding(source: Structure, target: Structure): void;

package/build/src/statements/overlay.d.ts

@@ -0,0 +1,3 @@
+import { Character, Structure } from "../types";
+import { ICharacter } from "../types/_character";
+export declare function overlay(value: Character | Structure, withh: ICharacter, _only?: ICharacter): void;

package/build/src/statements/raise_event.d.ts

@@ -0,0 +1 @@
+export declare function raiseEvent(): void;

package/build/src/statements/read_report.d.ts

@@ -0,0 +1,8 @@
+import { Table } from "../types";
+import { ICharacter } from "../types/_character";
+interface IReadReportOptions {
+    state?: ICharacter;
+    into?: Table;
+}
+export declare function readReport(name: ICharacter, options: IReadReportOptions): void;
+export {};

package/build/src/statements/read_table.d.ts

@@ -0,0 +1,27 @@
+import { DataReference, FieldSymbol, HashedTable, Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IReadTableOptions {
+    index?: INumeric | FieldSymbol | number;
+    into?: INumeric | ICharacter | Structure | Table | DataReference;
+    from?: INumeric | ICharacter | Structure | Table | DataReference;
+    referenceInto?: DataReference;
+    assigning?: FieldSymbol;
+    binarySearch?: boolean;
+    withTableKey?: boolean;
+    keyName?: string;
+    usesTableLine?: boolean;
+    withKey?: (i: any) => boolean;
+    withKeyValue?: {
+        key: (i: any) => any;
+        value: any;
+    }[];
+    withKeySimple?: {
+        [key: string]: any;
+    };
+}
+export type ReadTableReturn = {
+    subrc: number;
+    foundIndex: number;
+};
+export declare function readTable(table: Table | HashedTable | FieldSymbol, options?: IReadTableOptions): ReadTableReturn;

package/build/src/statements/receive.d.ts

@@ -0,0 +1,9 @@
+export interface IReceiveOptions {
+    exporting?: any;
+    importing?: any;
+    tables?: any;
+    changing?: any;
+    exceptions?: any;
+}
+export declare function _receiveSetResult(options: IReceiveOptions): void;
+export declare function receive(options: IReceiveOptions): void;

package/build/src/statements/replace.d.ts

@@ -0,0 +1,14 @@
+import { Table } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export type replaceInput = {
+    target: ICharacter | Table;
+    sectionLength?: INumeric;
+    sectionOffset?: INumeric;
+    regex?: ICharacter;
+    all: boolean;
+    with: ICharacter;
+    of: ICharacter;
+    ignoringCase?: boolean;
+};
+export declare function replace(input: replaceInput): void;

package/build/src/statements/rollback.d.ts

@@ -0,0 +1 @@
+export declare function rollback(): void;

package/build/src/statements/select.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "../context";
+import { SelectDatabaseOptions, SelectRuntimeOptions } from "../db/db";
+import { FieldSymbol, HashedTable, Structure, Table } from "../types";
+export declare class SelectDatabase {
+    private readonly context;
+    constructor(context: Context);
+    select(target: Structure | Table | HashedTable | FieldSymbol, input: SelectDatabaseOptions, runtimeOptions?: SelectRuntimeOptions): Promise<void>;
+}

package/build/src/statements/set_bit.d.ts

@@ -0,0 +1,4 @@
+import { Hex, XString } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export declare function setBit(number: INumeric, hex: XString | Hex, val?: INumeric | ICharacter): void;

package/build/src/statements/set_handler.d.ts

@@ -0,0 +1,3 @@
+import { ABAPObject, FieldSymbol } from "../types";
+import { ICharacter } from "../types/_character";
+export declare function setHandler(_methods: any[], _f: ABAPObject | FieldSymbol, _activation: ICharacter): void;

package/build/src/statements/set_locale.d.ts

@@ -0,0 +1,2 @@
+import { ICharacter } from "../types/_character";
+export declare function setLocale(_source: ICharacter): void;

package/build/src/statements/shift.d.ts

@@ -0,0 +1,12 @@
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IShiftOptions {
+    deletingLeading?: string | ICharacter;
+    deletingTrailing?: string | ICharacter;
+    places?: INumeric;
+    to?: ICharacter | string;
+    direction?: "LEFT" | "RIGHT";
+    circular?: boolean;
+    mode?: "BYTE" | "CHARACTER";
+}
+export declare function shift(target: ICharacter, options?: IShiftOptions): void;

package/build/src/statements/sort.d.ts

@@ -0,0 +1,10 @@
+import { FieldSymbol, Table } from "../types";
+export interface ISortOptions {
+    descending?: boolean;
+    skipSortedCheck?: boolean;
+    by?: {
+        component: string;
+        descending?: boolean;
+    }[];
+}
+export declare function sort(input: Table | FieldSymbol | any[], options?: ISortOptions): void;

package/build/src/statements/split.d.ts

@@ -0,0 +1,9 @@
+import { ICharacter } from "../types/_character";
+import { Table } from "../types";
+export interface ISplitOptions {
+    source: ICharacter | string;
+    at: ICharacter | string;
+    table?: Table;
+    targets?: ICharacter[];
+}
+export declare function split(param: ISplitOptions): void;

package/build/src/statements/translate.d.ts

@@ -0,0 +1,2 @@
+import { ICharacter } from "../types/_character";
+export declare function translate(input: ICharacter, i: ICharacter | string): void;

package/build/src/statements/update_database.d.ts

@@ -0,0 +1,14 @@
+import { Context } from "../context";
+import { FieldSymbol, Structure, Table } from "../types";
+import { ICharacter } from "../types/_character";
+export interface IUpdateDatabaseOptions {
+    from?: Structure | FieldSymbol;
+    table?: Table | FieldSymbol;
+    set?: string[];
+    where?: string;
+}
+export declare class UpdateDatabase {
+    private readonly context;
+    constructor(context: Context);
+    updateDatabase(table: string | ICharacter, options: IUpdateDatabaseOptions): Promise<number>;
+}

package/build/src/statements/wait.d.ts

@@ -0,0 +1,5 @@
+import { INumeric } from "../types/_numeric";
+export declare function wait(options: {
+    cond: () => any;
+    seconds?: INumeric;
+}): Promise<void>;

package/build/src/statements/write.d.ts

@@ -0,0 +1,17 @@
+import { Context } from "../context";
+import { FieldSymbol } from "../types/field_symbol";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IWriteOptions {
+    newLine?: boolean;
+    skipLine?: boolean;
+    target?: ICharacter;
+    exponent?: ICharacter | INumeric;
+    noGrouping?: boolean;
+    noSign?: boolean;
+}
+export declare class WriteStatement {
+    private readonly context;
+    constructor(context: Context);
+    write(source: INumeric | ICharacter | FieldSymbol | string | number, options?: IWriteOptions): void;
+}

package/build/src/template_formatting.d.ts

@@ -0,0 +1,14 @@
+import { ICharacter } from "./types/_character";
+import { INumeric } from "./types/_numeric";
+type options = {
+    timestamp?: string;
+    date?: string;
+    time?: string;
+    pad?: string;
+    width?: number;
+    decimals?: number;
+    currency?: any;
+    align?: "left" | "right";
+};
+export declare function templateFormatting(source: ICharacter | INumeric, options?: options): string;
+export {};

package/build/src/throw_error.d.ts

@@ -0,0 +1 @@
+export declare function throwError(name: string): void;

package/build/src/types/_abstract_type_data.d.ts

@@ -0,0 +1,5 @@
+export type AbstractTypeData = {
+    qualifiedName?: string;
+    conversionExit?: string;
+    ddicName?: string;
+};

package/build/src/types/_character.d.ts

@@ -0,0 +1,11 @@
+import { Hex } from "./hex";
+import { INumeric } from "./_numeric";
+export interface ICharacter {
+    set(value: ICharacter | string): void;
+    get(): string;
+    clear(): void;
+    getOffset(input: {
+        offset?: number | INumeric | Hex;
+        length?: number | INumeric | Hex;
+    }): ICharacter;
+}

package/build/src/types/_date_helper.d.ts

@@ -0,0 +1,2 @@
+export declare function getDateFromNumber(value: number): string;
+export declare function getNumberFromDate(value: string): number;

package/build/src/types/_numeric.d.ts

@@ -0,0 +1,5 @@
+export interface INumeric {
+    set(value: INumeric | number): void;
+    get(): number;
+    clear(): void;
+}

package/build/src/types/abap_object.d.ts

@@ -0,0 +1,14 @@
+export declare class ABAPObject {
+    private value;
+    private readonly qualifiedName;
+    private readonly RTTIName;
+    constructor(input?: {
+        qualifiedName?: string;
+        RTTIName?: string;
+    });
+    get(): any;
+    clear(): void;
+    getQualifiedName(): string | undefined;
+    getRTTIName(): string | undefined;
+    set(value: ABAPObject | any): this;
+}

package/build/src/types/character.d.ts

@@ -0,0 +1,27 @@
+import { FieldSymbol } from "./field_symbol";
+import { Hex } from "./hex";
+import { Structure } from "./structure";
+import { AbstractTypeData } from "./_abstract_type_data";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+import { Integer } from "./integer";
+export declare class Character implements ICharacter {
+    private value;
+    private constant;
+    private readonly length;
+    private readonly extra;
+    constructor(length?: number, extra?: AbstractTypeData);
+    setConstant(): this;
+    set(value: ICharacter | string | Structure | FieldSymbol | Integer): this;
+    getQualifiedName(): string | undefined;
+    getConversionExit(): string | undefined;
+    getDDICName(): string | undefined;
+    getLength(): number;
+    clear(): void;
+    get(): string;
+    getTrimEnd(): string;
+    getOffset(input: {
+        offset?: number | INumeric | Hex;
+        length?: number | INumeric | Hex;
+    }): Character;
+}

package/build/src/types/data_reference.d.ts

@@ -0,0 +1,29 @@
+import { INumeric } from "./_numeric";
+import { ICharacter } from "./_character";
+import { ABAPObject } from "./abap_object";
+import { Table } from "./table";
+import { String } from "./string";
+import { Structure } from "./structure";
+import { Float } from "./float";
+import { Hex } from "./hex";
+type PointerType = INumeric | Table | ICharacter | ABAPObject | undefined | Structure | Float;
+export declare class DataReference {
+    private pointer;
+    private readonly type;
+    constructor(type: PointerType);
+    getType(): PointerType;
+    assign(pointer: PointerType): void;
+    unassign(): void;
+    getPointer(): PointerType;
+    dereference(): PointerType;
+    clear(): void;
+    get(): any;
+    array(): any;
+    getArrayLength(): any;
+    set(value: any): void | Float | ABAPObject | this | Table | Structure;
+    getOffset(input: {
+        offset?: number | INumeric | Hex;
+        length?: number | INumeric | Hex;
+    }): String;
+}
+export {};

package/build/src/types/date.d.ts

@@ -0,0 +1,20 @@
+import { Hex } from "./hex";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+import { String } from "./string";
+export declare class Date implements ICharacter {
+    private value;
+    private readonly qualifiedName;
+    constructor(input?: {
+        qualifiedName?: string;
+    });
+    getQualifiedName(): string | undefined;
+    set(value: INumeric | ICharacter | Hex | string | number): this;
+    clear(): void;
+    get(): string;
+    getNumeric(): number;
+    getOffset(input: {
+        offset?: number | INumeric | Hex;
+        length?: number | INumeric | Hex;
+    }): String;
+}

package/build/src/types/decfloat34.d.ts

@@ -0,0 +1,11 @@
+import { Hex } from "./hex";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+export declare class DecFloat34 {
+    private value;
+    constructor();
+    set(value: INumeric | ICharacter | Hex | string | number): this;
+    clear(): void;
+    getRaw(): number;
+    get(): string;
+}

package/build/src/types/field_symbol.d.ts

@@ -0,0 +1,32 @@
+import { INumeric } from "./_numeric";
+import { ICharacter } from "./_character";
+import { ABAPObject } from "./abap_object";
+import { Table } from "./table";
+import { Structure } from "./structure";
+import { Hex } from "./hex";
+import { Float } from "./float";
+type PointerType = INumeric | Table | ICharacter | ABAPObject | undefined | Structure | Float;
+export declare class FieldSymbol {
+    private pointer;
+    private casting;
+    private readonly type;
+    constructor(type?: PointerType);
+    getQualifiedName(): any;
+    assign(pointer: PointerType): void;
+    setCasting(): void;
+    unassign(): void;
+    isAssigned(): boolean;
+    getPointer(): any;
+    dereference(): INumeric | Float | ICharacter | ABAPObject | Table | Structure | undefined;
+    clear(): void | Structure | undefined;
+    get(): any;
+    appendInitial(): import("./table").TableRowType | undefined;
+    array(): any;
+    getArrayLength(): any;
+    set(value: any): this;
+    getOffset(input: {
+        offset?: number | INumeric | Hex;
+        length?: number | INumeric | Hex;
+    }): any;
+}
+export {};

package/build/src/types/float.d.ts

@@ -0,0 +1,15 @@
+import { Hex } from "./hex";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+export declare class Float {
+    private value;
+    private readonly qualifiedName;
+    constructor(input?: {
+        qualifiedName?: string;
+    });
+    getQualifiedName(): string | undefined;
+    set(value: INumeric | ICharacter | Hex | string | number): this;
+    clear(): void;
+    getRaw(): number;
+    get(): string;
+}

package/build/src/types/hex.d.ts

@@ -0,0 +1,20 @@
+import { Float } from "./float";
+import { Integer } from "./integer";
+import { XString } from "./xstring";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+export declare class Hex implements ICharacter {
+    private value;
+    private readonly length;
+    constructor(input?: {
+        length?: number;
+    });
+    set(value: ICharacter | INumeric | string | number | Integer | Float): this;
+    getLength(): number;
+    clear(): void;
+    get(): string;
+    getOffset(input: {
+        offset?: number | INumeric | Hex;
+        length?: number | INumeric | Hex;
+    }): XString;
+}

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

@@ -0,0 +1,18 @@
+export * from "./abap_object";
+export * from "./character";
+export * from "./data_reference";
+export * from "./date";
+export * from "./decfloat34";
+export * from "./field_symbol";
+export * from "./float";
+export * from "./hex";
+export * from "./integer";
+export * from "./integer8";
+export * from "./numc";
+export * from "./packed";
+export * from "./string";
+export * from "./structure";
+export * from "./table";
+export * from "./time";
+export * from "./utc_long";
+export * from "./xstring";

package/build/src/types/integer.d.ts

@@ -0,0 +1,15 @@
+import { Float } from "./float";
+import { Hex } from "./hex";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+export declare class Integer implements INumeric {
+    private value;
+    private readonly qualifiedName;
+    constructor(input?: {
+        qualifiedName?: string;
+    });
+    getQualifiedName(): string | undefined;
+    set(value: INumeric | ICharacter | Hex | string | number | Integer | Float): this;
+    clear(): void;
+    get(): number;
+}

package/build/src/types/integer8.d.ts

@@ -0,0 +1,16 @@
+import { Float } from "./float";
+import { Hex } from "./hex";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+import { Integer } from "./integer";
+export declare class Integer8 implements INumeric {
+    private value;
+    private readonly qualifiedName;
+    constructor(input?: {
+        qualifiedName?: string;
+    });
+    getQualifiedName(): string | undefined;
+    set(value: INumeric | ICharacter | Hex | string | number | Integer8 | Integer | Float): this;
+    clear(): void;
+    get(): number;
+}

package/build/src/types/numc.d.ts

@@ -0,0 +1,21 @@
+import { Hex } from "./hex";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+export declare class Numc implements ICharacter {
+    private value;
+    private readonly length;
+    private readonly qualifiedName;
+    constructor(input?: {
+        length?: number;
+        qualifiedName?: string;
+    });
+    getQualifiedName(): string | undefined;
+    set(value: INumeric | ICharacter | Hex | string | number, raw?: boolean): this | undefined;
+    getLength(): number;
+    clear(): void;
+    get(): string;
+    getOffset(input: {
+        offset?: number | INumeric | Hex;
+        length?: number | INumeric | Hex;
+    }): Numc;
+}

package/build/src/types/packed.d.ts

@@ -0,0 +1,19 @@
+import { INumeric } from "./_numeric";
+export declare class Packed implements INumeric {
+    private value;
+    private readonly length;
+    private readonly decimals;
+    private readonly qualifiedName;
+    constructor(input?: {
+        length?: number;
+        decimals?: number;
+        qualifiedName?: string;
+    });
+    getQualifiedName(): string | undefined;
+    private round;
+    set(value: INumeric | number | string): this;
+    getLength(): number;
+    getDecimals(): number;
+    clear(): void;
+    get(): number;
+}

package/build/src/types/string.d.ts

@@ -0,0 +1,19 @@
+import { FieldSymbol } from "./field_symbol";
+import { Hex } from "./hex";
+import { ICharacter } from "./_character";
+import { INumeric } from "./_numeric";
+export declare class String implements ICharacter {
+    private value;
+    private readonly qualifiedName;
+    constructor(input?: {
+        qualifiedName?: string;
+    });
+    getQualifiedName(): string | undefined;
+    set(value: ICharacter | string | number | FieldSymbol): String;
+    clear(): void;
+    get(): string;
+    getOffset(input: {
+        offset?: number | INumeric | Hex;
+        length?: number | INumeric | Hex;
+    }): String;
+}