@supernova-studio/pulsar-core 2.2.6 → 2.3.0

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

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

package/build/main/core/src/engine/ExportEngineLegacy.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 PCExportEngineLegacy {
+    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/main/core/src/engine/ExportEngineNew.d.ts

@@ -0,0 +1,12 @@
+import { PCExportConfiguration } from './configuration/ExportConfiguration';
+import { PCExportWriterMemoryStore } from './writing/writers/memory/ExportWriterStore';
+import { AnyOutputFile } from '@supernovaio/sdk';
+export declare class PCExportEngineNew {
+    configuration: PCExportConfiguration;
+    runId: string;
+    constructor(configuration: PCExportConfiguration);
+    processExportValidate(): Promise<boolean>;
+    processExport(): Promise<PCExportWriterMemoryStore>;
+    processExportValidated(): Promise<Array<AnyOutputFile>>;
+    convertFilesToStore(files: Array<AnyOutputFile>): void;
+}

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

@@ -0,0 +1,24 @@
+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 { DSMBridge, DSMBridgeConfiguration, DSMExecutionContext, PLBlueprintFactory, PLDebugger } from '@supernova-studio/pulsar-language';
+import { PCPulsarExporterMode } from '../../pulsar/Pulsar';
+import { PCExporterSource } from '../../model/sources/ExporterSource';
+export declare class PCExportConfiguration {
+    exporter: PCExporter;
+    exportMode: PCPulsarExporterMode;
+    logger: PCLogger;
+    debugger: PLDebugger;
+    dsmStore: DSMReferenceStore;
+    dsmBridgeConfig: DSMBridgeConfiguration;
+    dsmBridge: DSMBridge;
+    outputStore: PCExportWriterMemoryStore;
+    outputPathPrefix: string;
+    blueprintFactory: PLBlueprintFactory;
+    sandboxData: Object;
+    debugMode: boolean;
+    constructor(exporter: PCExporter, logger: PCLogger, dsmStore: DSMReferenceStore, dsmBridgeConfig: DSMBridgeConfiguration, exportMode: PCPulsarExporterMode, sandboxData: Object, debugEnabled: boolean, legacy: boolean);
+    preloadSources(sources: Array<PCExporterSource>, factory: PLBlueprintFactory): PLDebugger;
+    newExecutionContext(metadata: object | null, systemData: object): DSMExecutionContext;
+}

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

@@ -0,0 +1,20 @@
+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';
+import { PCExporterMapAsset } from '../../model/maps/ExporterMapAsset';
+import { PCExporterMapBundledResource } from '../../model/maps/ExporterMapBundledResource';
+export declare class PCExportDataProducer {
+    configuration: PCExportConfiguration;
+    processingQueue: PCExportDataQueue;
+    constructor(exportConfiguration: PCExportConfiguration);
+    validateCanProduceData(): Promise<void>;
+    produceData(): Promise<Array<PCExportDataResponse>>;
+    private validateOutputProcessingCondition;
+    generateRequestsForBlueprintMap(map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    generateRequestsForBundledResourceMap(map: PCExporterMapBundledResource): Array<PCExportDataRequest>;
+    generateRequestsForAssetMap(map: PCExporterMapAsset): Array<PCExportDataRequest>;
+    generatePrimaryResponsesFromFinishedRequests(requests: Array<PCExportDataRequest>): Array<PCExportDataResponse>;
+    generateEmittedResponsesFromFinishedRequests(requests: Array<PCExportDataRequest>): Array<PCExportDataResponse>;
+}

package/build/main/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/main/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/main/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/main/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/main/core/src/engine/generation/requests/ExportDataRequest.d.ts

@@ -0,0 +1,21 @@
+import { PCExportConfiguration } from '../../configuration/ExportConfiguration';
+import { PCExporterMapBlueprint } from './../../../model/maps/ExporterMapBlueprint';
+import { PCExportDataRequestDataStore } from './ExportDataRequestDataStore';
+import { PCExportDataRequestNameStore } from './ExportDataRequestNameStore';
+import { PCExporterMapAsset } from '../../../model/maps/ExporterMapAsset';
+import { PCExporterMapBundledResource } from '../../../model/maps/ExporterMapBundledResource';
+import { PLEmittedContent } from '@supernova-studio/pulsar-language';
+export declare class PCExportDataRequest {
+    dataStore: PCExportDataRequestDataStore | null;
+    nameStore: PCExportDataRequestNameStore | null;
+    emittedContent: Array<PLEmittedContent> | null;
+    map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset;
+    configuration: PCExportConfiguration;
+    processingError: Error | null;
+    processingFinished: boolean;
+    constructor(configuration: PCExportConfiguration, map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset);
+    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/main/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/main/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/main/core/src/engine/generation/requests/ExportDataRequestProducer.d.ts

@@ -0,0 +1,23 @@
+import { PCExportConfiguration } from '../../configuration/ExportConfiguration';
+import { PCExportDataRequest } from './ExportDataRequest';
+import { PCExporterSource } from '../../../model/sources/ExporterSource';
+import { PCExporterMapBlueprint } from '../../../model/maps/ExporterMapBlueprint';
+import { PCExporterMapAsset } from '../../../model/maps/ExporterMapAsset';
+import { PCExporterMapBundledResource } from '../../../model/maps/ExporterMapBundledResource';
+export declare class PCExportDataRequestProducer {
+    configuration: PCExportConfiguration;
+    constructor(exportConfiguration: PCExportConfiguration);
+    produceRequestsForBlueprintMap(map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    produceRequestsForBundledResourceMap(map: PCExporterMapBundledResource): Array<PCExportDataRequest>;
+    produceRequestsForAssetMap(map: PCExporterMapAsset): 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>;
+    createExporterEntryRequestsForDSMDocumentationPageOption(source: PCExporterSource, map: PCExporterMapBlueprint): Array<PCExportDataRequest>;
+    createExporterEntryRequestsForBundledResource(map: PCExporterMapBundledResource): Array<PCExportDataRequest>;
+    createExporterEntryRequestsForAsset(map: PCExporterMapAsset): Array<PCExportDataRequest>;
+}

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

@@ -0,0 +1,15 @@
+import { PCExportDataRequest } from './ExportDataRequest';
+import { PCExporterMapBlueprint } from './../../../model/maps/ExporterMapBlueprint';
+import { PCExportDataRequestDataStore } from './ExportDataRequestDataStore';
+import { PCExportDataRequestNameStore } from './ExportDataRequestNameStore';
+import { PLEmittedContent } from '@supernova-studio/pulsar-language';
+import { PCExporterMapAsset } from '../../../model/maps/ExporterMapAsset';
+import { PCExporterMapBundledResource } from '../../../model/maps/ExporterMapBundledResource';
+export declare class PCExportDataResponse {
+    dataStore: PCExportDataRequestDataStore;
+    nameStore: PCExportDataRequestNameStore;
+    emittedContent: Array<PLEmittedContent>;
+    map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset;
+    request: PCExportDataRequest;
+    constructor(request: PCExportDataRequest, map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset, dataStore: PCExportDataRequestDataStore, nameStore: PCExportDataRequestNameStore, emittedContent: Array<PLEmittedContent>);
+}

package/build/main/core/src/engine/generation/requests/specific/dsm/ExportDataRequestAsset.d.ts

@@ -0,0 +1,15 @@
+import { PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { PCExportDataRequest } from '../../ExportDataRequest';
+import { AssetFormat } from '@supernovaio/supernova-sdk';
+import { AssetScale } from '@supernovaio/supernova-sdk';
+import { RenderedAsset } from '@supernovaio/supernova-sdk';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+import { PCExporterMapAsset, PCExporterMapAssetFormat, PCExporterMapAssetScale } from '../../../../../model/maps/ExporterMapAsset';
+export declare class PCExportDataRequestAsset extends PCExportDataRequest {
+    executionContext: PLExecutionContext;
+    constructor(configuration: PCExportConfiguration, map: PCExporterMapAsset, executionContext: PLExecutionContext);
+    produceData(): Promise<PCExportDataRequest>;
+    formatToSDKFormat(format: PCExporterMapAssetFormat): AssetFormat;
+    scaleToSDKScale(scale: PCExporterMapAssetScale): AssetScale;
+    processAssetData(resource: PCExporterMapAsset): Promise<Array<RenderedAsset>>;
+}

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

@@ -0,0 +1,17 @@
+import { PLEmittedContent, PLExecutionContext, PLLogger } from '@supernova-studio/pulsar-language';
+import { PCExportDataRequest } from '../../ExportDataRequest';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+import { PCExporterMapBlueprint } from '../../../../../model/maps/ExporterMapBlueprint';
+import { PCExporterSource } from '../../../../../model/sources/ExporterSource';
+export declare class PCExportDataRequestBlueprint extends PCExportDataRequest {
+    executionContext: PLExecutionContext;
+    constructor(configuration: PCExportConfiguration, map: PCExporterMapBlueprint, executionContext: PLExecutionContext);
+    processBlueprintData(source: PCExporterSource, context: Object, name: string | null): Promise<{
+        data: any;
+        emittedContext: Array<PLEmittedContent>;
+    }>;
+    formatTimings(timings: Map<string, number>): string;
+    ellipsis(str: string, num?: number, ellipsisStr?: string): string;
+    logUserData(logger: PLLogger, source: PCExporterSource, name: string | null): void;
+    logBlueprintProcessingFailure(logger: PLLogger, source: PCExporterSource, name: string | null): void;
+}

package/build/main/core/src/engine/generation/requests/specific/dsm/ExportDataRequestBundledResource.d.ts

@@ -0,0 +1,11 @@
+import { PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { PCExportDataRequest } from '../../ExportDataRequest';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+import { PCExporterMapBundledResource } from '../../../../../model/maps/ExporterMapBundledResource';
+export declare class PCExportDataRequestBundledResource extends PCExportDataRequest {
+    executionContext: PLExecutionContext;
+    constructor(configuration: PCExportConfiguration, map: PCExporterMapBundledResource, executionContext: PLExecutionContext);
+    produceData(): Promise<PCExportDataRequest>;
+    processBundledResourceData(resource: PCExporterMapBundledResource): Promise<Map<string, string>>;
+    private isDirectory;
+}

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

@@ -0,0 +1,13 @@
+import { PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { DSMReferenceStoreEntry } from '../../../../../model/dsm/DSMReferenceStore';
+import { PCExporterMapBlueprint } from '../../../../../model/maps/ExporterMapBlueprint';
+import { PCExporterSource } from '../../../../../model/sources/ExporterSource';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+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/main/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMComponentGroup.d.ts

@@ -0,0 +1,13 @@
+import { PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { DSMReferenceStoreEntry } from '../../../../../model/dsm/DSMReferenceStore';
+import { PCExporterMapBlueprint } from '../../../../../model/maps/ExporterMapBlueprint';
+import { PCExporterSource } from '../../../../../model/sources/ExporterSource';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+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/main/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMDocumentationPage.d.ts

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

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

@@ -0,0 +1,11 @@
+import { PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { PCExporterMapBlueprint } from '../../../../../model/maps/ExporterMapBlueprint';
+import { PCExporterSource } from '../../../../../model/sources/ExporterSource';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+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/main/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMTheme.d.ts

@@ -0,0 +1,13 @@
+import { PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { DSMReferenceStoreEntry } from '../../../../../model/dsm/DSMReferenceStore';
+import { PCExporterMapBlueprint } from '../../../../../model/maps/ExporterMapBlueprint';
+import { PCExporterSource } from '../../../../../model/sources/ExporterSource';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+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/main/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMTokenGroup.d.ts

@@ -0,0 +1,13 @@
+import { PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { DSMReferenceStoreEntry } from '../../../../../model/dsm/DSMReferenceStore';
+import { PCExporterMapBlueprint } from '../../../../../model/maps/ExporterMapBlueprint';
+import { PCExporterSource } from '../../../../../model/sources/ExporterSource';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+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/main/core/src/engine/generation/requests/specific/dsm/ExportDataRequestDSMTokenType.d.ts

@@ -0,0 +1,13 @@
+import { PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { DSMReferenceStoreEntry } from '../../../../../model/dsm/DSMReferenceStore';
+import { PCExporterMapBlueprint } from '../../../../../model/maps/ExporterMapBlueprint';
+import { PCExporterSource } from '../../../../../model/sources/ExporterSource';
+import { PCExportConfiguration } from '../../../../configuration/ExportConfiguration';
+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/main/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/main/core/src/engine/items/construction/ExportItem.d.ts

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

package/build/main/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/main/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/main/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/main/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/main/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/main/core/src/engine/items/requests/ExportItemResponse.d.ts

@@ -0,0 +1,11 @@
+import { PCExporterMapAsset } from '../../../model/maps/ExporterMapAsset';
+import { PCExporterMapBundledResource } from '../../../model/maps/ExporterMapBundledResource';
+import { PCExporterMapBlueprint } from './../../../model/maps/ExporterMapBlueprint';
+import { PCExportItem } from './../construction/ExportItem';
+import { PCExportItemRequest } from './ExportItemRequest';
+export declare class PCExportItemResponse {
+    item: PCExportItem;
+    map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset;
+    request: PCExportItemRequest;
+    constructor(item: PCExportItem, map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset, request: PCExportItemRequest);
+}

package/build/main/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/main/core/src/engine/jsruntime/JSExportContext.d.ts

@@ -0,0 +1,10 @@
+import { PCExportConfiguration } from '../configuration/ExportConfiguration';
+import { AnyOutputFile } from '@supernovaio/sdk';
+export declare class JSExportContext {
+    private exportFinished;
+    constructor();
+    /** Evaluate javascript string with Pulsar core enhancements. Javascript context is contained, sandboxed environment and only allows access to few specific objects on global scope */
+    executeJS(jsString: string, configuration: PCExportConfiguration, exportCallback: (files: Array<AnyOutputFile>) => void, exportErrorCallback: (error: Error) => void): Promise<void>;
+    /** Register core engine function that enhnances the core cpabilities of the language */
+    processExecutedFiles(files: any): void;
+}

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

@@ -0,0 +1,9 @@
+import { PLBlueprint, PLBlueprintConfiguration, PLExecutionContext } from '@supernova-studio/pulsar-language';
+import { PLBlueprintLoader } from '@supernova-studio/pulsar-language';
+import { PCExporter } from '../../model/exporters/Exporter';
+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/main/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/main/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/main/core/src/engine/writing/requests/ExportWriterRequest.d.ts

@@ -0,0 +1,16 @@
+import { PCExporterMapAsset } from '../../../model/maps/ExporterMapAsset';
+import { PCExporterMapBundledResource } from '../../../model/maps/ExporterMapBundledResource';
+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 | PCExporterMapBundledResource | PCExporterMapAsset;
+    configuration: PCExportConfiguration;
+    processingError: Error | null;
+    processingFinished: boolean;
+    constructor(configuration: PCExportConfiguration, item: PCExportItem, map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset);
+    writeItem(): Promise<PCExportItem>;
+    requestSuccesful(_: PCExportItem): void;
+    requestFailed(error: Error): void;
+}

package/build/main/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/main/core/src/engine/writing/requests/ExportWriterResponse.d.ts

@@ -0,0 +1,11 @@
+import { PCExportWriterRequest } from './ExportWriterRequest';
+import { PCExporterMapBlueprint } from './../../../model/maps/ExporterMapBlueprint';
+import { PCExportItem } from './../../items/construction/ExportItem';
+import { PCExporterMapAsset } from '../../../model/maps/ExporterMapAsset';
+import { PCExporterMapBundledResource } from '../../../model/maps/ExporterMapBundledResource';
+export declare class PCExportWriterResponse {
+    item: PCExportItem;
+    map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset;
+    request: PCExportWriterRequest;
+    constructor(request: PCExportWriterRequest, map: PCExporterMapBlueprint | PCExporterMapBundledResource | PCExporterMapAsset, item: PCExportItem);
+}

package/build/main/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;
+}