@supernova-studio/pulsar-core 1.0.41 → 1.0.43

package/build/typings/language/src/extensions/dsm/functions/tokens/DSMFunctionAllShadowTokens.d.ts

@@ -0,0 +1,9 @@
+import { DSMExecutionContext } from "../../DSMExecutionContext";
+import { PLInterpreterContext } from "../../../../interpreter/InterpreterContext";
+import { PLFunctionArgument } from "../../../../interpreter/functions/FunctionArgument";
+import { PLFunction } from "../../../../interpreter/functions/Function";
+export declare class DSMFunctionAllShadowTokens extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    provideValueUsingArguments(_args: Array<PLFunctionArgument>, _context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/extensions/dsm/functions/tokens/DSMFunctionAllTokens.d.ts

@@ -0,0 +1,9 @@
+import { DSMExecutionContext } from "../../DSMExecutionContext";
+import { PLInterpreterContext } from "../../../../interpreter/InterpreterContext";
+import { PLFunctionArgument } from "../../../../interpreter/functions/FunctionArgument";
+import { PLFunction } from "../../../../interpreter/functions/Function";
+export declare class DSMFunctionAllTokens extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    provideValueUsingArguments(_args: Array<PLFunctionArgument>, _context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/extensions/dsm/functions/tokens/DSMFunctionAllTypographyTokens.d.ts

@@ -0,0 +1,9 @@
+import { DSMExecutionContext } from "../../DSMExecutionContext";
+import { PLInterpreterContext } from "../../../../interpreter/InterpreterContext";
+import { PLFunctionArgument } from "../../../../interpreter/functions/FunctionArgument";
+import { PLFunction } from "../../../../interpreter/functions/Function";
+export declare class DSMFunctionAllTypographyTokens extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    provideValueUsingArguments(_args: Array<PLFunctionArgument>, _context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/extensions/dsm/functions/tokens/DSMFunctionTokenById.d.ts

@@ -0,0 +1,9 @@
+import { DSMExecutionContext } from "../../DSMExecutionContext";
+import { PLInterpreterContext } from "../../../../interpreter/InterpreterContext";
+import { PLFunctionArgument } from "../../../../interpreter/functions/FunctionArgument";
+import { PLFunction } from "../../../../interpreter/functions/Function";
+export declare class DSMFunctionTokenById extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    provideValueUsingArguments(args: Array<PLFunctionArgument>, context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/extensions/dsm/resolver/DSMFunctionResolveTheme.d.ts

@@ -0,0 +1,9 @@
+import { DSMExecutionContext } from "../DSMExecutionContext";
+import { PLInterpreterContext } from "../../../interpreter/InterpreterContext";
+import { PLFunctionArgument } from "../../../interpreter/functions/FunctionArgument";
+import { PLFunction } from "../../../interpreter/functions/Function";
+export declare class DSMFunctionResolveTheme extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    provideValueUsingArguments(args: Array<PLFunctionArgument>, context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/extensions/dsm/resolver/DSMFunctionResolveTokens.d.ts

@@ -0,0 +1,9 @@
+import { DSMExecutionContext } from "../DSMExecutionContext";
+import { PLInterpreterContext } from "../../../interpreter/InterpreterContext";
+import { PLFunctionArgument } from "../../../interpreter/functions/FunctionArgument";
+import { PLFunction } from "../../../interpreter/functions/Function";
+export declare class DSMFunctionResolveTokens extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    provideValueUsingArguments(args: Array<PLFunctionArgument>, context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/extensions/dsm/resolver/DSMResolver.d.ts

@@ -0,0 +1,14 @@
+import { RawBorderValue, RawGradientValue, RawRadiusValue, RawShadowValue, ResolvedBorderValue, ResolvedGradientValue, ResolvedRadiusValue, ResolvedShadowValue, ResolvedTypographyValue, ResolvedToken, Theme, Token, TokenType, RawTypographyValue } from "./types";
+export declare function resolveToken(token: Token, tokens: Token[]): ResolvedToken;
+export declare function resolveGradientValue(value: RawGradientValue, tokens: Token[]): ResolvedGradientValue;
+export declare function resolveBorderValue(value: RawBorderValue, tokens: Token[]): ResolvedBorderValue;
+export declare function resolveRadiusValue(value: RawRadiusValue, tokens: Token[]): ResolvedRadiusValue;
+export declare function resolveShadowValue(value: RawShadowValue, tokens: Token[]): ResolvedShadowValue;
+export declare function resolveTypographyValue(value: RawTypographyValue, tokens: Token[]): ResolvedTypographyValue;
+export declare function resolveTokenValue(type: TokenType, value: any, tokens: Token[]): any;
+export declare function shouldBeUnreachable(param: never): void;
+export declare function resolveTokens(tokens: Token[]): ResolvedToken[];
+export declare function resolveTheme(theme: Theme, tokens: ResolvedToken[]): {
+    overridenTokens: ResolvedToken[];
+    allTokens: ResolvedToken[];
+};

package/build/typings/language/src/extensions/dsm/resolver/types.d.ts

@@ -0,0 +1,121 @@
+export declare enum TokenType {
+    Color = "Color",
+    Border = "Border",
+    Font = "Font",
+    Gradient = "Gradient",
+    Shadow = "Shadow",
+    Radius = "Radius",
+    Measure = "Measure",
+    Image = "Image",
+    Text = "Text",
+    Opacity = "Opacity",
+    Typography = "Typography"
+}
+export declare enum TextCase {
+    Original = "Original",
+    Upper = "Upper",
+    Lower = "Lower",
+    Camel = "Camel"
+}
+export declare enum TextDecoration {
+    None = "None",
+    Underline = "Underline",
+    Strikethrough = "Strikethrough"
+}
+export declare type ColorValue = string;
+export declare type MeasureValue = {
+    unit: string;
+    measure: number;
+};
+export declare type FontValue = {
+    family: string;
+    subfamily: string;
+};
+export declare type Token<V = any> = {
+    meta?: ItemMeta;
+    id?: string;
+    persistentId?: string;
+    type?: TokenType;
+    data: TokenData<V>;
+};
+export declare type ResolvedToken<V = any> = {
+    type: TokenType;
+    meta?: ItemMeta;
+    value: V;
+    aliasTo?: Token;
+    source: Token;
+};
+export declare type ThemeOverride = {
+    tokenPersistentId: string;
+    type: TokenType;
+    data: TokenData;
+};
+export declare type Theme = {
+    id: string;
+    persistentId: string;
+    meta: ItemMeta;
+    overrides: ThemeOverride[];
+};
+declare type TokenData<V = any> = {
+    aliasTo?: string;
+    value?: V;
+};
+declare type ItemMeta = {
+    meta?: {
+        name: string;
+        description: string;
+    };
+};
+export declare type GradientStop<COLOR> = {
+    position: number;
+    color: COLOR;
+};
+export declare type GradientValue<COLOR> = {
+    type: string;
+    from: any;
+    to: any;
+    stops: GradientStop<COLOR>[];
+};
+export declare type BorderValue<COLOR, MEASURE> = {
+    isEnabled: boolean;
+    position: string;
+    color: COLOR;
+    width: MEASURE;
+};
+export declare type RadiusValue<MEASURE> = {
+    radius?: MEASURE;
+    topLeft?: MEASURE;
+    topRight?: MEASURE;
+    bottomRight?: MEASURE;
+    bottomLeft?: MEASURE;
+};
+export declare type ShadowValue<COLOR, MEASURE> = {
+    isEnabled: boolean;
+    color: COLOR;
+    x: MEASURE;
+    y: MEASURE;
+    radius: MEASURE;
+    spread: MEASURE;
+    opacity: number;
+};
+export declare type TypographyValue<FONT, MEASURE> = {
+    font: FONT;
+    fontSize: MEASURE;
+    textCase: TextCase;
+    textDecoration: TextDecoration;
+    letterSpacing: MEASURE;
+    lineHeight: MEASURE;
+    paragraphIndent: MEASURE;
+    paragraphSpacing: MEASURE;
+};
+export declare type RawGradientValue = GradientValue<TokenData>;
+export declare type RawBorderValue = BorderValue<TokenData, TokenData>;
+export declare type RawRadiusValue = RadiusValue<TokenData>;
+export declare type RawShadowValue = ShadowValue<TokenData, TokenData>;
+export declare type RawTypographyValue = TypographyValue<TokenData, TokenData>;
+export declare type ResolvedGradientValue = GradientValue<ResolvedToken<ColorValue>>;
+export declare type ResolvedBorderValue = BorderValue<ResolvedToken<ColorValue>, ResolvedToken<MeasureValue>>;
+export declare type ResolvedShadowValue = ShadowValue<ResolvedToken<ColorValue>, ResolvedToken<MeasureValue>>;
+export declare type ResolvedRadiusValue = RadiusValue<ResolvedToken<MeasureValue>>;
+export declare type ResolvedTypographyValue = TypographyValue<ResolvedToken<FontValue>, ResolvedToken<MeasureValue>>;
+export {};

package/build/typings/language/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./exports";

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

@@ -0,0 +1,46 @@
+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";
+export declare class PLExecutionContext {
+    functions: Map<string, PLFunction>;
+    transformers: Map<string, PLTransformer>;
+    flows: Map<string, PLFlow>;
+    blueprintLoader: PLBlueprintLoader;
+    blueprintEmitter: PLBlueprintEmitter;
+    variableContext: PLVariableContext;
+    logger: PLLogger;
+    debugger: PLDebugger;
+    executedScope: Array<string>;
+    executedBlueprint: string;
+    defaultTransformers: Array<PLTransformer>;
+    defaultFlows: Array<PLFlow>;
+    defaultFunctions: Array<PLFunction>;
+    constructor(load?: PLBlueprintLoader, emit?: PLBlueprintEmitter, log?: PLLogger, debug?: PLDebugger);
+    provideCustomFunctions(): Array<PLFunction>;
+    provideCustomTransformers(): Array<PLTransformer>;
+    provideCustomFlows(): Array<PLFlow>;
+    registerDefaultFunctions(): void;
+    registerDefaultTransformers(): void;
+    registerDefaultFlows(): 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;
+    getFunctionReturnStack(): Map<string, any>[];
+}

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

@@ -0,0 +1,30 @@
+import { PLInterpreterContext } from "./InterpreterContext";
+import { PLBlueprintConfiguration } from "../blueprints/BlueprintConfiguration";
+import { PLBlueprint } from "../blueprints/Blueprint";
+import { PLExecutionContext } from "./ExecutionContext";
+import { SyntaxNodeText } from "../parser/syntax/nodes/SyntaxNodeText";
+import { SyntaxNodeSubstitution } from "../parser/syntax/nodes/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): Promise<string>;
+    interpretGroupNode(groupNode: SyntaxNodeGroup, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<string>;
+    interpretTextNode(node: SyntaxNodeText, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<string>;
+    interpretSubstitutionNode(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>;
+}

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

@@ -0,0 +1,11 @@
+import { FlowAdjustment } from "./flows/FlowIterator";
+export declare class PLInterpreterContext {
+    data: Map<string, any>;
+    constructor(data: Map<string, any>, additions?: Map<string, any> | null);
+    stringValueForKey(key: string, context: Map<string, any> | null): string | null;
+    stringValueForKeyComponents(components: Array<string>, context: Map<string, any> | null): string | null;
+    anyValueForKey(key: string, context: Map<string, any> | null): any | null;
+    anyValueForKeyComponents(components: Array<string>, context: Map<string, any> | null): any | null;
+    recreateContextWithAdjustments(adjustments: FlowAdjustment): PLInterpreterContext;
+    modifyContextWithAdjustments(adjustments: FlowAdjustment): PLInterpreterContext;
+}

package/build/typings/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/typings/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/typings/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/typings/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/typings/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 = Map<string, any>;
+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/typings/language/src/interpreter/flows/FlowOutput.d.ts

@@ -0,0 +1,12 @@
+import { PLExecutionContext } from "../ExecutionContext";
+import { PLFlowSource } from "./FlowSource";
+export declare class PLFlowOutput {
+    originalBackingProperty: string;
+    backingProperty: string;
+    containedQuotes: boolean;
+    constructor(argument: string);
+    asString(): string;
+    asNumber(): number | null;
+    asBool(): boolean | null;
+    asSource(executionContext: PLExecutionContext): PLFlowSource;
+}

package/build/typings/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/SyntaxNodeSubstitution";
+export declare class PLFlowSource {
+    backingProperty: SyntaxNodeSubstitution;
+    constructor(source: SyntaxNodeSubstitution);
+    asValue(context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any | null>;
+    asString(): string;
+    directive(): string;
+}

package/build/typings/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/typings/language/src/interpreter/flows/specific/debug/FlowLog.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 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;
+}

package/build/typings/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/typings/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/typings/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/typings/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/typings/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/typings/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/typings/language/src/interpreter/flows/specific/inject/FlowInject.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";
+import { PLBlueprint } from "../../../../blueprints/Blueprint";
+export declare class PLFlowInject extends PLFlow {
+    flowFormat(): Array<PLFlowFormat>;
+    executionType(): PLFlowExecutionType;
+    cachedBlueprints: Map<string, PLBlueprint>;
+    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/typings/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>;
+}