@supernova-studio/pulsar-core 1.0.41 → 1.0.43

package/build/typings/language/src/interpreter/transformers/Transformer.d.ts

@@ -0,0 +1,30 @@
+import { PLInterpreterContext } from "../InterpreterContext";
+import { PLDocumentable } from "../../tools/documentation/Documentable";
+import { PLDoc } from "../../tools/documentation/Doc";
+import { PLExecutionContext } from "../ExecutionContext";
+import { PLTransformerArgument } from "./TransformerArgument";
+export declare class PLTransformer implements PLDocumentable {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc | null;
+    isPrivate(): boolean;
+    constructor();
+    transformValueUsingArgumentString(value: any, argumentString: string, context: PLInterpreterContext, executionContext: PLExecutionContext, isRoot: boolean): Promise<any | null>;
+    transformValueUsingArguments(value: any, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext, isRoot: boolean): Promise<any | null>;
+    transformStringValue(_value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+    transformBooleanValue(_value: boolean, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+    transformNumericValue(_value: number, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+    transformMapValue(_value: Map<any, any>, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext, _isRoot: boolean): Promise<any | null>;
+    transformArrayValue(_value: Array<any>, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+    transformNullValue(_args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+    expectString(position: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<string>;
+    expectInt(position: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectDouble(position: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectBool(position: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<boolean>;
+    expectAnyNonNull(position: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<any>;
+    expectAny(position: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<any>;
+    expectArray(position: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<Array<any>>;
+    expectDictionary(position: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, ec: PLExecutionContext): Promise<Map<any, any>>;
+    expectArgument(position: number, args: Array<PLTransformerArgument>): PLTransformerArgument;
+    equals(obj: PLTransformer): boolean;
+}

package/build/typings/language/src/interpreter/transformers/TransformerArgument.d.ts

@@ -0,0 +1,16 @@
+import { PLInterpreterContext } from "../InterpreterContext";
+import { PLExecutionContext } from "../ExecutionContext";
+export declare class PLTransformerArgument {
+    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/transformers/specific/array/TransformerAppend.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerAppend extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerAt.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerAt extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerConcat.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerConcat extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerEnumerated.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerEnumerated extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<Map<any, any>>;
+}

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerFirst.d.ts

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

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerFrom.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerFrom extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerJoin.d.ts

@@ -0,0 +1,11 @@
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+import { PLTransformer } from "../../Transformer";
+import { PLTransformerArgument } from "../../TransformerArgument";
+export declare class PLTransformerJoin extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerRandom.d.ts

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

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerRange.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerRange extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerReversed.d.ts

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

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerShuffled.d.ts

@@ -0,0 +1,12 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerShuffled extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+    shuffle(array: Array<any>): any[];
+}

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerSorted.d.ts

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

package/build/typings/language/src/interpreter/transformers/specific/array/TransformerUntil.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerUntil extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformArrayValue(value: Array<any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/map/TransformerAdd.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerAdd extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformMapValue(value: Map<any, any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/map/TransformerAlwaysRootValue.d.ts

@@ -0,0 +1,11 @@
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+import { PLTransformerValue } from "./TransformerValue";
+export declare class PLTransformerAlwaysRootValue extends PLTransformerValue {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformMapValue(value: Map<any, any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any | null>;
+}

package/build/typings/language/src/interpreter/transformers/specific/map/TransformerKeys.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerKeys extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformMapValue(value: Map<any, any>, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/map/TransformerValue.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerValue extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformMapValue(value: Map<any, any>, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext, isRoot: boolean): Promise<any | null>;
+}

package/build/typings/language/src/interpreter/transformers/specific/map/TransformerValues.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerValues extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformMapValue(value: Map<any, any>, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerAbsolute.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerAbsolute extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerAddedBy.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerAddedBy extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerCeiled.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerCeiled extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerDividedBy.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerDividedBy extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerFloored.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerFloored extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerMultipliedBy.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerMultipledBy extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerNegative.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerNegative extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerPositive.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerPositive extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerRounded.d.ts

@@ -0,0 +1,12 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerRounded extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+    rounded(value: any, toPlaces: number): number;
+}

package/build/typings/language/src/interpreter/transformers/specific/numeric/TransformerSubtractedBy.d.ts

@@ -0,0 +1,11 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerSubtractedBy extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformNumericValue(value: number, args: Array<PLTransformerArgument>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any>;
+}

package/build/typings/language/src/interpreter/transformers/specific/shared/TransformerCount.d.ts

@@ -0,0 +1,13 @@
+import { PLTransformer } from "../../Transformer";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+import { PLTransformerArgument } from "../../TransformerArgument";
+import { PLExecutionContext } from "../../../ExecutionContext";
+import { PLInterpreterContext } from "../../../InterpreterContext";
+export declare class PLTransformerCount extends PLTransformer {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    transformStringValue(value: string, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+    transformMapValue(value: Map<any, any>, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+    transformArrayValue(value: Array<any>, _args: Array<PLTransformerArgument>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any>;
+}

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

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

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

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

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

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

package/build/typings/language/src/interpreter/transformers/specific/shared/TransformerIsDictionary.d.ts

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

package/build/typings/language/src/interpreter/transformers/specific/shared/TransformerIsNull.d.ts

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

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

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

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

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

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

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

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

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

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

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