/**
 * WEBHOOKS & ASYNC CALLBACKS
 * Event streaming, retry logic, signature verification
 */
export declare enum WebhookEvent {
    REQUEST_STARTED = "request.started",
    REQUEST_COMPLETED = "request.completed",
    REQUEST_FAILED = "request.failed",
    BATCH_STARTED = "batch.started",
    BATCH_COMPLETED = "batch.completed",
    BATCH_FAILED = "batch.failed",
    MODEL_CHANGED = "model.changed",
    COST_ALERT = "cost.alert",
    QUOTA_EXCEEDED = "quota.exceeded"
}
export declare enum DeliveryStatus {
    PENDING = "pending",
    DELIVERING = "delivering",
    DELIVERED = "delivered",
    FAILED = "failed",
    RETRY = "retry",
    CANCELLED = "cancelled"
}
export interface WebhookConfig {
    id: string;
    url: string;
    events: WebhookEvent[];
    secret: string;
    enabled: boolean;
    max_retries: number;
    retry_delay_ms: number;
    timeout_ms: number;
    headers?: Record<string, string>;
    created_at: Date;
}
export interface WebhookPayload {
    id: string;
    event: WebhookEvent;
    timestamp: Date;
    data: Record<string, unknown>;
    tenant_id: string;
}
export interface WebhookDelivery {
    id: string;
    webhook_id: string;
    payload: WebhookPayload;
    status: DeliveryStatus;
    attempts: number;
    next_retry?: Date;
    last_error?: string;
    delivered_at?: Date;
    created_at: Date;
}
export interface CallbackConfig {
    url: string;
    headers?: Record<string, string>;
    timeout_ms?: number;
}
export declare class WebhookManager {
    private webhooks;
    private deliveries;
    private retry_queue;
    private processing_interval?;
    constructor(config?: {
        process_interval_ms?: number;
    });
    /**
     * Register webhook
     */
    register(params: {
        url: string;
        events: WebhookEvent[];
        secret: string;
        max_retries?: number;
        retry_delay_ms?: number;
        timeout_ms?: number;
        headers?: Record<string, string>;
    }): WebhookConfig;
    /**
     * Emit event
     */
    emit(event: WebhookEvent, data: Record<string, unknown>, tenant_id: string): Promise<void>;
    /**
     * Get webhook
     */
    get(webhook_id: string): WebhookConfig | null;
    /**
     * List webhooks
     */
    list(): WebhookConfig[];
    /**
     * Update webhook
     */
    update(webhook_id: string, updates: Partial<Omit<WebhookConfig, 'id' | 'created_at'>>): WebhookConfig | null;
    /**
     * Delete webhook
     */
    delete(webhook_id: string): boolean;
    /**
     * Get delivery status
     */
    getDelivery(delivery_id: string): WebhookDelivery | null;
    /**
     * Get deliveries for webhook
     */
    getDeliveries(webhook_id: string): WebhookDelivery[];
    /**
     * Stop processing
     */
    stop(): void;
    private startProcessing;
    private processQueue;
    private deliver;
    private sign;
    private generateId;
}
export declare class AsyncCallbackManager {
    private callbacks;
    /**
     * Register callback for async operation
     */
    register(operation_id: string, config: CallbackConfig): void;
    /**
     * Trigger callback
     */
    trigger(operation_id: string, result: {
        success: boolean;
        data?: unknown;
        error?: string;
    }): Promise<void>;
    /**
     * Remove callback
     */
    remove(operation_id: string): boolean;
    /**
     * Check if callback exists
     */
    has(operation_id: string): boolean;
}
export interface EventStreamListener {
    id: string;
    events: WebhookEvent[];
    callback: (event: WebhookPayload) => void | Promise<void>;
}
export declare class EventStreamManager {
    private listeners;
    private event_buffer;
    private buffer_size;
    constructor(config?: {
        buffer_size?: number;
    });
    /**
     * Subscribe to events
     */
    subscribe(events: WebhookEvent[], callback: (event: WebhookPayload) => void | Promise<void>): string;
    /**
     * Unsubscribe from events
     */
    unsubscribe(listener_id: string): boolean;
    /**
     * Publish event
     */
    publish(event: WebhookPayload): Promise<void>;
    /**
     * Get recent events
     */
    getRecentEvents(event_type?: WebhookEvent, limit?: number): WebhookPayload[];
    /**
     * Clear buffer
     */
    clearBuffer(): void;
    private generateId;
}
//# sourceMappingURL=webhook-manager.d.ts.map