@supernova-studio/pulsar-core 2.0.13 → 2.0.15

package/build/main/language/src/interpreter/transformers/specific/shared/TransformerFormatDate.d.ts

@@ -0,0 +1,13 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerFormatDate extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformValue(value: any, args: any[], context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    format(format: string, date: Date): string;
+}

package/build/main/language/src/interpreter/transformers/specific/shared/TransformerIsArray.d.ts

@@ -0,0 +1,14 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerIsArray extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(_value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformBooleanValue(_value: boolean, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformNumericValue(_value: number, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformMapValue(_value: Map<any, any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext, _isRoot: boolean): any | null;
+    transformArrayValue(_value: Array<any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/shared/TransformerIsBool.d.ts

@@ -0,0 +1,14 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerIsBool extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(_value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformBooleanValue(_value: boolean, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformNumericValue(_value: number, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformMapValue(_value: Map<any, any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext, _isRoot: boolean): any | null;
+    transformArrayValue(_value: Array<any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/shared/TransformerIsNumber.d.ts

@@ -0,0 +1,14 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerIsNumber extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(_value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformBooleanValue(_value: boolean, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformNumericValue(_value: number, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformMapValue(_value: Map<any, any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext, _isRoot: boolean): any | null;
+    transformArrayValue(_value: Array<any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/shared/TransformerIsObject.d.ts

@@ -0,0 +1,14 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from '../../../InterpreterContext';
+export declare class PLTransformerIsObject extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(_value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformBooleanValue(_value: boolean, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformNumericValue(_value: number, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformMapValue(_value: Map<any, any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext, _isRoot: boolean): any | null;
+    transformArrayValue(_value: Array<any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/shared/TransformerIsString.d.ts

@@ -0,0 +1,14 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerIsString extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(_value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformBooleanValue(_value: boolean, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformNumericValue(_value: number, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformMapValue(_value: Map<any, any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext, _isRoot: boolean): any | null;
+    transformArrayValue(_value: Array<any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/shared/TransformerToString.d.ts

@@ -0,0 +1,14 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerToString extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformBooleanValue(value: boolean, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformNumericValue(value: number, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformArrayValue(value: Array<any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformMapValue(_value: Map<any, any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext, _isRoot: boolean): any | null;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerCamelcased.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerCamelcased extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerCapitalized.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerCapitalized extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerContains.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerContains extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformArrayValue(value: Array<any>, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerDefault.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerDefault extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformNullValue(args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerEndsWith.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerEndsWith extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerExtended.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerExtended extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerLowercased.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerLowercased extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerPrefixed.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerPrefixed extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerReplacing.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerReplacing extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSlashDoubleQuotes.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSlashDoubleQuotes extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSlashNewlines.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSlashNewlines extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSlashSingleQuotes.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSlashSingleQuotes extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSnakecased.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSnakecased extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSplit.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSplit extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSplitExpr.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSplitExpr extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSplitNewlines.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSplitNewlines extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerStartsWith.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerStartsWith extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSubstring.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSubstring extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerSuffixed.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerSuffixed extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerTrimmingCharacter.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from '../../../InterpreterContext';
+export declare class PLTransformerTrimmingCharacter extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    trim(s: any, c: any): string;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerTrimmingSpaces.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerTrimmingSpaces extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/transformers/specific/string/TransformerUppercased.d.ts

@@ -0,0 +1,10 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+export declare class PLTransformerUppercased extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/language/src/interpreter/variables/Variable.d.ts

@@ -0,0 +1,22 @@
+import { PLVariableType } from './VariableContext';
+export declare class PLVariable {
+    /** Context */
+    type: PLVariableType;
+    /** Variable identifier */
+    identifier: string;
+    /** Context identifiers where it was defined, which is used in scope lookup */
+    scope: Array<string>;
+    /** If set, variable can be redefined after it was defined for the first time */
+    isMutable: boolean;
+    /** If set, variable is considered global and will be available in any context */
+    isGlobal: boolean;
+    /** Data payload of the variable */
+    payload: any;
+    constructor(identifier: string, scope: Array<string>, isMutable: boolean, isGlobal: boolean, payload: any, type?: PLVariableType);
+    static immutableProperty(scope: Array<string>, identifier: string, payload: any, type?: PLVariableType): PLVariable;
+    static mutableProperty(scope: Array<string>, identifier: string, payload: any, type?: PLVariableType): PLVariable;
+    static immutableGlobalProperty(scope: Array<string>, identifier: string, payload: any, type?: PLVariableType): PLVariable;
+    setPayload(payload: any): void;
+    isAvailableInContext(flowIdentifier: Array<string>): boolean;
+    debugDescription(): string;
+}

package/build/main/language/src/interpreter/variables/VariableContext.d.ts

@@ -0,0 +1,14 @@
+import { PLVariable } from './Variable';
+export declare enum PLVariableType {
+    user = 0,
+    dsContext = 1
+}
+export declare class PLVariableContext {
+    stack: Array<PLVariable>;
+    functionReturnStack: Array<Object>;
+    constructor();
+    setVariable(identifier: string, isGlobal: boolean, isMutable: boolean, context: Array<string>, payload: any): void;
+    getVariable(identifier: string, context: Array<string>): PLVariable;
+    getVariableFailable(identifier: string, context: Array<string>): PLVariable | null;
+    variables(identifier: string): Array<PLVariable>;
+}

package/build/main/language/src/parser/Tokenization/Concrete/ConcreteBuffer.d.ts

@@ -0,0 +1,19 @@
+import { ConcreteToken } from './ConcreteToken';
+export declare class ConcreteBuffer {
+    tokens: Array<ConcreteToken>;
+    isEmpty(): boolean;
+    size(): number;
+    constructor(tokens: Array<ConcreteToken>);
+    addToken(token: ConcreteToken): void;
+    addTokens(tokens: [ConcreteToken]): void;
+    removeFirst(): ConcreteToken | null;
+    removeLast(): ConcreteToken | null;
+    removeAt(at: number): ConcreteToken | null;
+    removeLastFew(count: number): Array<ConcreteToken>;
+    removeFirstFew(count: number): Array<ConcreteToken>;
+    shallowCopy(): ConcreteBuffer;
+    first(): ConcreteToken | null;
+    last(): ConcreteToken | null;
+    lookahead(offset: number): ConcreteToken | null;
+    debugDescription(): string;
+}

package/build/main/language/src/parser/Tokenization/Concrete/ConcreteParser.d.ts

@@ -0,0 +1,25 @@
+import { PLDebugger } from '../../../debugger/Debugger';
+import { PLBlueprintConfiguration } from './../../../blueprints/BlueprintConfiguration';
+import { LexicalBuffer } from './../Lexical/LexicalBuffer';
+import { LexicalToken } from './../Lexical/LexicalToken';
+import { ConcreteBuffer } from './ConcreteBuffer';
+import { ConcreteToken } from './ConcreteToken';
+interface ExtractionResult {
+    token: ConcreteToken;
+    size: number;
+}
+export declare class ConcreteParser {
+    tokens: LexicalBuffer;
+    configuration: PLBlueprintConfiguration;
+    debugger: PLDebugger;
+    constructor(tokens: LexicalBuffer, configuration: PLBlueprintConfiguration, debug: PLDebugger);
+    parse(): ConcreteBuffer;
+    extractTextToken(tokens: Array<LexicalToken>, prefix: string): ExtractionResult;
+    extractSubstitutionToken(tokens: Array<LexicalToken>, openingToken: LexicalToken): ExtractionResult;
+    extractCommentToken(tokens: Array<LexicalToken>): number;
+    extractFlow(tokens: Array<LexicalToken>, lineOffset: number, isFirstLineDirective: boolean, openingToken: LexicalToken): ExtractionResult;
+    isEqual(t1: LexicalToken, t2: LexicalToken): boolean;
+    isText(t1: LexicalToken): boolean;
+    textFrom(token: LexicalToken): string;
+}
+export {};

package/build/main/language/src/parser/Tokenization/Concrete/ConcreteToken.d.ts

@@ -0,0 +1,21 @@
+import { LexicalToken } from '../Lexical/LexicalToken';
+export declare enum ConcreteTokenType {
+    text = "text",
+    substitution = "substitution",
+    flow = "flow",
+    flowEnd = "flowEnd"
+}
+export declare class ConcreteToken {
+    /** Type of the concrete token */
+    type: ConcreteTokenType;
+    /** Additional information associated with the token - usually its payload */
+    associatedValue: string | null;
+    /** Line offset from the line beginning */
+    lineOffset: number;
+    /** Flag signifying that the concrete token is the first executable token on a single processed line (but might not be the only one) */
+    firstLineDirective: boolean;
+    /** Lexical tokens providing raw information for the concrete token */
+    lts: LexicalToken[];
+    /** Debug symbol identifier */
+    debugSymbol: string | null;
+}

package/build/main/language/src/parser/Tokenization/Lexical/LexicalBuffer.d.ts

@@ -0,0 +1,22 @@
+import { LexicalToken } from './LexicalToken';
+export declare class LexicalBuffer {
+    tokens: Array<LexicalToken>;
+    lastId: number;
+    isEmpty(): boolean;
+    size(): number;
+    constructor(tokens: Array<LexicalToken>);
+    addToken(token: LexicalToken): void;
+    addTokens(tokens: Array<LexicalToken>): void;
+    removeFirst(): LexicalToken | null;
+    removeLast(): LexicalToken | null;
+    removeAt(at: number): LexicalToken | null;
+    removeLastFew(count: number): Array<LexicalToken>;
+    removeFirstFew(count: number): Array<LexicalToken>;
+    shallowCopy(): LexicalBuffer;
+    shallowCopyOmittingVirtualTokens(): LexicalBuffer;
+    first(): LexicalToken | null;
+    last(): LexicalToken | null;
+    lookahead(offset: number): LexicalToken | null;
+    sequentialIdentifier(): string;
+    debugDescription(): string;
+}

package/build/main/language/src/parser/Tokenization/Lexical/LexicalParser.d.ts

@@ -0,0 +1,14 @@
+import { PLDebugger } from '../../../debugger/Debugger';
+import { PLBlueprintConfiguration } from './../../../blueprints/BlueprintConfiguration';
+import { LexicalBuffer } from './LexicalBuffer';
+import { LexicalToken } from './LexicalToken';
+export declare class LexicalParser {
+    definition: string;
+    configuration: PLBlueprintConfiguration;
+    debugger: PLDebugger;
+    constructor(definition: string, configuration: PLBlueprintConfiguration, debug: PLDebugger);
+    parse(): LexicalBuffer;
+    enclosingFlowTagCombination(line: number, character: number): Array<LexicalToken>;
+    openingToken(from: string, line: number, character: number): LexicalToken | null;
+    enclosingToken(from: string, line: number, character: number): LexicalToken | null;
+}

package/build/main/language/src/parser/Tokenization/Lexical/LexicalToken.d.ts

@@ -0,0 +1,24 @@
+export declare enum LexicalTokenType {
+    openingSubstitution = "openingSubstitution",
+    enclosingSubstitution = "enclosingSubstitution",
+    openingFlow = "openingFlow",
+    enclosingFlow = "enclosingFlow",
+    flowEnd = "flowEnd",
+    openingComment = "openingComment",
+    enclosingComment = "enclosingComment",
+    openingEditorPlaceholder = "openingEditorPLaceholder",
+    enclosingEditorPlaceholder = "enclosingEditorPlaceholder",
+    plainText = "plainText",
+    newline = "newline"
+}
+export declare class LexicalToken {
+    type: LexicalTokenType;
+    associatedValue: string | null;
+    startChar: number;
+    startLine: number;
+    endChar: number;
+    endLine: number;
+    debugSymbol: string | null;
+    /** Flag signifying that token was created by the system */
+    virtual: boolean;
+}

package/build/main/language/src/parser/errors/LanguageError.d.ts

@@ -0,0 +1,5 @@
+import { PLErrorAnalysis } from './LanguageErrorAnalysis';
+export declare class PLError extends Error {
+    analysis: PLErrorAnalysis | null;
+    constructor(message: string, analysis: PLErrorAnalysis | null);
+}

package/build/main/language/src/parser/errors/LanguageErrorAnalysis.d.ts

@@ -0,0 +1,26 @@
+export declare enum PLErrorSeverityType {
+    warning = 0,
+    error = 1
+}
+export declare enum PLErrorSourceType {
+    analyzer = 0,
+    runtime = 1
+}
+export declare type PLErrorRange = {
+    startLine: number;
+    startChar: number;
+    endLine: number;
+    endChar: number;
+};
+export declare class PLErrorAnalysis {
+    severity?: PLErrorSeverityType;
+    source?: PLErrorSourceType;
+    range?: PLErrorRange;
+    filename?: string;
+    constructor(severity?: PLErrorSeverityType, source?: PLErrorSourceType, filename?: string, range?: {
+        startLine: number;
+        startChar: number;
+        endLine: number;
+        endChar: number;
+    });
+}

package/build/main/language/src/parser/errors/LoggerErrorUtility.d.ts

@@ -0,0 +1,8 @@
+import { PLBlueprint } from '../../blueprints/Blueprint';
+import { PLExecutionContext } from '../../interpreter/ExecutionContext';
+export declare class PLLoggerErrorUtility {
+    executionContext: PLExecutionContext;
+    blueprint: PLBlueprint | undefined;
+    constructor(executionContext: PLExecutionContext, blueprint?: PLBlueprint | undefined);
+    reportErrorToActiveLogger(error: Error): void;
+}

package/build/main/language/src/parser/symbols/Symbol.d.ts

@@ -0,0 +1,29 @@
+import { SymbolType } from './SymbolType';
+export interface SymbolModel {
+    identifier: string;
+    source: string;
+    startLine: number;
+    startChar: number;
+    endLine: number;
+    endChar: number;
+    type: SymbolType;
+}
+export declare class Symbol implements SymbolModel {
+    identifier: string;
+    source: string;
+    startLine: number;
+    startChar: number;
+    endLine: number;
+    endChar: number;
+    type: SymbolType;
+    constructor(model: SymbolModel);
+    /** Retrieve symbol data without identifier */
+    anonymizedSymbolData(): {
+        source: string;
+        startLine: number;
+        startChar: number;
+        endLine: number;
+        endChar: number;
+        type: SymbolType;
+    };
+}