@supernova-studio/pulsar-core 1.0.41 → 1.0.43

package/build/typings/core/src/pulsar/managers/loaders/remote/PulsarExporterGitHubLoader.d.ts

@@ -0,0 +1,12 @@
+import { PCPulsarBaseLoader } from "../PulsarBaseLoader";
+import { PCExporter } from "../../../../model/exporters/Exporter";
+import JSZip from 'jszip';
+import { PCPulsarFile, PCPulsarFileMap } from "../../generators/PulsarFileGenerator";
+export declare class PCPulsarExporterGitHubLoader extends PCPulsarBaseLoader {
+    repositoryURL: string;
+    constructor(githubURL: string);
+    initialize(): Promise<PCExporter>;
+    downloadZIPFromURL(url: string): Promise<JSZip>;
+    processZIP(zip: JSZip): Promise<PCPulsarFileMap>;
+    parseUnzippedFile(file: JSZip.JSZipObject): Promise<PCPulsarFile | null>;
+}

package/build/typings/core/src/pulsar/managers/loaders/remote/PulsarExporterZIPLoader.d.ts

@@ -0,0 +1,12 @@
+import { PCPulsarBaseLoader } from "../PulsarBaseLoader";
+import { PCExporter } from "../../../../model/exporters/Exporter";
+import JSZip from 'jszip';
+import { PCPulsarFile, PCPulsarFileMap } from "../../generators/PulsarFileGenerator";
+export declare class PCPulsarExporterZIPLoader extends PCPulsarBaseLoader {
+    zipSourceURL: string;
+    constructor(sourceZIPURL: string);
+    initialize(): Promise<PCExporter>;
+    downloadZIPFromURL(url: string): Promise<JSZip>;
+    processZIP(zip: JSZip): Promise<PCPulsarFileMap>;
+    parseUnzippedFile(file: JSZip.JSZipObject): Promise<PCPulsarFile | null>;
+}

package/build/typings/core/src/pulsar/managers/validators/PulsarExporterConfigFileValidator.d.ts

@@ -0,0 +1,7 @@
+import { PCExporter, PCExporterModel } from "../../../model/exporters/Exporter";
+export declare class PCPulsarExporterConfigurationFileValidator {
+    validateExporterConfigFileContent(content: string): PCExporterModel;
+    validateOutputConfigFileContent(content: string, exporter: PCExporter): Object;
+    validateSourceConfigFileContent(content: string, exporter: PCExporter): Object;
+    validateParseJSONContent(content: string): Object;
+}

package/build/typings/core/src/tools/Logger.d.ts

@@ -0,0 +1,3 @@
+import { PLLogger } from "../../../language/src/interpreter/loggers/Logger";
+export declare class PCLogger extends PLLogger {
+}

package/build/typings/core/src/tools/LoggerDefaultMessages.d.ts

@@ -0,0 +1,9 @@
+import { PLLoggerDefaultMessages } from "../../../language/src/interpreter/loggers/LoggerDefaultMessages";
+export declare class PCLoggerDefaultMessages {
+    static compilerStart: PLLoggerDefaultMessages;
+    static compilerBuildSuccessful: PLLoggerDefaultMessages;
+    static compilerBuildFailure: PLLoggerDefaultMessages;
+    static interpreterStart: PLLoggerDefaultMessages;
+    static interpreterRenderingSuccessful: PLLoggerDefaultMessages;
+    static interpreterRenderingFailure: PLLoggerDefaultMessages;
+}

package/build/typings/language/src/blueprints/Blueprint.d.ts

@@ -0,0 +1,9 @@
+import { SyntaxTree } from "../parser/syntax/SyntaxTree";
+import { PLBlueprintConfiguration } from "./BlueprintConfiguration";
+export declare class PLBlueprint {
+    id: string;
+    declaration: string;
+    syntax: SyntaxTree;
+    configuration: PLBlueprintConfiguration;
+    constructor(declaration: string, syntax: SyntaxTree, configuration: PLBlueprintConfiguration, id: string);
+}

package/build/typings/language/src/blueprints/BlueprintConfiguration.d.ts

@@ -0,0 +1,17 @@
+export declare class PLBlueprintConfiguration {
+    readonly openingWrapperIdentifier = "{";
+    readonly closingWrapperIdentifier = "}";
+    readonly openingSubstitutionIdentifier = "{";
+    readonly closingSubstitutionIdentifier = "}";
+    readonly openingFlowIdentifier = "[";
+    readonly closingFlowIdentifier = "]";
+    readonly flowEnd = "/";
+    readonly openingCommentIdentifier = "*";
+    readonly closingCommentIdentifier = "*";
+    readonly openingEditorPlaceholderIdentifier = "#";
+    readonly closingEditorPlaceholderIdentifier = "#";
+    readonly openingCodeSyncBlock = "// <";
+    readonly closingCodeSyncBlock = "// >";
+    constructor();
+    static default(): PLBlueprintConfiguration;
+}

