@devrev/ts-adaas 1.0.4 → 1.1.0

package/dist/types/extraction.d.ts

@@ -1,6 +1,7 @@
 import { InputData } from '@devrev/typescript-sdk/dist/snap-ins';
 import { Artifact } from '../uploader/uploader.interfaces';
 import { ErrorRecord } from './common';
+import { DonV2, LoaderReport } from './loading';
 /**
  * EventType is an enum that defines the different types of events that can be sent to the external extractor from ADaaS.
  * The external extractor can use these events to know what to do next in the extraction process.
@@ -13,7 +14,11 @@ export declare enum EventType {
     ExtractionDataDelete = "EXTRACTION_DATA_DELETE",
     ExtractionAttachmentsStart = "EXTRACTION_ATTACHMENTS_START",
     ExtractionAttachmentsContinue = "EXTRACTION_ATTACHMENTS_CONTINUE",
-    ExtractionAttachmentsDelete = "EXTRACTION_ATTACHMENTS_DELETE"
+    ExtractionAttachmentsDelete = "EXTRACTION_ATTACHMENTS_DELETE",
+    StartLoadingData = "START_LOADING_DATA",
+    ContinueLoadingData = "CONTINUE_LOADING_DATA",
+    StartDeletingLoaderState = "START_DELETING_LOADER_STATE",
+    StartDeletingLoaderAttachmentsState = "START_DELETING_LOADER_ATTACHMENTS_STATE"
 }
 /**
  * ExtractorEventType is an enum that defines the different types of events that can be sent from the external extractor to ADaaS.
@@ -35,9 +40,11 @@ export declare enum ExtractorEventType {
     ExtractionAttachmentsDone = "EXTRACTION_ATTACHMENTS_DONE",
     ExtractionAttachmentsError = "EXTRACTION_ATTACHMENTS_ERROR",
     ExtractionAttachmentsDeleteDone = "EXTRACTION_ATTACHMENTS_DELETE_DONE",
-    ExtractionAttachmentsDeleteError = "EXTRACTION_ATTACHMENTS_DELETE_ERROR"
+    ExtractionAttachmentsDeleteError = "EXTRACTION_ATTACHMENTS_DELETE_ERROR",
+    UnknownEventType = "UNKNOWN_EVENT_TYPE"
 }
 /**
+ * @deprecated
  * ExtractionMode is an enum that defines the different modes of extraction that can be used by the external extractor.
  * It can be either INITIAL or INCREMENTAL. INITIAL mode is used for the first/initial import, while INCREMENTAL mode is used for doing syncs.
  */
@@ -45,6 +52,15 @@ export declare enum ExtractionMode {
     INITIAL = "INITIAL",
     INCREMENTAL = "INCREMENTAL"
 }
+/**
+ * ExtractionMode is an enum that defines the different modes of extraction that can be used by the external extractor.
+ * It can be either INITIAL or INCREMENTAL. INITIAL mode is used for the first/initial import, while INCREMENTAL mode is used for doing syncs.
+ */
+export declare enum SyncMode {
+    INITIAL = "INITIAL",
+    INCREMENTAL = "INCREMENTAL",
+    LOADING = "LOADING"
+}
 /**
  * ExternalSyncUnit is an interface that defines the structure of an external sync unit (repos, projects, ...) that can be extracted.
  * It must contain an ID, a name, and a description. It can also contain the number of items in the external sync unit.
@@ -60,21 +76,27 @@ export interface ExternalSyncUnit {
  * EventContextIn is an interface that defines the structure of the input event context that is sent to the external extractor from ADaaS.
  */
 export interface EventContextIn {
-    mode: string;
     callback_url: string;
+    dev_org: string;
     dev_org_id: string;
+    dev_user: string;
     dev_user_id: string;
-    external_sync_unit_id?: string;
-    sync_unit_id?: string;
-    sync_run_id: string;
-    external_system_id: string;
-    uuid: string;
-    worker_data_url: string;
+    external_sync_unit: string;
+    external_sync_unit_id: string;
+    external_sync_unit_name: string;
     external_system: string;
     external_system_type: string;
     import_slug: string;
+    mode: string;
+    request_id: string;
     snap_in_slug: string;
+    sync_run: string;
+    sync_run_id: string;
     sync_tier: string;
+    sync_unit: DonV2;
+    sync_unit_id: string;
+    uuid: string;
+    worker_data_url: string;
 }
 /**
  * EventContextOut is an interface that defines the structure of the output event context that is sent from the external extractor to ADaaS.
@@ -106,6 +128,9 @@ export interface EventData {
      * @deprecated This field is deprecated and should not be used.
      */
     artifacts?: Artifact[];
