@supernova-studio/pulsar-core 2.0.14 → 2.0.15

package/build/main/core/src/tests/dynamic_execution/DynamicExecutionSupport.d.ts

@@ -0,0 +1,4 @@
+import { PCEngineSourceProcessingResult } from '../../exports';
+import { PCExporterContributionConfigurationItemModel } from '@pulsar/core/model/exporters/ExporterContributionConfigurationItem';
+export declare function executeBlueprintWithJSHelper(blueprint: string, jsHelper: string): Promise<PCEngineSourceProcessingResult>;
+export declare function executeBlueprintWithJSHelperAndConfiguration(blueprint: string, jsHelper: string, configuration: Array<PCExporterContributionConfigurationItemModel>): Promise<PCEngineSourceProcessingResult>;

package/build/main/core/src/tests/dynamic_execution/TestConfigurableExecution.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/dynamic_execution/TestJSConstantExecution.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/dynamic_execution/TestJSFunctionExecution.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/dynamic_execution/TestJSTransformerExecution.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/lib.pulsar/TestPulsarBlueprintManipulation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/lib.pulsar/TestPulsarCodeManipulation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/lib.pulsar/TestPulsarExporterManipulation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/packages/TestGitHubPackageDownloader.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/packages/TestRemotePackageDownloader.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/packages/TestZipping.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/scenarios/TestBrowserScenario.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/core/src/tests/scenarios/TestCIScenario.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,9 @@
+import { PLLoggerDefaultMessages } from '@pulsar/language/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/main/core/src/tools/Timer.d.ts

@@ -0,0 +1,14 @@
+export declare type PCTimerStart = {
+    rs: number;
+    rns: number;
+    name: string;
+};
+export declare type PCTimerEnd = {
+    durationMs: number;
+    name: string;
+};
+export declare class PCTimer {
+    static newTimer(name: string): PCTimerStart;
+    static endTimer(timer: PCTimerStart, report?: boolean): PCTimerEnd;
+    static asSeconds(timer: PCTimerEnd): string;
+}

package/build/main/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/main/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/main/language/src/blueprints/BlueprintFactory.d.ts

@@ -0,0 +1,9 @@
+import { PLBlueprintConfiguration } from './BlueprintConfiguration';
+import { PLBlueprint } from './Blueprint';
+import { PLExecutionContext } from '../interpreter/ExecutionContext';
+export declare class PLBlueprintFactory {
+    private cacheBlueprints;
+    private cache;
+    constructor(enableCache?: boolean);
+    blueprint(declaration: string, id: string, executionContext?: PLExecutionContext, configuration?: PLBlueprintConfiguration): PLBlueprint;
+}

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

@@ -0,0 +1,23 @@
+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 traverseChildren = "traverseChildren";
+    static readonly case = "case";
+    static readonly default = "default";
+    static readonly switch = "switch";
+    static readonly global = "global";
+    static readonly const = "const";
+    static readonly set = "set";
+    static readonly let = "let";
+    static readonly equal = "=";
+}

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

@@ -0,0 +1,12 @@
+export declare class PLKeywordsFunctions {
+    static readonly blueprintsCall = "call";
+    static readonly supportArraysToZippedMap = "zippedMap";
+    static readonly varDefined = "isDefined";
+    static readonly varMutable = "isMutable";
+    static readonly varGlobal = "isGlobal";
+    static readonly networkGetNetworkData = "getNetworkData";
+    static readonly networkGetBasicAuth = "getAuth";
+    static readonly networkGetBearerAuth = "getBearer";
+    static readonly randomString = "randomString";
+    static readonly randomInt = "randomInt";
+}

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

@@ -0,0 +1,63 @@
+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 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 splitNewlines = "splitNewlines";
+    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 startsWith = "startsWith";
+    static readonly endsWith = "endsWith";
+    static readonly count = "count";
+    static readonly formatDate = "formatDate";
+    static readonly isArray = "isArray";
+    static readonly isBool = "isBool";
+    static readonly isObject = "isObject";
+    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 last = "last";
+    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";
+    static readonly jsExecutionPrefix = "";
+}

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

