@supernova-studio/pulsar-core 1.0.41 → 1.0.43

package/build/typings/core/src/browser-bundle.d.ts

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

package/build/typings/core/src/engine/ExportEngine.d.ts

@@ -0,0 +1,17 @@
+import { PCExportConfiguration } from "./configuration/ExportConfiguration";
+import { PCExportItemWriter } from "./writing/writers/ExportItemWriter";
+import { PCExportItemProducer } from "./items/ExportItemProducer";
+import { PCExportDataProducer } from "./generation/ExportDataProducer";
+import { PCExportWriterResponse } from "./writing/requests/ExportWriterResponse";
+import { PCExportWriterMemoryStore } from "./writing/writers/memory/ExportWriterStore";
+export declare class PCExportEngine {
+    dataProducer: PCExportDataProducer;
+    itemProducer: PCExportItemProducer;
+    itemWriter: PCExportItemWriter;
+    configuration: PCExportConfiguration;
+    runId: string;
+    constructor(configuration: PCExportConfiguration);
+    processExportValidate(): Promise<boolean>;
+    processExport(): Promise<PCExportWriterMemoryStore>;
+    processExportValidated(): Promise<Array<PCExportWriterResponse>>;
+}

package/build/typings/core/src/engine/configuration/ExportConfiguration.d.ts

@@ -0,0 +1,18 @@
+import { PCExporter } from "../../model/exporters/Exporter";
+import { PCLogger } from "../../tools/Logger";
+import { DSMReferenceStore } from "../../model/dsm/DSMReferenceStore";
+import { PCExportWriterMemoryStore } from "../writing/writers/memory/ExportWriterStore";
+import { DSMBridgeConfiguration, DSMExecutionContext } from "../../../../language/src/index";
+import { PCPulsarExporterMode } from "../../pulsar/Pulsar";
+export declare class PCExportConfiguration {
+    exporter: PCExporter;
+    exportMode: PCPulsarExporterMode;
+    logger: PCLogger;
+    dsmStore: DSMReferenceStore;
+    dsmBridgeConfig: DSMBridgeConfiguration;
+    outputStore: PCExportWriterMemoryStore;
+    outputPathPrefix: string;
+    sandboxData: Object;
+    constructor(exporter: PCExporter, logger: PCLogger, dsmStore: DSMReferenceStore, dsmBridgeConfig: DSMBridgeConfiguration, exportMode: PCPulsarExporterMode, sandboxData: Object);
+    newExecutionContext(): DSMExecutionContext;
+}

package/build/typings/core/src/engine/generation/ExportDataProducer.d.ts

