import { AuthService } from "@backstage/backend-plugin-api";
import { Config } from "@backstage/config";
import { TaskStore } from "@backstage/plugin-scaffolder-backend";
import { SerializedTask, SerializedTaskEvent, TaskBroker, TaskBrokerDispatchOptions, TaskContext, TaskStatus } from "@backstage/plugin-scaffolder-node";
import { WorkspaceProvider } from "@backstage/plugin-scaffolder-node/alpha";
import { Observable } from "@backstage/types";
import { Logger } from "winston";
export declare class StorageTaskBroker implements TaskBroker {
    private readonly storage;
    private readonly logger;
    private readonly config?;
    private readonly auth?;
    private readonly additionalWorkspaceProviders?;
    constructor(storage: TaskStore, logger: Logger, config?: Config | undefined, auth?: AuthService | undefined, additionalWorkspaceProviders?: Record<string, WorkspaceProvider> | undefined);
    list(options?: {
        createdBy?: string;
        status?: TaskStatus;
        filters?: {
            createdBy?: string | string[];
            status?: TaskStatus | TaskStatus[];
        };
        pagination?: {
            limit?: number;
            offset?: number;
        };
        order?: {
            order: "asc" | "desc";
            field: string;
        }[];
    }): Promise<{
        tasks: SerializedTask[];
        totalTasks?: number;
    }>;
    private deferredDispatch;
    private registerCancellable;
    recoverTasks(): Promise<void>;
    /**
     * {@inheritdoc TaskBroker.claim}
     */
    claim(): Promise<TaskContext>;
    /**
     * {@inheritdoc TaskBroker.dispatch}
     */
    dispatch(options: TaskBrokerDispatchOptions): Promise<{
        taskId: string;
    }>;
    /**
     * {@inheritdoc TaskBroker.get}
     */
    get(taskId: string): Promise<SerializedTask>;
    /**
     * {@inheritdoc TaskBroker.event$}
     */
    event$(options: {
        taskId: string;
        after?: number;
    }): Observable<{
        events: SerializedTaskEvent[];
    }>;
    /**
     * {@inheritdoc TaskBroker.vacuumTasks}
     */
    vacuumTasks(options: {
        timeoutS: number;
    }): Promise<void>;
    private waitForDispatch;
    private signalDispatch;
    cancel(taskId: string): Promise<void>;
    retry?(taskId: string): Promise<void>;
}
//# sourceMappingURL=storage-task.d.ts.map