import { BaseErrorTrackingProvider } from '../../base-error-tracking-provider.js';
import type { ProviderConfig, ConsentSettings } from '../../../types/provider.js';
import type { ErrorContext } from '../../../definitions.js';
interface RollbarConfig extends ProviderConfig {
    accessToken: string;
    environment?: string;
    codeVersion?: string;
    platform?: string;
    endpoint?: string;
    maxItems?: number;
    itemsPerMinute?: number;
    captureUncaught?: boolean;
    captureUnhandledRejections?: boolean;
    autoInstrument?: {
        network?: boolean;
        log?: boolean;
        dom?: boolean;
        navigation?: boolean;
        connectivity?: boolean;
    };
    payload?: {
        environment?: string;
        client?: {
            javascript?: {
                source_map_enabled?: boolean;
                guess_uncaught_frames?: boolean;
            };
        };
        server?: {
            host?: string;
            root?: string;
            branch?: string;
        };
        person?: {
            id?: string;
            username?: string;
            email?: string;
        };
    };
    transform?: (payload: any) => any;
    onSendCallback?: (isUncaught: boolean, args: any[]) => void;
    scrubFields?: string[];
    scrubHeaders?: string[];
    checkIgnore?: (isUncaught: boolean, args: any[], payload: any) => boolean;
    logLevel?: 'critical' | 'error' | 'warning' | 'info' | 'debug';
    reportLevel?: 'critical' | 'error' | 'warning' | 'info' | 'debug';
    uncaughtErrorLevel?: 'critical' | 'error' | 'warning' | 'info' | 'debug';
    hostWhiteList?: string[];
    hostBlackList?: string[];
    ignoredMessages?: string[];
    verbose?: boolean;
    enabled?: boolean;
    telemetry?: boolean;
    maxTelemetryEvents?: number;
    telemetryTypes?: string[];
    autoCollectErrors?: boolean;
    wrapGlobalEventHandlers?: boolean;
    captureIp?: boolean | 'anonymize';
    captureEmail?: boolean;
    captureUsername?: boolean;
}
interface RollbarSDK {
    init: (config: any) => void;
    configure: (config: any) => void;
    critical: (message: string | Error, extra?: any, callback?: (err: any, data: any) => void) => void;
    error: (message: string | Error, extra?: any, callback?: (err: any, data: any) => void) => void;
    warning: (message: string | Error, extra?: any, callback?: (err: any, data: any) => void) => void;
    info: (message: string | Error, extra?: any, callback?: (err: any, data: any) => void) => void;
    debug: (message: string | Error, extra?: any, callback?: (err: any, data: any) => void) => void;
    log: (message: string | Error, extra?: any, callback?: (err: any, data: any) => void) => void;
    scope: (options: any) => RollbarSDK;
    addTransform: (transform: (payload: any) => any) => void;
    addCheckIgnore: (checkIgnore: (isUncaught: boolean, args: any[], payload: any) => boolean) => void;
    person: (person: any) => void;
    telemetry: {
        captureEvent: (type: string, metadata?: any, level?: string) => void;
        captureLog: (message: string, level?: string, extra?: any) => void;
        captureNetwork: (metadata: any, level?: string) => void;
        captureDom: (element: Element, event: string, metadata?: any, level?: string) => void;
        captureNavigation: (from: string, to: string, metadata?: any, level?: string) => void;
        captureConnectivity: (metadata: any, level?: string) => void;
    };
    wrap: (func: (...args: any[]) => any, context?: any) => (...args: any[]) => any;
    loadFull: () => void;
    captureEvent: (type: string, metadata: any, level?: string) => void;
    lambdaHandler: (handler: (...args: any[]) => any) => (...args: any[]) => any;
    isIgnored: (payload: any) => boolean;
    buildPayload: (data: any) => any;
    sendPayload: (payload: any, callback?: (err: any, response: any) => void) => void;
    wait: (callback: (err: any) => void) => void;
    captureUncaughtExceptions: (enabled?: boolean) => void;
    captureUnhandledRejections: (enabled?: boolean) => void;
    global: (options: any) => RollbarSDK;
}
declare global {
    interface Window {
        Rollbar?: RollbarSDK;
    }
}
export declare class RollbarErrorTrackingProvider extends BaseErrorTrackingProvider {
    readonly id = "rollbar";
    readonly name = "Rollbar Error Tracking";
    readonly version = "1.0.0";
    private rollbar?;
    private _rollbarConfig;
    private scriptLoaded;
    protected doInitialize(config: RollbarConfig): Promise<void>;
    private loadRollbarSDK;
    protected doShutdown(): Promise<void>;
    protected doUpdateConsent(consent: ConsentSettings): Promise<void>;
    protected doLogError(error: Error | string, context?: ErrorContext): Promise<void>;
    private mapSeverityToRollbarLevel;
    protected doSetUserContext(user: Record<string, any>): void;
    protected doSetExtraContext(key: string, value: any): void;
    protected doSetTags(tags: Record<string, string>): void;
    protected doCaptureException(exception: Error, context: ErrorContext): Promise<void>;
    protected doProviderReset(): Promise<void>;
    protected doEnable(): Promise<void>;
    protected doDisable(): Promise<void>;
    protected doAddBreadcrumb(message: string, category?: string, data?: Record<string, any>): void;
    protected doLogMessage(message: string, level: 'debug' | 'info' | 'warning', _extra?: Record<string, any>): Promise<void>;
    protected doCaptureBreadcrumb(breadcrumb: {
        message: string;
        category?: string;
        level?: string;
        data?: Record<string, any>;
    }): Promise<void>;
    protected doSetDebugMode(enabled: boolean): void;
    /**
     * Configure Rollbar with new options
     */
    configure(config: Partial<RollbarConfig>): void;
    /**
     * Create a new Rollbar instance with scoped configuration
     */
    scope(options: any): RollbarSDK | null;
    /**
     * Add a transform function
     */
    addTransform(transform: (payload: any) => any): void;
    /**
     * Add a check ignore function
     */
    addCheckIgnore(checkIgnore: (isUncaught: boolean, args: any[], payload: any) => boolean): void;
    /**
     * Wrap a function to capture errors
     */
    wrap(func: (...args: any[]) => any, context?: any): ((...args: any[]) => any) | null;
    /**
     * Load the full Rollbar SDK
     */
    loadFull(): void;
    /**
     * Capture a custom event
     */
    captureEvent(type: string, metadata: any, level?: string): void;
    /**
     * Capture telemetry log
     */
    captureTelemetryLog(message: string, level?: string, extra?: any): void;
    /**
     * Capture telemetry network event
     */
    captureTelemetryNetwork(metadata: any, level?: string): void;
    /**
     * Capture telemetry DOM event
     */
    captureTelemetryDom(element: Element, event: string, metadata?: any, level?: string): void;
    /**
     * Capture telemetry navigation event
     */
    captureTelemetryNavigation(from: string, to: string, metadata?: any, level?: string): void;
    /**
     * Capture telemetry connectivity event
     */
    captureTelemetryConnectivity(metadata: any, level?: string): void;
    /**
     * Check if an error would be ignored
     */
    isIgnored(payload: any): boolean;
    /**
     * Build a payload
     */
    buildPayload(data: any): any;
    /**
     * Send a payload
     */
    sendPayload(payload: any, callback?: (err: any, response: any) => void): void;
    /**
     * Wait for all items to be sent
     */
    wait(callback: (err: any) => void): void;
    /**
     * Enable/disable uncaught exception capturing
     */
    captureUncaughtExceptions(enabled?: boolean): void;
    /**
     * Enable/disable unhandled rejection capturing
     */
    captureUnhandledRejections(enabled?: boolean): void;
    /**
     * Get global Rollbar instance
     */
    global(options: any): RollbarSDK | null;
}
export {};