+    reports?: LoaderReport[];
+    processed_files?: string[];
+    stats_file?: string;
 }
 /**
  * DomainObject is an interface that defines the structure of a domain object that can be extracted.
@@ -157,3 +182,11 @@ export interface ExtractorEvent {
     event_context: EventContextOut;
     event_data?: EventData;
 }
+/**
+ * LoaderEvent
+ */
+export interface LoaderEvent {
+    event_type: string;
+    event_context: EventContextOut;
+    event_data?: EventData;
+}

package/dist/types/extraction.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = void 0;
+exports.SyncMode = exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = void 0;
 /**
  * EventType is an enum that defines the different types of events that can be sent to the external extractor from ADaaS.
  * The external extractor can use these events to know what to do next in the extraction process.
  */
 var EventType;
 (function (EventType) {
+    // Extraction
     EventType["ExtractionExternalSyncUnitsStart"] = "EXTRACTION_EXTERNAL_SYNC_UNITS_START";
     EventType["ExtractionMetadataStart"] = "EXTRACTION_METADATA_START";
     EventType["ExtractionDataStart"] = "EXTRACTION_DATA_START";
@@ -15,6 +16,11 @@ var EventType;
     EventType["ExtractionAttachmentsStart"] = "EXTRACTION_ATTACHMENTS_START";
     EventType["ExtractionAttachmentsContinue"] = "EXTRACTION_ATTACHMENTS_CONTINUE";
     EventType["ExtractionAttachmentsDelete"] = "EXTRACTION_ATTACHMENTS_DELETE";
+    // Loading
+    EventType["StartLoadingData"] = "START_LOADING_DATA";
+    EventType["ContinueLoadingData"] = "CONTINUE_LOADING_DATA";
+    EventType["StartDeletingLoaderState"] = "START_DELETING_LOADER_STATE";
+    EventType["StartDeletingLoaderAttachmentsState"] = "START_DELETING_LOADER_ATTACHMENTS_STATE";
 })(EventType || (exports.EventType = EventType = {}));
 /**
  * ExtractorEventType is an enum that defines the different types of events that can be sent from the external extractor to ADaaS.
@@ -22,6 +28,7 @@ var EventType;
  */
 var ExtractorEventType;
 (function (ExtractorEventType) {
+    // Extraction
     ExtractorEventType["ExtractionExternalSyncUnitsDone"] = "EXTRACTION_EXTERNAL_SYNC_UNITS_DONE";
     ExtractorEventType["ExtractionExternalSyncUnitsError"] = "EXTRACTION_EXTERNAL_SYNC_UNITS_ERROR";
     ExtractorEventType["ExtractionMetadataDone"] = "EXTRACTION_METADATA_DONE";
@@ -38,8 +45,11 @@ var ExtractorEventType;
     ExtractorEventType["ExtractionAttachmentsError"] = "EXTRACTION_ATTACHMENTS_ERROR";
     ExtractorEventType["ExtractionAttachmentsDeleteDone"] = "EXTRACTION_ATTACHMENTS_DELETE_DONE";
     ExtractorEventType["ExtractionAttachmentsDeleteError"] = "EXTRACTION_ATTACHMENTS_DELETE_ERROR";
+    // Unknown
+    ExtractorEventType["UnknownEventType"] = "UNKNOWN_EVENT_TYPE";
 })(ExtractorEventType || (exports.ExtractorEventType = ExtractorEventType = {}));
 /**
+ * @deprecated
  * ExtractionMode is an enum that defines the different modes of extraction that can be used by the external extractor.
  * It can be either INITIAL or INCREMENTAL. INITIAL mode is used for the first/initial import, while INCREMENTAL mode is used for doing syncs.
  */
