export declare const queueRouter: import("@trpc/server").TRPCBuiltRouter<{
    ctx: import("../trpc").Context;
    meta: object;
    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
    transformer: false;
}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
    clean: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            status: string;
        };
        output: {
            name: string;
        };
        meta: object;
    }>;
    empty: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
        };
        output: {
            name: string;
        };
        meta: object;
    }>;
    pause: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
        };
        output: {
            name: string;
        };
        meta: object;
    }>;
    pauseAll: import("@trpc/server").TRPCMutationProcedure<{
        input: void;
        output: string;
        meta: object;
    }>;
    resume: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
        };
        output: {
            name: string;
        };
        meta: object;
    }>;
    resumeAll: import("@trpc/server").TRPCMutationProcedure<{
        input: void;
        output: string;
        meta: object;
    }>;
    addJob: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            data: {
                [x: string]: unknown;
            };
            name?: string | undefined;
            opts?: {
                [x: string]: unknown;
            } | undefined;
        };
        output: {
            name: string;
        };
        meta: object;
    }>;
    addJobScheduler: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            template: {
                data: Record<string, unknown>;
                name?: string | undefined;
                opts?: {
                    attempts?: unknown;
                    backoff?: unknown;
                    continueParentOnFailure?: boolean | undefined;
                    failParentOnFailure?: boolean | undefined;
                    ignoreDependencyOnFailure?: boolean | undefined;
                    keepLogs?: unknown;
                    lifo?: unknown;
                    priority?: unknown;
                    removeDependencyOnFailure?: boolean | undefined;
                    removeOnComplete?: unknown;
                    removeOnFail?: unknown;
                    sizeLimit?: unknown;
                    stackTraceLimit?: unknown;
                    telemetry?: {
                        metadata?: string | undefined;
                        omitContext?: boolean | undefined;
                    } | undefined;
                    timestamp?: number | undefined;
                } | undefined;
            };
            opts: {
                pattern?: string | undefined;
                every?: number | undefined;
                tz?: string | undefined;
                limit?: number | undefined;
                startDate?: string | number | Date | undefined;
                endDate?: string | number | Date | undefined;
                offset?: number | undefined;
                immediately?: boolean | undefined;
            };
        };
        output: {
            name: string;
        };
        meta: object;
    }>;
    byName: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
        };
        output: {
            displayName: string;
            name: string;
            paused: boolean;
            type: "bull" | "bullmq" | "groupmq" | "bee";
            supports: {
                groups: boolean;
                logs: boolean;
                flows: boolean;
                schedulerUpdate: boolean;
                updateData: boolean;
                addJobOptions: boolean;
                addJobOptionKeys: readonly string[];
                jobNames: boolean;
                pause: boolean;
                resume: boolean;
                clean: boolean | {
                    supportedStatuses: string[];
                };
                discard: boolean;
                retry: boolean;
                promote: boolean;
                schedulers: boolean;
                priorities: boolean;
                empty: boolean;
                metrics: boolean;
                statuses: string[];
                workers: boolean;
                changeDelay: boolean;
                changePriority: boolean;
                deduplication: boolean;
                concurrencyLimit: boolean;
                rateLimit: boolean;
            };
            access: import("../access").ResolvedQueueAccess;
            counts: {
                active: number;
                completed: number;
                delayed: number;
                failed: number;
                waiting: number;
                prioritized: number;
                "waiting-children": number;
                paused: number;
            };
            client: {
                usedMemoryPercentage: number;
                usedMemoryHuman: string;
                totalMemoryHuman: string;
                uptimeInSeconds: number;
                connectedClients: number;
                blockedClients: number;
                maxClients: number;
                version: string;
            } | null;
        };
        meta: object;
    }>;
    list: import("@trpc/server").TRPCQueryProcedure<{
        input: void;
        output: {
            displayName: string;
            name: string;
            paused: boolean | null;
            failedCount: number | null;
            supports: {
                pause: boolean;
                resume: boolean;
            };
            access: import("../access").ResolvedQueueAccess;
        }[];
        meta: object;
    }>;
    metrics: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
            type: "failed" | "completed";
            start: number;
            end: number;
        };
        output: import("../queue-adapters/base.adapter").QueueMetrics;
        meta: object;
    }>;
    groups: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
        };
        output: {
            id: string;
            count: number;
            status: "active" | "paused" | "rate-limited";
        }[];
        meta: object;
    }>;
    workers: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
        };
        output: {
            id: string;
            name?: string;
            ageSeconds?: number;
            idleSeconds?: number;
        }[] | null;
        meta: object;
    }>;
    limits: import("@trpc/server").TRPCQueryProcedure<{
        input: {
            queueName: string;
        };
        output: import("../queue-adapters/base.adapter").QueueLimits | null;
        meta: object;
    }>;
    setConcurrency: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            concurrency: number | null;
        };
        output: {
            success: boolean;
        };
        meta: object;
    }>;
    setRateLimit: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
            limit: {
                max: number;
                duration: number;
            } | null;
        };
        output: {
            success: boolean;
        };
        meta: object;
    }>;
    clearRateLimit: import("@trpc/server").TRPCMutationProcedure<{
        input: {
            queueName: string;
        };
        output: {
            success: boolean;
        };
        meta: object;
    }>;
}>>;
//# sourceMappingURL=queue.d.ts.map