@@ -0,0 +1,15 @@
+import { PCExportDataQueue } from "./queue/ExportDataQueue";
+import { PCExportConfiguration } from "../configuration/ExportConfiguration";
+import { PCExportDataResponse } from "./requests/ExportDataResponse";
+import { PCExporterMapBlueprint } from "../../model/maps/ExporterMapBlueprint";
+import { PCExportDataRequest } from "./requests/ExportDataRequest";
+export declare class PCExportDataProducer {
+    configuration: PCExportConfiguration;
+    processingQueue: PCExportDataQueue;
+    constructor(exportConfiguration: PCExportConfiguration);
+    validateCanProduceData(): Promise<void>;
+    produceData(): Promise<Array<PCExportDataResponse>>;
+    generateRequestsForMap(map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    generatePrimaryResponsesFromFinishedRequests(requests: Array<PCExportDataRequest>): Array<PCExportDataResponse>;
+    generateEmittedResponsesFromFinishedRequests(requests: Array<PCExportDataRequest>): Array<PCExportDataResponse>;
+}

package/build/typings/core/src/engine/generation/queue/ExportDataQueue.d.ts

@@ -0,0 +1,16 @@
+import { PCExportDataQueueOperation } from "./ExportDataQueueOperation";
+import { PCExportDataRequest } from "../requests/ExportDataRequest";
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+export declare class PCExportDataQueue {
+    configuration: PCExportConfiguration;
+    waitingOperations: Array<PCExportDataQueueOperation>;
+    isLockedForChanges: boolean;
+    isFinished: boolean;
+    requests: Array<PCExportDataRequest>;
+    requestsCompleted: number;
+    constructor(configuration: PCExportConfiguration);
+    addQueuedRequest(request: PCExportDataRequest): void;
+    addQueuedRequests(requests: Array<PCExportDataRequest>): void;
+    clearQueue(): void;
+    processQueue(): Promise<Array<PCExportDataRequest>>;
+}

package/build/typings/core/src/engine/generation/queue/ExportDataQueueOperation.d.ts

@@ -0,0 +1,6 @@
+import { PCExportDataRequest } from "../requests/ExportDataRequest";
+export declare class PCExportDataQueueOperation {
+    request: PCExportDataRequest;
+    constructor(request: PCExportDataRequest);
+    processOperation(): Promise<PCExportDataRequest>;
+}

package/build/typings/core/src/engine/generation/requests/ExportDataEmittedResponseProducer.d.ts

@@ -0,0 +1,7 @@
+import { PCExportDataRequest } from "./ExportDataRequest";
+import { PCExportDataResponse } from "./ExportDataResponse";
+export declare class PCExportDataEmittedResponseProducer {
+    constructor();
+    produceEmittedResponsesFromRequests(requests: Array<PCExportDataRequest>): Array<PCExportDataResponse>;
+    produceEmittedResponsesFromRequest(request: PCExportDataRequest): Array<PCExportDataResponse>;
+}

package/build/typings/core/src/engine/generation/requests/ExportDataPrimaryResponseProducer.d.ts

@@ -0,0 +1,7 @@
+import { PCExportDataResponse } from "./ExportDataResponse";
+import { PCExportDataRequest } from "./ExportDataRequest";
+export declare class PCExportDataPrimaryResponseProducer {
+    constructor();
+    producePrimaryResponsesFromRequests(requests: Array<PCExportDataRequest>): Array<PCExportDataResponse>;
+    producePrimaryResponseFromRequest(request: PCExportDataRequest): PCExportDataResponse;
+}

package/build/typings/core/src/engine/generation/requests/ExportDataRequest.d.ts

@@ -0,0 +1,19 @@
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+import { PCExporterMapBlueprint } from "../../../model/maps/ExporterMapBlueprint";
+import { PCExportDataRequestDataStore } from "./ExportDataRequestDataStore";
+import { PCExportDataRequestNameStore } from "./ExportDataRequestNameStore";
+import { PLEmittedContent } from "../../../../../language/src/index";
+export declare class PCExportDataRequest {
+    dataStore: PCExportDataRequestDataStore | null;
+    nameStore: PCExportDataRequestNameStore | null;
+    emittedContent: Array<PLEmittedContent> | null;
+    map: PCExporterMapBlueprint;
+    configuration: PCExportConfiguration;
+    processingError: Error | null;
+    processingFinished: boolean;
+    constructor(configuration: PCExportConfiguration, map: PCExporterMapBlueprint);
+    produceData(): Promise<PCExportDataRequest>;
+    requestSuccesfullGeneratingPlainData(plainData: any, nameData: Map<string, any>, emittedContent: Array<PLEmittedContent>): void;
+    requestSuccessfullGeneratingMultipartData(multipartData: Map<string, any>, multipartNameData: Map<string, Map<string, any>>, emittedContent: Array<PLEmittedContent>): void;
+    requestFailed(error: Error): void;
+}

package/build/typings/core/src/engine/generation/requests/ExportDataRequestDataStore.d.ts

@@ -0,0 +1,16 @@
+export declare enum PCExportDataRequestDataStoreMode {
+    plain = 0,
+    multipart = 1
+}
+export declare class PCExportDataRequestDataStore {
+    plainDataKey: string;
+    dataStore: Map<string, any>;
+    mode: PCExportDataRequestDataStoreMode;
+    static storeWithPlainData(data: any): PCExportDataRequestDataStore;
+    static storeWithMultipartData(data: Map<string, any>): PCExportDataRequestDataStore;
+    constructor(mode: PCExportDataRequestDataStoreMode);
+    /** Plain data. Note that if data was created using "multipart" mode, exception will be thrown */
+    plainData(): any;
+    /** Multipart data. Note that is data was created using "plain" mode, this will still work. Use .plainDataKey property to access the stored data in that case */
+    multipartData(): Map<string, any>;
+}

package/build/typings/core/src/engine/generation/requests/ExportDataRequestNameStore.d.ts

@@ -0,0 +1,22 @@
+export declare enum PCExportDataRequestNameStoreMode {
+    plain = 0,
+    multipart = 1,
+    resolved = 2
+}
+export declare class PCExportDataRequestNameStore {
+    plainDataKey: string;
+    resolvedDataKey: string;
+    nameStore: Map<string, Map<string, any>>;
+    mode: PCExportDataRequestNameStoreMode;
+    constructor(mode: PCExportDataRequestNameStoreMode);
+    static storeWithResolvedName(name: string): PCExportDataRequestNameStore;
+    static storeWithPlainData(data: Map<string, any>): PCExportDataRequestNameStore;
+    static storeWithMultipartData(data: Map<string, any>): PCExportDataRequestNameStore;
+    plainData(): Map<string, any>;
+    multipartData(): Map<string, Map<string, any>>;
+    resolvedData(): string;
+    checkInCorrectMode(mode: PCExportDataRequestNameStoreMode): boolean;
+    isPlain(): boolean;
+    isMultipart(): boolean;
+    isResolved(): boolean;
+}

package/build/typings/core/src/engine/generation/requests/ExportDataRequestProducer.d.ts

@@ -0,0 +1,16 @@
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+import { PCExportDataRequest } from "./ExportDataRequest";
+import { PCExporterSource } from "../../../model/sources/ExporterSource";
+import { PCExporterMapBlueprint } from "../../../model/maps/ExporterMapBlueprint";
+export declare class PCExportDataRequestProducer {
+    configuration: PCExportConfiguration;
+    constructor(exportConfiguration: PCExportConfiguration);
+    produceRequestsForMap(map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    createExporterEntryDSMDataRequest(source: PCExporterSource, map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    createExporterEntryRequestsForDSMGenericOption(source: PCExporterSource, map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    createExporterEntryRequestsForDSMComponentOption(source: PCExporterSource, map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    createExporterEntryRequestsForDSMComponentGroupOption(source: PCExporterSource, map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    createExporterEntryRequestsForDSMTokenGroupOption(source: PCExporterSource, map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    createExporterEntryRequestsForDSMThemeOption(source: PCExporterSource, map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    createExporterEntryRequestsForDSMTokenTypeOption(source: PCExporterSource, map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+}

package/build/typings/core/src/engine/generation/requests/ExportDataResponse.d.ts

@@ -0,0 +1,13 @@
+import { PCExportDataRequest } from "./ExportDataRequest";
+import { PCExporterMapBlueprint } from "../../../model/maps/ExporterMapBlueprint";
+import { PCExportDataRequestDataStore } from "./ExportDataRequestDataStore";
+import { PCExportDataRequestNameStore } from "./ExportDataRequestNameStore";
+import { PLEmittedContent } from "../../../../../language/src/index";
+export declare class PCExportDataResponse {
+    dataStore: PCExportDataRequestDataStore;
+    nameStore: PCExportDataRequestNameStore;
+    emittedContent: Array<PLEmittedContent>;
+    map: PCExporterMapBlueprint;
+    request: PCExportDataRequest;
+    constructor(request: PCExportDataRequest, map: PCExporterMapBlueprint, dataStore: PCExportDataRequestDataStore, nameStore: PCExportDataRequestNameStore, emittedContent: Array<PLEmittedContent>);
+}

package/build/typings/core/src/engine/generation/requests/specific/dsm/ExportDataRequestBlueprint.d.ts

@@ -0,0 +1,14 @@
+import { PCExportConfiguration } from "../../../../configuration/ExportConfiguration";
+import { PCExporterMapBlueprint } from "../../../../../model/maps/ExporterMapBlueprint";
+import { PCExporterSource } from "../../../../../model/sources/ExporterSource";
+import { PLEmittedContent, PLExecutionContext } from "../../../../../../../language/src/index";
+import { PCExportDataRequest } from "../../ExportDataRequest";
+export declare class PCExportDataRequestBlueprint extends PCExportDataRequest {
+    executionContext: PLExecutionContext;
+    constructor(configuration: PCExportConfiguration, map: PCExporterMapBlueprint, executionContext: PLExecutionContext);
+    processBlueprintData(source: PCExporterSource, context: Map<string, any>, name: string | null): Promise<{
+        data: any;
+        emittedContext: Array<PLEmittedContent>;
+    }>;
+    logBlueprintProcessingFailure(error: Error, source: PCExporterSource, name: string | null): void;
+}

package/build/typings/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMComponent.d.ts

@@ -0,0 +1,13 @@
+import { PCExportConfiguration } from "../../../../configuration/ExportConfiguration";
+import { DSMReferenceStoreEntry } from "../../../../../model/dsm/DSMReferenceStore";
+import { PCExporterMapBlueprint } from "../../../../../model/maps/ExporterMapBlueprint";
+import { PCExporterSource } from "../../../../../model/sources/ExporterSource";
+import { PLExecutionContext } from "../../../../../../../language/src/index";
+import { PCExportDataRequest } from "../../ExportDataRequest";
+import { PCExportDataRequestBlueprint } from "./ExportDataRequestBlueprint";
+export declare class PCExportDataRequestDSMComponent extends PCExportDataRequestBlueprint {
+    source: PCExporterSource;
+    entry: DSMReferenceStoreEntry;
+    constructor(entry: DSMReferenceStoreEntry, source: PCExporterSource, map: PCExporterMapBlueprint, configuration: PCExportConfiguration, executionContext: PLExecutionContext);
+    produceData(): Promise<PCExportDataRequest>;
+}

package/build/typings/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMComponentGroup.d.ts

@@ -0,0 +1,13 @@
+import { PCExportConfiguration } from "../../../../configuration/ExportConfiguration";
+import { DSMReferenceStoreEntry } from "../../../../../model/dsm/DSMReferenceStore";
+import { PCExporterMapBlueprint } from "../../../../../model/maps/ExporterMapBlueprint";
+import { PCExporterSource } from "../../../../../model/sources/ExporterSource";
+import { PLExecutionContext } from "../../../../../../../language/src/index";
+import { PCExportDataRequest } from "../../ExportDataRequest";
+import { PCExportDataRequestBlueprint } from "./ExportDataRequestBlueprint";
+export declare class PCExportDataRequestDSMComponentGroup extends PCExportDataRequestBlueprint {
+    source: PCExporterSource;
+    entry: DSMReferenceStoreEntry;
+    constructor(entry: DSMReferenceStoreEntry, source: PCExporterSource, map: PCExporterMapBlueprint, configuration: PCExportConfiguration, executionContext: PLExecutionContext);
+    produceData(): Promise<PCExportDataRequest>;
+}

package/build/typings/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMGeneric.d.ts

@@ -0,0 +1,11 @@
+import { PCExportConfiguration } from "../../../../configuration/ExportConfiguration";
+import { PCExporterMapBlueprint } from "../../../../../model/maps/ExporterMapBlueprint";
+import { PCExporterSource } from "../../../../../model/sources/ExporterSource";
+import { PLExecutionContext } from "../../../../../../../language/src/index";
+import { PCExportDataRequest } from "../../ExportDataRequest";
+import { PCExportDataRequestBlueprint } from "./ExportDataRequestBlueprint";
+export declare class PCExportDataRequestDSMGeneric extends PCExportDataRequestBlueprint {
+    source: PCExporterSource;
+    constructor(source: PCExporterSource, map: PCExporterMapBlueprint, configuration: PCExportConfiguration, executionContext: PLExecutionContext);
+    produceData(): Promise<PCExportDataRequest>;
+}

package/build/typings/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMTheme.d.ts

@@ -0,0 +1,13 @@
+import { PCExportConfiguration } from "../../../../configuration/ExportConfiguration";
+import { DSMReferenceStoreEntry } from "../../../../../model/dsm/DSMReferenceStore";
+import { PCExporterMapBlueprint } from "../../../../../model/maps/ExporterMapBlueprint";
+import { PCExporterSource } from "../../../../../model/sources/ExporterSource";
+import { PLExecutionContext } from "../../../../../../../language/src/index";
+import { PCExportDataRequest } from "../../ExportDataRequest";
+import { PCExportDataRequestBlueprint } from "./ExportDataRequestBlueprint";
+export declare class PCExportDataRequestDSMTheme extends PCExportDataRequestBlueprint {
+    source: PCExporterSource;
+    entry: DSMReferenceStoreEntry;
+    constructor(entry: DSMReferenceStoreEntry, source: PCExporterSource, map: PCExporterMapBlueprint, configuration: PCExportConfiguration, executionContext: PLExecutionContext);
+    produceData(): Promise<PCExportDataRequest>;
+}

package/build/typings/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMTokenGroup.d.ts

@@ -0,0 +1,13 @@
+import { PCExportConfiguration } from "../../../../configuration/ExportConfiguration";
+import { DSMReferenceStoreEntry } from "../../../../../model/dsm/DSMReferenceStore";
+import { PCExporterMapBlueprint } from "../../../../../model/maps/ExporterMapBlueprint";
+import { PCExporterSource } from "../../../../../model/sources/ExporterSource";
+import { PLExecutionContext } from "../../../../../../../language/src/index";
+import { PCExportDataRequest } from "../../ExportDataRequest";
+import { PCExportDataRequestBlueprint } from "./ExportDataRequestBlueprint";
+export declare class PCExportDataRequestDSMTokenGroup extends PCExportDataRequestBlueprint {
+    source: PCExporterSource;
+    entry: DSMReferenceStoreEntry;
+    constructor(entry: DSMReferenceStoreEntry, source: PCExporterSource, map: PCExporterMapBlueprint, configuration: PCExportConfiguration, executionContext: PLExecutionContext);
+    produceData(): Promise<PCExportDataRequest>;
+}

package/build/typings/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMTokenType.d.ts

@@ -0,0 +1,13 @@
+import { PCExportConfiguration } from "../../../../configuration/ExportConfiguration";
+import { DSMReferenceStoreEntry } from "../../../../../model/dsm/DSMReferenceStore";
+import { PCExporterMapBlueprint } from "../../../../../model/maps/ExporterMapBlueprint";
+import { PCExporterSource } from "../../../../../model/sources/ExporterSource";
+import { PLExecutionContext } from "../../../../../../../language/src/index";
+import { PCExportDataRequest } from "../../ExportDataRequest";
+import { PCExportDataRequestBlueprint } from "./ExportDataRequestBlueprint";
+export declare class PCExportDataRequestDSMTokenType extends PCExportDataRequestBlueprint {
+    source: PCExporterSource;
+    entry: DSMReferenceStoreEntry;
+    constructor(entry: DSMReferenceStoreEntry, source: PCExporterSource, map: PCExporterMapBlueprint, configuration: PCExportConfiguration, executionContext: PLExecutionContext);
+    produceData(): Promise<PCExportDataRequest>;
+}

package/build/typings/core/src/engine/items/ExportItemProducer.d.ts

@@ -0,0 +1,14 @@
+import { PCExportItemQueue } from "./queue/ExportItemQueue";
+import { PCExportConfiguration } from "../configuration/ExportConfiguration";
+import { PCExportDataResponse } from "../generation/requests/ExportDataResponse";
+import { PCExportItemRequest } from "./requests/ExportItemRequest";
+import { PCExportItemResponse } from "./requests/ExportItemResponse";
+export declare class PCExportItemProducer {
+    configuration: PCExportConfiguration;
+    processingQueue: PCExportItemQueue;
+    constructor(exportConfiguration: PCExportConfiguration);
+    validateCanProduceItems(): Promise<void>;
+    produceItemsFromResponses(responses: Array<PCExportDataResponse>): Promise<Array<PCExportItemResponse>>;
+    generateRequestsForDataResponse(dataResponse: PCExportDataResponse): Array<PCExportItemRequest>;
+    generateResponsesFromFinishedRequests(finishedRequests: Array<PCExportItemRequest>): Array<PCExportItemResponse>;
+}

package/build/typings/core/src/engine/items/construction/ExportItem.d.ts

@@ -0,0 +1,8 @@
+import { PCExporterMapBlueprint } from "../../../model/maps/ExporterMapBlueprint";
+export declare class PCExportItem {
+    map: PCExporterMapBlueprint;
+    contentData: any;
+    nameData: Map<string, any>;
+    resolvedName: string | null;
+    constructor(map: PCExporterMapBlueprint, contentData: any, nameData: Map<string, any>, resolvedName: string | null);
+}

package/build/typings/core/src/engine/items/construction/ExportItemBuilder.d.ts

@@ -0,0 +1,9 @@
+import { PCExportDataResponse } from "../../generation/requests/ExportDataResponse";
+import { PCExportItem } from "./ExportItem";
+import { PCExportDataRequest } from "../../generation/requests/ExportDataRequest";
+export declare class PCExportItemBuilder {
+    constructor();
+    buildItemsUsingResponse(response: PCExportDataResponse): Array<PCExportItem>;
+    buildBlueprintItemsUsingRequest(_request: PCExportDataRequest, response: PCExportDataResponse): Array<PCExportItem>;
+    buildAssetItemsUsingRequest(_request: PCExportDataRequest, _response: PCExportDataResponse): Array<PCExportItem>;
+}

package/build/typings/core/src/engine/items/queue/ExportItemQueue.d.ts

@@ -0,0 +1,16 @@
+import { PCExportItemRequest } from "../requests/ExportItemRequest";
+import { PCExportItemQueueOperation } from "./ExportItemQueueOperation";
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+export declare class PCExportItemQueue {
+    configuration: PCExportConfiguration;
+    waitingOperations: Array<PCExportItemQueueOperation>;
+    isLockedForChanges: boolean;
+    isFinished: boolean;
+    requests: Array<PCExportItemRequest>;
+    requestsCompleted: number;
+    constructor(configuration: PCExportConfiguration);
+    addQueuedRequest(request: PCExportItemRequest): void;
+    addQueuedRequests(requests: Array<PCExportItemRequest>): void;
+    clearQueue(): void;
+    processQueue(): Promise<Array<PCExportItemRequest>>;
+}

package/build/typings/core/src/engine/items/queue/ExportItemQueueOperation.d.ts

@@ -0,0 +1,6 @@
+import { PCExportItemRequest } from "../requests/ExportItemRequest";
+export declare class PCExportItemQueueOperation {
+    request: PCExportItemRequest;
+    constructor(request: PCExportItemRequest);
+    processOperation(): Promise<PCExportItemRequest>;
+}

package/build/typings/core/src/engine/items/requests/ExportItemRequest.d.ts

@@ -0,0 +1,16 @@
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+import { PCExportDataResponse } from "../../generation/requests/ExportDataResponse";
+import { PCExportItem } from "../construction/ExportItem";
+export declare class PCExportItemRequest {
+    items: Array<PCExportItem> | null;
+    error: Error | null;
+    dataResponse: PCExportDataResponse;
+    configuration: PCExportConfiguration;
+    processingError: Error | null;
+    processingFinished: boolean;
+    constructor(configuration: PCExportConfiguration, dataResponse: PCExportDataResponse);
+    produceItem(): Promise<Array<PCExportItem>>;
+    cancel(): void;
+    requestSuccessful(items: Array<PCExportItem>): void;
+    requestFailed(error: Error): void;
+}

package/build/typings/core/src/engine/items/requests/ExportItemRequestProducer.d.ts

@@ -0,0 +1,8 @@
+import { PCExportDataResponse } from "../../generation/requests/ExportDataResponse";
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+import { PCExportItemRequest } from "./ExportItemRequest";
+export declare class PCExportItemRequestProducer {
+    configuration: PCExportConfiguration;
+    constructor(exportConfiguration: PCExportConfiguration);
+    produceRequestsForDataResponse(dataResponse: PCExportDataResponse): Array<PCExportItemRequest>;
+}

package/build/typings/core/src/engine/items/requests/ExportItemResponse.d.ts

@@ -0,0 +1,9 @@
+import { PCExporterMapBlueprint } from "../../../model/maps/ExporterMapBlueprint";
+import { PCExportItem } from "../construction/ExportItem";
+import { PCExportItemRequest } from "./ExportItemRequest";
+export declare class PCExportItemResponse {
+    item: PCExportItem;
+    map: PCExporterMapBlueprint;
+    request: PCExportItemRequest;
+    constructor(item: PCExportItem, map: PCExporterMapBlueprint, request: PCExportItemRequest);
+}

package/build/typings/core/src/engine/items/requests/ExportItemResponseProducer.d.ts

@@ -0,0 +1,7 @@
+import { PCExportItemRequest } from "./ExportItemRequest";
+import { PCExportItemResponse } from "./ExportItemResponse";
+export declare class PCExportItemResponseProducer {
+    constructor();
+    produceResponsesFromRequests(requests: Array<PCExportItemRequest>): Array<PCExportItemResponse>;
+    produceResponseFromRequest(request: PCExportItemRequest): Array<PCExportItemResponse>;
+}

package/build/typings/core/src/engine/loaders/BlueprintLoader.d.ts

@@ -0,0 +1,9 @@
+import { PCExporter } from "../../model/exporters/Exporter";
+import { PLBlueprint, PLBlueprintConfiguration, PLExecutionContext } from "../../../../language/src/index";
+import { PLBlueprintLoader } from "../../../../language/src/interpreter/loaders/BlueprintLoader";
+export declare class PCBlueprintLoader extends PLBlueprintLoader {
+    exporter: PCExporter;
+    constructor(exporter: PCExporter);
+    loadBlueprint(blueprintId: string, executionContext: PLExecutionContext, configuration: PLBlueprintConfiguration): PLBlueprint;
+    loadSourceForSourceId(sourceId: string, executionContext: PLExecutionContext, configuration: PLBlueprintConfiguration): PLBlueprint;
+}

package/build/typings/core/src/engine/writing/queue/ExportWriterQueue.d.ts

@@ -0,0 +1,16 @@
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+import { PCExportWriterQueueOperation } from "./ExportWriterQueueOperation";
+import { PCExportWriterRequest } from "../requests/ExportWriterRequest";
+export declare class PCExportWriterQueue {
+    configuration: PCExportConfiguration;
+    waitingOperations: Array<PCExportWriterQueueOperation>;
+    isLockedForChanges: boolean;
+    isFinished: boolean;
+    requests: Array<PCExportWriterRequest>;
+    requestsCompleted: number;
+    constructor(configuration: PCExportConfiguration);
+    addQueuedRequest(request: PCExportWriterRequest): void;
+    addQueuedRequests(requests: Array<PCExportWriterRequest>): void;
+    clearQueue(): void;
+    processQueue(): Promise<Array<PCExportWriterRequest>>;
+}

package/build/typings/core/src/engine/writing/queue/ExportWriterQueueOperation.d.ts

@@ -0,0 +1,6 @@
+import { PCExportWriterRequest } from "../requests/ExportWriterRequest";
+export declare class PCExportWriterQueueOperation {
+    request: PCExportWriterRequest;
+    constructor(request: PCExportWriterRequest);
+    processOperation(): Promise<PCExportWriterRequest>;
+}

package/build/typings/core/src/engine/writing/requests/ExportWriterRequest.d.ts

@@ -0,0 +1,14 @@
+import { PCExporterMapBlueprint } from "../../../model/maps/ExporterMapBlueprint";
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+import { PCExportItem } from "../../items/construction/ExportItem";
+export declare class PCExportWriterRequest {
+    item: PCExportItem;
+    map: PCExporterMapBlueprint;
+    configuration: PCExportConfiguration;
+    processingError: Error | null;
+    processingFinished: boolean;
+    constructor(configuration: PCExportConfiguration, item: PCExportItem, map: PCExporterMapBlueprint);
+    writeItem(): Promise<PCExportItem>;
+    requestSuccesful(_: PCExportItem): void;
+    requestFailed(error: Error): void;
+}

package/build/typings/core/src/engine/writing/requests/ExportWriterRequestProducer.d.ts

@@ -0,0 +1,8 @@
+import { PCExportWriterRequest } from "./ExportWriterRequest";
+import { PCExportItemResponse } from "../../items/requests/ExportItemResponse";
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+export declare class PCExportWriterRequestProducer {
+    configuration: PCExportConfiguration;
+    constructor(configuration: PCExportConfiguration);
+    produceRequestsForItemResponse(response: PCExportItemResponse): Array<PCExportWriterRequest>;
+}

package/build/typings/core/src/engine/writing/requests/ExportWriterResponse.d.ts

@@ -0,0 +1,9 @@
+import { PCExportWriterRequest } from "./ExportWriterRequest";
+import { PCExporterMapBlueprint } from "../../../model/maps/ExporterMapBlueprint";
+import { PCExportItem } from "../../items/construction/ExportItem";
+export declare class PCExportWriterResponse {
+    item: PCExportItem;
+    map: PCExporterMapBlueprint;
+    request: PCExportWriterRequest;
+    constructor(request: PCExportWriterRequest, map: PCExporterMapBlueprint, item: PCExportItem);
+}

package/build/typings/core/src/engine/writing/requests/ExportWriterResponseProducer.d.ts

@@ -0,0 +1,7 @@
+import { PCExportWriterResponse } from "./ExportWriterResponse";
+import { PCExportWriterRequest } from "./ExportWriterRequest";
+export declare class PCExportWriterResponseProducer {
+    constructor();
+    produceResponsesFromRequests(requests: Array<PCExportWriterRequest>): Array<PCExportWriterResponse>;
+    produceResponseFromRequest(request: PCExportWriterRequest): PCExportWriterResponse;
+}

package/build/typings/core/src/engine/writing/writers/ExportItemWriter.d.ts

@@ -0,0 +1,14 @@
+import { PCExportWriterRequest } from "../requests/ExportWriterRequest";
+import { PCExportWriterResponse } from "../requests/ExportWriterResponse";
+import { PCExportItemResponse } from "../../items/requests/ExportItemResponse";
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+import { PCExportWriterQueue } from "../queue/ExportWriterQueue";
+export declare class PCExportItemWriter {
+    configuration: PCExportConfiguration;
+    processingQueue: PCExportWriterQueue;
+    constructor(exportConfiguration: PCExportConfiguration);
+    validateCanWriteItems(): Promise<void>;
+    write(itemResponses: Array<PCExportItemResponse>): Promise<Array<PCExportWriterResponse>>;
+    generateRequestsForItemResponse(itemResponse: PCExportItemResponse): Array<PCExportWriterRequest>;
+    generateResponsesFromFinishedRequests(finishedRequests: Array<PCExportWriterRequest>): Array<PCExportWriterResponse>;
+}

package/build/typings/core/src/engine/writing/writers/ExportWriterRuleProcessor.d.ts

@@ -0,0 +1,9 @@
+import { PLInterpreterContext } from "../../../../../language/src/index";
+import { PCExportConfiguration } from "../../configuration/ExportConfiguration";
+export declare class PCExportWriterRuleProcessor {
+    configuration: PCExportConfiguration;
+    constructor(configuration: PCExportConfiguration);
+    resolveDestinationURL(dynamicRule: string, data: Map<string, any>, root: string | null): Promise<string>;
+    resolvedDestinationURL(staticRule: string, root: string | null): string;
+    interpreterContext(data: Map<string, any>): PLInterpreterContext;
+}

package/build/typings/core/src/engine/writing/writers/memory/ExportWriterMemory.d.ts

@@ -0,0 +1,4 @@
+import { PCExportItemWriter } from "../ExportItemWriter";
+export declare class PCExportWriterFileSystem extends PCExportItemWriter {
+    validateCanWriteItems(): Promise<void>;
+}

package/build/typings/core/src/engine/writing/writers/memory/ExportWriterMemoryRequest.d.ts

@@ -0,0 +1,5 @@
+import { PCExportWriterRequest } from "../../requests/ExportWriterRequest";
+import { PCExportItem } from "../../../items/construction/ExportItem";
+export declare class PCExportWriterMemoryRequest extends PCExportWriterRequest {
+    writeItem(): Promise<PCExportItem>;
+}

package/build/typings/core/src/engine/writing/writers/memory/ExportWriterStore.d.ts

@@ -0,0 +1,5 @@
+export declare class PCExportWriterMemoryStore {
+    dataStore: Map<string, any>;
+    constructor();
+    storeItem(item: any, path: string): void;
+}

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

@@ -0,0 +1,8 @@
+export { PCPulsar, PCPulsarExporterMode } from "./pulsar/Pulsar";
+export { PCPulsarStaticAnalysis } from "./pulsar/PulsarStaticAnalysis";
+export { DSMReferenceStore } from "./model/dsm/DSMReferenceStore";
+export * from "./pulsar/PulsarInterface";
+export { PCPulsarZIPGenerator } from "./pulsar/managers/generators/PulsarExporterZIPGenerator";
+export { PCPulsarExporterJSONGenerator } from "./pulsar/managers/generators/PulsarExporterJSONGenerator";
+export * from "./pulsar/PulsarInterface";
+export { PLLogger, PLLog, PLLogType } from "../../language/src/interpreter/loggers/Logger";

package/build/typings/core/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./exports";

package/build/typings/core/src/model/dsm/DSMReferenceStore.d.ts

@@ -0,0 +1,28 @@
+export declare type DSMReferenceStoreEntry = {
+    id: string;
+    name: string;
+};
+export declare type DSMReferenceStoreModel = {
+    components: Array<DSMReferenceStoreEntry>;
+    componentGroups: Array<DSMReferenceStoreEntry>;
+    tokenGroups: Array<DSMReferenceStoreEntry>;
+    tokenTypes: Array<DSMReferenceStoreEntry>;
+    themes: Array<DSMReferenceStoreEntry>;
+};
+export declare class DSMReferenceStore {
+    components: Array<DSMReferenceStoreEntry>;
+    componentGroups: Array<DSMReferenceStoreEntry>;
+    tokenGroups: Array<DSMReferenceStoreEntry>;
+    tokenTypes: Array<DSMReferenceStoreEntry>;
+    themes: Array<DSMReferenceStoreEntry>;
+    contexts: Array<DSMReferenceStoreEntry>;
+    constructor(data: DSMReferenceStoreModel);
+    emptyState(): DSMReferenceStoreEntry;
+    executableComponentGroups(): Array<DSMReferenceStoreEntry>;
+    executableComponents(): Array<DSMReferenceStoreEntry>;
+    executableTokenGroups(): Array<DSMReferenceStoreEntry>;
+    executableTokenTypes(): Array<DSMReferenceStoreEntry>;
+    executableThemes(): Array<DSMReferenceStoreEntry>;
+    private retrieveFixingEmptyState;
+    private arrayIsEmptyState;
+}