@@ -48,3 +58,13 @@ var ExtractionMode;
     ExtractionMode["INITIAL"] = "INITIAL";
     ExtractionMode["INCREMENTAL"] = "INCREMENTAL";
 })(ExtractionMode || (exports.ExtractionMode = ExtractionMode = {}));
+/**
+ * ExtractionMode is an enum that defines the different modes of extraction that can be used by the external extractor.
+ * It can be either INITIAL or INCREMENTAL. INITIAL mode is used for the first/initial import, while INCREMENTAL mode is used for doing syncs.
+ */
+var SyncMode;
+(function (SyncMode) {
+    SyncMode["INITIAL"] = "INITIAL";
+    SyncMode["INCREMENTAL"] = "INCREMENTAL";
+    SyncMode["LOADING"] = "LOADING";
+})(SyncMode || (exports.SyncMode = SyncMode = {}));

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export { ErrorLevel, ErrorRecord, LogRecord, AdapterUpdateParams, InitialDomainMapping, } from './common';
-export { EventType, ExtractorEventType, ExtractionMode, ExternalSyncUnit, EventContextIn, EventContextOut, ConnectionData, EventData, DomainObjectState, AirdropEvent, AirdropMessage, ExtractorEvent, } from './extraction';
+export { EventType, ExtractorEventType, ExtractionMode, ExternalSyncUnit, EventContextIn, EventContextOut, ConnectionData, EventData, DomainObjectState, AirdropEvent, AirdropMessage, ExtractorEvent, SyncMode, } from './extraction';
+export { LoaderEventType, ExternalSystemItem, ExternalSystemItemLoadingResponse, ExternalSystemItemLoadingParams, } from './loading';
 export { NormalizedItem, NormalizedAttachment, RepoInterface, } from '../repo/repo.interfaces';
 export { AdapterState } from '../state/state.interfaces';
 export { Artifact, ArtifactsPrepareResponse, UploadResponse, StreamResponse, StreamAttachmentsResponse, SsorAttachment, } from '../uploader/uploader.interfaces';

package/dist/types/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = exports.ErrorLevel = void 0;
+exports.LoaderEventType = exports.SyncMode = exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = exports.ErrorLevel = void 0;
 // Common
 var common_1 = require("./common");
 Object.defineProperty(exports, "ErrorLevel", { enumerable: true, get: function () { return common_1.ErrorLevel; } });
@@ -9,3 +9,7 @@ var extraction_1 = require("./extraction");
 Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return extraction_1.EventType; } });
 Object.defineProperty(exports, "ExtractorEventType", { enumerable: true, get: function () { return extraction_1.ExtractorEventType; } });
 Object.defineProperty(exports, "ExtractionMode", { enumerable: true, get: function () { return extraction_1.ExtractionMode; } });
+Object.defineProperty(exports, "SyncMode", { enumerable: true, get: function () { return extraction_1.SyncMode; } });
+// Loading
+var loading_1 = require("./loading");
+Object.defineProperty(exports, "LoaderEventType", { enumerable: true, get: function () { return loading_1.LoaderEventType; } });

package/dist/types/loading.d.ts

