@supernova-studio/pulsar-core 2.0.14 → 2.0.15

package/build/main/language/src/interpreter/functions/Function.d.ts

@@ -0,0 +1,31 @@
+import { PLDocumentable } from './../../tools/documentation/Documentable';
+import { PLDoc } from '../../tools/documentation/Doc';
+import { PLExecutionContext } from '../ExecutionContext';
+import { PLInterpreterContext } from './../InterpreterContext';
+export declare enum PLFunctionType {
+    topLevel = 0,
+    ds = 1,
+    js = 2
+}
+export declare class PLFunction implements PLDocumentable {
+    numberOfArguments(): number;
+    isVariadic(): boolean;
+    keyword(): string;
+    documentation(): PLDoc | null;
+    isPrivate(): boolean;
+    type(): PLFunctionType;
+    isAsync(): boolean;
+    constructor();
+    provideValueUsingArgumentsSync(_args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any | null;
+    provideValueUsingArguments(_args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any | null>;
+    enrichArgumentError(position: number, error: Error, executionContext: PLExecutionContext): Error;
+    expectString(position: number, args: Array<any>, _context: PLInterpreterContext, ec: PLExecutionContext): Promise<string>;
+    expectNumber(position: number, args: Array<any>, _context: PLInterpreterContext, ec: PLExecutionContext): Promise<number>;
+    expectBool(position: number, args: Array<any>, _context: PLInterpreterContext, ec: PLExecutionContext): Promise<boolean>;
+    expectArray(position: number, args: Array<any>, _context: PLInterpreterContext, ec: PLExecutionContext): Promise<Array<any>>;
+    expectObject(position: number, args: Array<any>, _context: PLInterpreterContext, ec: PLExecutionContext): Promise<Map<any, any> | Object>;
+    expectAnyNonNull(position: number, args: Array<any>, _context: PLInterpreterContext, ec: PLExecutionContext): Promise<any>;
+    expectAny(position: number, args: Array<any>, _context: PLInterpreterContext, ec: PLExecutionContext): Promise<any>;
+    expectArgument(position: number, args: Array<any>): any;
+    equals(obj: PLFunction): boolean;
+}

package/build/main/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';
+export declare class PLFunctionCall extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    isAsync(): boolean;
+    provideValueUsingArguments(args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): Promise<any | null>;
+}

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

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

package/build/main/language/src/interpreter/functions/specific/random/FunctionRandomInt.d.ts

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

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

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

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

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

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

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

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

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

package/build/main/language/src/interpreter/javascript/JSContext.d.ts

@@ -0,0 +1,18 @@
+import { PLExecutionContext } from '../ExecutionContext';
+import { JSFunction } from './JSFunction';
+import { JSTransformer } from './JSTransformer';
+export declare class JSContext {
+    private executionContext;
+    private bridge;
+    constructor(executionContext: PLExecutionContext, configuration: Object);
+    /** Evaluate javascript string with Pulsar core enhancements. Javascript context is contained, sandboxed environment and only allows access to few specific objects on global scope */
+    registerHelper(helperString: string): void;
+    /** Register core engine function that enhnances the core cpabilities of the language */
+    registerFunction(func: JSFunction): void;
+    /** Register core engine transformer that enhances the core capabilities of the language */
+    registerTransformer(transformer: JSTransformer): void;
+    /** Register core engine payload that will be added to every execution of every blueprint when it runs. Registered payload is global, immutable property and is protected against override */
+    registerPayload(name: string, payload: any): void;
+    blueprintData(): object | null;
+    systemData(): object | null;
+}

package/build/main/language/src/interpreter/javascript/JSContextBridge.d.ts

@@ -0,0 +1,16 @@
+import { JSContext } from './JSContext';
+export declare class JSContextBridge {
+    /** Connector back to the executor */
+    jsContext: JSContext;
+    /** User provided configuration */
+    exportConfiguration: Object;
+    constructor(jsContext: JSContext, configurationData: Object);
+    registerFunction(name: string, callback: () => any): void;
+    registerAsyncFunction(name: string, callback: () => any): void;
+    registerTransformer(name: string, callback: () => any): void;
+    registerTypedTransformer(name: string, type: string, callback: () => any): void;
+    private registerConfiguredTransformer;
+    registerPayload(name: string, payload: any): void;
+    blueprintData(): object | null;
+    systemData(): object | null;
+}

package/build/main/language/src/interpreter/javascript/JSFunction.d.ts

@@ -0,0 +1,20 @@
+import { PLDoc } from '../../tools/documentation/Doc';
+import { PLExecutionContext } from '../ExecutionContext';
+import { PLFunction, PLFunctionType } from '../functions/Function';
+import { PLInterpreterContext } from '../InterpreterContext';
+export declare class JSFunction extends PLFunction {
+    numberOfArguments(): number;
+    isVariadic(): boolean;
+    keyword(): string;
+    documentation(): PLDoc | null;
+    isPrivate(): boolean;
+    type(): PLFunctionType;
+    isAsync(): boolean;
+    private name;
+    private async;
+    private dynamicArgumentCount;
+    private executor;
+    constructor(name: string, numberOfArguments: number, async: boolean, dynamicExecutor: () => any);
+    provideValueUsingArguments(args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): Promise<any | null>;
+    provideValueUsingArgumentsSync(args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any | null;
+}

package/build/main/language/src/interpreter/javascript/JSTransformer.d.ts

@@ -0,0 +1,30 @@
+import { PLDoc } from '../../tools/documentation/Doc';
+import { PLExecutionContext } from '../ExecutionContext';
+import { PLInterpreterContext } from '../InterpreterContext';
+import { PLTransformer } from '../transformers/Transformer';
+export declare enum JSTransformerEnforcedType {
+    unrestriced = "unrestricted",
+    forcedNumber = "number",
+    forcedString = "string",
+    forcedBoolean = "boolean",
+    forcedArray = "array",
+    forcedObject = "object"
+}
+export declare class JSTransformer extends PLTransformer {
+    numberOfArguments(): number;
+    isVariadic(): boolean;
+    keyword(): string;
+    documentation(): PLDoc | null;
+    isPrivate(): boolean;
+    private name;
+    private dynamicArgumentCount;
+    private executor;
+    private enforcedType;
+    constructor(name: string, numberOfArguments: number, dynamicExecutor: () => any, enforcedType: JSTransformerEnforcedType);
+    transformStringValue(value: string, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformBooleanValue(value: boolean, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformNumericValue(value: number, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformMapValue(value: Map<any, any>, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext, isRoot: boolean): any | null;
+    transformArrayValue(value: Array<any>, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformDynamicValue(value: any, args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

package/build/main/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/main/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/main/language/src/interpreter/loggers/Logger.d.ts

@@ -0,0 +1,47 @@
+import { PLBlueprint, PLExecutionContext } from '../../exports';
+import { Symbol } from '../../parser/symbols/Symbol';
+import { SyntaxNode } from '../../parser/syntax/nodes/SyntaxNode';
+import { PLVariable } from '../variables/Variable';
+import { PLLoggerDefaultMessage } from './LoggerDefaultMessages';
+export declare enum PLLogType {
+    success = "success",
+    info = "info",
+    warning = "warning",
+    error = "error",
+    user = "user"
+}
+export interface PLLog {
+    stackTrace: PLTrace;
+    time: Date;
+    type: PLLogType;
+    message: string;
+}
+export declare type PLTrace = {
+    executedNode: SyntaxNode | undefined;
+    variables: Array<PLVariable> | undefined;
+    executedBlueprint: PLBlueprint | undefined;
+    additionalInfo: string | undefined;
+    symbol: Symbol | undefined;
+};
+export declare class PLLogger {
+    logs: Array<PLLog>;
+    timings: Map<string, number>;
+    constructor();
+    emptyLogs(): void;
+    store(log: PLLog): PLLog;
+    formatIntoHuman(log: PLLog, paths: Map<string, string> | undefined): string;
+    formatMessage(log: PLLog, paths: Map<string, string> | undefined): string;
+    deduplicatedLogs(): Array<PLLog>;
+    formatStacktraceIntoHuman(log: PLLog, paths: Map<string, string>): Array<string> | undefined;
+    formattedDate(date: Date): string;
+    logSuccess(message: string, stackTrace: PLTrace): PLLog;
+    logInfo(message: string, stackTrace: PLTrace): PLLog;
+    logWarning(message: string, stackTrace: PLTrace): PLLog;
+    logError(message: string, stackTrace: PLTrace): PLLog;
+    logUser(message: string, stackTrace: PLTrace): PLLog;
+    logType(type: PLLogType, message: string, stackTrace: PLTrace): PLLog;
+    logSystem(systemMessage: PLLoggerDefaultMessage, stackTrace: PLTrace): PLLog;
+    addDuration(key: string, duration: number): void;
+    static makeTrace(ec: PLExecutionContext, blueprint: PLBlueprint, additionalInfo?: string | undefined, symbol?: Symbol | undefined): PLTrace;
+    static makeEmptyTrace(): PLTrace;
+}

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

@@ -0,0 +1,14 @@
+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;
+    static interpreterInjectedRenderingFailure: PLLoggerDefaultMessage;
+}

package/build/main/language/src/interpreter/transformers/Transformer.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';
+export declare class PLTransformer implements PLDocumentable {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc | null;
+    isPrivate(): boolean;
+    constructor();
+    transformValue(value: any, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformValueUsingArguments(value: any, args: Array<any>, context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformStringValue(_value: string, _args: Array<any>, _context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformBooleanValue(_value: boolean, _args: Array<any>, _context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformNumericValue(_value: number, _args: Array<any>, _context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformMapValue(_value: Map<any, any>, _args: Array<any>, _context: PLInterpreterContext, executionContext: PLExecutionContext, _isRoot: boolean): any;
+    transformArrayValue(_value: Array<any>, _args: Array<any>, _context: PLInterpreterContext, executionContext: PLExecutionContext): any;
+    transformNullValue(_args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    expectString(position: number, args: Array<any>): string;
+    expectNumber(position: number, args: Array<any>): number;
+    expectBool(position: number, args: Array<any>): boolean;
+    expectAnyNonNull(position: number, args: Array<any>): any;
+    expectAny(position: number, args: Array<any>): any;
+    expectArray(position: number, args: Array<any>): Array<any>;
+    expectObject(position: number, args: Array<any>): Map<any, any>;
+    expectArgument(position: number, args: Array<any>): any;
+    equals(obj: PLTransformer): boolean;
+}

package/build/main/language/src/interpreter/transformers/specific/array/TransformerAppend.d.ts

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

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

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

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

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

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

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

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

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

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

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

package/build/main/language/src/interpreter/transformers/specific/array/TransformerLast.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { PLTransformer } from '../../Transformer';
+import { PLDoc } from '../../../../tools/documentation/Doc';
+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<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformMapValue(value: Map<any, any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+    transformArrayValue(value: Array<any>, _args: Array<any>, _context: PLInterpreterContext, _executionContext: PLExecutionContext): any;
+}

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

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