import { Model } from 'mongoose';
import { AuthenticatedUser } from '../auth/interfaces/jwt-payload.interface';
import { CreateAuditEventDto } from './dto/create-audit-event.dto';
import { CreateAhaRuleVersionDto } from './dto/create-aha-rule-version.dto';
import { QueryAhaProgressDto } from './dto/query-aha-progress.dto';
import { AhaMetricsQuery, AuditEventFilters } from './dto/query-audit-events.dto';
import { AuditEventDocument } from './schemas/audit-event.schema';
import { AuditEventRollupDocument } from './schemas/audit-event-rollup.schema';
import { AhaProgressDocument } from './schemas/aha-progress.schema';
import { AhaRuleVersion, AhaRuleVersionDocument } from './schemas/aha-rule-version.schema';
type AhaRuleSnapshot = {
    version: string;
    label: string;
    description?: string;
    is_active: boolean;
    key_events: AhaKeyEventRuleSnapshot[];
    allowed_key_screens: string[];
    min_distinct_key_screens: number;
    min_return_days: number;
    created_by?: string;
};
type AhaKeyEventRuleSnapshot = {
    key: string;
    label: string;
    event_names: string[];
    min_count: number;
    required: boolean;
};
type CreateBatchResult = {
    inserted: number;
    duplicates: number;
};
export declare class AuditEventsService {
    private readonly auditEventModel;
    private readonly auditEventRollupModel;
    private readonly ahaProgressModel;
    private readonly ahaRuleVersionModel;
    constructor(auditEventModel: Model<AuditEventDocument>, auditEventRollupModel: Model<AuditEventRollupDocument>, ahaProgressModel: Model<AhaProgressDocument>, ahaRuleVersionModel: Model<AhaRuleVersionDocument>);
    createBatch(events: CreateAuditEventDto[], user?: AuthenticatedUser): Promise<CreateBatchResult>;
    findAll(filters?: AuditEventFilters): Promise<{
        events: (import("mongoose").FlattenMaps<AuditEventDocument> & Required<{
            _id: import("mongoose").Types.ObjectId;
        }> & {
            __v: number;
        })[];
        total: number;
        limit: number;
        offset: number;
    }>;
    findRollups(filters?: AuditEventFilters): Promise<{
        rollups: (import("mongoose").FlattenMaps<AuditEventRollupDocument> & Required<{
            _id: import("mongoose").Types.ObjectId;
        }> & {
            __v: number;
        })[];
        total: number;
        limit: number;
        offset: number;
    }>;
    getAhaMetrics(query: AhaMetricsQuery): Promise<{
        rule_version: string;
        rule: AhaRuleSnapshot | 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<AhaRuleSnapshot>;
    listAhaRuleVersions(): Promise<AhaRuleSnapshot[]>;
    createAhaRuleVersion(dto: CreateAhaRuleVersionDto, user?: AuthenticatedUser): Promise<import("mongoose").Document<unknown, {}, AhaRuleVersionDocument, {}, {}> & AhaRuleVersion & import("mongoose").Document<import("mongoose").Types.ObjectId, any, any, Record<string, any>, {}> & Required<{
        _id: import("mongoose").Types.ObjectId;
    }> & {
        __v: number;
    }>;
    listAhaProgress(query?: QueryAhaProgressDto): Promise<{
        items: (import("mongoose").FlattenMaps<AhaProgressDocument> & Required<{
            _id: import("mongoose").Types.ObjectId;
        }> & {
            __v: number;
        })[];
        total: number;
        limit: number;
        offset: number;
    }>;
    getAhaRuleSnippet(): Promise<{
        rule_version: string;
        snippet: string;
    }>;
    previewRollups(filters?: AuditEventFilters): 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(filters?: AuditEventFilters): Promise<{
        upserted_count: number;
        raw_count: number;
    }>;
    pruneRolledUpEvents(filters?: AuditEventFilters): Promise<{
        deleted_count: number;
        rollup_count: number;
    }>;
    deleteRollups(filters?: AuditEventFilters): Promise<{
        deleted_count: number;
    }>;
    deleteSelectedRollups(rollupKeys: string[]): Promise<{
        deleted_count: number;
    }>;
    deleteAuditEvents(filters?: AuditEventFilters): Promise<{
        deleted_count: number;
    }>;
    deleteSelectedAuditEvents(eventIds: string[]): Promise<{
        deleted_count: number;
    }>;
    private resolveActor;
    private assertUnknownActorAllowed;
    private assertMetadataSize;
    private updateAhaProgressFromEvents;
    private isAhaRelevantEvent;
    private buildKeyEventsByEventName;
    private resolveNextKeyEventCounts;
    private resolveNextKeyEventsSeen;
    private resolveNextKeyEventsCompleted;
    private resolveNextKeyEventsCompletedAt;
    private areRequiredKeyEventsCompleted;
    private resolveNextKeyScreensSeen;
    private isReturnEventSatisfied;
    private resolveAhaReachedAt;
    private getAhaRuleByVersion;
    private buildDefaultAhaRule;
    private calculateDayDiff;
    private validateAhaRuleVersion;
    private buildAhaKeyEventMetrics;
    private buildRollupGroups;
    private buildQuery;
    private buildSingleFieldProjection;
    private buildPresenceProjection;
    private buildFieldInPeriodExpression;
    private buildRollupMatch;
    private buildRollupQuery;
    private buildPrunableRollupQuery;
    private buildQueryForRollup;
    private formatRollupDay;
    private countDuplicateKeyErrors;
    private hasNonDuplicateWriteError;
    private getWriteErrors;
    private getBulkInsertedCount;
}
export {};