@@ -0,0 +1,95 @@
+import { AirdropEvent } from './extraction';
+import { Mappers } from '../mappers/mappers';
+import { ErrorRecord } from './common';
+export interface StatsFileObject {
+    id: string;
+    item_type: string;
+    file_name: string;
+    count: string;
+}
+export interface FileToLoad {
+    id: string;
+    file_name: string;
+    itemType: string;
+    count: number;
+    lineToProcess: number;
+    completed: boolean;
+}
+export interface ExternalSystemItem {
+    id: {
+        devrev: DonV2;
+        external?: string;
+    };
+    created_date: string;
+    modified_date: string;
+    data: any;
+}
+export interface ExternalSystemItemLoadingParams {
+    item: ExternalSystemItem;
+    mappers: Mappers;
+    event: AirdropEvent;
+}
+export interface ExternalSystemItemLoadingResponse {
+    id?: string;
+    error?: string;
+    modifiedDate?: string;
+    delay?: number;
+}
+export interface ExternalSystemItemLoadedItem {
+    id?: string;
+    error?: string;
+    modifiedDate?: string;
+}
+export type ExternalSystemLoadingFunction = ({ item, mappers, event, }: ExternalSystemItemLoadingParams) => Promise<ExternalSystemItemLoadingResponse>;
+export interface ItemTypeToLoad {
+    itemType: string;
+    create: ExternalSystemLoadingFunction;
+    update: ExternalSystemLoadingFunction;
+}
+export interface ItemTypesToLoadParams {
+    itemTypesToLoad: ItemTypeToLoad[];
+}
+export interface LoaderReport {
+    item_type: string;
+    [ActionType.CREATED]?: number;
+    [ActionType.UPDATED]?: number;
+    [ActionType.SKIPPED]?: number;
+    [ActionType.DELETED]?: number;
+    [ActionType.FAILED]?: number;
+}
+export interface RateLimited {
+    delay: number;
+}
+export interface LoadItemResponse {
+    error?: ErrorRecord;
+    report?: LoaderReport;
+    rateLimit?: RateLimited;
+}
+export interface LoadItemTypesResponse {
+    reports: LoaderReport[];
+    processed_files: string[];
+}
+export declare enum ActionType {
+    CREATED = "created",
+    UPDATED = "updated",
+    SKIPPED = "skipped",
+    DELETED = "deleted",
+    FAILED = "failed"
+}
+export type DonV2 = string;
+export type SyncMapperRecord = {
+    external_ids: string[];
+    secondary_ids: string[];
+    devrev_ids: string[];
+    status: string[];
+    input_file?: string;
+};
+export declare enum LoaderEventType {
+    DataLoadingProgress = "DATA_LOADING_PROGRESS",
+    DataLoadingDelay = "DATA_LOADING_DELAYED",
+    DataLoadingDone = "DATA_LOADING_DONE",
+    DataLoadingError = "DATA_LOADING_ERROR",
+    LoaderStateDeletionDone = "LOADER_STATE_DELETION_DONE",
+    LoaderStateDeletionError = "LOADER_STATE_DELETION_ERROR",
+    UnknownEventType = "UNKNOWN_EVENT_TYPE"
+}

package/dist/types/loading.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoaderEventType = exports.ActionType = void 0;
+var ActionType;
+(function (ActionType) {
+    ActionType["CREATED"] = "created";
+    ActionType["UPDATED"] = "updated";
+    ActionType["SKIPPED"] = "skipped";
+    ActionType["DELETED"] = "deleted";
+    ActionType["FAILED"] = "failed";
+})(ActionType || (exports.ActionType = ActionType = {}));
+var LoaderEventType;
+(function (LoaderEventType) {
+    LoaderEventType["DataLoadingProgress"] = "DATA_LOADING_PROGRESS";
+    LoaderEventType["DataLoadingDelay"] = "DATA_LOADING_DELAYED";
+    LoaderEventType["DataLoadingDone"] = "DATA_LOADING_DONE";
+    LoaderEventType["DataLoadingError"] = "DATA_LOADING_ERROR";
+    LoaderEventType["LoaderStateDeletionDone"] = "LOADER_STATE_DELETION_DONE";
+    LoaderEventType["LoaderStateDeletionError"] = "LOADER_STATE_DELETION_ERROR";
+    LoaderEventType["UnknownEventType"] = "UNKNOWN_EVENT_TYPE";
+})(LoaderEventType || (exports.LoaderEventType = LoaderEventType = {}));

package/dist/types/workers.d.ts

@@ -3,6 +3,7 @@ import { MessagePort } from 'node:worker_threads';
 import { State } from '../state/state';
 import { WorkerAdapter } from '../workers/worker-adapter';
 import { ExtractorEventType, AirdropEvent } from './extraction';
