@devrev/airsync-sdk 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/airsync-sdk.d.ts

@@ -14,12 +14,6 @@ declare enum ActionType {
     FAILED = "failed"
 }
 
-/**
- * AdapterState is an interface that defines the structure of the adapter state that is used by the external extractor.
- * It extends the connector state with additional fields including snapInVersionId and attachmentsMetadata.
- */
-export declare type AdapterState<ConnectorState> = ConnectorState & SdkState;
-
 export declare enum AirSyncDefaultItemTypes {
     EXTERNAL_DOMAIN_METADATA = "external_domain_metadata",
     ATTACHMENTS = "attachments",
@@ -76,6 +70,18 @@ export declare interface ArtifactsPrepareResponse {
     }[];
 }
 
+/**
+ * ArtifactToUpload is an interface that defines the structure of the response from the get upload url endpoint.
+ */
+declare interface ArtifactToUpload {
+    upload_url: string;
+    artifact_id: string;
+    form_data: {
+        key: string;
+        value: string;
+    }[];
+}
+
 /**
  * Attachments configuration for a record type.
  */
@@ -108,6 +114,134 @@ declare interface AxiosErrorResponse {
     message?: string;
 }
 
+/**
+ * BaseAdapter holds the state and behavior shared by both sync modes and owns
+ * the `emit` control-protocol flow as a template method. Mode-specific adapters
+ * (`ExtractionAdapter`, `LoadingAdapter`) implement the abstract hooks to inject
+ * their own pre-emit work and event payload shaping.
+ *
+ * @typeParam ConnectorState - the connector-owned state shape
+ * @typeParam StateClass - the mode's `BaseState` subclass
+ */
+declare abstract class BaseAdapter<ConnectorState, StateClass extends BaseState<ConnectorState, BaseSdkState>> {
+    readonly event: AirSyncEvent;
+    readonly options?: WorkerAdapterOptions;
+    isTimeout: boolean;
+    hasWorkerEmitted: boolean;
+    protected adapterState: StateClass;
+    protected uploader: Uploader;
+    constructor({ event, adapterState, options, }: {
+        event: AirSyncEvent;
+        adapterState: StateClass;
+        options?: WorkerAdapterOptions;
+    });
+    get state(): ConnectorState;
+    set state(value: ConnectorState);
+    postState(): Promise<void>;
+    /**
+     * Pre-emit hook run before any state is persisted or the event is sent.
+     * Extraction uploads pending repos and updates extraction boundaries here;
+     * loading has nothing to do. Throwing aborts the emit (the caller signals
+     * worker exit).
+     */
+    protected abstract beforeEmit(newEventType: ExtractorEventType | LoaderEventType): Promise<void>;
+    /**
+     * Builds the mode-specific extras merged into the emitted event payload
+     * (extraction: artifacts; loading: reports + processed files).
+     */
+    protected abstract buildEmitPayload(newEventType: ExtractorEventType | LoaderEventType): EventData;
+    /**
+     * Post-emit hook run after the event has been sent successfully. Extraction
+     * clears its accumulated artifacts here; loading has nothing to do.
+     */
+    protected abstract afterEmit(newEventType: ExtractorEventType | LoaderEventType): void;
+    /**
+     *  Emits an event to the platform.
+     *
+     * @param newEventType - The event type to be emitted
+     * @param data - The data to be sent with the event
+     */
+    emit(newEventType: ExtractorEventType | LoaderEventType, data?: EventData): Promise<void>;
+}
+
+/**
+ * BaseSdkState holds SDK bookkeeping common to every sync mode.
+ */
+declare interface BaseSdkState {
+    snapInVersionId?: string;
+}
+
+/**
+ * BaseState owns the state lifecycle shared by every sync mode: connector vs.
+ * SDK state separation, fetch/init/post against the platform, the v1->v2
+ * migration shim, and the snap-in-version-gated initial domain mapping install.
+ *
+ * Mode-specific subclasses (`ExtractionState`, `LoadingState`) narrow `sdkState`
+ * to their own SDK state shape and add mode-specific setup in their factories.
+ *
+ * @typeParam ConnectorState - the connector-owned state shape
+ * @typeParam SdkState - the SDK bookkeeping shape for this mode
+ */
+declare abstract class BaseState<ConnectorState, SdkState extends BaseSdkState> {
+    protected _connectorState: ConnectorState;
+    protected _sdkState: SdkState;
+    protected _extractionScope: ExtractionScope;
+    protected readonly initialSdkState: SdkState;
+    protected readonly event: AirSyncEvent;
+    private workerUrl;
+    private devrevToken;
+    private syncUnitId;
+    private requestId;
+    constructor({ event, initialState }: StateInterface<ConnectorState>, initialSdkState: SdkState);
+    /** Connector-owned state. This is what `adapter.state` exposes to snap-in code. */
+    get state(): ConnectorState;
+    set state(value: ConnectorState);
+    /** SDK-internal bookkeeping state. Never exposed to connector code. */
+    get sdkState(): SdkState;
+    set sdkState(value: SdkState);
+    get extractionScope(): ExtractionScope;
+    /**
+     * Installs the initial domain mapping when the snap-in version in state does
+     * not match the version in the event context. Shared by all modes so that a
+     * loading run still installs the mapping if extraction has not done so.
+     */
+    installInitialDomainMappingIfNeeded(initialDomainMapping?: InitialDomainMapping): Promise<void>;
+    /**
+     * Initializes the state for this adapter instance by fetching from API
+     * or creating an initial state if none exists (404).
+     *
+     * Reads both the v2 `{ connectorState, sdkState }` envelope and a legacy flat
+     * v1 blob (connector keys merged with SDK keys), migrating the latter on read.
+     * Always persists the v2 envelope going forward.
+     * @param initialState The initial connector state provided by the spawn function
+     */
+    init(initialState: ConnectorState): Promise<void>;
+    /**
+     * Normalizes a parsed on-disk state into the `{ connectorState, sdkState }`
+     * envelope, migrating a legacy flat v1 blob if needed.
+     *
+     * - v2 envelope (`{ connectorState, sdkState }`): used as-is.
+     * - v1 flat blob: SDK-owned keys (`V1_SDK_STATE_KEYS`) split into `sdkState`,
+     *   everything else becomes connector state.
+     * - Malformed envelope (one side present, the other missing) fails loud.
+     */
+    private normalizeFetchedState;
+    /**
+     *  Updates the state of the adapter by posting to API.
+     *  Persists the v2 `{ connectorState, sdkState }` envelope.
+     * @param {object} state - The connector state to be updated
+     */
+    postState(state?: ConnectorState): Promise<void>;
+    /**
+     *  Fetches the state of the adapter from API.
+     * @return  The raw state data from API
+     */
+    fetchState(): Promise<{
+        state: string;
+        objects?: string;
+    }>;
+}
+
 /**
  * Collection constraints for fields that are collections of values.
  */