package/build/typings/language/src/blueprints/BlueprintFactory.d.ts

@@ -0,0 +1,6 @@
+import { PLBlueprintConfiguration } from "./BlueprintConfiguration";
+import { PLBlueprint } from "./Blueprint";
+import { PLExecutionContext } from "../interpreter/ExecutionContext";
+export declare class PLBlueprintFactory {
+    static blueprint(declaration: string, id: string, executionContext?: PLExecutionContext, configuration?: PLBlueprintConfiguration): PLBlueprint;
+}

package/build/typings/language/src/configuration/KeywordsFlows.d.ts

@@ -0,0 +1,21 @@
+export declare class PLKeywordsFlows {
+    static readonly codeMerge = "code";
+    static readonly log = "log";
+    static readonly emit = "emit";
+    static readonly import = "import";
+    static readonly return = "return";
+    static readonly if = "if";
+    static readonly else = "else";
+    static readonly elseIf = "elseif";
+    static readonly inject = "inject";
+    static readonly for = "for";
+    static readonly map = "map";
+    static readonly traverse = "traverse";
+    static readonly case = "case";
+    static readonly default = "default";
+    static readonly switch = "switch";
+    static readonly global = "global";
+    static readonly let = "let";
+    static readonly set = "set";
+    static readonly var = "var";
+}

package/build/typings/language/src/configuration/KeywordsFunctions.d.ts

@@ -0,0 +1,32 @@
+export declare class PLKeywordsFunctions {
+    static readonly blueprintsCall = "blueprints.call";
+    static readonly booleanAnd = "boolean.and";
+    static readonly booleanOr = "boolean.or";
+    static readonly booleanNot = "boolean.not";
+    static readonly booleanTernaryValue = "boolean.ternaryValue";
+    static readonly compareEquals = "compare.equals";
+    static readonly compareEmpty = "compare.empty";
+    static readonly compareNull = "compare.null";
+    static readonly compareNonNull = "compare.nonnull";
+    static readonly compareGreaterThan = "compare.greaterThan";
+    static readonly compareGreaterThanEquals = "compare.greaterThanEquals";
+    static readonly compareLessThan = "compare.lessThan";
+    static readonly compareLessThanEquals = "compare.lessThanEquals";
+    static readonly initNewArray = "init.array";
+    static readonly initNewDictionary = "init.dictionary";
+    static readonly initNewDate = "init.date";
+    static readonly initNewNull = "init.null";
+    static readonly initNewNumber = "init.number";
+    static readonly initNewString = "init.string";
+    static readonly randomNumber = "random.number";
+    static readonly randomNumberArray = "random.numericArray";
+    static readonly randomString = "random.string";
+    static readonly randomStringArray = "random.stringArray";
+    static readonly supportArraysToZippedMap = "support.arraysToZippedMap";
+    static readonly varDefined = "support.varDefined";
+    static readonly varMutable = "support.varMutable";
+    static readonly varGlobal = "support.varGlobal";
+    static readonly networkGetAnonymous = "network.get.anonymous";
+    static readonly networkGetBasicAuth = "network.get.basicAuth";
+    static readonly networkGetBearerAuth = "network.get.bearerAuth";
+}

package/build/typings/language/src/configuration/KeywordsTranformers.d.ts