+import { LoaderEventType } from './loading';
 /**
  * WorkerAdapterInterface is an interface for WorkerAdapter class.
  * @interface WorkerAdapterInterface
@@ -105,7 +106,7 @@ export declare enum WorkerMessageSubject {
 export interface WorkerMessageEmitted {
     subject: WorkerMessageSubject.WorkerMessageEmitted;
     payload: {
-        eventType: ExtractorEventType;
+        eventType: ExtractorEventType | LoaderEventType;
     };
 }
 /**

package/dist/uploader/uploader.d.ts

@@ -34,5 +34,9 @@ export declare class Uploader {
     private parseJsonl;
     private stream;
     private getFileStreamResponse;
+    getJsonObjectByArtifactId({ artifactId, isGzipped, }: {
+        artifactId: string;
+        isGzipped?: boolean;
+    }): Promise<object[] | object | void>;
     private downloadToLocal;
 }

package/dist/uploader/uploader.interfaces.d.ts

@@ -1,6 +1,7 @@
 import { AirdropEvent } from '../types/extraction';
 import { WorkerAdapterOptions } from '../types/workers';
 import { ErrorRecord } from '../types/common';
+import { ExternalSystemItem, StatsFileObject } from '../types/loading';
 export interface UploaderFactoryInterface {
     event: AirdropEvent;
     options?: WorkerAdapterOptions;
@@ -61,3 +62,11 @@ export interface SsorAttachment {
         external: string;
     };
 }
+export interface StatsFileResponse {
+    error?: ErrorRecord;
+    statsFile?: StatsFileObject[];
+}
+export interface TransformerFileResponse {
+    error?: ErrorRecord;
+    transformerFile?: ExternalSystemItem[];
+}

package/dist/uploader/uploader.js

@@ -319,6 +319,26 @@ class Uploader {
             }
         }
     }
+    async getJsonObjectByArtifactId({ artifactId, isGzipped = false, }) {
+        const artifactUrl = await this.getArtifactDownloadUrl(artifactId);
+        if (!artifactUrl) {
+            return;
+        }
+        const artifact = await this.downloadArtifact(artifactUrl);
+        if (!artifact) {
+            return;
+        }
+        if (isGzipped) {
+            const decompressedArtifact = await this.decompressGzip(artifact);
+            if (!decompressedArtifact) {
+                return;
+            }
+            const jsonlObject = Buffer.from(decompressedArtifact).toString('utf-8');
+            return js_jsonl_1.jsonl.parse(jsonlObject);
+        }
+        const jsonlObject = Buffer.from(artifact).toString('utf-8');
+        return js_jsonl_1.jsonl.parse(jsonlObject);
+    }
     async downloadToLocal(itemType, fetchedObjects) {
         console.log(`Downloading ${itemType} to local file system.`);
         try {

package/dist/workers/create-worker.js

@@ -15,8 +15,8 @@ async function createWorker(workerData) {
             const worker = new node_worker_threads_1.Worker(workerFile, {
                 workerData,
             });
-            worker.on(workers_1.WorkerEvent.WorkerError, () => {
-                logger.error('Worker error');
+            worker.on(workers_1.WorkerEvent.WorkerError, (error) => {
+                logger.error('Worker error', error);
                 reject();
             });
             worker.on(workers_1.WorkerEvent.WorkerOnline, () => {

package/dist/workers/default-workers/data-loading.d.ts

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

package/dist/workers/default-workers/data-loading.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const process_task_1 = require("workers/process-task");
+const loading_1 = require("../../types/loading");
+(0, process_task_1.processTask)({
+    task: async ({ adapter }) => {
+        await adapter.emit(loading_1.LoaderEventType.DataLoadingDone, {
+            reports: adapter.reports,
+            processed_files: adapter.processedFiles,
+        });
+    },
+    onTimeout: async ({ adapter }) => {
+        await adapter.postState();
+        await adapter.emit(loading_1.LoaderEventType.DataLoadingProgress, {
+            reports: adapter.reports,
+            processed_files: adapter.processedFiles,
+        });
+    },
+});

package/dist/workers/spawn.js

@@ -9,8 +9,7 @@ const logger_1 = require("../logger/logger");
 const constants_1 = require("../common/constants");
 const workers_1 = require("../types/workers");
 const create_worker_1 = require("./create-worker");
-function getWorkerPath({ event, connectorWorkerPath, options, }) {
-    const logger = new logger_1.Logger({ event, options });
+function getWorkerPath({ event, connectorWorkerPath, }) {
     if (!constants_1.ALLOWED_EVENT_TYPES.includes(event.payload.event_type)) {
         return null;
     }
@@ -18,6 +17,7 @@ function getWorkerPath({ event, connectorWorkerPath, options, }) {
         return connectorWorkerPath;
     let path = null;
     switch (event.payload.event_type) {
+        // Extraction
         case extraction_1.EventType.ExtractionExternalSyncUnitsStart:
             path = __dirname + '/default-workers/external-sync-units-extraction';
             break;
@@ -33,16 +33,28 @@ function getWorkerPath({ event, connectorWorkerPath, options, }) {
             path = __dirname + '/default-workers/attachments-extraction';
             break;
         case extraction_1.EventType.ExtractionDataDelete:
-            path = __dirname + '/default-workers/data-deletion.js';
+            path = __dirname + '/default-workers/data-deletion';
             break;
         case extraction_1.EventType.ExtractionAttachmentsDelete:
             path = __dirname + '/default-workers/attachments-deletion';
             break;
+        // Loading
+        case extraction_1.EventType.StartLoadingData:
+        case extraction_1.EventType.ContinueLoadingData:
+            path = __dirname + '/default-workers/data-loading';
+            break;
         default:
-            logger.error('Worker script not found for event type: ' +
-                event.payload.event_type +
-                '.');
-            path = null;
+            (0, control_protocol_1.emit)({
+                event,
+                eventType: extraction_1.ExtractorEventType.UnknownEventType,
+                data: {
+                    error: {
+                        message: 'Unrecognized event type in spawn ' +
+                            event.payload.event_type +
+                            '.',
+                    },
+                },
+            });
     }
     return path;
 }
@@ -144,7 +156,7 @@ class Spawn {
             this.resolve(true);
             return;
         }
-        const timeoutEventType = (0, helpers_1.getErrorExtractorEventType)(this.event.payload.event_type);
+        const timeoutEventType = (0, helpers_1.getTimeoutErrorEventType)(this.event.payload.event_type);
         if (timeoutEventType !== null) {
             const { eventType } = timeoutEventType;
             await (0, control_protocol_1.emit)({

package/dist/workers/worker-adapter.d.ts

@@ -1,9 +1,11 @@
 import { AirdropEvent, ExtractorEventType, EventData } from '../types/extraction';
+import { LoaderEventType } from '../types/loading';
 import { AdapterState } from '../state/state.interfaces';
 import { Artifact } from '../uploader/uploader.interfaces';
 import { WorkerAdapterInterface, WorkerAdapterOptions } from '../types/workers';
 import { Repo } from '../repo/repo';
 import { RepoInterface } from '../repo/repo.interfaces';
+import { ExternalSystemItem, ItemTypesToLoadParams, ItemTypeToLoad, LoaderReport, LoadItemResponse, LoadItemTypesResponse } from '../types/loading';
 export declare function createWorkerAdapter<ConnectorState>({ event, adapterState, parentPort, options, }: WorkerAdapterInterface<ConnectorState>): WorkerAdapter<ConnectorState>;
 /**
  * WorkerAdapter class is used to interact with Airdrop platform. It is passed to the snap-in
@@ -28,9 +30,15 @@ export declare class WorkerAdapter<ConnectorState> {
     private parentPort;
     private isTimeout;
     private repos;
+    private loaderReports;
+    private _processedFiles;
+    private mappers;
+    private uploader;
     constructor({ event, adapterState, parentPort, options, }: WorkerAdapterInterface<ConnectorState>);
     get state(): AdapterState<ConnectorState>;
     set state(value: AdapterState<ConnectorState>);
+    get reports(): LoaderReport[];
+    get processedFiles(): string[];
     initializeRepos(repos: RepoInterface[]): void;
     getRepo(itemType: string): Repo | undefined;
     postState(): Promise<void>;
@@ -42,7 +50,12 @@ export declare class WorkerAdapter<ConnectorState> {
      * @param {ExtractorEventType} newEventType - The event type to be emitted
      * @param {EventData=} data - The data to be sent with the event
      */
-    emit(newEventType: ExtractorEventType, data?: EventData): Promise<void>;
+    emit(newEventType: ExtractorEventType | LoaderEventType, data?: EventData): Promise<void>;
     uploadAllRepos(): Promise<void>;
     handleTimeout(): void;
+    loadItemTypes({ itemTypesToLoad, }: ItemTypesToLoadParams): Promise<LoadItemTypesResponse>;
+    loadItem({ item, itemTypeToLoad, }: {
+        item: ExternalSystemItem;
+        itemTypeToLoad: ItemTypeToLoad;
+    }): Promise<LoadItemResponse>;
 }