/// <reference types="node" />
import type { LogContext } from '@balena/jellyfish-logger';
import type { AutumnDBSession, Contract } from 'autumndb';
import type { Map, WorkerContext } from '../types';
import * as errors from './errors';
import * as oauth from './oauth';
import * as pipeline from './pipeline';
import * as syncContext from './sync-context';
import type { HttpRequestOptions, Integration, IntegrationDefinition, IntegrationInitializationOptions, SequenceItem } from './types';
export { errors, Integration, IntegrationDefinition, IntegrationInitializationOptions, HttpRequestOptions, oauth, SequenceItem, };
/**
 * Jellyfish sync library module.
 *
 * @module sync
 */
interface SyncOptions {
    integrations?: Map<IntegrationDefinition>;
}
export declare class Sync {
    integrations: Map<IntegrationDefinition>;
    errors: typeof errors;
    pipeline: typeof pipeline;
    constructor(options?: SyncOptions);
    /**
     * @summary Gets external user
     * @function
     * @public
     *
     * @param {Object} syncActionContext - sync action context
     * @param {String} name - integration name
     * @param {String} credentials - access token for external provider api
     * @returns {Object} external user
     */
    whoami(syncActionContext: syncContext.SyncActionContext, name: string, credentials: any): Promise<any>;
    /**
     * @summary Gets local user matching the external user
     * @function
     * @public
     *
     * @param {Object} context - execution context
     * @param {String} name - integration name
     * @param {Object} externalUser - external user
     * @param {Object} options - options
     * @param {String} options.slug - slug to be used as a fallback to get a user
     * @returns {Object} external user
     */
    match(context: syncContext.SyncActionContext, name: string, externalUser: any, options: {
        slug: string;
    }): Promise<Contract<import("autumndb").ContractData, {
        [key: string]: Contract<import("autumndb").ContractData, any>[];
    }> | null>;
    getExternalUserSyncEventData(logContext: LogContext, name: string, externalUser: any): Promise<any>;
    /**
     * @summary Associate a user with an external OAuth service
     * @function
     * @public
     *
     * @param name - integration name
     * @param userContract - user to associate external token to
     * @param credentials - external provider's api token
     * @param context - sync action context
     * @returns upserted user contract
     */
    associate(name: string, userContract: Contract, credentials: any, context: syncContext.SyncActionContext): Promise<Contract<import("autumndb").ContractData, {
        [key: string]: Contract<import("autumndb").ContractData, any>[];
    }> | null>;
    /**
     * @summary Check if an external event request is valid
     * @function
     * @public
     *
     * @param logContext - log context
     * @param name - integration name
     * @param token - token details
     * @param event - event
     * @param event.raw - raw event payload
     * @param event.headers - request headers
     * @returns whether the external event should be accepted or not
     */
    isValidEvent(logContext: LogContext, name: string, token: any, event: {
        raw: any;
        headers: any;
    }): Promise<boolean>;
    /**
     * @summary Mirror back a contract insert coming from Jellyfish
     * @function
     * @public
     *
     * @param name - integration name
     * @param token - token details
     * @param contract - action target contract
     * @param context - sync action context
     * @param options - options object
     * @param options.actor - actor id
     * @param options.origin - oauth origin url
     * @param options.defaultUser - default user id
     * @returns inserted contracts
     */
    mirror(name: string, token: any, contract: Contract, context: syncContext.SyncActionContext, options: {
        actor: string;
        origin: string;
        defaultUser: string;
    }): Promise<Contract<import("autumndb").ContractData, {
        [key: string]: Contract<import("autumndb").ContractData, any>[];
    }>[]>;
    /**
     * @summary Translate an external event into Jellyfish
     * @function
     * @public
     *
     * @param name - integration name
     * @param token - token details
     * @param contract - action target contract
     * @param context - execution context
     * @param options - options
     * @param options.actor - actor id
     * @param options.defaultUser - default user id
     * @param options.origin - oauth origin url
     * @returns inserted contracts
     */
    translate(name: string, token: string, contract: Contract, context: syncContext.SyncActionContext, options: {
        actor: string;
        defaultUser: string;
        origin: string;
    }): Promise<Contract<import("autumndb").ContractData, {
        [key: string]: Contract<import("autumndb").ContractData, any>[];
    }>[]>;
    /**
     * @summary Fetch a file synced in an external service
     * @function
     * @public
     *
     * @param name - integration name
     * @param token - token details
     * @param file - file id
     * @param context - sync action context
     * @param options - options object
     * @param options.actor - actor id
     * @returns file
     */
    getFile(name: string, token: any, file: string, context: syncContext.SyncActionContext, options: {
        actor: string;
    }): Promise<Buffer | null>;
    getActionContext(provider: string, workerContext: WorkerContext, context: any, session: AutumnDBSession): {
        getContactByEmail: (email: string) => Promise<Contract<import("autumndb").ContractData, {
            [key: string]: Contract<import("autumndb").ContractData, any>[];
        }> | null>;
        getElementBySlug: (slug: string, usePrivilegedSession?: boolean) => Promise<any>;
        getElementById: (id: string) => Promise<any>;
        getOauthProviderByIntegration: (integration: string) => Promise<any>;
        getElementByMirrorId: (type: string, mirrorId: string, getOptions?: {
            usePattern?: boolean | undefined;
        }) => Promise<any>;
        getElementByMirrorIds: (type: string, mirrorIds: string[]) => Promise<any>;
        logContext: LogContext;
        log: {
            warn: (message: string, data: any) => void;
            error: (message: string, data: any) => void;
            debug: (message: string, data: any) => void;
            info: (message: string, data: any) => void;
            exception: (message: string, error: any) => void;
        };
        getLocalUsername: (username: string) => string;
        getRemoteUsername: (username: string) => string;
        upsertElement: (type: string, object: Partial<Contract<import("autumndb").ContractData, {
            [key: string]: Contract<import("autumndb").ContractData, any>[];
        }>> | {
            id: string;
            type: string;
            patch: import("fast-json-patch").Operation[];
        }, options: {
            actor?: string | undefined;
            timestamp?: Date | undefined;
            originator?: string | undefined;
        }) => Promise<Contract<import("autumndb").ContractData, {
            [key: string]: Contract<import("autumndb").ContractData, any>[];
        }> | null>;
        query: (query: import("autumndb").JsonSchema, options?: import("autumndb").QueryOptions | undefined) => Promise<Contract<import("autumndb").ContractData, {
            [key: string]: Contract<import("autumndb").ContractData, any>[];
        }>[]>;
    };
}