@@ -0,0 +1,60 @@
+export declare class PLKeywordsTransformers {
+    static readonly absolute = "absolute";
+    static readonly addedBy = "addedBy";
+    static readonly ceiled = "ceiled";
+    static readonly dividedBy = "dividedBy";
+    static readonly floored = "floored";
+    static readonly multipliedBy = "multipliedBy";
+    static readonly negative = "negative";
+    static readonly positive = "positive";
+    static readonly rounded = "rounded";
+    static readonly subtractedBy = "subtractedBy";
+    static readonly camelcased = "camelcased";
+    static readonly capizalited = "capitalized";
+    static readonly contains = "contains";
+    static readonly default = "default";
+    static readonly equals = "equals";
+    static readonly equalsTernary = "equalsTernary";
+    static readonly extended = "extended";
+    static readonly lowercased = "lowercased";
+    static readonly prefixed = "prefixed";
+    static readonly replacing = "replacing";
+    static readonly slashDoubleQuotes = "slashDoubleQuotes";
+    static readonly slashNewlines = "slashNewlines";
+    static readonly slashSingleQuotes = "slashSingleQuotes";
+    static readonly snakecased = "snakecased";
+    static readonly split = "split";
+    static readonly splitExpr = "splitExpr";
+    static readonly substring = "substring";
+    static readonly suffixed = "suffixed";
+    static readonly trimming = "trimming";
+    static readonly trimmingSpaces = "trimmingSpaces";
+    static readonly uppercased = "uppercased";
+    static readonly count = "count";
+    static readonly formatDate = "formatDate";
+    static readonly isArray = "isArray";
+    static readonly isBool = "isBool";
+    static readonly isDictionary = "isDictionary";
+    static readonly isNull = "isNull";
+    static readonly isNumber = "isNumber";
+    static readonly isString = "isString";
+    static readonly toString = "toString";
+    static readonly join = "join";
+    static readonly append = "append";
+    static readonly at = "at";
+    static readonly concat = "concat";
+    static readonly enumerated = "enumerated";
+    static readonly first = "first";
+    static readonly from = "from";
+    static readonly random = "random";
+    static readonly range = "range";
+    static readonly reversed = "reversed";
+    static readonly shuffled = "shuffled";
+    static readonly sorted = "sorted";
+    static readonly until = "until";
+    static readonly add = "add";
+    static readonly keys = "keys";
+    static readonly value = "value";
+    static readonly alwaysRootValue = "alwaysRootValue";
+    static readonly values = "values";
+}

package/build/typings/language/src/debugger/Debugger.d.ts

@@ -0,0 +1,26 @@
+import { PLError } from "../parser/errors/LanguageError";
+import { SyntaxNode } from "../parser/syntax/nodes/SyntaxNode";
+import { ConcreteToken } from "../parser/Tokenization/Concrete/ConcreteToken";
+import { LexicalToken } from "../parser/Tokenization/Lexical/LexicalToken";
+import { PLDebuggerErrorBuilder } from "./DebuggerErrorBuilder";
+import { PLSymbolTable } from "../parser/symbols/SymbolTable";
+import { PLParserConcreteError, PLParserLexicalError, PLParserSyntaxError } from "./DebuggerErrors";
+export declare class PLDebugger {
+    symbolTable: PLSymbolTable;
+    errorBuilder: PLDebuggerErrorBuilder;
+    constructor();
+    reportError(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError): PLError;
+    reportAnalysisError(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError): PLError;
+    reportRuntimeError(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError): PLError;
+    reportAnalysisErrorFromLexicalToken(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, token: LexicalToken): PLError;
+    reportAnalysisErrorFromLexicalTokens(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, tokens: Array<LexicalToken>): PLError;
+    reportAnalysisErrorFromConcreteToken(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, token: ConcreteToken): PLError;
+    reportAnalysisErrorFromConcreteTokens(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, tokens: Array<ConcreteToken>): PLError;
+    reportAnalysisErrorFromSyntaxNode(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, syntaxNode: SyntaxNode): PLError;
+    reportAnalysisErrorFromSyntaxNodes(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, syntaxNode: Array<SyntaxNode>): PLError;
+    reportRuntimeErrorFromSyntaxNode(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, syntaxNode: SyntaxNode): PLError;
+    reportRuntimeErrorFromSyntaxNodes(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, syntaxNode: Array<SyntaxNode>): PLError;
+    nonEmptyDebugSymbolsFromLexicalTokens(tokens: Array<LexicalToken>): Array<string>;
+    nonEmptyDebugSymbolsFromConcreteTokens(tokens: Array<ConcreteToken>): Array<string>;
+    nonEmptyDebugSymbolsFromSyntaxNodes(syntaxNodes: Array<SyntaxNode>): Array<string>;
+}

package/build/typings/language/src/debugger/DebuggerErrorBuilder.d.ts

@@ -0,0 +1,14 @@
+import { PLError } from "../parser/errors/LanguageError";
+import { PLErrorRange, PLErrorSourceType } from "../parser/errors/LanguageErrorAnalysis";
+import { Symbol } from "../parser/symbols/Symbol";
+import { PLSymbolTable } from "../parser/symbols/SymbolTable";
+import { PLDebuggerErrors, PLParserConcreteError, PLParserLexicalError, PLParserSyntaxError } from "./DebuggerErrors";
+export declare class PLDebuggerErrorBuilder {
+    symbolTable: PLSymbolTable;
+    errors: PLDebuggerErrors;
+    constructor(symbolTable: PLSymbolTable);
+    error(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, source: PLErrorSourceType | null, symbols: Array<string>): PLError;
+    warning(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, source: PLErrorSourceType | null, symbols: Array<string>): PLError;
+    private errorOfType;
+    symbolsToRange(symbols: Array<Symbol>): PLErrorRange | null;
+}

