import { type FailureSignature } from "../failures";
import type { AdaptedJob, JobPageMeta } from "../queue-adapters/base.adapter";
declare const JOB_STATUSES: readonly ["completed", "failed", "delayed", "active", "prioritized", "waiting", "waiting-children", "paused"];
type JobListStatus = (typeof JOB_STATUSES)[number];
export declare const jobRouter: import("@trpc/server").TRPCBuiltRouter<{
    ctx: import("../trpc").Context;
    meta: object;
    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
    transformer: false;
}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
    retry: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
        };
        output: AdaptedJob;
        meta: object;
    }>;
    discard: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
        };
        output: AdaptedJob;
        meta: object;
    }>;
    rerun: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
        };
        output: AdaptedJob;
        meta: object;
    }>;
    promote: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
        };
        output: AdaptedJob;
        meta: object;
    }>;
    bulkPromoteByFilter: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            status: "delayed";
            maxScanned?: number | undefined;
            from?: number | undefined;
            to?: number | undefined;
            fromOffset?: number | undefined;
            toOffset?: number | undefined;
            groupId?: string | undefined;
            query?: string | undefined;
            name?: string | undefined;
        };
        output: {
            scanned: number;
            matched: number;
            succeeded: number;
            failed: number;
            partial: boolean;
            scanLimitReached: boolean;
        };
        meta: object;
    }>;
    remove: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
        };
        output: AdaptedJob;
        meta: object;
    }>;
    bulkRemove: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobIds: string[];
        };
        output: {
            succeeded: number;
            failed: number;
        };
        meta: object;
    }>;
    bulkRemoveByFilter: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            status: "failed" | "active" | "paused" | "completed" | "waiting" | "delayed" | "waiting-children" | "prioritized";
            error?: string | undefined;
            maxScanned?: number | undefined;
            from?: number | undefined;
            to?: number | undefined;
            fromOffset?: number | undefined;
            toOffset?: number | undefined;
            groupId?: string | undefined;
            query?: string | undefined;
            name?: string | undefined;
        };
        output: {
            scanned: number;
            matched: number;
            succeeded: number;
            failed: number;
            partial: boolean;
            scanLimitReached: boolean;
        };
        meta: object;
    }>;
    bulkRetry: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobIds: string[];
        };
        output: {
            succeeded: number;
            failed: number;
        };
        meta: object;
    }>;
    bulkRetryByFilter: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            status: "failed";
            error?: string | undefined;
            maxScanned?: number | undefined;
            from?: number | undefined;
            to?: number | undefined;
            fromOffset?: number | undefined;
            toOffset?: number | undefined;
            groupId?: string | undefined;
            query?: string | undefined;
            name?: string | undefined;
        };
        output: {
            total: number;
            scanned: number;
            matched: number;
            succeeded: number;
            failed: number;
            partial: boolean;
            scanLimitReached: boolean;
        };
        meta: object;
    }>;
    bulkRemoveByGroup: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            groupId: string;
            maxScanned?: number | undefined;
        };
        output: {
            total: number;
            succeeded: number;
            failed: number;
            scanned: number;
            partial: boolean;
            scanLimitReached: boolean;
        };
        meta: object;
    }>;
    byId: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
            jobId: string;
        };
        output: {
            status: "failed" | "active" | "paused" | "completed" | "waiting" | "delayed" | "waiting-children" | "prioritized" | null;
            errorFingerprint: string | null;
            id: string;
            name: string;
            data: Record<string, unknown>;
            opts: import("../queue-adapters/base.adapter").JobOptions;
            createdAt: Date;
            processedAt: Date | null;
            finishedAt: Date | null;
            failedReason?: string;
            stacktrace?: string[];
            retriedAt: Date | null;
            returnValue?: unknown;
            groupId?: string;
            progress?: number;
            attemptsMade?: number;
            rawName?: string;
            processedBy?: string;
            attemptsStarted?: number;
            stalledCounter?: number;
            deduplicationId?: string;
            runAt?: Date | null;
            priority?: number;
        } | null;
        meta: object;
    }>;
    logs: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
            jobId: string;
        };
        output: string[] | null;
        meta: object;
    }>;
    search: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
            query: string;
            statuses?: ("failed" | "active" | "paused" | "completed" | "waiting" | "delayed" | "waiting-children" | "prioritized")[] | undefined;
            limit?: number | undefined;
            maxScanned?: number | undefined;
        };
        output: {
            results: Array<{
                job: AdaptedJob;
                status: JobListStatus | null;
            }>;
            scanned: number;
            partial: boolean;
            scanLimitReached: boolean;
            resultLimitReached: boolean;
        };
        meta: object;
    }>;
    updateData: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
            data: {
                [x: string]: unknown;
            };
            retry?: boolean | undefined;
        };
        output: AdaptedJob;
        meta: object;
    }>;
    changeDelay: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
            runAt: number;
        };
        output: AdaptedJob;
        meta: object;
    }>;
    changePriority: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
            priority: number;
        };
        output: AdaptedJob;
        meta: object;
    }>;
    removeDeduplication: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            jobId: string;
        };
        output: {
            released: boolean;
        };
        meta: object;
    }>;
    types: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
            minutes: number;
        };
        output: {
            now: number;
            minutes: number;
            scanned: number;
            scanLimitReached: boolean;
            types: {
                name: string;
                completed: number;
                failed: number;
                failureRate: number;
                p50: number | null;
                p95: number | null;
                lastFinishedAt: number;
            }[];
        };
        meta: object;
    }>;
    find: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            query: string;
            limit?: number | undefined;
        };
        output: {
            results: {
                queueName: string;
                queueDisplayName: string;
                status: "failed" | "active" | "paused" | "completed" | "waiting" | "delayed" | "waiting-children" | "prioritized" | null;
                job: AdaptedJob;
            }[];
            scanned: number;
            partial: boolean;
        };
        meta: object;
    }>;
    errorGroups: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
            range?: "1h" | "24h" | "7d" | "all" | undefined;
        };
        output: {
            now: number;
            range: "1h" | "24h" | "7d" | "all";
            scanned: number;
            scanLimitReached: boolean;
            failedInRange: number;
            oldestFailureAt: number | null;
            groups: (FailureSignature & {
                count: number;
                firstSeen: number;
                lastSeen: number;
                hourly: number[];
            })[];
        };
        meta: object;
    }>;
    runTimes: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
            minutes: number;
        };
        output: {
            count: number;
            p50: number | null;
            p95: number | null;
            buckets: Array<number | null>;
            now: number;
            minutes: number;
            scanned: number;
            scanLimitReached: boolean;
        };
        meta: object;
    }>;
    list: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
            limit: number;
            status: "failed" | "active" | "paused" | "completed" | "waiting" | "delayed" | "waiting-children" | "prioritized";
            error?: string | undefined;
            searchInData?: boolean | undefined;
            scanLimit?: number | undefined;
            sort?: "queue" | "newest" | "oldest" | undefined;
            from?: number | undefined;
            to?: number | undefined;
            fromOffset?: number | undefined;
            toOffset?: number | undefined;
            cursor?: number | undefined;
            groupId?: string | undefined;
            query?: string | undefined;
            name?: string | undefined;
        };
        output: {
            totalCount: number;
            numOfPages: number;
            nextCursor: number | undefined;
            jobs: AdaptedJob[];
            searchMeta: {
                scanned: number;
                capped: boolean;
                scanLimit: number;
            };
            errorGroup: FailureSignature | null;
        } | {
            totalCount: number;
            numOfPages: number;
            nextCursor: number | undefined;
            jobs: AdaptedJob[];
            searchMeta: JobPageMeta | undefined;
            errorGroup?: undefined;
        };
        meta: object;
    }>;
}>>;
export {};
//# sourceMappingURL=job.d.ts.map