import { AuthenticatedUser } from '../auth/interfaces/jwt-payload.interface';
import { AuditEventsService } from './audit-events.service';
import { CreateAhaRuleVersionDto } from './dto/create-aha-rule-version.dto';
import { CreateAuditEventsBatchDto } from './dto/create-audit-event.dto';
export declare class AuditEventsController {
    private readonly auditEventsService;
    constructor(auditEventsService: AuditEventsService);
    create(dto: CreateAuditEventsBatchDto, user?: AuthenticatedUser): Promise<{
        inserted: number;
        duplicates: number;
    }>;
    findAll(query: Record<string, string>): Promise<{
        events: (import("mongoose").FlattenMaps<import("./schemas/audit-event.schema").AuditEventDocument> & Required<{
            _id: import("mongoose").Types.ObjectId;
        }> & {
            __v: number;
        })[];
        total: number;
        limit: number;
        offset: number;
    }>;
    findRollups(query: Record<string, string>): Promise<{
        rollups: (import("mongoose").FlattenMaps<import("./schemas/audit-event-rollup.schema").AuditEventRollupDocument> & Required<{
            _id: import("mongoose").Types.ObjectId;
        }> & {
            __v: number;
        })[];
        total: number;
        limit: number;
        offset: number;
    }>;
    getAhaMetrics(query: Record<string, string>): Promise<{
        rule_version: string;
        rule: {
            version: string;
            label: string;
            description?: string;
            is_active: boolean;
            key_events: {
                key: string;
                label: string;
                event_names: string[];
                min_count: number;
                required: boolean;
            }[];
            allowed_key_screens: string[];
            min_distinct_key_screens: number;
            min_return_days: number;
            created_by?: string;
        } | null;
        period: {
            endDate?: Date | undefined;
            startDate?: Date | undefined;
        };
        totals: {
            actors_started: number;
            key_events_completed: number;
            key_screens_completed: number;
            return_completed: number;
            aha_reached: number;
        };
        key_events: {
            actors_seen: number;
            actors_completed: number;
            total_count: number;
            key: string;
            label: string;
            event_names: string[];
            min_count: number;
            required: boolean;
        }[];
    }>;
    getActiveAhaRule(): Promise<{
        version: string;
        label: string;
        description?: string;
        is_active: boolean;
        key_events: {
            key: string;
            label: string;
            event_names: string[];
            min_count: number;
            required: boolean;
        }[];
        allowed_key_screens: string[];
        min_distinct_key_screens: number;
        min_return_days: number;
        created_by?: string;
    }>;
    listAhaRuleVersions(): Promise<{
        version: string;
        label: string;
        description?: string;
        is_active: boolean;
        key_events: {
            key: string;
            label: string;
            event_names: string[];
            min_count: number;
            required: boolean;
        }[];
        allowed_key_screens: string[];
        min_distinct_key_screens: number;
        min_return_days: number;
        created_by?: string;
    }[]>;
    createAhaRuleVersion(dto: CreateAhaRuleVersionDto, user?: AuthenticatedUser): Promise<import("mongoose").Document<unknown, {}, import("./schemas/aha-rule-version.schema").AhaRuleVersionDocument, {}, {}> & import("./schemas/aha-rule-version.schema").AhaRuleVersion & import("mongoose").Document<import("mongoose").Types.ObjectId, any, any, Record<string, any>, {}> & Required<{
        _id: import("mongoose").Types.ObjectId;
    }> & {
        __v: number;
    }>;
    listAhaProgress(query: Record<string, string>): Promise<{
        items: (import("mongoose").FlattenMaps<import("./schemas/aha-progress.schema").AhaProgressDocument> & Required<{
            _id: import("mongoose").Types.ObjectId;
        }> & {
            __v: number;
        })[];
        total: number;
        limit: number;
        offset: number;
    }>;
    getAhaRuleSnippet(): Promise<{
        rule_version: string;
        snippet: string;
    }>;
    previewRollups(query: Record<string, string>): Promise<{
        raw_count: number;
        group_count: number;
        duplicate_count: number;
        estimated_bytes: number;
        groups: {
            rollup_key: string;
            day: string;
            event_name: string;
            actor_id: string;
            actor_role: "advisor" | "client" | "unknown";
            source: "web" | "api" | "mobile";
            client_uuid?: string;
            count: number;
            first_seen_at: Date;
            last_seen_at: Date;
            rolled_up_until: Date;
            sample_session_ids: string[];
            sample_correlation_ids: string[];
            metadata: Record<string, unknown>;
            estimated_bytes?: number;
        }[];
    }>;
    runRollups(query: Record<string, string>): Promise<{
        upserted_count: number;
        raw_count: number;
    }>;
    pruneRolledUpEvents(query: Record<string, string>): Promise<{
        deleted_count: number;
        rollup_count: number;
    }>;
    deleteRollups(query: Record<string, string>): Promise<{
        deleted_count: number;
    }>;
    deleteSelectedRollups(rollupKeys: string[]): Promise<{
        deleted_count: number;
    }>;
    deleteSelectedAuditEvents(eventIds: string[]): Promise<{
        deleted_count: number;
    }>;
    deleteAuditEvents(query: Record<string, string>): Promise<{
        deleted_count: number;
    }>;
    private parseFilters;
    private parseAhaQuery;
    private parseAhaProgressQuery;
}