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

package/dist/airsync-sdk.d.ts

@@ -0,0 +1,1802 @@
+import axios from 'axios';
+import { AxiosError } from 'axios';
+import { AxiosInstance } from 'axios';
+import { AxiosResponse } from 'axios';
+import { InputData } from '@devrev/typescript-sdk/dist/snap-ins';
+import type { RawAxiosResponseHeaders } from 'axios';
+import { Worker as Worker_2 } from 'worker_threads';
+
+declare enum ActionType {
+    CREATED = "created",
+    UPDATED = "updated",
+    SKIPPED = "skipped",
+    DELETED = "deleted",
+    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",
+    EXTERNAL_SYNC_UNITS = "external_sync_units"
+}
+
+/**
+ * AirSyncEvent is an interface that defines the structure of the event that is sent to the external extractor from the AirSync platform.
+ * It contains the context, payload, execution metadata, and input data as common snap-ins.
+ */
+export declare interface AirSyncEvent {
+    context: {
+        secrets: {
+            service_account_token: string;
+        };
+        snap_in_version_id: string;
+        snap_in_id: string;
+    };
+    payload: AirSyncMessage;
+    execution_metadata: {
+        devrev_endpoint: string;
+    };
+    input_data: InputData;
+}
+
+/**
+ * AirSyncMessage is an interface that defines the structure of the payload/message that is sent to the external extractor from the AirSync platform.
+ */
+export declare interface AirSyncMessage {
+    connection_data: ConnectionData;
+    event_context: EventContext;
+    event_type: EventType;
+    event_data?: EventData;
+}
+
+/**
+ * Artifact is an interface that defines the structure of an artifact. Artifact is a file that is generated by the extractor and uploaded to the AirSync platform.
+ */
+export declare interface Artifact {
+    id: string;
+    item_type: string;
+    item_count: number;
+}
+
+/**
+ * ArtifactsPrepareResponse is an interface that defines the structure of the response from the prepare artifacts endpoint.
+ */
+export declare interface ArtifactsPrepareResponse {
+    url: string;
+    id: string;
+    form_data: {
+        key: string;
+        value: string;
+    }[];
+}
+
+/**
+ * Attachments configuration for a record type.
+ */
+declare interface Attachments {
+    /** Whether attachments can be extracted */
+    is_extractable?: boolean;
+    /** Whether attachments can be loaded: that is, whether the connector supports creating it in the system */
+    is_loadable?: boolean;
+}
+
+export { axios }
+
+export declare const axiosClient: AxiosInstance;
+
+declare interface AxiosErrorResponse {
+    config: {
+        method: string | undefined;
+        params: any;
+        url: string | undefined;
+    };
+    isAxiosError: boolean;
+    isCorsOrNoNetworkError: boolean;
+    response?: {
+        data: unknown;
+        headers: RawAxiosResponseHeaders;
+        status: number;
+        statusText: string;
+    };
+    code?: string;
+    message?: string;
+}
+
+/**
+ * Collection constraints for fields that are collections of values.
+ */
+export declare interface CollectionData {
+    min_length?: number;
+    max_length?: number;
+}
+
+/**
+ * Conditional privilege data for authorization.
+ */
+export declare interface ConditionalPrivilegeData {
+    /** The possible record types or record type categories that can be targeted in conditional privilege. */
+    type_keys: RecordTypeKey[];
+}
+
+/**
+ * ConnectionData is an interface that defines the structure of the connection data that is sent to the external extractor from the AirSync platform.
+ * It contains the organization ID, organization name, key, and key type.
+ */
+export declare interface ConnectionData {
+    org_id: string;
+    org_name: string;
+    key: string;
+    key_type: string;
+}
+
+/**
+ * Creates a mock AirSyncEvent for testing.
+ *
+ * @param mockServerUrl - Base URL for the mock server. Defaults to {@link MOCK_SERVER_DEFAULT_URL}.
+ *   The `callback_url`, `worker_data_url`, and `devrev_endpoint` fields are
+ *   derived from this value unless explicitly overridden.
+ * @param overrides - Deep partial of AirSyncEvent. Any provided fields are
+ *   deep-merged on top of the defaults.
+ */
+export declare function createMockEvent(mockServerUrl?: string, overrides?: DeepPartial<AirSyncEvent>): AirSyncEvent;
+
+/**
+ * Custom link data for defining link types.
+ */
+export declare interface CustomLinkData {
+    /** The field that defines the link types in the system. */
+    link_type_field: FieldKey;
+    link_direction_names: Record<string, CustomLinkNames> | null;
+}
+
+/**
+ * Custom link names for forward and backward directions.
+ */
+export declare interface CustomLinkNames {
+    /** The forward name of the link */
+    forward_name: string;
+    /** The backward name of the link */
+    backward_name: string;
+}
+
+/**
+ * Custom stage definition in a stage diagram.
+ */
+export declare interface CustomStage {
+    /** The state this stage belongs to. Must match the ones defined in the diagram 'states' field or be one of the default options: 'open', 'in_progress', 'closed'. */
+    state?: StateKey;
+    /** A list of stage names that this stage can transition to. */
+    transitions_to?: StageKey[];
+}
+
+/**
+ * Custom state definition in a stage diagram.
+ */
+export declare interface CustomState {
+    /** The human readable name of the custom state. */
+    name: string;
+    /** Denotes that this state is an end state. */
+    is_end_state?: boolean;
+    /** The sort order of the state. */
+    ordinal?: number;
+}
+
+/**
+ * Recursively makes all properties of T optional.
+ */
+export declare type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+declare type DonV2 = string;
+
+/**
+ * Enum field data containing possible values.
+ */
+export declare interface EnumData {
+    values: EnumValue[];
+}
+
+/**
+ * Enum value definition.
+ */
+export declare interface EnumValue {
+    /** The enum value that actually occurs in the json data */
+    key: EnumValueKey;
+    /** The human readable name of the enum value */
+    name?: string;
+    description?: string;
+    /** Deprecated enum values may still occur in the data, but should not be used in new data */
+    is_deprecated?: boolean;
+}
+
+/** Key identifying an enum value in EnumValue.key or stage diagram stages map keys. */
+export declare type EnumValueKey = string;
+
+/**
+ * ErrorRecord is an interface that defines the structure of an error record.
+ */
+export declare interface ErrorRecord {
+    message: string;
+}
+
+/**
+ * EventContext is an interface that defines the structure of the event context that is sent to the external connector from AirSync.
+ */
+export declare interface EventContext {
+    callback_url: string;
+    dev_oid: string;
+    dev_org_id: string;
+    dev_uid: string;
+    event_type_adaas: string;
+    external_sync_unit_id: string;
+    external_sync_unit_name: string;
+    external_system_id: string;
+    external_system_name: string;
+    external_system_type: string;
+    /**
+     * Resolved start timestamp of extraction (ISO 8601 format).
+     * Automatically computed by the SDK from extraction_start_time and worker state.
+     * This is the field developers should read to know when to start extracting from.
+     */
+    extract_from?: string;
+    import_slug: string;
+    initial_sync_scope?: InitialSyncScope;
+    mode: string;
+    request_id: string;
+    request_id_adaas: string;
+    run_id: string;
+    sequence_version: string;
+    snap_in_slug: string;
+    snap_in_version_id: string;
+    sync_tier: string;
+    sync_unit: DonV2;
+    sync_unit_id: string;
+    worker_data_url: string;
+    /**
+     * Start time value for extraction, as sent by the platform.
+     * The SDK resolves this into a concrete ISO 8601 timestamp on extract_from.
+     */
+    extraction_start_time?: TimeValue;
+    /**
+     * End time value for extraction, as sent by the platform.
+     * The SDK resolves this into a concrete ISO 8601 timestamp on extract_to.
+     */
+    extraction_end_time?: TimeValue;
+    /**
+     * Resolved end timestamp of extraction (ISO 8601 format).
+     * Automatically computed by the SDK from extraction_end_time and worker state.
+     * This is the field developers should read to know when to stop extracting at.
+     */
+    extract_to?: string;
+}
+
+/**
+ * EventData is an interface that defines the structure of the event data that is sent from the external extractor to the AirSync platform.
+ */
+export declare interface EventData {
+    error?: ErrorRecord;
+    delay?: number;
+    artifacts?: Artifact[];
+    reports?: LoaderReport[];
+    processed_files?: string[];
+    stats_file?: string;
+}
+
+/**
+ * EventType is an enum that defines the different types of events that can be sent to the external extractor from the AirSync platform.
+ * The external extractor can use these events to know what to do next in the extraction process.
+ */
+export declare enum EventType {
+    StartExtractingExternalSyncUnits = "START_EXTRACTING_EXTERNAL_SYNC_UNITS",
+    StartExtractingMetadata = "START_EXTRACTING_METADATA",
+    StartExtractingData = "START_EXTRACTING_DATA",
+    ContinueExtractingData = "CONTINUE_EXTRACTING_DATA",
+    StartDeletingExtractorState = "START_DELETING_EXTRACTOR_STATE",
+    StartExtractingAttachments = "START_EXTRACTING_ATTACHMENTS",
+    ContinueExtractingAttachments = "CONTINUE_EXTRACTING_ATTACHMENTS",
+    StartDeletingExtractorAttachmentsState = "START_DELETING_EXTRACTOR_ATTACHMENTS_STATE",
+    StartLoadingData = "START_LOADING_DATA",
+    ContinueLoadingData = "CONTINUE_LOADING_DATA",
+    StartLoadingAttachments = "START_LOADING_ATTACHMENTS",
+    ContinueLoadingAttachments = "CONTINUE_LOADING_ATTACHMENTS",
+    StartDeletingLoaderState = "START_DELETING_LOADER_STATE",
+    StartDeletingLoaderAttachmentState = "START_DELETING_LOADER_ATTACHMENT_STATE",
+    UnknownEventType = "UNKNOWN_EVENT_TYPE"
+}
+
+/**
+ * External domain metadata describing the logical structure of an external system.
+ */
+export declare interface ExternalDomainMetadata {
+    /** The record types in the domain */
+    record_types: Record<RecordTypeKey, RecordType>;
+    /** Record type categories */
+    record_type_categories?: Record<RecordTypeCategoryKey, RecordTypeCategory>;
+    /** Struct types for reusable field structures */
+    struct_types?: Record<StructTypeKey, StructType>;
+    /** The schema version of the metadata format itself. */
+    schema_version?: SchemaVersion;
+}
+
+export declare type ExternalProcessAttachmentFunction = ({ attachment, stream, }: {
+    attachment: NormalizedAttachment;
+    stream: ExternalSystemAttachmentStreamingFunction;
+}) => Promise<ProcessAttachmentReturnType>;
+
+/**
+ * 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.
+ */
+export declare interface ExternalSyncUnit {
+    id: string;
+    name: string;
+    description: string;
+    item_count?: number;
+    item_type?: string;
+}
+
+export declare interface ExternalSystemAttachment {
+    reference_id: DonV2;
+    parent_type: string;
+    parent_reference_id: DonV2;
+    file_name: string;
+    file_type: string;
+    file_size: number;
+    url: string;
+    valid_until: string;
+    created_by_id: string;
+    created_date: string;
+    modified_by_id: string;
+    modified_date: string;
+    parent_id?: string;
+    grand_parent_id?: string;
+}
+
+export declare type ExternalSystemAttachmentIteratorFunction<NewBatch, ConnectorState> = ({ reducedAttachments, adapter, stream, }: {
+    reducedAttachments: NewBatch;
+    adapter: WorkerAdapter<ConnectorState>;
+    stream: ExternalSystemAttachmentStreamingFunction;
+}) => Promise<ProcessAttachmentReturnType>;
+
+declare interface ExternalSystemAttachmentProcessors<ConnectorState, Batch, NewBatch> {
+    reducer: ExternalSystemAttachmentReducerFunction<Batch, NewBatch, ConnectorState>;
+    iterator: ExternalSystemAttachmentIteratorFunction<NewBatch, ConnectorState>;
+}
+
+export declare type ExternalSystemAttachmentReducerFunction<Batch, NewBatch, ConnectorState> = ({ attachments, adapter, batchSize, }: {
+    attachments: Batch;
+    adapter: WorkerAdapter<ConnectorState>;
+    batchSize?: number;
+}) => NewBatch;
+
+export declare type ExternalSystemAttachmentStreamingFunction = ({ item, event, }: ExternalSystemAttachmentStreamingParams) => Promise<ExternalSystemAttachmentStreamingResponse>;
+
+export declare interface ExternalSystemAttachmentStreamingParams {
+    item: NormalizedAttachment;
+    event: AirSyncEvent;
+}
+
+export declare interface ExternalSystemAttachmentStreamingResponse {
+    httpStream?: AxiosResponse;
+    error?: ErrorRecord;
+    delay?: number;
+}
+
+export declare interface ExternalSystemItem {
+    id: {
+        devrev: DonV2;
+        external?: string;
+    };
+    created_date: string;
+    modified_date: string;
+    data: any;
+}
+
+export declare interface ExternalSystemItem {
+    id: {
+        devrev: DonV2;
+        external?: string;
+    };
+    created_date: string;
+    modified_date: string;
+    data: any;
+}
+
+export declare interface ExternalSystemItemLoadingParams<Type> {
+    item: Type;
+    mappers: Mappers;
+    event: AirSyncEvent;
+}
+
+export declare interface ExternalSystemItemLoadingResponse {
+    id?: string;
+    error?: string;
+    modifiedDate?: string;
+    delay?: number;
+}
+
+declare type ExternalSystemLoadingFunction<Item> = ({ item, mappers, event, }: ExternalSystemItemLoadingParams<Item>) => Promise<ExternalSystemItemLoadingResponse>;
+
+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",
+    USER_DELETED = "ERROR_CODE=USER_DELETED"
+}
+
+/**
+ * ExtractionScope represents the parsed extraction scope from the platform.
+ * Each key is an item type name, and the value indicates whether it should be extracted.
+ */
+export declare type ExtractionScope = Record<string, {
+    extract: boolean;
+}>;
+
+/**
+ * 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.
+ */
+export declare interface ExtractorEvent {
+    event_type: string;
+    event_context: EventContext;
+    event_data?: EventData;
+    worker_metadata?: WorkerMetadata;
+}
+
+/**
+ * ExtractorEventType is an enum that defines the different types of events that can be sent from the external extractor to the AirSync platform.
+ * The external extractor can use these events to inform the AirSync platform about the progress of the extraction process.
+ */
+export declare enum ExtractorEventType {
+    ExternalSyncUnitExtractionDone = "EXTERNAL_SYNC_UNIT_EXTRACTION_DONE",
+    ExternalSyncUnitExtractionError = "EXTERNAL_SYNC_UNIT_EXTRACTION_ERROR",
+    MetadataExtractionDone = "METADATA_EXTRACTION_DONE",
+    MetadataExtractionError = "METADATA_EXTRACTION_ERROR",
+    DataExtractionProgress = "DATA_EXTRACTION_PROGRESS",
+    DataExtractionDelayed = "DATA_EXTRACTION_DELAYED",
+    DataExtractionDone = "DATA_EXTRACTION_DONE",
+    DataExtractionError = "DATA_EXTRACTION_ERROR",
+    ExtractorStateDeletionDone = "EXTRACTOR_STATE_DELETION_DONE",
+    ExtractorStateDeletionError = "EXTRACTOR_STATE_DELETION_ERROR",
+    AttachmentExtractionProgress = "ATTACHMENT_EXTRACTION_PROGRESS",
+    AttachmentExtractionDelayed = "ATTACHMENT_EXTRACTION_DELAYED",
+    AttachmentExtractionDone = "ATTACHMENT_EXTRACTION_DONE",
+    AttachmentExtractionError = "ATTACHMENT_EXTRACTION_ERROR",
+    ExtractorAttachmentsStateDeletionDone = "EXTRACTOR_ATTACHMENTS_STATE_DELETION_DONE",
+    ExtractorAttachmentsStateDeletionError = "EXTRACTOR_ATTACHMENTS_STATE_DELETION_ERROR",
+    UnknownEventType = "UNKNOWN_EVENT_TYPE"
+}
+
+/**
+ * Field definition with type discriminator and type-specific data.
+ */
+export declare interface Field {
+    /** The type of the field */
+    type: FieldType;
+    /** The human readable name of the field */
+    name?: string;
+    description?: string;
+    /** Required fields are required in the domain model of the external system. */
+    is_required?: boolean;
+    /** Read only fields can't be set (when creating or updating a record), but are filled in by some process in the system. */
+    is_read_only?: boolean | null;
+    /** Fields that are write only should only be written to. */
+    is_write_only?: boolean | null;
+    /** Indexed fields can be used for searching, sorting or filtering. */
+    is_indexed?: boolean | null;
+    /** Indicates that the field can be used to uniquely lookup a record. */
+    is_identifier?: boolean | null;
+    /** Default value for the field */
+    default_value?: boolean | number | string;
+    /** If collection is set, the field is a 'collection' of the given type. */
+    collection?: CollectionData;
+    int?: IntData;
+    float?: FloatData;
+    text?: TextData;
+    enum?: EnumData | null;
+    reference?: ReferenceData;
+    typed_reference?: TypedReferenceData;
+    struct?: StructData;
+    permission?: PermissionData;
+    type_key?: TargetTypeKeyData;
+    field_reference?: FieldReferenceData;
+    record_type_privilege?: RecordTypePrivilegeData;
+    field_privilege?: FieldPrivilegeData;
+    conditional_privilege?: ConditionalPrivilegeData;
+    participation?: ParticipationData;
+}
+
+/**
+ * Field condition definition.
+ */
+export declare interface FieldCondition {
+    /** The value of the controlling field that will be compared against to see if the condition is met. */
+    value: unknown;
+    /** The comparator that will be used to compare the controlling field's value against the Value. */
+    comparator: FieldConditionComparator;
+    /** The fields that will be affected by the condition being met. */
+    affected_fields: FieldKey[];
+    /** The effect that will be applied to the affected fields if the condition is met. */
+    effect: FieldConditionEffect;
+}
+
+/**
+ * Comparator for field conditions.
+ */
+export declare type FieldConditionComparator = 'eq' | 'ne';
+
+/**
+ * Effect applied when a field condition is met.
+ */
+export declare type FieldConditionEffect = 'require' | 'show';
+
+/**
+ * Array of field conditions.
+ */
+export declare type FieldConditions = FieldCondition[];
+
+/** Key identifying a field within a record type or struct type fields map. */
+export declare type FieldKey = string;
+
+/**
+ * Field privilege data for authorization.
+ */
+export declare interface FieldPrivilegeData {
+    /** The possible record types or record type categories that can be targeted in field privilege. */
+    type_keys: RecordTypeKey[];
+}
+
+/**
+ * Field reference data (currently empty, reserved for future use).
+ */
+export declare interface FieldReferenceData {
+    [key: string]: never;
+}
+
+/**
+ * Field type discriminator.
+ */
+export declare type FieldType = 'bool' | 'int' | 'float' | 'text' | 'rich_text' | 'reference' | 'typed_reference' | 'enum' | 'date' | 'timestamp' | 'struct' | 'permission' | 'record_type_privilege' | 'field_privilege' | 'conditional_privilege' | 'participation';
+
+declare interface FileToLoad {
+    id: string;
+    file_name: string;
+    itemType: string;
+    count: number;
+    lineToProcess: number;
+    completed: boolean;
+}
+
+/**
+ * Float field constraints.
+ */
+export declare interface FloatData {
+    min?: number;
+    max?: number;
+}
+
+declare interface FromDevRev {
+    filesToLoad: FileToLoad[];
+}
+
+/**
+ * GetWorkerPathInterface is an interface for getting the worker path.
+ */
+export declare interface GetWorkerPathInterface {
+    event: AirSyncEvent;
+    workerBasePath?: string | null;
+}
+
+/**
+ * InitialDomainMapping is an interface that defines the structure of the initial domain mapping.
+ */
+export declare interface InitialDomainMapping {
+    starting_recipe_blueprint?: object;
+    additional_mappings?: object;
+}
+
+/**
+ * InitialSyncScope is an enum that defines the different scopes of initial sync that can be used by the external extractor.
+ */
+export declare enum InitialSyncScope {
+    FULL_HISTORY = "full-history",
+    TIME_SCOPED = "time-scoped"
+}
+
+export declare function installInitialDomainMapping(event: AirSyncEvent, initialDomainMappingJson: InitialDomainMapping): Promise<void>;
+
+/**
+ * Integer field constraints.
+ */
+export declare interface IntData {
+    min?: number;
+    max?: number;
+}
+
+/**
+ * Item is an interface that defines the structure of an item.
+ */
+declare type Item = Record<string, any>;
+
+declare interface ItemTypesToLoadParams {
+    itemTypesToLoad: ItemTypeToLoad[];
+}
+
+declare interface ItemTypeToLoad {
+    itemType: string;
+    create: ExternalSystemLoadingFunction<ExternalSystemItem>;
+    update: ExternalSystemLoadingFunction<ExternalSystemItem>;
+}
+
+export declare enum LoaderEventType {
+    DataLoadingProgress = "DATA_LOADING_PROGRESS",
+    DataLoadingDelayed = "DATA_LOADING_DELAYED",
+    DataLoadingDone = "DATA_LOADING_DONE",
+    DataLoadingError = "DATA_LOADING_ERROR",
+    AttachmentLoadingProgress = "ATTACHMENT_LOADING_PROGRESS",
+    AttachmentLoadingDelayed = "ATTACHMENT_LOADING_DELAYED",
+    AttachmentLoadingDone = "ATTACHMENT_LOADING_DONE",
+    AttachmentLoadingError = "ATTACHMENT_LOADING_ERROR",
+    LoaderStateDeletionDone = "LOADER_STATE_DELETION_DONE",
+    LoaderStateDeletionError = "LOADER_STATE_DELETION_ERROR",
+    LoaderAttachmentStateDeletionDone = "LOADER_ATTACHMENT_STATE_DELETION_DONE",
+    LoaderAttachmentStateDeletionError = "LOADER_ATTACHMENT_STATE_DELETION_ERROR",
+    UnknownEventType = "UNKNOWN_EVENT_TYPE"
+}
+
+declare interface LoaderReport {
+    item_type: string;
+    [ActionType.CREATED]?: number;
+    [ActionType.UPDATED]?: number;
+    [ActionType.SKIPPED]?: number;
+    [ActionType.DELETED]?: number;
+    [ActionType.FAILED]?: number;
+}
+
+declare interface LoadItemResponse {
+    error?: ErrorRecord;
+    report?: LoaderReport;
+    rateLimit?: RateLimited;
+}
+
+declare interface LoadItemTypesResponse {
+    reports: LoaderReport[];
+    processed_files: string[];
+}
+
+declare enum LogLevel {
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}
+
+/**
+ * Manages sync mapper records that link external system items to DevRev items.
+ *
+ * Used for tracking relationships between external and DevRev entities during sync operations.
+ */
+declare class Mappers {
+    private devrevApiEndpoint;
+    private devrevApiToken;
+    constructor({ event }: MappersFactoryInterface);
+    /**
+     * Retrieves a sync mapper record by DevRev ID.
+     *
+     * Used to find the mapping when you know the DevRev ID and want to find the external system ID.
+     *
+     * @param params - Query parameters of type MappersGetByTargetIdParams
+     * @returns Promise with response data containing the sync mapper record
+     */
+    getByTargetId(params: MappersGetByTargetIdParams): Promise<AxiosResponse<MappersGetByTargetIdResponse>>;
+    /**
+     * Retrieves a sync mapper record by external system ID.
+     *
+     * Used to find the mapping when you know the external system ID and want to find the DevRev ID.
+     *
+     * @param params - Query parameters of type MappersGetByExternalIdParams
+     * @returns Promise with response data containing the sync mapper record
+     */
+    getByExternalId(params: MappersGetByExternalIdParams): Promise<AxiosResponse<MappersGetByExternalIdResponse>>;
+    /**
+     * Creates a new sync mapper record to establish a relationship between external system
+     * entities and DevRev entities.
+     *
+     * This is called after importing an item from external system to DevRev to record
+     * the mapping for future synchronization operations.
+     *
+     * @param params - Creation parameters of type MappersCreateParams
+     * @returns Promise with response data containing the created sync mapper record
+     */
+    create(params: MappersCreateParams): Promise<AxiosResponse<MappersCreateResponse>>;
+    /**
+     * Updates an existing sync mapper record.
+     *
+     * Used to modify existing mappings when external system entities change or when
+     * additional DevRev entities need to be associated.
+     *
+     * @param params - Update parameters of type MappersUpdateParams
+     * @returns Promise with response data containing the updated sync mapper record
+     */
+    update(params: MappersUpdateParams): Promise<AxiosResponse<MappersUpdateResponse>>;
+}
+
+/**
+ * Parameters for creating a new sync mapper record.
+ */
+export declare interface MappersCreateParams {
+    /** The sync unit ID that scopes the synchronization context */
+    sync_unit: DonV2;
+    /** Array of external system identifiers */
+    external_ids: string[];
+    /**
+     * Optional map that labels values in `external_ids` with their usage context.
+     * Use when an external system requires different identifiers for different API calls
+     * (for example, a UUID for one endpoint and a login username for another).
+     *
+     * Example:
+     *   external_ids: ["2a1c...-uuid", "john_doe"]
+     *   secondary_ids: { "username": "john_doe" }
+     *
+     * Note: Values in `secondary_ids` are not indexed. If you need to look up by a
+     * secondary value (e.g., username), you must also include that value in `external_ids`.
+     */
+    secondary_ids?: Record<string, string>;
+    /** Array of DevRev entity IDs this mapping points to */
+    targets: DonV2[];
+    status: SyncMapperRecordStatus;
+    /**
+     * Input file names where the object was encountered.
+     * Used for observability and tracking.
+     */
+    input_files?: string[];
+    /**
+     * External version markers used to avoid update loops.
+     * After creating or updating the object in the external system, add its
+     * modified_date here. On subsequent extraction, the Loader skips applying the
+     * update if the modified_date is present (change originated in DevRev).
+     */
+    external_versions?: SyncMapperRecordExternalVersion[];
+    /**
+     * Opaque data for storing additional client-specific information.
+     * Fully managed by snapin authors.
+     */
+    extra_data?: string;
+}
+
+/**
+ * Response containing the newly created sync mapper record.
+ */
+declare interface MappersCreateResponse {
+    sync_mapper_record: SyncMapperRecord;
+}
+
+/**
+ * Configuration interface for creating a Mappers instance.
+ */
+declare interface MappersFactoryInterface {
+    event: AirSyncEvent;
+    options?: WorkerAdapterOptions;
+}
+
+/**
+ * Parameters for retrieving a sync mapper record by external system ID.
+ */
+export declare interface MappersGetByExternalIdParams {
+    /** The sync unit ID that scopes the synchronization context */
+    sync_unit: DonV2;
+    /** The identifier from the external system */
+    external_id: string;
+    /** The type of DevRev entity to look for */
+    target_type: SyncMapperRecordTargetType;
+}
+
+/**
+ * Response containing a sync mapper record retrieved by external ID.
+ */
+declare interface MappersGetByExternalIdResponse {
+    sync_mapper_record: SyncMapperRecord;
+}
+
+/**
+ * Parameters for retrieving a sync mapper record by DevRev target ID.
+ */
+export declare interface MappersGetByTargetIdParams {
+    /** The sync unit ID that scopes the synchronization context */
+    sync_unit: DonV2;
+    /** The DevRev entity ID to look up */
+    target: DonV2;
+}
+
+/**
+ * Response containing a sync mapper record retrieved by target ID.
+ */
+declare interface MappersGetByTargetIdResponse {
+    sync_mapper_record: SyncMapperRecord;
+}
+
+/**
+ * Parameters for updating an existing sync mapper record.
+ */
+export declare interface MappersUpdateParams {
+    /** The ID of the existing sync mapper record to update */
+    id: DonV2;
+    /** The sync unit ID that scopes the synchronization context */
+    sync_unit: DonV2;
+    /** External system IDs to add to the existing mapping */
+    external_ids: {
+        add: string[];
+    };
+    /**
+     * Optional map that labels values in `external_ids` with their usage context.
+     * Use when an external system requires different identifiers for different API calls
+     * (for example, a UUID for one endpoint and a login username for another).
+     *
+     * Example:
+     *   external_ids: ["2a1c...-uuid", "john_doe"]
+     *   secondary_ids: { "username": "john_doe" }
+     *
+     * Note: Values in `secondary_ids` are not indexed. If you need to look up by a
+     * secondary value (e.g., username), you must also include that value in `external_ids`.
+     */
+    secondary_ids?: Record<string, string>;
+    /** DevRev entity IDs to add to the existing mapping */
+    targets: {
+        add: DonV2[];
+    };
+    status: SyncMapperRecordStatus;
+    /**
+     * Input file names where the object was encountered.
+     * Used for observability and tracking.
+     */
+    input_files?: {
+        add: string[];
+    };
+    /**
+     * External version markers used to avoid update loops.
+     * After creating or updating the object in the external system, add its
+     * modified_date here. On subsequent extraction, the Loader skips applying the
+     * update if the modified_date is present (change originated in DevRev).
+     */
+    external_versions?: {
+        add: SyncMapperRecordExternalVersion[];
+    };
+    /**
+     * Opaque data for storing additional client-specific information.
+     * Fully managed by snapin authors.
+     */
+    extra_data?: string;
+}
+
+/**
+ * Response containing the updated sync mapper record.
+ */
+declare interface MappersUpdateResponse {
+    sync_mapper_record: SyncMapperRecord;
+}
+
+export declare const MOCK_SERVER_DEFAULT_URL = "http://localhost:0";
+
+/**
+ * MockServer used in tests to mock internal AirSync endpoints.
+ * This is a simple mock server that listens on a port and responds to requests.
+ * Supports per-test route configuration to simulate different response scenarios.
+ */
+export declare class MockServer {
+    private server;
+    private internalPort;
+    port: number;
+    baseUrl: string;
+    private routeHandlers;
+    private requests;
+    private requestCounts;
+    constructor(port?: number);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    /**
+     * Default route handler for the mock server. Returns { success: true } for
+     * routes that are not explicitly set.
+     */
+    private defaultRouteHandler;
+    private getRouteKey;
+    /**
+     * Configures a route to return a specific status code and optional response body.
+     */
+    setRoute(config: RouteConfig): void;
+    /**
+     * Resets all custom route handlers, restoring all default handlers.
+     * Also clears request tracking data.
+     */
+    resetRoutes(): void;
+    /**
+     * Returns the most recent request or undefined if no requests exist.
+     */
+    getLastRequest(): RequestInfo_2 | undefined;
+    /**
+     * Gets the number of requests made to a specific endpoint.
+     */
+    getRequestCount(method: string, path: string): number;
+    /**
+     * Gets all requests made to a specific endpoint.
+     */
+    getRequests(method: string, path: string): RequestInfo_2[];
+}
+
+/**
+ * NormalizedAttachment is an interface of attachment after normalization.
+ */
+export declare interface NormalizedAttachment {
+    url: string;
+    id: string;
+    file_name: string;
+    parent_id: string;
+    author_id?: string;
+    inline?: boolean;
+    content_type?: string;
+    grand_parent_id?: number | string;
+}
+
+/**
+ * NormalizedItem is an interface of item after normalization.
+ */
+export declare interface NormalizedItem {
+    id: string;
+    created_date: string;
+    modified_date: string;
+    data: object;
+}
+
+/**
+ * Participation field data specifying target record types.
+ */
+declare interface ParticipationData {
+    /** The record types that this participation reference can refer to */
+    refers_to: Record<RecordTypeKey, ReferenceDetail>;
+}
+
+/**
+ * Permission data associating a reference with a role.
+ */
+export declare interface PermissionData {
+    member_id?: ReferenceData;
+    role?: EnumData;
+}
+
+export declare type ProcessAttachmentReturnType = {
+    delay?: number;
+    error?: {
+        message: string;
+        fileSize?: number;
+    };
+} | undefined;
+
+/**
+ * Attachment structure, that stores both attachment id and its parent_id for deduplication on the SDK side.
+ */
+declare interface ProcessedAttachment {
+    id: string;
+    parent_id: string;
+}
+
+export declare function processTask<ConnectorState>({ task, onTimeout, }: ProcessTaskInterface<ConnectorState>): void;
+
+/**
+ * ProcessTaskInterface is an interface for ProcessTask class.
+ * @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>;
+}
+
+declare interface RateLimited {
+    delay: number;
+}
+
+/**
+ * Record type definition.
+ */
+export declare interface RecordType {
+    /** The fields of the record type */
+    fields: Record<FieldKey, Field>;
+    /** The human readable name of the record type */
+    name?: string;
+    description?: string;
+    category?: RecordTypeCategoryKey;
+    /** Whether the record type can be loaded (connector supports creating it in the system) */
+    is_loadable?: boolean;
+    /** Whether the record type sends the complete system state in every sync */
+    is_snapshot?: boolean;
+    /** Denotes that the record type has no ID field, primarily used for authorization policies */
+    no_identifier?: boolean;
+    /** Indicates the scope of this record type */
+    scope?: RecordTypeScope;
+    /** Field conditions for this record type */
+    conditions?: Record<FieldKey, FieldConditions>;
+    /** Stage diagram for workflow */
+    stage_diagram?: StageDiagram;
+    /** Link naming data for custom links */
+    link_naming_data?: CustomLinkData;
+    /** Attachments configuration */
+    attachments?: Attachments;
+}
+
+/**
+ * Record type category definition.
+ */
+export declare interface RecordTypeCategory {
+    /** The human readable name of the record type category */
+    name?: string;
+    /** Indicates whether a record can move between the record types of this category while preserving its identity */
+    are_record_type_conversions_possible?: boolean;
+}
+
+/** Key identifying a record type category in the record_type_categories map. */
+export declare type RecordTypeCategoryKey = string;
+
+/** Key identifying a record type in the record_types map, refers_to maps, or type_keys arrays. */
+export declare type RecordTypeKey = string;
+
+/**
+ * Record type privilege data for authorization.
+ */
+export declare interface RecordTypePrivilegeData {
+    /** The possible record types or record type categories that can be targeted in record type privilege. */
+    type_keys: RecordTypeKey[];
+}
+
+/**
+ * Scope of a record type.
+ */
+export declare type RecordTypeScope = 'metadata_is_system_scoped' | 'data_is_system_scoped';
+
+/**
+ * Reference field data specifying target record types.
+ */
+export declare interface ReferenceData {
+    /** The record types that this reference can refer to */
+    refers_to: Record<RecordTypeKey, ReferenceDetail>;
+    /** The parent reference refers to a record that has special ownership over the child */
+    reference_type?: ReferenceType;
+}
+
+/**
+ * Details about how a reference targets another record type.
+ */
+export declare interface ReferenceDetail {
+    /** The field in the target record type by which it is referenced. Assumed to be the primary key if not set. */
+    by_field?: FieldKey;
+}
+
+/**
+ * Reference type indicating parent-child relationship.
+ */
+export declare type ReferenceType = 'child' | 'parent';
+
+declare class Repo {
+    readonly itemType: string;
+    private items;
+    private normalize?;
+    private uploader;
+    private onUpload;
+    private options?;
+    uploadedArtifacts: Artifact[];
+    constructor({ event, itemType, normalize, onUpload, options, }: RepoFactoryInterface);
+    getItems(): (NormalizedItem | NormalizedAttachment | Item)[];
+    upload(batch?: (NormalizedItem | NormalizedAttachment | Item)[]): Promise<void | ErrorRecord>;
+    push(items: Item[]): Promise<boolean>;
+}
+
+/**
+ * RepoFactoryInterface is an interface that defines the structure of a repo factory which is used to create a repo.
+ */
+declare interface RepoFactoryInterface {
+    event: AirSyncEvent;
+    itemType: string;
+    normalize?: (record: object) => NormalizedItem | NormalizedAttachment;
+    onUpload: (artifact: Artifact) => void;
+    options?: WorkerAdapterOptions;
+}
+
+/**
+ * RepoInterface is an interface that defines the structure of a repo which is used to store and upload extracted data.
+ */
+export declare interface RepoInterface {
+    itemType: string;
+    normalize?: (record: object) => NormalizedItem | NormalizedAttachment;
+    overridenOptions?: WorkerAdapterOptions;
+}
+
+/**
+ * Information about a request received by the mock server.
+ */
+declare interface RequestInfo_2 {
+    /** The HTTP method (e.g., 'GET', 'POST') */
+    method: string;
+    /** The full URL path of the request */
+    url: string;
+    /** Optional request body (for POST/PUT requests) */
+    body?: unknown;
+}
+export { RequestInfo_2 as RequestInfo }
+
+/**
+ * Configuration for retry simulation behavior.
+ */
+export declare interface RetryConfig {
+    /** Number of times to return error before succeeding (default: 4) */
+    failureCount?: number;
+    /** 5xx status code to return during failures (default: 500) */
+    errorStatus?: number;
+    /** Optional error response body to send as JSON during failures */
+    errorBody?: unknown;
+    /** Optional headers to send with the error response */
+    headers?: Record<string, string>;
+    /** Optional delay in milliseconds before sending each failure response */
+    delay?: number;
+}
+
+/**
+ * Configuration object for setting up a route response.
+ */
+export declare interface RouteConfig {
+    /** The path of the route (e.g., '/callback_url', '/worker_data_url.get') */
+    path: string;
+    /** The HTTP method (e.g., 'GET', 'POST', 'PUT', 'DELETE') */
+    method: string;
+    /** The HTTP status code to return (e.g., 200, 401, 500) */
+    status: number;
+    /** Optional response body to send as JSON */
+    body?: unknown;
+    /** Optional headers to send with the response */
+    headers?: Record<string, string>;
+    /** Optional retry configuration for simulating failures before success */
+    retry?: RetryConfig;
+    /** Optional delay in milliseconds before sending the response */
+    delay?: number;
+}
+
+/**
+ * Schema version for the external domain metadata format.
+ */
+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.
+ * Includes CORS/network failure indicator when no response is available.
+ *
+ * @param error - Axios error to serialize
+ * @returns Structured object with error details
+ */
+export declare function serializeAxiosError(error: AxiosError): AxiosErrorResponse;
+
+/**
+ * Creates a new instance of Spawn class.
+ * Spawn class is responsible for spawning a new worker thread and managing the lifecycle of the worker.
+ * The class provides utilities to emit control events to the platform and exit the worker gracefully.
+ * In case of lambda timeout, the class emits a lambda timeout event to the platform.
+ * @param {SpawnFactoryInterface} options - The options to create a new instance of Spawn class
+ * @param {AirSyncEvent} options.event - The event object received from the platform
+ * @param {object} options.initialState - The initial state of the adapter
+ * @param {string} [options.baseWorkerPath] - The base path for the worker files, usually `__dirname`
+ * @returns {Promise<Spawn>} - A new instance of Spawn class
+ */
+export declare function spawn<ConnectorState>({ event, initialState, initialDomainMapping, options, baseWorkerPath, }: SpawnFactoryInterface<ConnectorState>): Promise<void>;
+
+/**
+ * SpawnFactoryInterface is an interface for Spawn class factory.
+ * Spawn class is responsible for spawning a new worker thread and managing the lifecycle of the worker.
+ * The class provides utilities to emit control events to the platform and exit the worker gracefully.
+ * In case of lambda timeout, the class emits a lambda timeout event to the platform.
+ * @interface SpawnFactoryInterface
+ * @constructor
+ * @param {AirSyncEvent} event - The event object received from the platform
+ * @param {object=} initialState - The initial state of the adapter
+ * @param {string} initialDomainMapping - The initial domain mapping
+ * @param {WorkerAdapterOptions} options - The options to create a new instance of Spawn class
+ * @param {string=} baseWorkerPath - The base path for the worker files, usually `__dirname`
+ */
+export declare interface SpawnFactoryInterface<ConnectorState> {
+    event: AirSyncEvent;
+    initialState: ConnectorState;
+    options?: WorkerAdapterOptions;
+    initialDomainMapping?: InitialDomainMapping;
+    baseWorkerPath?: string;
+}
+
+/**
+ * SpawnInterface is an interface for Spawn class.
+ * @interface SpawnInterface
+ * @constructor
+ * @param {AirSyncEvent} event - The event object received from the platform
+ * @param {Worker} worker - The worker thread
+ */
+export declare interface SpawnInterface {
+    event: AirSyncEvent;
+    worker: Worker_2;
+    options?: WorkerAdapterOptions;
+    resolve: (value: void | PromiseLike<void>) => void;
+    originalConsole?: Console;
+}
+
+/**
+ * SsorAttachment is an interface that defines the structure of the SSOR attachment.
+ */
+export declare interface SsorAttachment {
+    id: {
+        devrev: string;
+        external: string;
+    };
+    parent_id: {
+        external: string;
+    };
+    actor_id?: {
+        external: string;
+    };
+    inline?: boolean;
+}
+
+/**
+ * Stage diagram definition for record type workflow.
+ */
+export declare interface StageDiagram {
+    /** The field that represents the stage in the external system. */
+    controlling_field: FieldKey;
+    /** A map of the stages that should be created. Keys must match the enum values in the controlling field. */
+    stages: Record<StageKey, CustomStage>;
+    /** The stage that the parent record type starts in when it is created. */
+    starting_stage?: StageKey;
+    /** A map of the states/status categories that should be created. */
+    states?: Record<StateKey, CustomState>;
+    /** Denotes that this diagram has no explicit transitions and should be created as an 'all-to-all' diagram. */
+    all_transitions_allowed?: boolean;
+}
+
+/** 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;
+    initialDomainMapping?: InitialDomainMapping;
+    options?: WorkerAdapterOptions;
+}
+
+/** Key identifying a state in the stage diagram states map. */
+export declare type StateKey = string;
+
+/**
+ * StreamAttachmentsResponse is an interface that defines the structure of the response from the stream attachments through Uploader.
+ */
+export declare interface StreamAttachmentsResponse {
+    ssorAttachments?: SsorAttachment[];
+    error?: ErrorRecord;
+}
+
+declare type StreamAttachmentsReturnType = {
+    delay?: number;
+    error?: ErrorRecord;
+} | undefined;
+
+/**
+ * StreamResponse is an interface that defines the structure of the response from the stream of single attachment through Uploader.
+ */
+export declare interface StreamResponse {
+    ssorAttachment?: SsorAttachment;
+    error?: ErrorRecord;
+}
+
+/**
+ * Struct field data referencing a struct type.
+ */
+export declare interface StructData {
+    key?: StructTypeKey;
+}
+
+/**
+ * Struct type definition for reusable field structures.
+ */
+export declare interface StructType {
+    /** The fields of the struct type */
+    fields: Record<FieldKey, Field>;
+    /** The human readable name of the struct type */
+    name?: string;
+}
+
+/** Key identifying a struct type in the struct_types map. */
+export declare type StructTypeKey = string;
+
+/**
+ * Represents a sync mapper record that links external system entities to DevRev entities.
+ */
+declare interface SyncMapperRecord {
+    id: DonV2;
+    /** Array of external system IDs that map to the same DevRev object */
+    external_ids: string[];
+    /**
+     * Optional map that labels values in `external_ids` with their usage context.
+     * Use when an external system requires different identifiers for different API calls
+     * (for example, a UUID for one endpoint and a login username for another).
+     *
+     * Example:
+     *   external_ids: ["2a1c...-uuid", "john_doe"]
+     *   secondary_ids: { "username": "john_doe" }
+     *
+     * Note: Values in `secondary_ids` are not indexed. If you need to look up by a
+     * secondary value (e.g., username), you must also include that value in `external_ids`.
+     */
+    secondary_ids?: Record<string, string>;
+    /** Array of DevRev entity IDs this mapping points to */
+    targets: DonV2[];
+    status: SyncMapperRecordStatus;
+    /**
+     * Optional file name where the object data was found.
+     * Useful for debugging - helps locate the source of object data later.
+     */
+    input_files?: string[];
+    /**
+     * Records external-system changes to prevent update loops.
+     * When the Loader writes to the external system, store the object's
+     * modified_date here. During the next sync back to DevRev, if the extracted
+     * object's modified_date exists in this list the update is skipped (avoids
+     * re-applying a DevRev-originated change).
+     */
+    external_versions?: SyncMapperRecordExternalVersion[];
+    /**
+     * Free-form data storage for your use. Store any additional information here.
+     * Completely opaque to the platform - use however you need.
+     */
+    extra_data?: string;
+}
+
+/**
+ * External version tracking to prevent update loops.
+ * Used to identify changes that originated from your system.
+ */
+declare interface SyncMapperRecordExternalVersion {
+    /** Sync recipe version at the time the external change was written */
+    recipe_version: number;
+    /** External system modified timestamp (ISO 8601 string) used for loop detection */
+    modified_date: string;
+}
+
+/**
+ * Status of a sync mapper record indicating its operational state.
+ */
+export declare enum SyncMapperRecordStatus {
+    /** The mapping is active and operational (default) */
+    OPERATIONAL = "operational",
+    /** The mapping was filtered out by user filter settings */
+    FILTERED = "filtered",
+    /**
+     * The external object should be ignored in sync operations.
+     * Use to prevent objects from being created or updated in DevRev.
+     */
+    IGNORED = "ignored"
+}
+
+/**
+ * Types of DevRev entities that can be targets in sync mapper records.
+ */
+export declare enum SyncMapperRecordTargetType {
+    ACCESS_CONTROL_ENTRY = "access_control_entry",
+    ACCOUNT = "account",
+    AIRSYNC_AUTHORIZATION_POLICY = "airdrop_authorization_policy",
+    AIRSYNC_FIELD_AUTHORIZATION_POLICY = "airdrop_field_authorization_policy",
+    AIRSYNC_PLATFORM_GROUP = "airdrop_platform_group",
+    ARTICLE = "article",
+    ARTIFACT = "artifact",
+    CHAT = "chat",
+    CONVERSATION = "conversation",
+    CUSTOM_OBJECT = "custom_object",
+    DIRECTORY = "directory",
+    GROUP = "group",
+    INCIDENT = "incident",
+    LINK = "link",
+    MEETING = "meeting",
+    OBJECT_MEMBER = "object_member",
+    PART = "part",
+    REV_ORG = "rev_org",
+    ROLE = "role",
+    ROLE_SET = "role_set",
+    TAG = "tag",
+    TIMELINE_COMMENT = "timeline_comment",
+    USER = "user",
+    WORK = "work"
+}
+
+/**
+ * SyncMode is an enum that defines the different modes of sync that can be used by the external extractor.
+ * It can be either INITIAL, INCREMENTAL or LOADING. INITIAL mode is used for
+ * the first/initial import, while INCREMENTAL mode is used for doing syncs. LOADING mode is used for
+ * loading data from DevRev to the external system.
+ */
+export declare enum SyncMode {
+    INITIAL = "INITIAL",
+    INCREMENTAL = "INCREMENTAL",
+    LOADING = "LOADING"
+}
+
+/**
+ * Target type key data for authorization policy.
+ */
+export declare interface TargetTypeKeyData {
+    /** The possible record types or record type categories that can be targeted in authorization policy. */
+    type_keys: RecordTypeKey[];
+}
+
+/**
+ * TaskAdapterInterface is an interface for TaskAdapter class.
+ * @interface TaskAdapterInterface
+ * @constructor
+ * @param {WorkerAdapter} adapter - The adapter object
+ */
+export declare interface TaskAdapterInterface<ConnectorState> {
+    adapter: WorkerAdapter<ConnectorState>;
+}
+
+/**
+ * Text field constraints.
+ */
+export declare interface TextData {
+    min_length?: number;
+    max_length?: number;
+}
+
+/**
+ * TimeUnit is an enum that defines the supported Go duration units for time window calculations.
+ * These correspond directly to Go's time.ParseDuration units.
+ */
+export declare enum TimeUnit {
+    /** Nanoseconds */
+    NANOSECONDS = "ns",
+    /** Microseconds (ASCII alias) */
+    MICROSECONDS = "us",
+    /** Microseconds (Unicode alias) */
+    MICROSECONDS_MU = "\u00B5s",
+    /** Milliseconds */
+    MILLISECONDS = "ms",
+    /** Seconds */
+    SECONDS = "s",
+    /** Minutes */
+    MINUTES = "m",
+    /** Hours */
+    HOURS = "h"
+}
+
+/**
+ * TimeValue is an interface that represents a time value used in extraction start/end times.
+ * It contains a type (which denotes how the value should be resolved) and an optional value.
+ * - For ABSOLUTE: value is an ISO 8601 timestamp
+ * - For *_WINDOW types: value is a Go duration string (e.g. '500ms', '30s', '5m', '2h')
+ * - For other types: value is not used
+ */
+export declare interface TimeValue {
+    type: TimeValueType;
+    value?: string;
+}
+
+/**
+ * TimeValueType is an enum that defines the type of a time value used in extraction start/end times.
+ * The platform sends these types to indicate how the extraction time should be resolved by the SDK.
+ */
+export declare enum TimeValueType {
+    /** Oldest timestamp from worker state */
+    WORKERS_OLDEST = "workers_oldest",
+    /** Oldest timestamp from worker state minus a duration window */
+    WORKERS_OLDEST_MINUS_WINDOW = "workers_oldest_minus_window",
+    /** Newest timestamp from worker state */
+    WORKERS_NEWEST = "workers_newest",
+    /** Newest timestamp from worker state plus a duration window */
+    WORKERS_NEWEST_PLUS_WINDOW = "workers_newest_plus_window",
+    /** Current time */
+    CURRENT_TIME = "current_time",
+    /** User-specified absolute timestamp */
+    ABSOLUTE_TIME = "absolute_time",
+    /** No bound - extract all available data */
+    UNBOUNDED = "unbounded"
+}
+
+declare interface ToDevRev {
+    attachmentsMetadata: {
+        artifactIds: string[];
+        lastProcessed: number;
+        lastProcessedAttachmentsIdsList?: ProcessedAttachment[];
+    };
+}
+
+/**
+ * Typed reference field data specifying target record types.
+ */
+export declare interface TypedReferenceData {
+    /** The record types that this reference can refer to */
+    refers_to: Record<RecordTypeKey, ReferenceDetail>;
+    /** The parent reference refers to a record that has special ownership over the child */
+    reference_type?: ReferenceType;
+}
+
+/**
+ * Sentinel value representing an unbounded (no limit) extraction timestamp.
+ * Used as the resolved value for TimeValueType.UNBOUNDED, stored as workersOldest
+ * when the initial import has no lower time bound. The Unix epoch ensures that
+ * no real extraction timestamp can be earlier, preventing accidental overwrites
+ * of the boundary by subsequent syncs (e.g. reconciliation with absolute dates).
+ */
+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;
+    /**
+     * 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;
+    postState(): Promise<void>;
+    get artifacts(): Artifact[];
+    set artifacts(artifacts: Artifact[]);
+    /**
+     *  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>;
+    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>;
+    /**
+     * Destroys a stream to prevent memory leaks.
+     * @param httpStream - The axios response stream to destroy
+     */
+    private destroyHttpStream;
+    loadAttachment({ item, create, }: {
+        item: ExternalSystemAttachment;
+        create: ExternalSystemLoadingFunction<ExternalSystemAttachment>;
+    }): Promise<LoadItemResponse>;
+    /**
+     * 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>;
+}
+
+/**
+ * WorkerAdapterInterface is an interface for WorkerAdapter class.
+ * @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
+ */
+export declare interface WorkerAdapterInterface<ConnectorState> {
+    event: AirSyncEvent;
+    adapterState: State<ConnectorState>;
+    options?: WorkerAdapterOptions;
+}
+
+/**
+ * WorkerAdapterOptions represents the options for WorkerAdapter class.
+ * @interface WorkerAdapterOptions
+ * @constructor
+ * @param {boolean=} isLocalDevelopment - A flag to indicate if the adapter is being used in local development
+ * @param {number=} timeout - The timeout for the worker thread
+ * @param {number=} batchSize - Maximum number of extracted items in a batch
+ * @param {Record<EventType, string>=} workerPathOverrides - A map of event types to custom worker paths to override default worker paths
+ */
+export declare interface WorkerAdapterOptions {
+    isLocalDevelopment?: boolean;
+    timeout?: number;
+    batchSize?: number;
+    workerPathOverrides?: WorkerPathOverrides;
+    skipConfirmation?: boolean;
+}
+
+/**
+ * WorkerData represents the structure of the worker data object.
+ */
+export declare interface WorkerData<ConnectorState> {
+    event: AirSyncEvent;
+    initialState: ConnectorState;
+    workerPath: string;
+    initialDomainMapping?: InitialDomainMapping;
+    options?: WorkerAdapterOptions;
+}
+
+/**
+ * WorkerEvent represents the standard worker events.
+ */
+export declare enum WorkerEvent {
+    WorkerMessage = "message",
+    WorkerOnline = "online",
+    WorkerError = "error",
+    WorkerExit = "exit"
+}
+
+/**
+ * WorkerMessage represents the structure of the worker message.
+ */
+export declare type WorkerMessage = WorkerMessageEmitted | WorkerMessageExit | WorkerMessageLog | WorkerMessageFailed;
+
+/**
+ * WorkerMessageEmitted interface represents the structure of the emitted worker message.
+ */
+export declare interface WorkerMessageEmitted {
+    subject: WorkerMessageSubject.WorkerMessageEmitted;
+    payload: {
+        eventType: ExtractorEventType | LoaderEventType;
+    };
+}
+
+/**
+ * WorkerMessageExit interface represents the structure of the exit worker message.
+ */
+export declare interface WorkerMessageExit {
+    subject: WorkerMessageSubject.WorkerMessageExit;
+}
+
+/**
+ * WorkerMessageFailed interface represents the structure of the worker failed message.
+ * Sent from the worker thread before calling process.exit(1) to convey the specific
+ * error reason to the main thread.
+ */
+export declare interface WorkerMessageFailed {
+    subject: WorkerMessageSubject.WorkerMessageFailed;
+    payload: {
+        message: string;
+    };
+}
+
+/**
+ * WorkerMessageLog interface represents the structure of the worker log message.
+ */
+export declare interface WorkerMessageLog {
+    subject: WorkerMessageSubject.WorkerMessageLog;
+    payload: {
+        stringifiedArgs: string;
+        level: LogLevel;
+        isSdkLog?: boolean;
+    };
+}
+
+/**
+ * WorkerMessageSubject represents the handled worker message subjects.
+ */
+export declare enum WorkerMessageSubject {
+    WorkerMessageEmitted = "emit",
+    WorkerMessageExit = "exit",
+    WorkerMessageLog = "log",
+    WorkerMessageFailed = "failed"
+}
+
+/**
+ * WorkerMetadata is an interface that defines the structure of the worker metadata that is sent from the external extractor to the AirSync platform.
+ */
+declare interface WorkerMetadata {
+    adaas_library_version: string;
+}
+
+/**
+ * WorkerPathOverrides represents a mapping of event types to custom worker paths.
+ */
+export declare type WorkerPathOverrides = Partial<Record<EventType, string>>;
+
+export { }