// Type definitions for rollbar
// Project: Rollbar

export = Rollbar;

declare class Rollbar {
    constructor(options?: Rollbar.Configuration);
    static init(options: Rollbar.Configuration): Rollbar;
    static setComponents(components: Rollbar.Components): void;

    public global(options: Rollbar.Configuration): Rollbar;
    public configure(options: Rollbar.Configuration): Rollbar;
    public lastError(): Rollbar.MaybeError;

    public log(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
    public debug(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
    public info(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
    public warn(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
    public warning(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
    public error(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
    public critical(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
    public wait(callback: () => void): void;

    public captureEvent(metadata: object, level: Rollbar.Level): Rollbar.TelemetryEvent;

    public lambdaHandler<T = object>(handler: Rollbar.LambdaHandler<T>): Rollbar.LambdaHandler<T>;

    public errorHandler(): Rollbar.ExpressErrorHandler;

    // Used with rollbar-react for rollbar-react-native compatibility.
    public rollbar: Rollbar;

    // Exposed only for testing, should be changed via the configure method
    // DO NOT MODIFY DIRECTLY
    public options: Rollbar.Configuration;
}

declare namespace Rollbar {
    export type LambdaHandler<TEvent = any, TResult = any, TContext = any> = (
        event: TEvent,
        context: TContext,
        callback: Callback<TResult>,
    ) => void | Promise<TResult>;
    export type MaybeError = Error | undefined | null;
    export type Level = "debug" | "info" | "warning" | "error" | "critical";
    export type Dictionary = { [key: string]: unknown};
    /**
     * {@link https://docs.rollbar.com/docs/rollbarjs-configuration-reference#reference}
     */
    export interface Configuration {
        accessToken?: string;
        addErrorContext?: boolean;
        addRequestData?: (data: Dictionary, req: Dictionary) => void;
        autoInstrument?: AutoInstrumentOptions;
        captureDeviceInfo?: boolean;
        captureEmail?: boolean;
        captureIp?: boolean | "anonymize";
        captureLambdaTimeouts?: boolean;
        captureUncaught?: boolean;
        captureUnhandledRejections?: boolean;
        captureUsername?: boolean;
        checkIgnore?: (isUncaught: boolean, args: LogArgument[], item: Dictionary) => boolean;
        /**
         * `codeVersion` takes precedence over `code_version`, if provided.
         * `client.javascript.code_version` takes precedence over both top level properties.
         */
        codeVersion?: string;
        /**
         * `codeVersion` takes precedence over `code_version`, if provided.
         * `client.javascript.code_version` takes precedence over both top level properties.
         */
        code_version?: string;
        enabled?: boolean;
        endpoint?: string;
        exitOnUncaughtException?: boolean;
        environment?: string;
        filterTelemetry?: (e: TelemetryEvent) => boolean;
        host?: string; // used in node only
        hostBlackList?: string[]; // deprecated
        hostBlockList?: string[];
        hostWhiteList?: string[]; // deprecated
        hostSafeList?: string[];
        ignoredMessages?: (string | RegExp)[];
        ignoreDuplicateErrors?: boolean;
        includeItemsInTelemetry?: boolean;
        inspectAnonymousErrors?: boolean;
        itemsPerMinute?: number;
        locals?: LocalsOptions;
        logLevel?: Level;
        maxItems?: number;
        maxRetries?: number;
        maxTelemetryEvents?: number;
        nodeSourceMaps?: boolean;
        onSendCallback?: (isUncaught: boolean, args: LogArgument[], item: Dictionary) => void;
        overwriteScrubFields?: boolean;
        payload?: Payload;
        reportLevel?: Level;
        retryInterval?: number | null;
        rewriteFilenamePatterns?: string[];
        scrubFields?: string[];
        scrubHeaders?: string[];
        scrubPaths?: string[];
        scrubRequestBody?: boolean;
        scrubTelemetryInputs?: boolean;
        sendConfig?: boolean;
        stackTraceLimit?: number;
        telemetryScrubber?: TelemetryScrubber;
        timeout?: number;
        transform?: (data: Dictionary, item: Dictionary) => void | Promise<void>;
        transmit?: boolean;
        uncaughtErrorLevel?: Level;
        verbose?: boolean;
        version?: string;
        wrapGlobalEventHandlers?: boolean;
    }
    export type Callback<TResponse = any> = (err: MaybeError, response: TResponse) => void;
    export type LogArgument = string | Error | object | Dictionary | Callback | Date | any[] | undefined;
    export interface LogResult {
        uuid: string;
    }
    export interface TelemetryEvent {
        level: Level;
        type: string;
        timestamp_ms: number;
        body: Dictionary;
        source: string;
        uuid?: string;
    }
    export type AutoInstrumentOptions = boolean | AutoInstrumentSettings;
    export interface AutoInstrumentSettings {
        network?: boolean;
        networkResponseHeaders?: boolean | string[];
        networkResponseBody?: boolean;
        networkRequestBody?: boolean;
        log?: boolean;
        dom?: boolean;
        navigation?: boolean;
        connectivity?: boolean;
        contentSecurityPolicy?: boolean;
        errorOnContentSecurityPolicy?: boolean;
    }
    export type TelemetryScrubber = (description: TelemetryScrubberInput) => boolean;
    export type TelemetryScrubberInput = DomDescription | null;
    export interface DomDescription {
        tagName: string;
        id: string | undefined;
        classes: string[] | undefined;
        attributes: DomAttribute[];
    }
    export type DomAttributeKey = "type" | "name" | "title" | "alt";
    export interface DomAttribute {
        key: DomAttributeKey;
        value: string;
    }
    export type ExpressErrorHandler = (err: any, request: any, response: any, next: ExpressNextFunction) => any;
    export interface ExpressNextFunction {
      (err?: any): void;
    }
    class Locals {}
    export type LocalsType = typeof Locals;
    export type LocalsOptions = LocalsType | LocalsSettings;
    export interface LocalsSettings {
        module: LocalsType,
        enabled?: boolean;
        uncaughtOnly?: boolean;
        depth?: number;
        maxProperties?: number;
        maxArray?: number;
    }

    class Telemeter {}
    class Instrumenter {}

    export type TelemeterType = typeof Telemeter;
    export type InstrumenterType = typeof Instrumenter;
    export type TruncationType = object;
    export type ScrubType = (data: object, scrubFields?: string[], scrubPaths?: string[]) => object;
    export type WrapGlobalsType = (window?: any, handler?: any, shim?: any) => void;
    export type PolyfillJSONType = (JSON: any) => any;

    export interface Components {
        telemeter?: TelemeterType,
        instrumenter?: InstrumenterType,
        polyfillJSON?: PolyfillJSONType,
        wrapGlobals?: WrapGlobalsType,
        scrub?: ScrubType,
        truncation?: TruncationType
    }

    /**
      * @deprecated number is deprecated for this field
      */
     export type DeprecatedNumber = number;

    /**
     * {@link https://docs.rollbar.com/docs/rollbarjs-configuration-reference#payload-1}
     */
    export interface Payload {
        person?: {
            id: string | DeprecatedNumber | null;
            username?: string;
            email?: string;
            [property: string]: any;
        },
        context?: any;
        client?: {
            javascript?: {
                /**
                 * Version control number (i.e. git SHA) of the current revision. Used for linking filenames in stacktraces to GitHub.
                 * Note: for the purposes of nesting under the payload key, only code_version will correctly set the value in the final item.
                 * However, if you wish to set this code version at the top level of the configuration object rather than nested under
                 * the payload key, we will accept both codeVersion and code_version with codeVersion given preference if both happened
                 * to be defined. Furthermore, if code_version is nested under the payload key this will have the final preference over
                 * any value set at the top level.
                 */
                code_version?: string | DeprecatedNumber;
                /**
                 * When true, the Rollbar service will attempt to find and apply source maps to all frames in the stack trace.
                 * @default false
                 */
                source_map_enabled?: boolean;
                /**
                 * When true, the Rollbar service will attempt to apply source maps to frames even if they are missing column numbers.
                 * Works best when the minified javascript file is generated using newlines instead of semicolons.
                 * @default false
                 */
                guess_uncaught_frames?: boolean;
                [property: string]: any;
            }
            [property: string]: any;
        },
        /**
         * The environment that your code is running in.
         * @default undefined
         */
        environment?: string;
        server?: {
            /**
             * @default master
             */
            branch?: string;
            /**
             * The hostname of the machine that rendered the page.
             */
            host?: string;
            /**
             * It is used in two different ways: `source maps`, and `source control`.
             *
             * If you are looking for more information on it please go to:
             * {@link https://docs.rollbar.com/docs/source-maps}
             * {@link https://docs.rollbar.com/docs/source-control}
             */
            root?: string;
            [property: string]: any;
        },
        [property: string]: any;
    }
}