package/build/typings/language/src/debugger/DebuggerErrors.d.ts

@@ -0,0 +1,24 @@
+export declare enum PLParserLexicalError {
+}
+export declare enum PLParserConcreteError {
+    unclosedCommentTag = "unclosedCommentTag",
+    unclosedFlowTag = "unclosedFlowTag",
+    enclosingFlowTagPrecedingFlowDefinition = "enclosingFlowTagPrecedingFlowDefinition",
+    missingOpeningSubstitutionTag = "missingOpeningSubstitutionTag",
+    missingOpeningCommentTag = "missingOpeningCommentTag",
+    missingOpeningFlowTag = "missingOpeningFlowTag",
+    editorPlaceholderFound = "editorPlaceholderFound",
+    unclosedSubstitutionTag = "unclosedSubstitutionTag",
+    invalidSubstitutionStructure = "invalidSubstitutionStructure",
+    invalidFlowStructure = "invalidFlowStructure",
+    textTokenRequired = "textTokenRequired"
+}
+export declare enum PLParserSyntaxError {
+    missingEnclosingFlowTag = "missingEnclosingFlowTag"
+}
+export declare class PLDebuggerErrors {
+    messageTable: Object;
+    constructor();
+    errorTypeToMessage(type: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError): string;
+    generateMessageTable(): Object;
+}

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

@@ -0,0 +1,17 @@
+export { PLBlueprint } from "./blueprints/Blueprint";
+export { PLBlueprintFactory } from "./blueprints/BlueprintFactory";
+export { PLBlueprintConfiguration } from "./blueprints/BlueprintConfiguration";
+export { PLExecutionContext } from "./interpreter/ExecutionContext";
+export { PLInterpreter } from "./interpreter/Interpreter";
+export { PLInterpreterContext } from "./interpreter/InterpreterContext";
+export { PLMemoryBlueprintLoader } from "./interpreter/loaders/MemoryBlueprintLoader";
+export { PLEmittedContent } from "./interpreter/emitters/EmittedContent";
+export { PLBlueprintEmitter } from "./interpreter/emitters/BlueprintEmitter";
+export { PLMemoryBlueprintEmitter } from "./interpreter/emitters/MemoryBlueprintEmitter";
+export { DSMExecutionContext } from "./extensions/dsm/DSMExecutionContext";
+export { DSMBridge, DSMBridgeConfiguration } from "./extensions/dsm/DSMBridge";
+export { PLHighlightEngineToken } from "./tools/highlight/HighlightEngine";
+export { PLBlueprintHighlightEngine } from "./tools/highlight/BlueprintHighlightEngine";
+export { PLHighlightEngineStyle, PLHighlightEngineStyleFont } from "./tools/highlight/HighlightEngine";
+export { PLBlueprintAutocompleteEngine } from "./tools/autocomplete/BlueprintAutocompleteEngine";
+export { PLAutocompleteBlueprintSnippets } from "./tools/autocomplete/BlueprintSnippets";

package/build/typings/language/src/extensions/dsm/DSMBridge.d.ts

@@ -0,0 +1,23 @@
+export interface DSMBridgeConfiguration {
+    apiUrl: string;
+    apiVersion?: string;
+    accessToken: string;
+    designSystemId: string;
+    dsVersionId: string;
+}
+export declare class DSMBridge {
+    authToken: string;
+    dsmVersion: string;
+    dsmId: string;
+    dsmDataRequestURL: string;
+    dsmMetadataRequestURL: string;
+    dsmVersionRequestURL: string;
+    constructor(conf: DSMBridgeConfiguration);
+    getToken(): Promise<string>;
+    getDSMDataFromEndpoint(endpoint: string, filter: ((result: any) => any) | null): Promise<any>;
+    getDSMMetadataFromEndpoint(endpoint: string, filter: ((result: any) => any) | null): Promise<any>;
+    getDSMVersionDataFromEndpoint(endpoint: string, filter: ((result: any) => any) | null): Promise<any>;
+    private getDataForAuthenticatedEndpoint;
+    /** This function is not meant for production! Only use in tests */
+    static getAccessToken(username: string, password: string): Promise<string>;
+}

package/build/typings/language/src/extensions/dsm/DSMExecutionContext.d.ts

