/**
 * Worker Export - HumanReviewService WorkerEntrypoint
 *
 * Provides HumanReviewWorker (WorkerEntrypoint with connect() method)
 * and HumanReviewServiceCore (RpcTarget with review service methods).
 *
 * @packageDocumentation
 */
import { WorkerEntrypoint, RpcTarget } from 'cloudflare:workers';
/**
 * Environment bindings for the HumanReviewWorker
 */
export interface Env {
    AI: Ai;
    HUMAN_REVIEW_STATE: DurableObjectNamespace;
}
type ReviewRequestType = 'approval' | 'question' | 'task' | 'decision' | 'review';
type ReviewRequestStatus = 'pending' | 'in_progress' | 'completed' | 'rejected' | 'escalated' | 'timeout' | 'cancelled';
type ReviewPriority = 'low' | 'normal' | 'high' | 'critical';
interface ReviewRequest {
    id: string;
    type: ReviewRequestType;
    status: ReviewRequestStatus;
    priority: ReviewPriority;
    title: string;
    description: string;
    content: unknown;
    assignee?: string | string[];
    role?: string;
    team?: string;
    createdAt: Date;
    updatedAt: Date;
    completedAt?: Date;
    respondedBy?: string;
    response?: unknown;
    rejectionReason?: string;
    escalatedTo?: string;
    escalatedAt?: Date;
    metadata?: Record<string, unknown>;
}
interface ReviewDecision {
    requestId: string;
    decision: 'approved' | 'rejected';
    decidedBy: string;
    decidedAt: Date;
    comments?: string;
    conditions?: string[];
    feedback?: string;
}
interface ReviewFeedback {
    id: string;
    requestId: string;
    feedbackBy: string;
    feedbackAt: Date;
    rating?: number;
    comments: string;
    suggestions?: string[];
    tags?: string[];
}
interface QueueFilters {
    status?: ReviewRequestStatus[];
    priority?: ReviewPriority[];
    assignee?: string[];
    role?: string[];
    team?: string[];
    type?: ReviewRequestType[];
}
interface QueueOptions {
    filters?: QueueFilters;
    limit?: number;
    offset?: number;
    sortBy?: 'createdAt' | 'priority' | 'updatedAt';
    sortDirection?: 'asc' | 'desc';
}
interface EscalationOptions {
    to: string;
    reason?: string;
    priority?: ReviewPriority;
    notifyVia?: ('slack' | 'email' | 'sms' | 'web')[];
}
interface RequestReviewParams {
    type: ReviewRequestType;
    title: string;
    description: string;
    content: unknown;
    assignee?: string | string[];
    role?: string;
    team?: string;
    priority?: ReviewPriority;
    timeout?: number;
    metadata?: Record<string, unknown>;
}
interface ApproveParams {
    decidedBy: string;
    comments?: string;
    conditions?: string[];
}
interface RejectParams {
    decidedBy: string;
    reason: string;
    feedback?: string;
}
interface AddFeedbackParams {
    requestId: string;
    feedbackBy: string;
    rating?: number;
    comments: string;
    suggestions?: string[];
    tags?: string[];
}
interface QueueStats {
    total: number;
    pending: number;
    inProgress: number;
    completed: number;
    rejected: number;
    escalated: number;
    byPriority: Record<string, number>;
    avgResponseTime?: number;
}
/**
 * HumanReviewServiceCore - RpcTarget that provides human review operations
 *
 * This class is returned by HumanReviewWorker.connect() and provides:
 * - requestReview() - create review requests
 * - approve() - approve items
 * - reject() - reject items
 * - escalate() - escalate to higher authority
 * - getQueue() - list pending reviews
 * - addFeedback() - collect human feedback
 * - getDecision() - retrieve review decisions
 */
export declare class HumanReviewServiceCore extends RpcTarget {
    #private;
    constructor(env: Env);
    /**
     * Create a new review request
     */
    requestReview(params: RequestReviewParams): Promise<ReviewRequest>;
    /**
     * Approve a pending request
     */
    approve(requestId: string, params: ApproveParams): Promise<ReviewDecision>;
    /**
     * Reject a pending request
     */
    reject(requestId: string, params: RejectParams): Promise<ReviewDecision>;
    /**
     * Escalate a request to a higher authority
     */
    escalate(requestId: string, options: EscalationOptions): Promise<ReviewRequest>;
    /**
     * Get the review queue with optional filtering
     */
    getQueue(options?: QueueOptions): Promise<ReviewRequest[]>;
    /**
     * Add feedback to a request
     */
    addFeedback(params: AddFeedbackParams): Promise<ReviewFeedback>;
    /**
     * Get the decision for a request
     */
    getDecision(requestId: string): Promise<ReviewDecision | null>;
    /**
     * Get a request by ID
     */
    getRequest(requestId: string): Promise<ReviewRequest | null>;
    /**
     * List all feedback for a request
     */
    listFeedback(requestId: string): Promise<ReviewFeedback[]>;
    /**
     * Update the status of a request
     */
    updateStatus(requestId: string, status: ReviewRequestStatus, respondedBy?: string): Promise<ReviewRequest>;
    /**
     * Assign a request to one or more users
     */
    assign(requestId: string, assignee: string | string[]): Promise<ReviewRequest>;
    /**
     * Get queue statistics
     */
    getQueueStats(): Promise<QueueStats>;
}
/**
 * HumanReviewWorker - WorkerEntrypoint for human review service
 *
 * Extends WorkerEntrypoint to provide RPC access to HumanReviewServiceCore.
 * The connect() method returns an RpcTarget that can be used via Service Bindings.
 *
 * Usage:
 * ```ts
 * // In another worker with a service binding
 * const service = env.HUMAN_REVIEW.connect()
 * const request = await service.requestReview({...})
 * ```
 */
export declare class HumanReviewWorker extends WorkerEntrypoint<Env> {
    /**
     * Returns an RpcTarget that provides human review service methods
     */
    connect(): HumanReviewServiceCore;
}
export default HumanReviewWorker;
//# sourceMappingURL=worker.d.ts.map