@devrev/ts-adaas 0.0.1

package/dist/src/http/client.d.ts

@@ -0,0 +1,16 @@
+import { HTTPResponse } from './types';
+export declare const defaultResponse: HTTPResponse;
+export default class HTTPClient {
+    private retryAfter;
+    private retryAt;
+    private axiosInstance;
+    constructor();
+    /**
+     *
+     * Function to make a GET call to the endpoint.
+     * There is special handling for rate limit exceeded error.
+     * In case of rate limit exceeded, the function returns success as true and the delay time in seconds
+     * In case of any other error, the function returns success as false and the error message
+     */
+    getCall(endpoint: string, headers: Record<string, string>, params?: any): Promise<HTTPResponse>;
+}

package/dist/src/http/client.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultResponse = void 0;
+const axios_1 = __importStar(require("axios"));
+const constants_1 = require("./constants");
+exports.defaultResponse = {
+    data: {
+        delay: 0,
+        nextPage: 1,
+        records: [],
+    },
+    message: '',
+    success: false,
+};
+class HTTPClient {
+    constructor() {
+        this.retryAfter = 0;
+        this.retryAt = 0;
+        this.axiosInstance = axios_1.default.create();
+        // Add request interceptor to check for retryAfter before making a request
+        this.axiosInstance.interceptors.request.use((config) => {
+            // Check if retryAfter is not 0 and return a LIMIT_EXCEEDED error
+            if (this.retryAfter !== 0) {
+                // check if the current time is greater than the retryAt time
+                const currentTime = new Date().getTime();
+                if (currentTime < this.retryAt) {
+                    console.error('Rate limit exceeded. Interceptor has retryAfter: ' +
+                        this.retryAfter);
+                    // Rate limit exceeded.
+                    return Promise.reject(constants_1.RATE_LIMIT_EXCEEDED);
+                }
+                else {
+                    // Reset the retryAfter
+                    this.retryAfter = 0;
+                }
+            }
+            return config;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+    }
+    /**
+     *
+     * Function to make a GET call to the endpoint.
+     * There is special handling for rate limit exceeded error.
+     * In case of rate limit exceeded, the function returns success as true and the delay time in seconds
+     * In case of any other error, the function returns success as false and the error message
+     */
+    async getCall(endpoint, headers, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    params) {
+        var _a;
+        // Return the LIMIT_EXCEEDED error if the retryAfter is not 0
+        try {
+            const res = await this.axiosInstance.get(endpoint, {
+                headers: headers,
+                params: params,
+            });
+            return Object.assign(Object.assign({}, exports.defaultResponse), { data: {
+                    delay: 0,
+                    records: res.data,
+                }, success: true });
+        }
+        catch (error) {
+            console.log('Error in getCall: ' + JSON.stringify(error));
+            // send error to adapter
+            if ((0, axios_1.isAxiosError)(error)) {
+                if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === constants_1.RATE_LIMIT_EXCEEDED_STATUS_CODE) {
+                    this.retryAfter = error.response.headers['retry-after']
+                        ? error.response.headers['retry-after']
+                        : 0;
+                    this.retryAt = new Date().getTime() + this.retryAfter * 1000;
+                    console.warn('Rate limit exceeded. Error code: ' +
+                        error.response.status +
+                        ' RetryAfter: ' +
+                        this.retryAfter +
+                        ' RetryAt: ' +
+                        this.retryAt);
+                    return {
+                        data: {
+                            delay: this.retryAfter,
+                            records: [],
+                        },
+                        message: constants_1.RATE_LIMIT_EXCEEDED,
+                        success: true,
+                    };
+                }
+                if (error.response) {
+                    return Object.assign(Object.assign({}, exports.defaultResponse), { message: error.response.data });
+                }
+                else {
+                    return Object.assign(Object.assign({}, exports.defaultResponse), { message: error.message });
+                }
+            }
+            else {
+                if (this.retryAfter !== 0) {
+                    console.warn('Rate limit exceeded. Going to return the following response: ' +
+                        JSON.stringify(error));
+                    return {
+                        data: {
+                            delay: this.retryAfter,
+                            records: [],
+                        },
+                        message: typeof error === 'string'
+                            ? error
+                            : JSON.stringify(error, Object.getOwnPropertyNames(error)),
+                        success: true,
+                    };
+                }
+                return {
+                    data: {
+                        delay: this.retryAfter,
+                        records: [],
+                    },
+                    message: typeof error === 'string'
+                        ? error
+                        : JSON.stringify(error, Object.getOwnPropertyNames(error)),
+                    success: false,
+                };
+            }
+        }
+    }
+}
+exports.default = HTTPClient;

package/dist/src/http/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const RATE_LIMIT_EXCEEDED = "LIMIT_EXCEEDED";
+export declare const LAMBDA_LIMIT_EXCEEDED = "LAMBDA_LIMIT_EXCEEDED";
+export declare const RATE_LIMIT_EXCEEDED_STATUS_CODE = 429;

package/dist/src/http/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RATE_LIMIT_EXCEEDED_STATUS_CODE = exports.LAMBDA_LIMIT_EXCEEDED = exports.RATE_LIMIT_EXCEEDED = void 0;
+exports.RATE_LIMIT_EXCEEDED = 'LIMIT_EXCEEDED';
+exports.LAMBDA_LIMIT_EXCEEDED = 'LAMBDA_LIMIT_EXCEEDED';
+exports.RATE_LIMIT_EXCEEDED_STATUS_CODE = 429;

package/dist/src/http/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './types';
+export * from './constants';

package/dist/src/http/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./constants"), exports);

package/dist/src/http/types.d.ts

@@ -0,0 +1,12 @@
+export type HTTPResponse = {
+    success: boolean;
+    message: string;
+    data: Data;
+};
+interface Data {
+    records: object[];
+    delay: number;
+    nextPage?: number;
+    metadata?: object;
+}
+export {};

package/dist/src/http/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './adapter';
+export * from './demo-extractor';
+export * from './uploader';
+export * from './types';

package/dist/src/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adapter"), exports);
+__exportStar(require("./demo-extractor"), exports);
+__exportStar(require("./uploader"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/logging/index.d.ts

@@ -0,0 +1,31 @@
+declare enum LogLevel {
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    DEBUG = "debug"
+}
+/**
+ * Logger class to log messages based on the log level.
+ * The log level can be set to one of the following:
+ * - INFO
+ * - WARN
+ * - ERROR
+ * - DEBUG
+ *
+ * The log tags can be set to any key-value pair.
+ */
+declare class Logger {
+    private level;
+    private logTags;
+    private static instance;
+    private constructor();
+    private log;
+    static getInstance(level: LogLevel, logTags?: Record<string, any>): Logger;
+    setTags(tags: Record<string, any>): void;
+    addTags(tags: Record<string, any>): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+}
+export default Logger;

package/dist/src/logging/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Logger class to log messages based on the log level.
+ * The log level can be set to one of the following:
+ * - INFO
+ * - WARN
+ * - ERROR
+ * - DEBUG
+ *
+ * The log tags can be set to any key-value pair.
+ */
+class Logger {
+    // Private constructor to prevent instantiation
+    constructor(level, logTags = {}) {
+        this.logTags = {};
+        this.level = level;
+        this.logTags = logTags;
+    }
+    log(level, message) {
+        if (this.level === level) {
+            console.log(`[${level.toUpperCase()}]: ${message}`, this.logTags);
+        }
+    }
+    // Singleton instance
+    static getInstance(level, logTags = {}) {
+        if (!Logger.instance) {
+            Logger.instance = new Logger(level, logTags);
+        }
+        return Logger.instance;
+    }
+    // Set log tags destructively.
+    setTags(tags) {
+        this.logTags = tags;
+    }
+    // Add log tags. If the key already exists, it will be overwritten.
+    addTags(tags) {
+        this.logTags = Object.assign(Object.assign({}, this.logTags), tags);
+    }
+    info(message) {
+        this.log(LogLevel.INFO, message);
+    }
+    warn(message) {
+        this.log(LogLevel.WARN, message);
+    }
+    error(message) {
+        this.log(LogLevel.ERROR, message);
+    }
+    debug(message) {
+        this.log(LogLevel.DEBUG, message);
+    }
+}
+exports.default = Logger;

package/dist/src/types/common.d.ts

@@ -0,0 +1,33 @@
+export declare enum ErrorLevel {
+    Warning = "WARNING",
+    Error = "ERROR",
+    Info = "INFO"
+}
+export interface ErrorRecord {
+    message: string;
+}
+export interface LogRecord {
+    level: ErrorLevel;
+    message: string;
+}
+export interface Artifact {
+    id: string;
+    item_type: string;
+    item_count: number;
+}
+export interface ArtifactsPrepareResponse {
+    url: string;
+    id: string;
+    form_data: {
+        key: string;
+        value: string;
+    }[];
+}
+export interface AdapterUpdateParams {
+    artifact?: Artifact;
+    extractor_state?: object;
+}
+export interface UploadResponse {
+    artifact?: Artifact;
+    error?: ErrorRecord;
+}

package/dist/src/types/common.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorLevel = void 0;
+var ErrorLevel;
+(function (ErrorLevel) {
+    ErrorLevel["Warning"] = "WARNING";
+    ErrorLevel["Error"] = "ERROR";
+    ErrorLevel["Info"] = "INFO";
+})(ErrorLevel || (exports.ErrorLevel = ErrorLevel = {}));

package/dist/src/types/extraction.d.ts

@@ -0,0 +1,105 @@
+import { InputData, Context, ExecutionMetadata } from '@devrev/typescript-sdk/dist/snap-ins';
+import { Artifact, ErrorRecord } from './common';
+export declare enum EventType {
+    ExtractionExternalSyncUnitsStart = "EXTRACTION_EXTERNAL_SYNC_UNITS_START",
+    ExtractionMetadataStart = "EXTRACTION_METADATA_START",
+    ExtractionDataStart = "EXTRACTION_DATA_START",
+    ExtractionDataContinue = "EXTRACTION_DATA_CONTINUE",
+    ExtractionDataDelete = "EXTRACTION_DATA_DELETE",
+    ExtractionAttachmentsStart = "EXTRACTION_ATTACHMENTS_START",
+    ExtractionAttachmentsContinue = "EXTRACTION_ATTACHMENTS_CONTINUE",
+    ExtractionAttachmentsDelete = "EXTRACTION_ATTACHMENTS_DELETE"
+}
+export declare enum ExtractorEventType {
+    ExtractionExternalSyncUnitsDone = "EXTRACTION_EXTERNAL_SYNC_UNITS_DONE",
+    ExtractionExternalSyncUnitsError = "EXTRACTION_EXTERNAL_SYNC_UNITS_ERROR",
+    ExtractionMetadataDone = "EXTRACTION_METADATA_DONE",
+    ExtractionMetadataError = "EXTRACTION_METADATA_ERROR",
+    ExtractionDataProgress = "EXTRACTION_DATA_PROGRESS",
+    ExtractionDataDelay = "EXTRACTION_DATA_DELAY",
+    ExtractionDataDone = "EXTRACTION_DATA_DONE",
+    ExtractionDataError = "EXTRACTION_DATA_ERROR",
+    ExtractionDataDeleteDone = "EXTRACTION_DATA_DELETE_DONE",
+    ExtractionDataDeleteError = "EXTRACTION_DATA_DELETE_ERROR",
+    ExtractionAttachmentsProgress = "EXTRACTION_ATTACHMENTS_PROGRESS",
+    ExtractionAttachmentsDelay = "EXTRACTION_ATTACHMENTS_DELAY",
+    ExtractionAttachmentsDone = "EXTRACTION_ATTACHMENTS_DONE",
+    ExtractionAttachmentsError = "EXTRACTION_ATTACHMENTS_ERROR",
+    ExtractionAttachmentsDeleteDone = "EXTRACTION_ATTACHMENTS_DELETE_DONE",
+    ExtractionAttachmentsDeleteError = "EXTRACTION_ATTACHMENTS_DELETE_ERROR"
+}
+export interface EventData {
+    external_sync_units?: ExternalSyncUnit[];
+    progress?: number;
+    error?: ErrorRecord;
+    delay?: number;
+    artifacts?: Artifact[];
+}
+export declare enum ExtractionMode {
+    INITIAL = "INITIAL",
+    INCREMENTAL = "INCREMENTAL"
+}
+export interface ExternalSyncUnit {
+    id: string;
+    name: string;
+    description: string;
+    item_count: number;
+}
+export interface EventContextIn {
+    mode: string;
+    callback_url: string;
+    dev_org_id: string;
+    dev_user_id: string;
+    external_sync_unit_id?: string;
+    sync_unit_id?: string;
+    sync_run_id: string;
+    external_system_id: string;
+    uuid: string;
+}
+export interface EventContextOut {
+    uuid: string;
+    sync_run: string;
+    sync_unit?: string;
+}
+export interface ConnectionData {
+    org_id: string;
+    org_name: string;
+    key: string;
+    key_type: string;
+}
+export interface EventData {
+    external_sync_units?: ExternalSyncUnit[];
+    progress?: number;
+    error?: ErrorRecord;
+    delay?: number;
+    artifacts?: Artifact[];
+}
+export interface DomainObjectState {
+    name: string;
+    nextChunkId: number;
+    pages?: {
+        pages: number[];
+    };
+    lastModified: string;
+    isDone: boolean;
+    count: number;
+}
+export interface AirdropEvent {
+    context: Context;
+    payload: AirdropMessage;
+    execution_metadata: ExecutionMetadata;
+    input_data: InputData;
+}
+export interface AirdropMessage {
+    connection_data: ConnectionData;
+    event_context: EventContextIn;
+    event_type: EventType;
+    event_data?: EventData;
+    extractor_state?: any;
+}
+export interface ExtractorEvent {
+    event_type: string;
+    event_context: EventContextOut;
+    extractor_state: string;
+    event_data?: EventData;
+}

package/dist/src/types/extraction.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractionMode = exports.ExtractorEventType = exports.EventType = void 0;
+var EventType;
+(function (EventType) {
+    // Get the list of sync units (repos, projects, ...) that can be extracted
+    EventType["ExtractionExternalSyncUnitsStart"] = "EXTRACTION_EXTERNAL_SYNC_UNITS_START";
+    // Start the extraction of external sync unit's metadata (repos, projects, ...)
+    EventType["ExtractionMetadataStart"] = "EXTRACTION_METADATA_START";
+    // Start the extraction of a specific external sync unit
+    EventType["ExtractionDataStart"] = "EXTRACTION_DATA_START";
+    // Continue the extraction of a specific external sync unit
+    EventType["ExtractionDataContinue"] = "EXTRACTION_DATA_CONTINUE";
+    // Give the external extractor an opportunity to clean up after itself
+    EventType["ExtractionDataDelete"] = "EXTRACTION_DATA_DELETE";
+    // Extract all the attachments for a specific external sync unit
+    EventType["ExtractionAttachmentsStart"] = "EXTRACTION_ATTACHMENTS_START";
+    // Continue the extraction of attachments for a specific external sync unit
+    EventType["ExtractionAttachmentsContinue"] = "EXTRACTION_ATTACHMENTS_CONTINUE";
+    // Give the external extractor an opportunity to clean up after extractions of external sync units
+    EventType["ExtractionAttachmentsDelete"] = "EXTRACTION_ATTACHMENTS_DELETE";
+})(EventType || (exports.EventType = EventType = {}));
+var ExtractorEventType;
+(function (ExtractorEventType) {
+    /* Sync Units */
+    // Sent when the extraction of external sync units finished
+    ExtractorEventType["ExtractionExternalSyncUnitsDone"] = "EXTRACTION_EXTERNAL_SYNC_UNITS_DONE";
+    // Sent when there was an unrecoverable error for extraction of external sync units.
+    // Must contain a list of error records.
+    ExtractorEventType["ExtractionExternalSyncUnitsError"] = "EXTRACTION_EXTERNAL_SYNC_UNITS_ERROR";
+    /* Metadata */
+    // Sent when the extraction of metadata finished
+    ExtractorEventType["ExtractionMetadataDone"] = "EXTRACTION_METADATA_DONE";
+    // Sent when there was an unrecoverable error for extraction of metadata.
+    ExtractorEventType["ExtractionMetadataError"] = "EXTRACTION_METADATA_ERROR";
+    /* Data */
+    // Sent after a batch was extracted, contains artifact IDs of the uploaded files
+    ExtractorEventType["ExtractionDataProgress"] = "EXTRACTION_DATA_PROGRESS";
+    // Sent when there is a rate limit of more than ~1m, adapter will restart the extraction after the delay
+    ExtractorEventType["ExtractionDataDelay"] = "EXTRACTION_DATA_DELAY";
+    // Sent when the extraction of data finished
+    ExtractorEventType["ExtractionDataDone"] = "EXTRACTION_DATA_DONE";
+    // Sent when there was an unrecoverable error for extraction of data
+    ExtractorEventType["ExtractionDataError"] = "EXTRACTION_DATA_ERROR";
+    // Sent when the external extractor has finished cleaning up after itself
+    ExtractorEventType["ExtractionDataDeleteDone"] = "EXTRACTION_DATA_DELETE_DONE";
+    // Sent when there was an unrecoverable error for extraction of data
+    ExtractorEventType["ExtractionDataDeleteError"] = "EXTRACTION_DATA_DELETE_ERROR";
+    /* Attachments */
+    // Sent after a batch was extracted, contains artifact IDs of the uploaded files
+    ExtractorEventType["ExtractionAttachmentsProgress"] = "EXTRACTION_ATTACHMENTS_PROGRESS";
+    // Sent when there is a rate limit of more than ~30s, adapter will restart the extraction after the delay
+    ExtractorEventType["ExtractionAttachmentsDelay"] = "EXTRACTION_ATTACHMENTS_DELAY";
+    // Sent when the extraction of attachements is finished
+    ExtractorEventType["ExtractionAttachmentsDone"] = "EXTRACTION_ATTACHMENTS_DONE";
+    // Sent when there was an unrecoverable error for extraction of attachments
+    ExtractorEventType["ExtractionAttachmentsError"] = "EXTRACTION_ATTACHMENTS_ERROR";
+    // Sent when the external extractor has finished cleaning up after itself
+    ExtractorEventType["ExtractionAttachmentsDeleteDone"] = "EXTRACTION_ATTACHMENTS_DELETE_DONE";
+    // Sent when there was an unrecoverable error for extraction of attachments
+    ExtractorEventType["ExtractionAttachmentsDeleteError"] = "EXTRACTION_ATTACHMENTS_DELETE_ERROR";
+})(ExtractorEventType || (exports.ExtractorEventType = ExtractorEventType = {}));
+var ExtractionMode;
+(function (ExtractionMode) {
+    ExtractionMode["INITIAL"] = "INITIAL";
+    ExtractionMode["INCREMENTAL"] = "INCREMENTAL";
+})(ExtractionMode || (exports.ExtractionMode = ExtractionMode = {}));

package/dist/src/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './common';
+export * from './extraction';

package/dist/src/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./extraction"), exports);

package/dist/src/uploader/index.d.ts

@@ -0,0 +1,32 @@
+import { UploadResponse } from '../types/common';
+/**
+ * Uploader class is used to upload files to the DevRev platform.
+ * The class provides utilities to
+ * - prepare artifact
+ * - upload artifact
+ * - return the artifact information to the platform
+ *
+ * @class Uploader
+ * @constructor
+ * @param {string} endpoint - The endpoint of the DevRev platform
+ * @param {string} token - The token to authenticate with the DevRev platform
+ */
+export declare class Uploader {
+    private betaDevrevSdk;
+    private publicDevrevSdk;
+    constructor(endpoint: string, token: string);
+    /**
+     *
+     *  Uploads the file to the DevRev platform. The file is uploaded to the platform
+     *  and the artifact information is returned.
+     *
+     * @param {string} filename - The name of the file to be uploaded
+     * @param {string} entity - The entity type of the file to be uploaded
+     * @param {object[] | object} fetchedObjects - The objects to be uploaded
+     * @param filetype - The type of the file to be uploaded
+     * @returns {Promise<UploadResponse>} - The response object containing the artifact information
+     */
+    upload(filename: string, entity: string, fetchedObjects: object[] | object, filetype?: string): Promise<UploadResponse>;
+    private prepareArtifact;
+    private uploadToArtifact;
+}