@@ -0,0 +1,16 @@
+import { DSMBridge } from "./DSMBridge";
+import { PLExecutionContext } from "../../interpreter/ExecutionContext";
+import { PLFlow } from "../../interpreter/flows/Flow";
+import { PLTransformer } from "../../interpreter/transformers/Transformer";
+import { PLFunction } from "../../interpreter/functions/Function";
+import { PLLogger } from "../../interpreter/loggers/Logger";
+import { PLBlueprintLoader } from "../../interpreter/loaders/BlueprintLoader";
+import { PLBlueprintEmitter } from "../../interpreter/emitters/BlueprintEmitter";
+export declare class DSMExecutionContext extends PLExecutionContext {
+    bridge: DSMBridge;
+    sandboxData: Object;
+    constructor(blueprintLoader: PLBlueprintLoader, blueprintEmitter: PLBlueprintEmitter, logger: PLLogger, bridge: DSMBridge, sandboxData: Object);
+    provideCustomFunctions(): Array<PLFunction>;
+    provideCustomTransformers(): Array<PLTransformer>;
+    provideCustomFlows(): Array<PLFlow>;
+}

package/build/typings/language/src/extensions/dsm/configuration/DSMKeywordsFunctions.d.ts

@@ -0,0 +1,30 @@
+export declare class DSMKeywordsFunctions {
+    static readonly allAssets = "dsm.allAssets";
+    static readonly assetById = "dsm.assetById";
+    static readonly allFontAssets = "dsm.allFontAsset";
+    static readonly allBitmapAssets = "dsm.allBitmapAssets";
+    static readonly allTokens = "dsm.allTokens";
+    static readonly allThemes = "dsm.allThemes";
+    static readonly resolveTokens = "dsm.resolveTokens";
+    static readonly resolveTheme = "dsm.resolveTheme";
+    static readonly tokenById = "dsm.tokenById";
+    static readonly allImageTokens = "dsm.allImageTokens";
+    static readonly allMeasureTokens = "dsm.allMeasureTokens";
+    static readonly allRadiusTokens = "dsm.allRadiusTokens";
+    static readonly allColorTokens = "dsm.allColorTokens";
+    static readonly allFontTokens = "dsm.allFontTokens";
+    static readonly allGradientTokens = "dsm.allGradientTokens";
+    static readonly allShadowTokens = "dsm.allShadowTokens";
+    static readonly allBorderTokens = "dsm.allBorderTokens";
+    static readonly allTypographyTokens = "dsm.allTypographyTokens";
+    static readonly allComponents = "dsm.allComponents";
+    static readonly componentById = "dsm.componentById";
+    static readonly allComponentGroups = "dsm.allComponentGroups";
+    static readonly allTokenGroups = "dsm.allTokenGroups";
+    static readonly allVersions = "dsm.allVersions";
+    static readonly versionById = "dsm.versionById";
+    static readonly metadata = "dsm.metadata";
+    static readonly sandboxDataByComponentId = "sandbox.componentDataById";
+    static readonly fontsIsItalic = "dsm.fonts.isItalic";
+    static readonly fontsWeight = "dsm.fonts.weight";
+}

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

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

package/build/typings/language/src/extensions/dsm/functions/assets/DSMFunctionAllAssets.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/assets/DSMFunctionAllBitmapAssets.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/assets/DSMFunctionAllFontAssets.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/assets/DSMFunctionAssetById.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/components/DSMFunctionAllComponents.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/components/DSMFunctionComponentById.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/dsms/DSMFunctionAllVersions.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/dsms/DSMFunctionMetadata.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/dsms/DSMFunctionVersionById.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/fonts/DSMFunctionFontIsItalic.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/fonts/DSMFunctionFontWeight.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/groups/DSMFunctionAllComponentGroups.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/groups/DSMFunctionAllTokenGroups.d.ts

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

package/build/typings/language/src/extensions/dsm/functions/sandbox/DSMFunctionSandboxDataByComponentId.d.ts

@@ -0,0 +1,15 @@
+import { DSMExecutionContext } from "../../DSMExecutionContext";
+import { PLInterpreterContext } from "../../../../interpreter/InterpreterContext";
+import { PLFunctionArgument } from "../../../../interpreter/functions/FunctionArgument";
+import { PLFunction } from "../../../../interpreter/functions/Function";
+import { PLDoc } from "../../../../tools/documentation/Doc";
+export declare class DSMFunctionSandboxDataByComponentId extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    documentation(): PLDoc;
+    provideValueUsingArguments(args: Array<PLFunctionArgument>, context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+    prepareTemporarySandboxDataFromResult(result: any): Object;
+    randomString(): string;
+    randomConstant(): string;
+    randomBoolean(): boolean;
+}

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

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

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

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

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

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

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

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

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

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

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

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