@supernova-studio/pulsar-core 2.0.14 → 2.0.15

package/build/main/language/src/interpreter/ExecutionContext.d.ts

@@ -0,0 +1,56 @@
+import { PLBlueprintEmitter } from './emitters/BlueprintEmitter';
+import { PLBlueprintLoader } from './loaders/BlueprintLoader';
+import { PLFlow } from './flows/Flow';
+import { SyntaxNodeFlow } from './../parser/syntax/nodes/SyntaxNodeFlow';
+import { PLFunction } from './functions/Function';
+import { PLTransformer } from './transformers/Transformer';
+import { PLLogger } from './loggers/Logger';
+import { PLVariableContext } from './variables/VariableContext';
+import { PLDebugger } from '../debugger/Debugger';
+import { SyntaxNode } from '../parser/syntax/nodes/SyntaxNode';
+import 'ses';
+import { JSContext } from './javascript/JSContext';
+import { PLBlueprintFactory } from '../blueprints/BlueprintFactory';
+export declare class PLExecutionContext {
+    functions: Map<string, PLFunction>;
+    transformers: Map<string, PLTransformer>;
+    flows: Map<string, PLFlow>;
+    blueprintLoader: PLBlueprintLoader;
+    blueprintEmitter: PLBlueprintEmitter;
+    blueprintFactory: PLBlueprintFactory;
+    variableContext: PLVariableContext;
+    logger: PLLogger;
+    debugger: PLDebugger;
+    executedScope: Array<string>;
+    executedBlueprint: string;
+    executedNode: SyntaxNode;
+    jsContext: JSContext;
+    defaultTransformers: Array<PLTransformer>;
+    defaultFlows: Array<PLFlow>;
+    defaultFunctions: Array<PLFunction>;
+    constructor(load?: PLBlueprintLoader, emit?: PLBlueprintEmitter, log?: PLLogger, debug?: PLDebugger, construct?: PLBlueprintFactory);
+    provideCustomFunctions(): Array<PLFunction>;
+    provideCustomTransformers(): Array<PLTransformer>;
+    provideCustomFlows(): Array<PLFlow>;
+    registerDefaultFunctions(): void;
+    registerDefaultTransformers(): void;
+    registerDefaultFlows(): void;
+    provideTestFunction(): void;
+    registerFunction(fn: PLFunction): void;
+    registerTransformer(transformer: PLTransformer): void;
+    registerFlow(flow: PLFlow): void;
+    flow(key: string): PLFlow | null;
+    valueTransformer(): PLTransformer;
+    valueAlwaysRootTransformer(): PLTransformer;
+    transformer(key: string): PLTransformer | null;
+    function(key: string): PLFunction | null;
+    availableFlows(): Map<string, PLFlow>;
+    availableTransformers(): Map<string, PLTransformer>;
+    availableFunctions(): Map<string, PLFunction>;
+    setExecutedScopeForNode(node: SyntaxNodeFlow): void;
+    setExecutedScopeUsingScope(scope: Array<string>): void;
+    setExecutedBlueprint(id: string): void;
+    setExecutedNode(node: SyntaxNode): void;
+    getFunctionReturnStack(): Object[];
+    registerUsingJSHelper(helperCode: string): void;
+}

package/build/main/language/src/interpreter/Interpreter.d.ts