@@ -361,7 +495,7 @@ export declare interface ExternalSystemAttachment {
 
 export declare type ExternalSystemAttachmentIteratorFunction<NewBatch, ConnectorState> = ({ reducedAttachments, adapter, stream, }: {
     reducedAttachments: NewBatch;
-    adapter: WorkerAdapter<ConnectorState>;
+    adapter: ExtractionAdapter<ConnectorState>;
     stream: ExternalSystemAttachmentStreamingFunction;
 }) => Promise<ProcessAttachmentReturnType>;
 
@@ -372,7 +506,7 @@ declare interface ExternalSystemAttachmentProcessors<ConnectorState, Batch, NewB
 
 export declare type ExternalSystemAttachmentReducerFunction<Batch, NewBatch, ConnectorState> = ({ attachments, adapter, batchSize, }: {
     attachments: Batch;
-    adapter: WorkerAdapter<ConnectorState>;
+    adapter: ExtractionAdapter<ConnectorState>;
     batchSize?: number;
 }) => NewBatch;
 
@@ -424,6 +558,56 @@ export declare interface ExternalSystemItemLoadingResponse {
 
 declare type ExternalSystemLoadingFunction<Item> = ({ item, mappers, event, }: ExternalSystemItemLoadingParams<Item>) => Promise<ExternalSystemItemLoadingResponse>;
 
+/**
+ * ExtractionAdapter is the adapter passed to extraction tasks. It exposes the
+ * extraction surface (repos, artifacts, attachment streaming) and updates the
+ * extraction boundaries before emitting.
+ *
+ * @public
+ */
+export declare class ExtractionAdapter<ConnectorState> extends BaseAdapter<ConnectorState, ExtractionState<ConnectorState>> {
+    private _artifacts;
+    private repos;
+    private currentEventDataLength;
+    constructor(params: {
+        event: AirSyncEvent;
+        adapterState: ExtractionState<ConnectorState>;
+        options?: WorkerAdapterOptions;
+    });
+    get extractionScope(): ExtractionScope;
+    /**
+     * Returns whether the given item type should be extracted.
+     * Defaults to true if the scope is empty or the item type is not listed.
+     */
+    shouldExtract(itemType: string): boolean;
+    initializeRepos(repos: RepoInterface[]): void;
+    getRepo(itemType: string): Repo | undefined;
+    get artifacts(): Artifact[];
+    set artifacts(artifacts: Artifact[]);
+    protected beforeEmit(newEventType: ExtractorEventType | LoaderEventType): Promise<void>;
+    protected buildEmitPayload(newEventType: ExtractorEventType | LoaderEventType): EventData;
+    protected afterEmit(): void;
+    uploadAllRepos(): Promise<void>;
+    processAttachment(attachment: NormalizedAttachment, stream: ExternalSystemAttachmentStreamingFunction): Promise<ProcessAttachmentReturnType>;
+    /**
+     * Destroys a stream to prevent memory leaks.
+     * @param httpStream - The axios response stream to destroy
+     */
+    private destroyHttpStream;
+    /**
+     * Streams the attachments to the DevRev platform.
+     * The attachments are streamed to the platform and the artifact information is returned.
+     * @param params - The parameters to stream the attachments
+     * @returns The response object containing the ssorAttachment artifact information
+     * or error information if there was an error
+     */
+    streamAttachments<NewBatch>({ stream, processors, batchSize, }: {
+        stream: ExternalSystemAttachmentStreamingFunction;
+        processors?: ExternalSystemAttachmentProcessors<ConnectorState, NormalizedAttachment[], NewBatch>;
+        batchSize?: number;
+    }): Promise<StreamAttachmentsReturnType>;
+}
+
 export declare const enum ExtractionCommonError {
     EXTERNAL_SYNC_UNIT_DELETED = "ERROR_CODE=EXTERNAL_SYNC_UNIT_DELETED",
     EXTERNAL_SYNC_UNIT_DEACTIVATED = "ERROR_CODE=EXTERNAL_SYNC_UNIT_DEACTIVATED",
@@ -438,6 +622,41 @@ export declare type ExtractionScope = Record<string, {
     extract: boolean;
 }>;
 
+/**
+ * ExtractionSdkState holds SDK bookkeeping owned by the extraction modes.
+ */
+declare interface ExtractionSdkState extends BaseSdkState {
+    /** The pending (not yet committed) oldest extraction boundary (ISO 8601 timestamp).
+     *  Set on StartExtractingMetadata, reused across subsequent phases, cleared on AttachmentExtractionDone. */
+    pendingWorkersOldest?: string;
+    /** The pending (not yet committed) newest extraction boundary (ISO 8601 timestamp).
+     *  Set on StartExtractingMetadata, reused across subsequent phases, cleared on AttachmentExtractionDone. */
+    pendingWorkersNewest?: string;
+    /** The oldest point of extraction (ISO 8601 timestamp). */
+    workersOldest?: string;
+    /** The newest point of extraction (ISO 8601 timestamp). */
+    workersNewest?: string;
+    toDevRev?: ToDevRev;
+}
+
+/**
+ * ExtractionState is the per-mode state for extraction workers. It narrows
+ * `sdkState` to `ExtractionSdkState` (extraction boundaries + attachments
+ * bookkeeping) on top of the shared lifecycle provided by `BaseState`.
+ */
+declare class ExtractionState<ConnectorState> extends BaseState<ConnectorState, ExtractionSdkState> {
+    constructor(params: StateInterface<ConnectorState>);
+    /**
+     * Resolves the extraction window onto the event context.
+     *
+     * On StartExtractingMetadata: resolve fresh from the TimeValue objects in the
+     * event context and cache them as pending boundaries (always overwrite).
+     * On all other events: reuse the pending boundaries cached during
+     * StartExtractingMetadata. Finally, validate that extract_from < extract_to.
+     */
+    resolveExtractionWindow(): void;
+}
+
 /**
  * ExtractorEvent is an interface that defines the structure of the event that is sent from the external extractor to the AirSync platform.
  * It contains the event type, event context, extractor state, and event data.
@@ -659,6 +878,60 @@ declare interface LoaderReport {
     [ActionType.FAILED]?: number;
 }
 
+/**
+ * LoadingAdapter is the adapter passed to loading tasks. It exposes the loading
+ * surface (item/attachment loading, mappers, loader reports).
+ *
+ * @public
+ */
+export declare class LoadingAdapter<ConnectorState> extends BaseAdapter<ConnectorState, LoadingState<ConnectorState>> {
+    private loaderReports;
+    private _processedFiles;
+    private _mappers;
+    constructor(params: {
+        event: AirSyncEvent;
+        adapterState: LoadingState<ConnectorState>;
+        options?: WorkerAdapterOptions;
+    });
+    get reports(): LoaderReport[];
+    get processedFiles(): string[];
+    get mappers(): Mappers;
+    protected beforeEmit(): Promise<void>;
+    protected buildEmitPayload(newEventType: ExtractorEventType | LoaderEventType): EventData;
+    protected afterEmit(): void;
+    loadItemTypes({ itemTypesToLoad, }: ItemTypesToLoadParams): Promise<LoadItemTypesResponse>;
+    getLoaderBatches({ supportedItemTypes, }: {
+        supportedItemTypes: string[];
+    }): Promise<FileToLoad[]>;
+    loadAttachments({ create, }: {
+        create: ExternalSystemLoadingFunction<ExternalSystemAttachment>;
+    }): Promise<LoadItemTypesResponse>;
+    loadItem({ item, itemTypeToLoad, }: {
+        item: ExternalSystemItem;
+        itemTypeToLoad: ItemTypeToLoad;
+    }): Promise<LoadItemResponse>;
+    loadAttachment({ item, create, }: {
+        item: ExternalSystemAttachment;
+        create: ExternalSystemLoadingFunction<ExternalSystemAttachment>;
+    }): Promise<LoadItemResponse>;
+}
+
+/**
+ * LoadingSdkState holds SDK bookkeeping owned by the loading modes.
+ */
+declare interface LoadingSdkState extends BaseSdkState {
+    fromDevRev?: FromDevRev;
+}
+
+/**
+ * LoadingState is the per-mode state for loading workers. It narrows `sdkState`
+ * to `LoadingSdkState` (files-to-load bookkeeping) on top of the shared
+ * lifecycle provided by `BaseState`.
+ */
+declare class LoadingState<ConnectorState> extends BaseState<ConnectorState, LoadingSdkState> {
+    constructor(params: StateInterface<ConnectorState>);
+}
+
 declare interface LoadItemResponse {
     error?: ErrorRecord;
     report?: LoaderReport;
@@ -984,18 +1257,32 @@ declare interface ProcessedAttachment {
     parent_id: string;
 }
 
-export declare function processTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ConnectorState>): void;
+/**
+ * Entry point for an extraction worker. Builds an {@link ExtractionAdapter} and
+ * runs the provided task against it.
+ *
+ * @public
+ */
+export declare function processExtractionTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ExtractionAdapter<ConnectorState>>): void;
 
 /**
- * ProcessTaskInterface is an interface for ProcessTask class.
+ * Entry point for a loading worker. Builds a {@link LoadingAdapter} and runs the
+ * provided task against it.
+ *
+ * @public
+ */
+export declare function processLoadingTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<LoadingAdapter<ConnectorState>>): void;
+
+/**
+ * ProcessTaskInterface is the parameter shape for the process-task entry points.
  * @interface ProcessTaskInterface
  * @constructor
  * @param {function} task - The task to be executed, returns exit code
  * @param {function} onTimeout - The task to be executed on timeout, returns exit code
  */
-export declare interface ProcessTaskInterface<ConnectorState> {
-    task: (params: TaskAdapterInterface<ConnectorState>) => Promise<void>;
-    onTimeout: (params: TaskAdapterInterface<ConnectorState>) => Promise<void>;
+export declare interface ProcessTaskInterface<Adapter extends BaseAdapter<unknown, BaseState<unknown, BaseSdkState>>> {
+    task: (params: TaskAdapterInterface<Adapter>) => Promise<void>;
+    onTimeout: (params: TaskAdapterInterface<Adapter>) => Promise<void>;
 }
 
 declare interface RateLimited {
@@ -1170,22 +1457,6 @@ export declare interface RouteConfig {
  */
 export declare type SchemaVersion = 'v0.2.0';
 
-declare interface SdkState {
-    /** The pending (not yet committed) oldest extraction boundary (ISO 8601 timestamp).
-     *  Set on StartExtractingMetadata, reused across subsequent phases, cleared on AttachmentExtractionDone. */
-    pendingWorkersOldest?: string;
-    /** The pending (not yet committed) newest extraction boundary (ISO 8601 timestamp).
-     *  Set on StartExtractingMetadata, reused across subsequent phases, cleared on AttachmentExtractionDone. */
-    pendingWorkersNewest?: string;
-    /** The oldest point of extraction (ISO 8601 timestamp). */
-    workersOldest?: string;
-    /** The newest point of extraction (ISO 8601 timestamp). */
-    workersNewest?: string;
-    toDevRev?: ToDevRev;
-    fromDevRev?: FromDevRev;
-    snapInVersionId?: string;
-}
-
 /**
  * Serializes an Axios error into a structured format with HTTP request/response details.
  * Extracts method, URL, parameters, status code, headers, and data.
@@ -1281,39 +1552,6 @@ export declare interface StageDiagram {
 /** Key identifying a stage in the stage diagram stages map. */
 export declare type StageKey = string;
 
-declare class State<ConnectorState> {
-    private _state;
-    private _extractionScope;
-    private initialSdkState;
-    private workerUrl;
-    private devrevToken;
-    private syncUnitId;
-    private requestId;
-    constructor({ event, initialState }: StateInterface<ConnectorState>);
-    get state(): AdapterState<ConnectorState>;
-    set state(value: AdapterState<ConnectorState>);
-    get extractionScope(): ExtractionScope;
-    /**
-     * Initializes the state for this adapter instance by fetching from API
-     * or creating an initial state if none exists (404).
-     * @param initialState The initial connector state provided by the spawn function
-     */
-    init(initialState: ConnectorState): Promise<void>;
-    /**
-     *  Updates the state of the adapter by posting to API.
-     * @param {object} state - The state to be updated
-     */
-    postState(state?: AdapterState<ConnectorState>): Promise<void>;
-    /**
-     *  Fetches the state of the adapter from API.
-     * @return  The raw state data from API
-     */
-    fetchState(): Promise<{
-        state: string;
-        objects?: string;
-    }>;
-}
-
 declare interface StateInterface<ConnectorState> {
     event: AirSyncEvent;
     initialState: ConnectorState;
@@ -1485,13 +1723,13 @@ export declare interface TargetTypeKeyData {
 }
 
 /**
- * TaskAdapterInterface is an interface for TaskAdapter class.
+ * TaskAdapterInterface is the parameter shape passed to a task callback.
  * @interface TaskAdapterInterface
  * @constructor
- * @param {WorkerAdapter} adapter - The adapter object
+ * @param {BaseAdapter} adapter - The adapter object
  */
-export declare interface TaskAdapterInterface<ConnectorState> {
-    adapter: WorkerAdapter<ConnectorState>;
+export declare interface TaskAdapterInterface<Adapter extends BaseAdapter<unknown, BaseState<unknown, BaseSdkState>>> {
+    adapter: Adapter;
 }
 
 /**
@@ -1583,113 +1821,132 @@ export declare interface TypedReferenceData {
  */
 export declare const UNBOUNDED_DATE_TIME_VALUE = "1970-01-01T00:00:00.000Z";
 
-/**
- * UploadResponse is an interface that defines the structure of the response from upload through Uploader.
- */
-export declare interface UploadResponse {
-    artifact?: Artifact;
-    error?: ErrorRecord;
-}
-
-/**
- * WorkerAdapter class is used to interact with AirSync platform. It is passed to the snap-in
- * as parameter in processTask and onTimeout functions. The class provides
- * utilities to emit control events to the platform, update the state of the connector,
- * and upload artifacts to the platform.
- * @class WorkerAdapter
- * @constructor
- * @param options - The options to create a new instance of WorkerAdapter class
- * @param event - The event object received from the platform
- * @param initialState - The initial state of the adapter
- * @param isLocalDevelopment - A flag to indicate if the adapter is being used in local development
- * @param workerPath - The path to the worker file
- *
- * @public
- */
-export declare class WorkerAdapter<ConnectorState> {
-    readonly event: AirSyncEvent;
-    readonly options?: WorkerAdapterOptions;
-    isTimeout: boolean;
-    hasWorkerEmitted: boolean;
-    private adapterState;
-    private _artifacts;
-    private repos;
-    private currentEventDataLength;
-    private loaderReports;
-    private _processedFiles;
-    private _mappers;
-    private uploader;
-    constructor({ event, adapterState, options, }: WorkerAdapterInterface<ConnectorState>);
-    get state(): AdapterState<ConnectorState>;
-    set state(value: AdapterState<ConnectorState>);
-    get reports(): LoaderReport[];
-    get processedFiles(): string[];
-    get mappers(): Mappers;
-    get extractionScope(): ExtractionScope;
+declare class Uploader {
+    private isLocalDevelopment?;
+    private devrevApiEndpoint;
+    private devrevApiToken;
+    private requestId;
+    private defaultHeaders;
+    private skipConfirmation;
+    constructor({ event, options }: UploaderFactoryInterface);
     /**
-     * Returns whether the given item type should be extracted.
-     * Defaults to true if the scope is empty or the item type is not listed.
+     * Uploads the fetched objects to the DevRev platform. Fetched objects are compressed to a gzipped jsonl object and uploaded to the platform.
+     * @param {string} itemType - The type of the item to be uploaded
+     * @param {object[] | object} fetchedObjects - The objects to be uploaded
+     * @returns {Promise<UploadResponse>} - The response object containing the artifact information or error information if there was an error
      */
-    shouldExtract(itemType: string): boolean;
-    initializeRepos(repos: RepoInterface[]): void;
-    getRepo(itemType: string): Repo | undefined;
-    postState(): Promise<void>;
-    get artifacts(): Artifact[];
-    set artifacts(artifacts: Artifact[]);
+    upload(itemType: string, fetchedObjects: object[] | object): Promise<UploadResponse>;
     /**
-     *  Emits an event to the platform.
-     *
-     * @param newEventType - The event type to be emitted
-     * @param data - The data to be sent with the event
+     * Gets the upload URL for an artifact from the DevRev API.
+     * @param {string} filename - The name of the file to upload
+     * @param {string} fileType - The MIME type of the file
+     * @param {number} [fileSize] - Optional file size in bytes
+     * @returns {Promise<ArtifactToUpload | void>} The artifact upload information or undefined on error
      */
-    emit(newEventType: ExtractorEventType | LoaderEventType, data?: EventData): Promise<void>;
-    uploadAllRepos(): Promise<void>;
-    loadItemTypes({ itemTypesToLoad, }: ItemTypesToLoadParams): Promise<LoadItemTypesResponse>;
-    getLoaderBatches({ supportedItemTypes, }: {
-        supportedItemTypes: string[];
-    }): Promise<FileToLoad[]>;
-    loadAttachments({ create, }: {
-        create: ExternalSystemLoadingFunction<ExternalSystemAttachment>;
-    }): Promise<LoadItemTypesResponse>;
-    loadItem({ item, itemTypeToLoad, }: {
-        item: ExternalSystemItem;
-        itemTypeToLoad: ItemTypeToLoad;
-    }): Promise<LoadItemResponse>;
-    processAttachment(attachment: NormalizedAttachment, stream: ExternalSystemAttachmentStreamingFunction): Promise<ProcessAttachmentReturnType>;
+    getArtifactUploadUrl(filename: string, fileType: string, fileSize?: number): Promise<UploaderResult<ArtifactToUpload>>;
     /**
-     * Destroys a stream to prevent memory leaks.
-     * @param httpStream - The axios response stream to destroy
+     * Uploads an artifact file to the provided upload URL using multipart form data.
+     * @param {ArtifactToUpload} artifact - The artifact upload information containing upload URL and form data
+     * @param {Buffer} file - The file buffer to upload
+     * @returns {Promise<AxiosResponse | void>} The axios response or undefined on error
      */
-    private destroyHttpStream;
-    loadAttachment({ item, create, }: {
-        item: ExternalSystemAttachment;
-        create: ExternalSystemLoadingFunction<ExternalSystemAttachment>;
-    }): Promise<LoadItemResponse>;
+    uploadArtifact(artifact: ArtifactToUpload, file: Buffer): Promise<UploaderResult<AxiosResponse>>;
     /**
-     * Streams the attachments to the DevRev platform.
-     * The attachments are streamed to the platform and the artifact information is returned.
-     * @param params - The parameters to stream the attachments
-     * @returns The response object containing the ssorAttachment artifact information
-     * or error information if there was an error
+     * Streams an artifact file from an axios response to the upload URL.
+     * @param {ArtifactToUpload} artifact - The artifact upload information containing upload URL and form data
+     * @param {AxiosResponse} fileStream - The axios response stream containing the file data
+     * @returns {Promise<AxiosResponse | void>} The axios response or undefined on error
      */
-    streamAttachments<NewBatch>({ stream, processors, batchSize, }: {
-        stream: ExternalSystemAttachmentStreamingFunction;
-        processors?: ExternalSystemAttachmentProcessors<ConnectorState, NormalizedAttachment[], NewBatch>;
-        batchSize?: number;
-    }): Promise<StreamAttachmentsReturnType>;
+    streamArtifact(artifact: ArtifactToUpload, fileStream: AxiosResponse): Promise<UploaderResult<AxiosResponse>>;
+    /**
+     * Confirms that an artifact upload has been completed successfully.
+     * @param {string} artifactId - The ID of the artifact to confirm
+     * @returns {Promise<AxiosResponse | void>} The axios response or undefined on error
+     */
+    confirmArtifactUpload(artifactId: string): Promise<{
+        response?: AxiosResponse;
+        error?: unknown;
+    }>;
+    /**
+     * Destroys a stream to prevent resource leaks.
+     * @param {any} fileStream - The axios response stream to destroy
+     */
+    private destroyStream;
+    /**
+     * Retrieves attachment metadata from an artifact by downloading and parsing it.
+     * @param {object} param0 - Configuration object
+     * @param {string} param0.artifact - The artifact ID to download attachments from
+     * @returns {Promise<{attachments?: NormalizedAttachment[], error?: {message: string}}>} The attachments array or error object
+     */
+    getAttachmentsFromArtifactId({ artifact, }: {
+        artifact: string;
+    }): Promise<{
+        attachments?: NormalizedAttachment[];
+        error?: {
+            message: string;
+        };
+    }>;
+    /**
+     * Gets the download URL for an artifact from the DevRev API.
+     * @param {string} artifactId - The ID of the artifact to download
+     * @returns {Promise<string | void>} The download URL or undefined on error
+     */
+    private getArtifactDownloadUrl;
+    /**
+     * Downloads an artifact file from the given URL.
+     * @param {string} artifactUrl - The URL to download the artifact from
+     * @returns {Promise<Buffer | void>} The artifact file buffer or undefined on error
+     */
+    private downloadArtifact;
+    /**
+     * Retrieves and parses JSON objects from an artifact by artifact ID.
+     * @param {object} param0 - Configuration object
+     * @param {string} param0.artifactId - The artifact ID to download and parse
+     * @param {boolean} [param0.isGzipped=false] - Whether the artifact is gzipped
+     * @returns {Promise<object[] | object | void>} The parsed JSON objects or undefined on error
+     */
+    getJsonObjectByArtifactId({ artifactId, isGzipped, }: {
+        artifactId: string;
+        isGzipped?: boolean;
+    }): Promise<UploaderResult<object[] | object>>;
+}
+
+declare interface UploaderFactoryInterface {
+    event: AirSyncEvent;
+    options?: WorkerAdapterOptions;
+}
+
+/**
+ * Generic result type for uploader operations that can either succeed with a response or fail with an error.
+ * @template T The type of the successful response data
+ */
+declare type UploaderResult<T> = {
+    response: T;
+    error?: never;
+} | {
+    response?: never;
+    error: unknown;
+};
+
+/**
+ * UploadResponse is an interface that defines the structure of the response from upload through Uploader.
+ */
+export declare interface UploadResponse {
+    artifact?: Artifact;
+    error?: ErrorRecord;
 }
 
 /**
- * WorkerAdapterInterface is an interface for WorkerAdapter class.
+ * WorkerAdapterInterface is the constructor parameter shape for an adapter.
  * @interface WorkerAdapterInterface
  * @constructor
  * @param {AirSyncEvent} event - The event object received from the platform
- * @param {object=} initialState - The initial state of the adapter
- * @param {WorkerAdapterInterface} options - The options to create a new instance of WorkerAdapter class
+ * @param {BaseState} adapterState - The state instance for the adapter
+ * @param {WorkerAdapterOptions} options - The options to create a new adapter
  */
-export declare interface WorkerAdapterInterface<ConnectorState> {
+export declare interface WorkerAdapterInterface<ConnectorState, StateClass extends BaseState<ConnectorState, BaseSdkState>> {
     event: AirSyncEvent;
-    adapterState: State<ConnectorState>;
+    adapterState: StateClass;
     options?: WorkerAdapterOptions;
 }