import { Task, Guard } from './';
import { Logger } from './logger';
export interface Message {
    id: string;
}
export interface MessageTransformer<T extends Message, R extends Message> {
    transform(input: T): Promise<R | Array<R>>;
}
export interface MessageSource<T extends Message> {
    getNext(): Promise<T>;
    complete(message: T): Promise<void>;
    /**
     * Called when a message could not be completed, and is expected to be retried
     * (returned by some later getNext() call). This gives the implementation an opportunity
     * to apply a backoff strategy to the message.
     *
     * This returns the number of times a message has been attempted (including the latest
     * attempt).
     */
    backoff(message: T): Promise<number>;
    /**
     * Called when a message should be delayed for processing for some amount of time. The
     * message should not be redelivered until this amount of time has elapsed.
     *
     * This returns the number of times a message has been attempted (including the latest
     * attempt).
     */
    delay(message: T, delaySecs: number): Promise<number>;
}
export interface MessageSink<T extends Message> {
    persist(message: T): Promise<void>;
}
export interface SourceSinkConfig<T extends Message, R extends Message> {
    timeoutSec: number;
    guardScope: string;
    guard: Guard;
    source: MessageSource<T>;
    transformer: MessageTransformer<T, R>;
    sink?: MessageSink<R>;
    logger?: Logger;
}
export declare class SourceSinkTask<T extends Message, R extends Message> implements Task {
    private config;
    private log;
    constructor(config: SourceSinkConfig<T, R>);
    private checkGuard;
    execute(): Promise<boolean>;
    private post;
}
export declare class PassthroughTransformer<T extends Message> implements MessageTransformer<T, T> {
    transform(input: T): Promise<T>;
}