export type { Context, QueuedashAccessConfig, QueuedashAccessMode, QueuedashAccessRule, QueuedashAction, QueuedashBranding, QueuedashDefaultJobStatus, QueuedashDensity, QueuedashPrivacyConfig, QueuedashQueue, QueuedashQueueDiscoveryConfig, QueuedashRedactionConfig, QueuedashSearchConfig, QueuedashTheme, QueuedashTimestampMode, QueuedashUiConfig, } from "../trpc";
export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
    ctx: import("../trpc").Context;
    meta: object;
    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
    transformer: false;
}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
    flow: import("@trpc/server").TRPCBuiltRouter<{
        ctx: import("../trpc").Context;
        meta: object;
        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
        transformer: false;
    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
        links: import("@trpc/server").TRPCQueryProcedure<{
            input: {
                queueName: string;
                jobId: string;
            };
            output: {
                now: number;
                job: import("./flow").FlowJob;
                parent: import("./flow").FlowJob | null;
                parentHidden: boolean;
                blocksParent: boolean;
            } | null;
            meta: object;
        }>;
        tree: import("@trpc/server").TRPCQueryProcedure<{
            input: {
                queueName: string;
                jobId: string;
                childLimits?: Record<string, number> | undefined;
            };
            output: {
                now: number;
                root: import("./flow").FlowJob;
                parentHidden: boolean;
                truncated: boolean;
                maxChildLimit: number;
            };
            meta: object;
        }>;
    }>>;
    job: 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: import("../queue-adapters/base.adapter").AdaptedJob;
            meta: object;
        }>;
        discard: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                jobId: string;
            };
            output: import("../queue-adapters/base.adapter").AdaptedJob;
            meta: object;
        }>;
        rerun: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                jobId: string;
            };
            output: import("../queue-adapters/base.adapter").AdaptedJob;
            meta: object;
        }>;
        promote: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                jobId: string;
            };
            output: import("../queue-adapters/base.adapter").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: import("../queue-adapters/base.adapter").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: import("../queue-adapters/base.adapter").AdaptedJob;
                    status: ("failed" | "active" | "paused" | "completed" | "waiting" | "delayed" | "waiting-children" | "prioritized") | 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: import("../queue-adapters/base.adapter").AdaptedJob;
            meta: object;
        }>;
        changeDelay: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                jobId: string;
                runAt: number;
            };
            output: import("../queue-adapters/base.adapter").AdaptedJob;
            meta: object;
        }>;
        changePriority: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                jobId: string;
                priority: number;
            };
            output: import("../queue-adapters/base.adapter").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: import("../queue-adapters/base.adapter").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: (import("../failures").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: import("../queue-adapters/base.adapter").AdaptedJob[];
                searchMeta: {
                    scanned: number;
                    capped: boolean;
                    scanLimit: number;
                };
                errorGroup: import("../failures").FailureSignature | null;
            } | {
                totalCount: number;
                numOfPages: number;
                nextCursor: number | undefined;
                jobs: import("../queue-adapters/base.adapter").AdaptedJob[];
                searchMeta: import("../queue-adapters/base.adapter").JobPageMeta | undefined;
                errorGroup?: undefined;
            };
            meta: object;
        }>;
    }>>;
    queue: 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;
        }>;
    }>>;
    scheduler: import("@trpc/server").TRPCBuiltRouter<{
        ctx: import("../trpc").Context;
        meta: object;
        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
        transformer: false;
    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
        list: import("@trpc/server").TRPCQueryProcedure<{
            input: {
                queueName: string;
            };
            output: import("../queue-adapters/base.adapter").SchedulerInfo[];
            meta: object;
        }>;
        add: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                jobName: string;
                data: Record<string, unknown>;
                pattern?: string | undefined;
                every?: number | undefined;
                tz?: string | undefined;
            };
            output: {
                success: boolean;
            };
            meta: object;
        }>;
        update: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                key: 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: {
                success: boolean;
            };
            meta: object;
        }>;
        remove: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                jobSchedulerId: string;
            };
            output: {
                success: boolean;
            };
            meta: object;
        }>;
        bulkRemove: import("@trpc/server").TRPCMutationProcedure<{
            input: {
                queueName: string;
                jobSchedulerIds: string[];
            };
            output: import("../queue-adapters/base.adapter").SchedulerInfo[];
            meta: object;
        }>;
    }>>;
    settings: import("@trpc/server").TRPCBuiltRouter<{
        ctx: import("../trpc").Context;
        meta: object;
        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
        transformer: false;
    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
        get: import("@trpc/server").TRPCQueryProcedure<{
            input: void;
            output: {
                version: string;
                access: {
                    default: import("../trpc").QueuedashAccessMode;
                    rules: {
                        queues: string[];
                        mode: "full" | "read-only";
                        deny: import("../trpc").QueuedashAction[];
                    }[];
                };
                privacy: {
                    redactionEnabled: boolean;
                    expose: import("../presentation").ResolvedPrivacyExposure;
                };
                search: {
                    maxScanned: number;
                };
                discovery: {
                    type: "bull" | "bullmq" | undefined;
                    prefix: string;
                    refreshIntervalMs: number;
                    maxQueues: number;
                    discoveredCount: number;
                    enabled: boolean;
                    healthy: boolean;
                    lastAttemptAt?: number;
                    lastErrorAt?: number;
                    lastSuccessfulRefreshAt?: number;
                    truncated: boolean;
                };
            };
            meta: object;
        }>;
    }>>;
}>>;
export type AppRouter = typeof appRouter;
//# sourceMappingURL=_app.d.ts.map