@supernova-studio/pulsar-core 1.0.41 → 1.0.43

package/build/typings/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/typings/language/src/interpreter/flows/specific/loops/FlowTraverse.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 PLFlowTraverse 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>;
+    traverseMakeContext(context: Map<any, any>, 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/typings/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/typings/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/typings/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/typings/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/typings/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/typings/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>;
+}

package/build/typings/language/src/interpreter/flows/specific/var/FlowVar.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 PLFlowVar 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/functions/Function.d.ts

@@ -0,0 +1,28 @@
+import { PLDocumentable } from "../../tools/documentation/Documentable";
+import { PLDoc } from "../../tools/documentation/Doc";
+import { PLExecutionContext } from "../ExecutionContext";
+import { PLInterpreterContext } from "../InterpreterContext";
+import { PLFunctionArgument } from "./FunctionArgument";
+export declare class PLFunction implements PLDocumentable {
+    numberOfArguments(): number;
+    isVariadic(): boolean;
+    keyword(): string;
+    documentation(): PLDoc | null;
+    isPrivate(): boolean;
+    constructor();
+    provideValueUsingArgumentString(argumentString: string, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any | null>;
+    provideValueUsingArguments(_args: Array<PLFunctionArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any | null>;
+    parseArgumentsFromArgumentString(argumentString: string): Array<PLFunctionArgument>;
+    enrichArgumentError(position: number, error: Error): Error;
+    expectString(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<string>;
+    expectInt(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectDouble(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectNumeric(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectBool(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<boolean>;
+    expectArray(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<Array<any>>;
+    expectDictionary(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<Map<any, any>>;
+    expectAnyNonNull(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<any>;
+    expectAny(position: number, args: Array<PLFunctionArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<any>;
+    expectArgument(position: number, args: Array<PLFunctionArgument>): PLFunctionArgument;
+    equals(obj: PLFunction): boolean;
+}

package/build/typings/language/src/interpreter/functions/FunctionArgument.d.ts

@@ -0,0 +1,16 @@
+import { PLInterpreterContext } from "../InterpreterContext";
+import { PLExecutionContext } from "../ExecutionContext";
+export declare class PLFunctionArgument {
+    backingProperty: string;
+    constructor(argument: string, keyword: string, position: number);
+    expectString(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<string>;
+    expectInt(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectDouble(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectNumeric(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectBool(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<boolean>;
+    expectArray(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<Array<any>>;
+    expectDictionary(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<Map<any, any>>;
+    expectAnyNonNull(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<any>;
+    expectAny(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<any>;
+    resolveAsSource(interpreterContext: PLInterpreterContext, ec: PLExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/interpreter/functions/specific/blueprints/FunctionCall.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/boolean/FunctionAnd.d.ts

@@ -0,0 +1,10 @@
+import { PLInterpreterContext } from "../../../InterpreterContext";
+import { PLFunctionArgument } from "../../FunctionArgument";
+import { PLFunction } from "../../Function";
+import { PLExecutionContext } from "../../../ExecutionContext";
+export declare class PLFunctionAnd extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    isVariadic(): boolean;
+    provideValueUsingArguments(args: Array<PLFunctionArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/interpreter/functions/specific/boolean/FunctionNot.d.ts

@@ -0,0 +1,10 @@
+import { PLInterpreterContext } from "../../../InterpreterContext";
+import { PLFunctionArgument } from "../../FunctionArgument";
+import { PLFunction } from "../../Function";
+import { PLExecutionContext } from "../../../ExecutionContext";
+export declare class PLFunctionNot extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    isVariadic(): boolean;
+    provideValueUsingArguments(args: Array<PLFunctionArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/interpreter/functions/specific/boolean/FunctionOr.d.ts

@@ -0,0 +1,10 @@
+import { PLInterpreterContext } from "../../../InterpreterContext";
+import { PLFunctionArgument } from "../../FunctionArgument";
+import { PLFunction } from "../../Function";
+import { PLExecutionContext } from "../../../ExecutionContext";
+export declare class PLFunctionOr extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    isVariadic(): boolean;
+    provideValueUsingArguments(args: Array<PLFunctionArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/interpreter/functions/specific/boolean/FunctionTernary.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/compare/FunctionEquals.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/compare/FunctionEqualsEmpty.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/compare/FunctionEqualsNonNull.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/compare/FunctionEqualsNull.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/compare/FunctionGreaterThan.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/compare/FunctionGreaterThanEquals.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/compare/FunctionLessThan.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/compare/FunctionLessThanEquals.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/init/FunctionNewArray.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/init/FunctionNewDate.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/init/FunctionNewDictionary.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/init/FunctionNewNull.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/init/FunctionNewNumber.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/init/FunctionNewString.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/network/FunctionNetworkGetAnonymous.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/random/FunctionRandomNumber.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/random/FunctionRandomNumericArray.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/random/FunctionRandomString.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/random/FunctionRandomStringArray.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/support/FunctionArraysToZippedMap.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/support/FunctionVarDefined.d.ts

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

package/build/typings/language/src/interpreter/functions/specific/support/FunctionVarMutable.d.ts

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

package/build/typings/language/src/interpreter/loaders/BlueprintLoader.d.ts

@@ -0,0 +1,12 @@
+import { PLBlueprint } from "../../blueprints/Blueprint";
+import { PLExecutionContext } from "../ExecutionContext";
+import { PLBlueprintConfiguration } from "../../blueprints/BlueprintConfiguration";
+export declare class PLBlueprintLoader {
+    cachedBlueprints: Map<string, PLBlueprint>;
+    constructor();
+    cache(blueprint: PLBlueprint, id?: string | null): void;
+    cachedBlueprint(id: string): PLBlueprint | null;
+    removeCachedBlueprint(id: string): boolean;
+    removeCachedBlueprints(): void;
+    loadBlueprint(_blueprintId: string, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration): PLBlueprint;
+}

package/build/typings/language/src/interpreter/loaders/MemoryBlueprintLoader.d.ts

@@ -0,0 +1,10 @@
+import { PLBlueprintConfiguration } from "../../blueprints/BlueprintConfiguration";
+import { PLBlueprintLoader } from "./BlueprintLoader";
+import { PLExecutionContext } from "../ExecutionContext";
+import { PLBlueprint } from "../../blueprints/Blueprint";
+export declare class PLMemoryBlueprintLoader extends PLBlueprintLoader {
+    constructor(blueprints: Map<string, PLBlueprint>);
+    load(blueprint: PLBlueprint, key: string): void;
+    loadFromDefinition(definition: string, key: string, executionContext?: PLExecutionContext | null, configuration?: PLBlueprintConfiguration | null): void;
+    loadBlueprint(blueprintId: string, _executionContext: PLExecutionContext, _configuration: PLBlueprintConfiguration): PLBlueprint;
+}

package/build/typings/language/src/interpreter/loggers/Logger.d.ts

@@ -0,0 +1,27 @@
+import { PLLoggerDefaultMessage } from "./LoggerDefaultMessages";
+export declare enum PLLogType {
+    success = "success",
+    info = "info",
+    warning = "warning",
+    error = "error",
+    user = "user"
+}
+export interface PLLog {
+    id: string;
+    time: Date;
+    type: PLLogType;
+    message: string;
+}
+export declare class PLLogger {
+    logs: Array<PLLog>;
+    constructor();
+    emptyLogs(): void;
+    store(log: PLLog): PLLog;
+    logSuccess(message: string, id: string): PLLog;
+    logInfo(message: string, id: string): PLLog;
+    logWarning(message: string, id: string): PLLog;
+    logError(message: string, id: string): PLLog;
+    logUser(message: string, id: string): PLLog;
+    logType(type: PLLogType, message: string, id: string): PLLog;
+    logSystem(systemMessage: PLLoggerDefaultMessage, id: string): PLLog;
+}

package/build/typings/language/src/interpreter/loggers/LoggerDefaultMessages.d.ts

@@ -0,0 +1,13 @@
+import { PLLogType } from "./Logger";
+export interface PLLoggerDefaultMessage {
+    message: string;
+    type: PLLogType;
+}
+export declare class PLLoggerDefaultMessages {
+    static compilerStart: PLLoggerDefaultMessage;
+    static compilerBuildSuccessful: PLLoggerDefaultMessage;
+    static compilerBuildFailure: PLLoggerDefaultMessage;
+    static interpreterStart: PLLoggerDefaultMessage;
+    static interpreterRenderingSuccessful: PLLoggerDefaultMessage;
+    static interpreterRenderingFailure: PLLoggerDefaultMessage;
+}