@@ -0,0 +1,33 @@
+import { PLInterpreterContext } from './InterpreterContext';
+import { PLBlueprintConfiguration } from './../blueprints/BlueprintConfiguration';
+import { PLBlueprint } from '../blueprints/Blueprint';
+import { PLExecutionContext } from './ExecutionContext';
+import { SyntaxNode } from '../parser/syntax/nodes/SyntaxNode';
+import { SyntaxNodeText } from '../parser/syntax/nodes/SyntaxNodeText';
+import { SyntaxNodeSubstitution } from '../parser/syntax/nodes/substitution/SyntaxNodeSubstitution';
+import { SyntaxNodeFlow } from './../parser/syntax/nodes/SyntaxNodeFlow';
+import { FlowIteratorBodyResult } from './flows/FlowIterator';
+import { SyntaxNodeGroup } from './../parser/syntax/nodes/SyntaxNodeGroup';
+export declare class PLInterpreter {
+    blueprintConfiguration: PLBlueprintConfiguration;
+    currentlyInterpretingScope: Array<string>;
+    currentlyInterpretingBlueprint: PLBlueprint;
+    constructor(blueprintConfiguration?: PLBlueprintConfiguration | null);
+    interpret(blueprint: PLBlueprint, context: PLInterpreterContext, executionContext: PLExecutionContext, isInjected?: boolean): Promise<string>;
+    interpretGroupNode(groupNode: SyntaxNodeGroup, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<string>;
+    interpretTextNodeSync(node: SyntaxNodeText, context: PLInterpreterContext, executionContext: PLExecutionContext): string;
+    interpretSubstitutionNodeSync(node: SyntaxNodeSubstitution, context: PLInterpreterContext, executionContext: PLExecutionContext): string;
+    interpretSubstitutionNodeAsync(node: SyntaxNodeSubstitution, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<string>;
+    interpretFlowNode(node: SyntaxNodeFlow, context: PLInterpreterContext, rootContext: PLInterpreterContext, executionContext: PLExecutionContext): Promise<FlowIteratorBodyResult>;
+    processFlowBody(node: SyntaxNodeFlow, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<FlowIteratorBodyResult>;
+    processCustomExecutor(node: SyntaxNodeFlow, body: FlowIteratorBodyResult, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<FlowIteratorBodyResult>;
+    processContextAdjustmentIfNeeded(node: SyntaxNodeFlow, body: FlowIteratorBodyResult, context: PLInterpreterContext, executionContext: PLExecutionContext): PLInterpreterContext;
+    processVariableAdjustmentIfNeeded(node: SyntaxNodeFlow, scope: Array<string>, body: FlowIteratorBodyResult, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<PLExecutionContext>;
+    createNewExecutingScope(_executingContext: PLExecutionContext): Array<string>;
+    setExecutingScope(executionContext: PLExecutionContext, blueprint: PLBlueprint): void;
+    modifyExecutingScopeWithIncoming(node: SyntaxNodeFlow, executingContext: PLExecutionContext): Array<string>;
+    modifyExecutingScopeWithLeaving(node: SyntaxNodeFlow, executingContext: PLExecutionContext): Array<string>;
+    modifyExecutingScopeWithIncomingIteratorOf(_node: SyntaxNodeFlow, executingContext: PLExecutionContext): Array<string>;
+    modifyExecutingScopeWithLeavingIteratorOf(node: SyntaxNodeFlow, executingContext: PLExecutionContext): Array<string>;
+    setExecutingNode(executionContext: PLExecutionContext, node: SyntaxNode): void;
+}

package/build/main/language/src/interpreter/InterpreterContext.d.ts

@@ -0,0 +1,9 @@
+import { FlowAdjustment } from './flows/FlowIterator';
+export declare class PLInterpreterContext {
+    data: Object;
+    constructor(data: Object, additions?: Object | null);
+    anyValueForKey(key: string, context: Object | null): any | null;
+    recreateContextWithAdjustments(adjustments: FlowAdjustment): PLInterpreterContext;
+    modifyContextWithAdjustments(adjustments: FlowAdjustment): PLInterpreterContext;
+    isEmpty(data: Object): boolean;
+}

package/build/main/language/src/interpreter/emitters/BlueprintEmitter.d.ts

@@ -0,0 +1,5 @@
+import { PLEmittedContent } from './EmittedContent';
+export declare class PLBlueprintEmitter {
+    constructor();
+    emit(_resolvedContent: PLEmittedContent): void;
+}

package/build/main/language/src/interpreter/emitters/EmittedContent.d.ts

@@ -0,0 +1,6 @@
+export declare class PLEmittedContent {
+    filename: string;
+    content: string;
+    constructor(filename: string, content: string);
+    equals(obj: PLEmittedContent): boolean;
+}

package/build/main/language/src/interpreter/emitters/MemoryBlueprintEmitter.d.ts

@@ -0,0 +1,11 @@
+import { PLBlueprintEmitter } from './BlueprintEmitter';
+import { PLEmittedContent } from './EmittedContent';
+export declare class PLMemoryBlueprintEmitter extends PLBlueprintEmitter {
+    storage: Map<string, PLEmittedContent>;
+    isOverrideAllowed: boolean;
+    constructor(allowOverrides?: boolean);
+    emittedContentForFilename(filename: string): PLEmittedContent | null;
+    allEmittedContent(): Array<PLEmittedContent>;
+    clearEmittedFiles(): void;
+    emit(content: PLEmittedContent): void;
+}

package/build/main/language/src/interpreter/flows/Flow.d.ts

@@ -0,0 +1,37 @@
+import { PLBlueprintConfiguration } from './../../blueprints/BlueprintConfiguration';
+import { PLInterpreterContext } from './../InterpreterContext';
+import { PLExecutionContext } from '../ExecutionContext';
+import { PLFlowSource } from './FlowSource';
+import { FlowIterator, FlowIteratorBodyResult, FlowAdjustment } from './FlowIterator';
+import { PLFlowOutput } from './FlowOutput';
+export declare enum PLFlowExecutionType {
+    defaultBody = 0,
+    customBody = 1,
+    customWithoutBody = 2
+}
+export declare enum PLFlowFormatType {
+    keyword = 0,
+    source = 1,
+    output = 2
+}
+export declare enum PLFlowFormatRequirement {
+    required = 0,
+    optional = 1
+}
+export interface PLFlowFormat {
+    type: PLFlowFormatType;
+    requirement: PLFlowFormatRequirement;
+    definition: string;
+}
+export declare class PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    keyword(): string;
+    chainableFlows(): Array<string> | null;
+    canFormChainRoot(): boolean;
+    executionType(): PLFlowExecutionType;
+    constructor();
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<unknown>;
+}

package/build/main/language/src/interpreter/flows/FlowIterator.d.ts

@@ -0,0 +1,25 @@
+export interface FlowIteratorBodyResult {
+    result: string | null;
+    iterator: FlowIterator;
+    skippedBody: boolean;
+}
+export declare enum FlowIteratorType {
+    skip = 0,
+    singular = 1,
+    iterative = 2,
+    followthrough = 3
+}
+export declare type FlowAdjustment = Object;
+export declare class FlowIterator implements IterableIterator<FlowAdjustment> {
+    type: FlowIteratorType;
+    adjustments: Array<FlowAdjustment>;
+    followingContextEnhancement: FlowAdjustment | null;
+    constructor(adjustments: Array<FlowAdjustment>, type: FlowIteratorType, contextEnhancement: FlowAdjustment | null);
+    static followThroughExecution(followingContextEnhancement: FlowAdjustment | null): FlowIterator;
+    static noExecution(): FlowIterator;
+    static singleExecution(adjustment: FlowAdjustment): FlowIterator;
+    static iterativeExecution(adjustments: Array<FlowAdjustment>): FlowIterator;
+    private counter;
+    next(): IteratorResult<FlowAdjustment>;
+    [Symbol.iterator](): IterableIterator<FlowAdjustment>;
+}

package/build/main/language/src/interpreter/flows/FlowOutput.d.ts

@@ -0,0 +1,9 @@
+export declare class PLFlowOutput {
+    originalBackingProperty: string;
+    backingProperty: string;
+    containedQuotes: boolean;
+    constructor(argument: string);
+    asString(): string;
+    asNumber(): number | null;
+    asBool(): boolean | null;
+}

package/build/main/language/src/interpreter/flows/FlowSource.d.ts

@@ -0,0 +1,10 @@
+import { PLInterpreterContext } from './../InterpreterContext';
+import { PLExecutionContext } from '../ExecutionContext';
+import { SyntaxNodeSubstitution } from '../../parser/syntax/nodes/substitution/SyntaxNodeSubstitution';
+export declare class PLFlowSource {
+    backingProperty: SyntaxNodeSubstitution;
+    constructor(source: SyntaxNodeSubstitution);
+    asValue(context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any | null>;
+    asString(): string;
+    directive(): string;
+}

package/build/main/language/src/interpreter/flows/specific/code/FlowCodeMerge.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowCodeMerge extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/debug/FlowLog.d.ts

@@ -0,0 +1,18 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowLog extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+    convertToString(variable: any | null): string;
+    getCircularReplacer: () => (key: any, value: any) => any;
+}

package/build/main/language/src/interpreter/flows/specific/emit/FlowEmit.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowEmit extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(dataContext: PLInterpreterContext, body: FlowIteratorBodyResult, executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/function/FlowImport.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowImport extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, executionContext: PLExecutionContext, flowIdentifier: Array<string>, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/function/FlowReturn.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowReturn extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/if/FlowElse.d.ts

@@ -0,0 +1,19 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowElse extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    canFormChainRoot(): boolean;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    resolveAsTrue(): Promise<FlowIterator>;
+    resolveAsFalse(): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/if/FlowElseIf.d.ts

@@ -0,0 +1,20 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowElseIf extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    chainableFlows(): Array<string> | null;
+    canFormChainRoot(): boolean;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    resolveAsTrue(): Promise<FlowIterator>;
+    resolveAsFalse(): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/if/FlowIf.d.ts

@@ -0,0 +1,19 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowIf extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    chainableFlows(): Array<string> | null;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    resolveAsTrue(): Promise<FlowIterator>;
+    resolveAsFalse(): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/inject/FlowInject.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowInject extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(dataContext: PLInterpreterContext, body: FlowIteratorBodyResult, executionContext: PLExecutionContext, configuration: PLBlueprintConfiguration, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, lineOffset: number, firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/loops/FlowFor.d.ts

@@ -0,0 +1,17 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowFor extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    chainableFlows(): Array<string> | null;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(currentContext: PLInterpreterContext, executionContext: PLExecutionContext, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/loops/FlowMap.d.ts

@@ -0,0 +1,17 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowMap extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    chainableFlows(): Array<string> | null;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(currentContext: PLInterpreterContext, executionContext: PLExecutionContext, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/loops/FlowTraverse.d.ts

@@ -0,0 +1,18 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowTraverse extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    excludeRootData(): boolean;
+    createBodyIterator(currentContext: PLInterpreterContext, executionContext: PLExecutionContext, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    traverseMakeContext(context: Object, key: string, bindTo: string): Array<FlowAdjustment>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/loops/FlowTraverseChildren.d.ts

@@ -0,0 +1,6 @@
+import { PLFlowFormat } from '../../Flow';
+import { PLFlowTraverse } from './FlowTraverse';
+export declare class PLFlowTraverseChildren extends PLFlowTraverse {
+    flowFormat(): Array<PLFlowFormat>;
+    excludeRootData(): boolean;
+}

package/build/main/language/src/interpreter/flows/specific/switch/FlowCase.d.ts

@@ -0,0 +1,17 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowCase extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    chainableFlows(): Array<string> | null;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/switch/FlowDefault.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowDefault extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/switch/FlowSwitch.d.ts

@@ -0,0 +1,17 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowSwitch extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    chainableFlows(): Array<string> | null;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(currentContext: PLInterpreterContext, executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _flowIdentifier: Array<string>, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/var/FlowConst.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from '../../FlowOutput';
+import { PLInterpreterContext } from '../../../InterpreterContext';
+import { FlowIterator } from '../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from '../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from '../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from '../../FlowIterator';
+export declare class PLFlowConst extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, executionContext: PLExecutionContext, flowIdentifier: Array<string>, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/var/FlowGlobal.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowGlobal extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, executionContext: PLExecutionContext, flowIdentifier: Array<string>, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/var/FlowLet.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from '../../FlowOutput';
+import { PLInterpreterContext } from '../../../InterpreterContext';
+import { FlowIterator } from '../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from '../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from '../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from '../../FlowIterator';
+export declare class PLFlowLet extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, executionContext: PLExecutionContext, flowIdentifier: Array<string>, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}

package/build/main/language/src/interpreter/flows/specific/var/FlowSet.d.ts

@@ -0,0 +1,16 @@
+import { PLFlowOutput } from './../../FlowOutput';
+import { PLInterpreterContext } from './../../../InterpreterContext';
+import { FlowIterator } from './../../FlowIterator';
+import { PLFlow, PLFlowFormat, PLFlowExecutionType } from './../../Flow';
+import { PLExecutionContext } from '../../../ExecutionContext';
+import { PLFlowSource } from '../../FlowSource';
+import { PLBlueprintConfiguration } from './../../../../blueprints/BlueprintConfiguration';
+import { FlowIteratorBodyResult, FlowAdjustment } from './../../FlowIterator';
+export declare class PLFlowSet extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    createBodyIterator(_currentContext: PLInterpreterContext, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<FlowIterator>;
+    createFlowExecutor(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>, _lineOffset: number, _firstLineDirective: boolean): Promise<string | null>;
+    adjustInterpretingContext(_dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, _executionContext: PLExecutionContext, _outputs: Map<string, PLFlowOutput>, _sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): FlowAdjustment | null;
+    adjustExecutingContext(dataContext: PLInterpreterContext, _body: FlowIteratorBodyResult, executionContext: PLExecutionContext, flowIdentifier: Array<string>, outputs: Map<string, PLFlowOutput>, sources: Map<string, PLFlowSource>, _keywords: Map<string, boolean>): Promise<void>;
+}