import { Event, Breadcrumb, User, SeverityLevel, LogSeverityLevel, Stacktrace, Transport, SpanAttributes } from '@sentry/core';
export = sentryTestkit;
declare function sentryTestkit<T extends sentryTestkit.V6TransportClass | sentryTestkit.V7TransportFunction>(): sentryTestkit.TestkitResult<T>;
declare namespace sentryTestkit {
    interface Page {
        on(event: string, handler: (...args: any[]) => any): void;
        off(event: string, handler: (...args: any[]) => any): void;
    }
    interface ReportError {
        name: string;
        message: string;
        stacktrace: Stacktrace;
    }
    interface ReportFlag {
        flag: string;
        result: any;
    }
    interface Attachment {
        filename: string;
        contentType?: string;
        attachmentType?: string;
        data: Uint8Array;
        text: string;
    }
    interface Report {
        breadcrumbs: Breadcrumb[];
        error?: ReportError;
        message?: string;
        extra?: {
            [key: string]: any;
        };
        level: SeverityLevel;
        release?: string;
        user?: User;
        tags: {
            [key: string]: string;
        };
        flags: ReportFlag[];
        attachments: Attachment[];
        replayId?: string;
        originalReport: Event;
    }
    interface Span {
        spanId: string;
        traceId?: string;
        parentSpanId?: string;
        op?: string;
        description?: string;
        status?: string;
        origin?: string;
        startTimestamp?: number;
        endTimestamp?: number;
        data: {
            [key: string]: any;
        };
        attributes: {
            [key: string]: any;
        };
        isStandalone: boolean;
        originalSpan: any;
        id: string;
        span_id: string;
        parent_span_id?: string;
        trace_id?: string;
    }
    interface Transaction {
        name: string;
        traceId: string;
        spanId: string;
        parentSpanId?: string | null;
        data?: Record<string, any>;
        status?: string | null;
        op?: string | null;
        release?: string;
        extra?: Record<string, any>;
        tags: Record<string, any>;
        attributes: SpanAttributes;
        spans: Span[];
        user?: User;
    }
    interface Log {
        level: LogSeverityLevel;
        message: string;
        attributes: {
            [key: string]: any;
        };
        timestamp: number;
        traceId?: string;
        severityNumber?: number;
        originalLog: any;
    }
    interface FeedbackReport {
        message: string;
        name?: string;
        contactEmail?: string;
        url?: string;
        associatedEventId?: string;
        source?: string;
        replayId?: string;
        eventId?: string;
        originalFeedback: any;
    }
    type MetricType = 'counter' | 'gauge' | 'distribution';
    interface Metric {
        name: string;
        type: MetricType;
        value: number;
        unit?: string;
        attributes: {
            [key: string]: any;
        };
        timestamp: number;
        traceId?: string;
        spanId?: string;
        originalMetric: any;
    }
    type CheckInStatus = 'in_progress' | 'ok' | 'error';
    interface CheckIn {
        checkInId: string;
        monitorSlug: string;
        status: CheckInStatus;
        duration?: number;
        release?: string;
        environment?: string;
        originalCheckIn: any;
    }
    type SessionStatus = 'ok' | 'exited' | 'crashed' | 'abnormal';
    interface Session {
        sid: string;
        status: SessionStatus;
        errors: number;
        release?: string;
        environment?: string;
        duration?: number;
        originalSession: any;
    }
    interface SessionAggregate {
        started: string;
        exited: number;
        errored: number;
        crashed: number;
        abnormal: number;
        release?: string;
        environment?: string;
        originalAggregate: any;
    }
    type ReplayType = 'session' | 'buffer';
    interface Replay {
        replayId: string;
        segmentId: number;
        replayType?: ReplayType;
        traceIds: string[];
        errorIds: string[];
        urls: string[];
        timestamp?: number;
        release?: string;
        environment?: string;
        recording?: Uint8Array;
        originalReplay: any;
    }
    interface WaitForOptions {
        timeout?: number;
    }
    interface Testkit {
        puppeteer: {
            startListening(page: Page, baseUrl?: string): void;
            stopListening(page: Page): void;
        };
        playwright: {
            startListening(page: Page, baseUrl?: string): void;
            stopListening(page: Page): void;
        };
        reports(): Report[];
        transactions(): Transaction[];
        logs(): Log[];
        metrics(): Metric[];
        attachments(): Attachment[];
        feedback(): FeedbackReport[];
        checkIns(): CheckIn[];
        sessions(): Session[];
        sessionAggregates(): SessionAggregate[];
        replays(): Replay[];
        spans(): Span[];
        waitForReports(count: number, options?: WaitForOptions): Promise<Report[]>;
        waitForTransactions(count: number, options?: WaitForOptions): Promise<Transaction[]>;
        waitForLogs(count: number, options?: WaitForOptions): Promise<Log[]>;
        waitForMetrics(count: number, options?: WaitForOptions): Promise<Metric[]>;
        waitForAttachments(count: number, options?: WaitForOptions): Promise<Attachment[]>;
        waitForFeedback(count: number, options?: WaitForOptions): Promise<FeedbackReport[]>;
        waitForCheckIns(count: number, options?: WaitForOptions): Promise<CheckIn[]>;
        waitForSessions(count: number, options?: WaitForOptions): Promise<Session[]>;
        waitForSessionAggregates(count: number, options?: WaitForOptions): Promise<SessionAggregate[]>;
        waitForReplays(count: number, options?: WaitForOptions): Promise<Replay[]>;
        waitForSpans(count: number, options?: WaitForOptions): Promise<Span[]>;
        reset(): void;
        getExceptionAt(index: number): ReportError | undefined;
        findReport(e: Error): Report | undefined;
        findReportByMessage(message: string | RegExp): Report | undefined;
        findTransaction(name: string | RegExp): Transaction | undefined;
        findSpansByOp(op: string | RegExp): Span[];
        reportsWithTag(key: string, value?: string): Report[];
        transactionsWithTag(key: string, value?: any): Transaction[];
        isExist(e: Error): boolean;
    }
    interface LocalServer {
        start: (dsn: string) => Promise<void>;
        stop: () => Promise<void>;
        getDsn: () => string;
    }
    type V6TransportClass = {
        new (): Transport;
    };
    type V7TransportFunction = () => Transport;
    interface TestkitResult<Transport extends V6TransportClass | V7TransportFunction> {
        testkit: Testkit;
        sentryTransport: Transport;
        initNetworkInterceptor<T>(dsn: string, initCallback: (baseUrl: string, handleRequestBody: (requestBody: {
            [key: string]: any;
        }) => void) => T): T;
        localServer: LocalServer;
    }
}
//# sourceMappingURL=types.d.ts.map