@@ -0,0 +1,27 @@
+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;
+    executedFile: string;
+    constructor();
+    reportError(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportAnalysisError(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportRuntimeError(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportAnalysisErrorFromLexicalToken(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, token: LexicalToken, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportAnalysisErrorFromLexicalTokens(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, tokens: Array<LexicalToken>, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportAnalysisErrorFromConcreteToken(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, token: ConcreteToken, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportAnalysisErrorFromConcreteTokens(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, tokens: Array<ConcreteToken>, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportAnalysisErrorFromSyntaxNode(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, syntaxNode: SyntaxNode, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportAnalysisErrorFromSyntaxNodes(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, syntaxNode: Array<SyntaxNode>, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportRuntimeErrorFromSyntaxNode(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, syntaxNode: SyntaxNode, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    reportRuntimeErrorFromSyntaxNodes(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, syntaxNode: Array<SyntaxNode>, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    private nonEmptyDebugSymbolsFromLexicalTokens;
+    private nonEmptyDebugSymbolsFromConcreteTokens;
+    private nonEmptyDebugSymbolsFromSyntaxNodes;
+}

package/build/main/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>, filename: string, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    warning(error: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, source: PLErrorSourceType | null, symbols: Array<string>, filename: string, reportValue1?: string | undefined, reportValue2?: string | undefined): PLError;
+    private errorOfType;
+    symbolsToRange(symbols: Array<Symbol>): PLErrorRange | null;
+}

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

@@ -0,0 +1,41 @@
+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",
+    flowKeywordMissing = "flowKeywordMissing",
+    flowKeywordMismatch = "flowKeywordMismatch",
+    flowArgumentEmpty = "flowArgumentEmpty",
+    flowKeywordUnknown = "flowKeywordUnknown",
+    flowRequiredPartMustPrecedeOptional = "flowRequiredPartMustPrecedeOptional",
+    functionMustBeCalled = "functionMustBeCalled",
+    unknownFunction = "unknownFunction",
+    dotAfterFunctionInvocationExpected = "dotAfterFunctionInvocationExpected",
+    missingSubstitutionValue = "missingSubstitutionValue",
+    expectedDifferentNumberOfFunctionArguments = "expectedDifferentNumberOfFunctionArguments",
+    invalidFunctionArgument = "invalidFunctionArgument",
+    unknownTransformer = "unknownTransformer",
+    substitutionMustNotStartWithTransformer = "substitutionMustNotStartWithTransformer",
+    substitutionOutputNotString = "substitutionOutputNotString",
+    transformerSourceDataTypeMismatch = "transformerSourceDataTypeMismatch",
+    transformerSelfNotRoot = "transformerSelfNotRoot",
+    expectedDifferentNumberOfTransformerArguments = "expectedDifferentNumberOfTransformerArguments"
+}
+export declare class PLDebuggerErrors {
+    messageTable: Object;
+    constructor();
+    errorTypeToMessage(type: PLParserLexicalError | PLParserConcreteError | PLParserSyntaxError, value1: string | undefined, value2: string | undefined): string;
+    generateMessageTable(): Object;
+}

package/build/main/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/main/language/src/extensions/dsm/DSMBridge.d.ts

@@ -0,0 +1,38 @@
+import { PLLogger } from '../../interpreter/loggers/Logger';
+import { DSMDataCore } from './DSMDataCore';
+export interface DSMBridgeConfiguration {
+    apiUrl: string;
+    apiVersion?: string;
+    accessToken: string;
+    designSystemId: string;
+    designSystemVersionId: string;
+    brandId?: string;
+    themeId?: string;
+    exportPath?: string;
+    dsmRequestHook?: any;
+    debugMode?: boolean;
+    logger: PLLogger;
+}
+export declare class DSMBridge {
+    authToken: string;
+    dsmVersion: string;
+    dsmId: string;
+    dsmBrand: string | null;
+    dsmTheme: string | null;
+    dsmDataRequestURL: string;
+    dataCore: DSMDataCore;
+    apiUrl: string;
+    domain: string | null;
+    dsmRequestHook?: any;
+    debugMode: boolean;
+    logger: PLLogger | null;
+    constructor(conf: DSMBridgeConfiguration);
+    /** Retrieve DSM bridge that is only the shell object - in some situations, we don't need the network data, such as static analysis, autocomplete and so on */
+    static analysisOnlyBridge(): DSMBridge;
+    getToken(): Promise<string>;
+    getDSMDataFromEndpoint(endpoint: string, filter: ((result: any) => any) | null): Promise<any>;
+    private buildRequestConfig;
+    private getDataForAuthenticatedEndpoint;
+    /** This function is not meant for production! Only use in tests */
+    static getAccessToken(username: string, password: string): Promise<string>;
+}

package/build/main/language/src/extensions/dsm/DSMDataCore.d.ts

@@ -0,0 +1,135 @@
+import { DSMBridge } from './DSMBridge';
+import { DesignSystem, DocumentationGroup, DocumentationPage } from '@supernovaio/supernova-sdk';
+import { DesignSystemVersion } from '@supernovaio/supernova-sdk';
+import { Component } from '@supernovaio/supernova-sdk';
+import { Asset } from '@supernovaio/supernova-sdk';
+import { TokenGroup } from '@supernovaio/supernova-sdk';
+import { DocumentationItem } from '@supernovaio/supernova-sdk';
+import { DesignComponent } from '@supernovaio/supernova-sdk';
+import { DesignComponentGroup } from '@supernovaio/supernova-sdk';
+import { AssetGroup } from '@supernovaio/supernova-sdk';
+import { Documentation } from '@supernovaio/supernova-sdk';
+import { ExporterCustomBlock } from '@supernovaio/supernova-sdk';
+import { Token } from '@supernovaio/supernova-sdk';
+import { Brand } from '@supernovaio/supernova-sdk';
+import { TokenTheme } from '@supernovaio/supernova-sdk';
+export declare class DSMDataCore {
+    private sdk;
+    private bridge;
+    private versionMutex;
+    private versionsMutex;
+    private designSystemsMutex;
+    private documentationMutex;
+    private documentationItemMutex;
+    private tokenMutex;
+    private tokenGroupMutex;
+    private componentMutex;
+    private designComponentMutex;
+    private designComponentGroupMutex;
+    private brandsMutex;
+    private themesMutex;
+    private assetMutex;
+    private assetGroupMutex;
+    private exporterCustomBlockMutex;
+    private kvsMutex;
+    private executedVersion;
+    private rawVersions;
+    private rawDesignSystems;
+    private rawDocumentation;
+    private rawBrands;
+    private mappedBrands;
+    private rawThemes;
+    private mappedThemes;
+    private rawTokens;
+    private mappedTokens;
+    private rawTokenGroups;
+    private mappedTokenGroup;
+    private rawComponents;
+    private mappedComponents;
+    private rawDesignComponents;
+    private mappedDesignComponents;
+    private rawDesignComponentGroups;
+    private mappedDesignComponentsGroups;
+    private rawAssets;
+    private mappedAssets;
+    private rawAssetGroups;
+    private mappedAssetGroups;
+    private rawDocumentationItems;
+    private rawDocumentationPages;
+    private rawDocumentationGroups;
+    private rawDocumentationRoot;
+    private mappedDocumentationPages;
+    private mappedDocumentationGroups;
+    private rawExporterCustomBlocks;
+    private kvsData;
+    constructor(bridge: DSMBridge);
+    preloadData(): Promise<void>;
+    currentDomain(): Promise<string>;
+    designSystems(workspaceId: string): Promise<Array<DesignSystem>>;
+    version(): Promise<DesignSystemVersion>;
+    versions(): Promise<Array<DesignSystemVersion>>;
+    documentation(): Promise<Documentation>;
+    /** Fetch all brands and store them for further use */
+    brands(): Promise<Array<Brand>>;
+    /** Fetch brand by id with optimization for single id access (much faster for multiple brands defined in DS) */
+    brandById(brandId: string): Promise<Brand | null>;
+    /** Fetch all themes and store them for further use */
+    themes(): Promise<Array<TokenTheme>>;
+    /** Fetch theme by id with optimization for single id access (much faster for multiple themes defined in DS). Use can use both persistent and version-specific id. */
+    themeById(themeId: string): Promise<TokenTheme | null>;
+    /** Fetch themes for specific brand */
+    themesByBrandId(brandId: string): Promise<Array<TokenTheme>>;
+    /** Fetch all components in the design system */
+    components(): Promise<Array<Component>>;
+    /** Fetch component by id with optimization for single id access (much faster for multiple components defined in DS). You can use both persistent and version-specific id */
+    componentById(componentId: string): Promise<Component>;
+    /** Fetch components for specific brand */
+    componentsByBrandId(brandId: string): Promise<Array<Component>>;
+    /** Fetch all design components in the design system */
+    designComponents(): Promise<Array<DesignComponent>>;
+    /** Fetch design component by id with optimization for single id access (much faster for multiple components defined in DS) */
+    designComponentById(componentId: string): Promise<DesignComponent>;
+    /** Fetch design components for specific brand */
+    designComponentsByBrandId(brandId: string): Promise<Array<DesignComponent>>;
+    /** Fetch all design components in the design system */
+    designComponentGroups(): Promise<Array<DesignComponentGroup>>;
+    /** Fetch design component by id with optimization for single id access (much faster for multiple ground defined in DS) */
+    designComponentGroupById(groupId: string): Promise<DesignComponentGroup>;
+    /** Fetch design component groups for specific brand */
+    designComponentGroupByBrandId(brandId: string): Promise<Array<DesignComponentGroup>>;
+    /** Fetch all tokens in the design system */
+    tokens(): Promise<Array<Token>>;
+    /** Fetch tokens by id with optimization for single id access (much faster for multiple tokens defined in DS). You can use both persistent and version-specific id */
+    tokenById(tokenId: string | null): Promise<Token>;
+    /** Fetch tokens for specific brand */
+    tokensByBrandId(brandId: string): Promise<Array<Token>>;
+    /** Fetch all token groups in the design system */
+    tokenGroups(): Promise<Array<TokenGroup>>;
+    /** Fetch token groups by id with optimization for single id access (much faster for multiple tokens defined in DS). You can use both persistent and version-specific id */
+    tokenGroupById(tokenGroupId: string | null): Promise<TokenGroup | null>;
+    /** Fetch token groups for specific brand */
+    tokenGroupsByBrandId(brandId: string): Promise<Array<TokenGroup>>;
+    /** Fetch all assets in the design system */
+    assets(): Promise<Array<Asset>>;
+    /** Fetch asset by id with optimization for single id access (much faster for multiple assets defined in DS). You can use both persistent and version-specific id */
+    assetById(assetId: string | null): Promise<Asset>;
+    /** Fetch assets for specific brand */
+    assetsByBrandId(brandId: string): Promise<Array<Asset>>;
+    /** Fetch all asset groups in the design system */
+    assetGroups(): Promise<Array<AssetGroup>>;
+    /** Fetch asset group by id with optimization for single id access (much faster for multiple assets defined in DS). You can use both persistent and version-specific id */
+    assetGroupById(groupId: string | null): Promise<AssetGroup>;
+    /** Fetch asset groups for specific brand */
+    assetGroupsByBrandId(brandId: string): Promise<Array<AssetGroup>>;
+    documentationItems(): Promise<Array<DocumentationItem>>;
+    documentationPages(): Promise<Array<DocumentationPage>>;
+    /** Fetch page by id with optimization for single id access (much faster for multiple pages defined in DS). You can use both persistent and version-specific id */
+    documentationPageById(pageId: string): Promise<DocumentationPage | null>;
+    documentationGroups(): Promise<Array<DocumentationGroup>>;
+    documentationRoot(): Promise<DocumentationGroup>;
+    /** Fetch group by id with optimization for single id access (much faster for multiple groups defined in DS). You can use both persistent and version-specific id */
+    documentationGroupById(groupId: string): Promise<DocumentationGroup | null>;
+    currentExporterCustomBlocks(): Promise<Array<ExporterCustomBlock>>;
+    /** Fetch data from the key-value store or return undefined if it wasn't set just yet */
+    kvsDataByKey(key: string): Promise<any | null>;
+}

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

@@ -0,0 +1,23 @@
+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';
+import { PLBlueprintFactory } from '../../blueprints/BlueprintFactory';
+export declare class DSMExecutionContext extends PLExecutionContext {
+    /** API-enabled communication bridge */
+    bridge: DSMBridge;
+    /** Sandbox payload for dynamic configuration of export blueprints */
+    sandboxData: Object;
+    /** User configuration data */
+    configurationData: Object;
+    /** Exporter configuration */
+    exporterData: Object;
+    constructor(blueprintLoader: PLBlueprintLoader, blueprintEmitter: PLBlueprintEmitter, logger: PLLogger, factory: PLBlueprintFactory, bridge: DSMBridge, sandboxData: Object, configurationData: Object, exporterData: Object);
+    provideCustomFunctions(): Array<PLFunction>;
+    provideCustomTransformers(): Array<PLTransformer>;
+    provideCustomFlows(): Array<PLFlow>;
+}

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

@@ -0,0 +1,52 @@
+export declare class DSMKeywordsFunctions {
+    static readonly allComponents = "allComponents";
+    static readonly componentById = "componentById";
+    static readonly allDesignComponents = "allDesignComponents";
+    static readonly designComponentById = "designComponentById";
+    static readonly allTokens = "allTokens";
+    static readonly tokensByType = "tokensByType";
+    static readonly tokensByGroupId = "tokensByGroupId";
+    static readonly tokenById = "tokenById";
+    static readonly tokensByApplyingThemes = "tokensByApplyingThemes";
+    static readonly allTokensByApplyingThemes = "allTokensByApplyingThemes";
+    static readonly allAssets = "allAssets";
+    static readonly assetsByGroupId = "assetsByGroupId";
+    static readonly assetById = "assetById";
+    static readonly allTokenGroups = "allTokenGroups";
+    static readonly allTokenGroupTrees = "allTokenGroupTrees";
+    static readonly tokenGroupsOfType = "tokenGroupsOfType";
+    static readonly tokenGroupTreeByType = "tokenGroupTreeByType";
+    static readonly tokenGroupContainingTokenId = "tokenGroupContainingTokenId";
+    static readonly tokenGroupById = "tokenGroupById";
+    static readonly allAssetGroups = "allAssetGroups";
+    static readonly assetGroupTree = "assetGroupTree";
+    static readonly assetGroupById = "assetGroupById";
+    static readonly assetGroupContainingAssetId = "assetGroupContainingAssetId";
+    static readonly currentWorkspace = "currentWorkspace";
+    static readonly currentDesignSystem = "currentDesignSystem";
+    static readonly currentDesignSystemSwitcher = "currentDesignSystemSwitcher";
+    static readonly designSystemById = "designSystemById";
+    static readonly currentDesignSystemVersion = "currentDesignSystemVersion";
+    static readonly allDesignSystemVersions = "allDesignSystemVersions";
+    static readonly allBrands = "allBrands";
+    static readonly currentBrand = "currentBrand";
+    static readonly brandById = "brandById";
+    static readonly allThemes = "allThemes";
+    static readonly themeById = "themeById";
+    static readonly currentTheme = "currentTheme";
+    static readonly fontsIsBold = "isFontBold";
+    static readonly fontsIsRegular = "isFontRegular";
+    static readonly fontsIsItalic = "isFontItalic";
+    static readonly fontsWeight = "fontWeight";
+    static readonly configuration = "exportConfiguration";
+    static readonly packageConfiguration = "exportPackageConfiguration";
+    static readonly docsAllPages = "allDocumentationPages";
+    static readonly docsPageById = "documentationPageById";
+    static readonly docsPageToMarkdown = "documentationPageToMarkdown";
+    static readonly docsAllGroups = "allDocumentationGroups";
+    static readonly docsGroupById = "documentationGroupById";
+    static readonly docsRootGroup = "rootDocumentationGroup";
+    static readonly docsConfiguration = "documentationConfiguration";
+    static readonly docsDomain = "documentationDomain";
+    static readonly kvsData = "kvsData";
+}

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

@@ -0,0 +1,10 @@
+import { DSMExecutionContext } from '../../DSMExecutionContext';
+import { PLInterpreterContext } from '../../../../interpreter/InterpreterContext';
+import { PLFunction, PLFunctionType } from '../../../../interpreter/functions/Function';
+export declare class DSMFunctionAllAssets extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    type(): PLFunctionType;
+    isAsync(): boolean;
+    provideValueUsingArguments(args: Array<any>, context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}

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

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

package/build/main/language/src/extensions/dsm/functions/assets/DSMFunctionAssetsByGroupId.d.ts

@@ -0,0 +1,10 @@
+import { DSMExecutionContext } from '../../DSMExecutionContext';
+import { PLInterpreterContext } from '../../../../interpreter/InterpreterContext';
+import { PLFunction, PLFunctionType } from '../../../../interpreter/functions/Function';
+export declare class DSMFunctionAssetsByGroupId extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    type(): PLFunctionType;
+    isAsync(): boolean;
+    provideValueUsingArguments(args: Array<any>, context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}

package/build/main/language/src/extensions/dsm/functions/brands/DSMFunctionAllBrands.d.ts

@@ -0,0 +1,10 @@
+import { DSMExecutionContext } from '../../DSMExecutionContext';
+import { PLInterpreterContext } from '../../../../interpreter/InterpreterContext';
+import { PLFunction, PLFunctionType } from '../../../../interpreter/functions/Function';
+export declare class DSMFunctionAllBrands extends PLFunction {
+    numberOfArguments(): number;
+    keyword(): string;
+    type(): PLFunctionType;
+    isAsync(): boolean;
+    provideValueUsingArguments(args: Array<any>, context: PLInterpreterContext, executionContext: DSMExecutionContext): Promise<any | null>;
+}