declare enum BreadcrumbType {
    DOM = "dom",
    HTTP = "http"
}
declare enum BreadcrumbCategory {
    ROUTE = "route"
}
interface Breadcrumb {
    type: BreadcrumbType;
    level?: string;
    category?: BreadcrumbCategory;
    message?: string;
    timestamp: number;
}

interface RangersToken {
    web_id: string;
    ssid: string;
    user_unique_id: string;
}

interface BatchProps {
    maxBatchReportLength?: number;
    batchReportWait?: number;
}
declare type CommonConfig = MutableConfig & BatchProps & {
    sampleRate: number;
    userId: string;
    sessionId: string;
    reportDomain: string;
    reportPath: string;
    pid: string;
    maxBreadcrumbs: number;
    finderInstance?: FinderInstance;
};
interface MutableConfig {
    context: Record<string, any>;
}
interface FinderInstance {
    getToken: (callback: (token: RangersToken) => void) => void;
    getAbSdkVersion: () => string;
    onAbSdkVersionChange: (callback: (vids: string) => void) => void;
}
declare type ClientExtraConfig = {
    version: string;
};
declare type DefaultConfig = CommonConfig & Flags;
interface Flags {
    hookPath: boolean;
    hookRequest: boolean;
    enableCapture: boolean;
}
interface RequiredUserConfig {
    aid: number;
}
declare type UserConfig = RequiredUserConfig & Partial<DefaultConfig>;
declare type ClientConfig = RequiredUserConfig & DefaultConfig & ClientExtraConfig;

declare type SendEvent = BatchEvent;
declare enum SendEventType {
    BATCH = "batch"
}
interface BatchEvent {
    ev_type: SendEventType.BATCH;
    list: BatchEventItem[];
}
declare type BatchEventItem = ReportEvent & {
    common: CommonReportParams;
};
declare type CommonReportParams = EnvInfo & {
    aid: number;
    pid: string;
    rangers_sdk_version: string;
    timestamp: number;
    user_unique_id: string;
    device_id: string;
    session_id: string;
    app_session_id: string;
    page_session_id: string;
    context: Context;
    uuid?: string;
    ssid?: string;
    ab_sdk_version?: string;
};
declare type Context = Record<string, string>;
declare type ReportEvent = PageviewReportEvent | JsErrorReportEvent | RequestReportEvent | SetDataReportEvent | PageFirstLoadReportEvent | PageOnReadyReportEvent;
declare enum ReportEventType {
    PAGEVIEW = "pageview",
    JS_ERROR = "js_error",
    REQUEST = "ajax",
    SET_DATA = "set_data",
    ON_READY = "on_ready",
    FIRST_LOAD = "first_load"
}
interface PageviewReportEvent {
    ev_type: ReportEventType.PAGEVIEW;
}
interface JsErrorReportEvent {
    ev_type: ReportEventType.JS_ERROR;
    event: JsErrorEvent;
    breadcrumbs: Breadcrumb[];
}
interface JsErrorEvent {
    name: string;
    message: string;
    stack: string;
    rawMessage: string;
}
interface RequestReportEvent {
    ev_type: ReportEventType.REQUEST;
    event: RequestEvent;
}
interface RequestEvent {
    req_url: string;
    method: string;
    req_status: 0 | 1;
    err_msg: string;
    resp_status: number;
    req_start_time: number;
    req_end_time: number;
    header: Record<string, string>;
    req_param: string;
    perf: ReqPerf | {};
    req_size: number;
    resp_size: number;
}
interface ReqPerf {
    redirectStart: number;
    redirectEnd: number;
    fetchStart: number;
    domainLookupStart: number;
    domainLookupEnd: number;
    connectStart: number;
    connectEnd: number;
    SSLconnectionStart: number;
    SSLconnectionEnd: number;
    requestStart: number;
    requestEnd: number;
    responseStart: number;
    responseEnd: number;
    rtt: number;
    httpRttEstimate: number;
    transportRttEstimate: number;
}
interface PageOnReadyReportEvent {
    ev_type: ReportEventType.ON_READY;
    event: PageOnReadyEvent;
}
interface PageOnReadyEvent {
    onLoadStart: number;
    onLoadEnd: number;
    onShowStart: number;
    onShowEnd: number;
    onReadyStart: number;
    onReadyEnd: number;
}
interface PageFirstLoadReportEvent {
    ev_type: ReportEventType.FIRST_LOAD;
    event: PageFirstLoadEvent;
}
interface PageFirstLoadEvent {
    firstReqStart: number;
    firstReqEnd: number;
    firstLoadStart: number;
    firstLoadEnd: number;
}
interface SetDataReportEvent {
    ev_type: ReportEventType.SET_DATA;
    event: SetDataEvent;
}
interface SetDataEvent {
    setDataStart: number;
    setDataEnd: number;
    setDataSize: number;
    data: string;
}
declare type BackendEvent = BackendDeviceIdEvent | BackendEnvInfoEvent | BackendFinderConfigEvent | BackendTesterSdkVersionEvent | BackendNetworkStatusEvent | BackendGlobalJsErrorEvent | BackendJsErrorEvent | BackendAppSessionEvent | BackendPageSessionEvent | BackendRequestEvent | BackendSetDataEvent | BackendPageOnReadyEvent | BackendPageFirstLoadEvent;
declare enum BackendEventType {
    DEVICE_ID = "device_id",
    FINDER_CONFIG = "finder_config",
    TESTER_SDK_VERSION = "tester_sdk_version",
    ENV_INFO = "env_info",
    NETWORK_STATUS = "network_status",
    JS_ERROR = "js_error",
    GLOBAL_JS_ERROR = "global_js_error",
    APP_SESSION = "app_session",
    PAGE_SESSION = "page_session",
    REQUEST = "request",
    SET_DATA = "set_data",
    PAGE_ON_READY = "page_on_ready",
    PAGE_FIRST_LOAD = "page_first_load"
}
interface BackendDeviceIdEvent {
    ev_type: BackendEventType.DEVICE_ID;
    data: {
        deviceId: string;
    };
}
interface BackendEnvInfoEvent {
    ev_type: BackendEventType.ENV_INFO;
    data: EnvInfo;
}
interface BackendFinderConfigEvent {
    ev_type: BackendEventType.FINDER_CONFIG;
    data: DataFinderConfig;
}
interface BackendTesterSdkVersionEvent {
    ev_type: BackendEventType.TESTER_SDK_VERSION;
    data: {
        ab_sdk_version: string;
    };
}
interface BackendNetworkStatusEvent {
    ev_type: BackendEventType.NETWORK_STATUS;
    data: NetworkStatus;
}
interface BackendJsErrorEvent {
    ev_type: BackendEventType.JS_ERROR;
    data: JsErrorEvent;
    context: EventContext;
}
interface BackendGlobalJsErrorEvent {
    ev_type: BackendEventType.GLOBAL_JS_ERROR;
    data: JsErrorEvent;
}
interface BackendAppSessionEvent {
    ev_type: BackendEventType.APP_SESSION;
    data: {
        appSessionId: string;
    };
}
interface BackendPageSessionEvent {
    ev_type: BackendEventType.PAGE_SESSION;
    data: {
        pid: string;
        pageSessionId: string;
    };
}
interface BackendRequestEvent {
    ev_type: BackendEventType.REQUEST;
    data: RequestEvent;
    context: EventContext;
}
interface BackendSetDataEvent {
    ev_type: BackendEventType.SET_DATA;
    data: SetDataEvent;
    context: EventContext;
}
interface BackendPageOnReadyEvent {
    ev_type: BackendEventType.PAGE_ON_READY;
    data: PageOnReadyEvent;
}
interface BackendPageFirstLoadEvent {
    ev_type: BackendEventType.PAGE_FIRST_LOAD;
    data: PageFirstLoadEvent;
    context: EventContext;
}
interface EventContext {
    pid: string;
    pageSessionId: string;
    context: Context;
}
declare type EnvInfo = SystemInfo & NetworkStatus;
interface SystemInfo {
    host_platform: string;
    host_app_name: string;
    host_app_version: string;
    platform: string;
    sdk_version: string;
    os_name: string;
    os_version: string;
    device_brand: string;
    device_model: string;
    resolution: string;
    screen_width: number;
    screen_height: number;
    pixel_ratio: number;
}
interface NetworkStatus {
    network_type: string;
}
interface DataFinderConfig {
    user_unique_id: string;
    ssid: string;
}

declare type AnyObject = Record<string, any>;
declare type LifeCycleHandler<T> = (this: any, options?: T) => void;
interface AppLifeCycles {
    onLaunch: LifeCycleHandler<LaunchShowOptions>;
    onShow: LifeCycleHandler<LaunchShowOptions>;
    onHide: LifeCycleHandler<void>;
    onError: LifeCycleHandler<string>;
    onPageNotFount: LifeCycleHandler<PageNotFoundOptions>;
    onUnhandledRejection: LifeCycleHandler<{
        promise: Promise<unknown>;
        reason: unknown;
    }>;
}
declare type AppInitOptions = AppLifeCycles & {
    [key: string]: any;
};
interface LaunchShowOptions {
    path: string;
    query: AnyObject;
    scene: number;
    shareTicket: string;
    referrerInfo?: {
        appId: string;
        extraData?: any;
    };
}
interface PageNotFoundOptions {
    path: string;
    query: AnyObject;
    isEntryPage: boolean;
}
interface PageLifeCycles {
    onLoad: LifeCycleHandler<{
        query: Record<string, string | undefined>;
    }>;
    onShow: LifeCycleHandler<never>;
    onReady: LifeCycleHandler<never>;
    onHide: LifeCycleHandler<never>;
    onUnload: LifeCycleHandler<never>;
    onPullDownRefresh: LifeCycleHandler<never>;
}
declare type PageInitOptions = PageLifeCycles & {
    data: AnyObject;
    [key: string]: any;
};
interface ComponentInitOptions {
    behaviors: any[];
    data: AnyObject;
    properties: AnyObject;
    methods: PageLifeCycles & {
        [key: string]: any;
    };
}
declare type AppInitFn = (options: Partial<AppInitOptions>) => void;
declare type PageInitFn = (options: PageInitOptions) => void;
declare type ComponentInitFn = (options: ComponentInitOptions) => void;
interface RequestOptions {
    url: string;
    method?: 'GET' | 'POST' | 'OPTIONS' | 'PUT' | 'HEAD' | 'DELETE' | 'TRACE' | 'CONNECT';
    data?: string | AnyObject | ArrayBuffer;
    header?: Record<string, string>;
    dataType?: 'json' | string;
    responseType?: 'text' | 'arraybuffer';
    success?: (res: RequestResult) => void;
    fail?: (res: GeneralResult) => void;
    complete?: (res: GeneralResult) => void;
}
interface RequestResult {
    data: string | AnyObject | ArrayBuffer;
    header?: Record<string, string>;
    cookies?: string[];
    profile?: RequestResultProfile;
    statusCode: number;
    errMsg: string;
}
interface RequestResultProfile {
    redirectStart: number;
    redirectEnd: number;
    fetchStart: number;
    domainLookupStart: number;
    domainLookupEnd: number;
    connectStart: number;
    connectEnd: number;
    SSLconnectionStart: number;
    SSLconnectionEnd: number;
    requestStart: number;
    requestEnd: number;
    responseStart: number;
    responseEnd: number;
    rtt: number;
    estimate_nettype: string;
    httpRttEstimate: number;
    transportRttEstimate: number;
    downstreamThroughputKbpsEstimate: number;
    throughputKbps: number;
}
interface GeneralResult {
    errMsg: string;
}

interface Transport {
    /**
     * Send prepared event to reporting backend
     * @param event Event to send to endpoint
     * @param options
     */
    sendEvent(event: SendEvent): void;
    /**
     * General request method
     * @param options
     */
    request(options: RequestOptions): void;
}

declare type BackendOptions = ClientConfig;
declare type BackendClass = new (options: BackendOptions, callback: BackendCallback) => Backend;
interface BackendCallback {
    (event: BackendEvent): void;
}
declare abstract class Backend {
    sdk: any;
    protected readonly callback: BackendCallback;
    protected originalAppFn: AppInitFn;
    protected originalPageFn: PageInitFn;
    protected options: BackendOptions;
    protected transport?: Transport;
    private reportUrl;
    private pid;
    private deviceId;
    private appSessionId;
    private pageSessionId;
    private capturedContext;
    private readonly taskStack;
    private taskTracks;
    constructor(options: BackendOptions, callback: BackendCallback);
    init(): void;
    sendEvent(ev: SendEvent): void;
    collectEnvInfo(): void;
    collectFinderConfig(): void;
    collectTesterSdkVersion(): void;
    getStorage(key: string): any;
    setStorage(key: string, data: any): any;
    protected setupTransport(): {
        sendEvent: (event: SendEvent) => void;
        request: (options: RequestOptions) => void;
    };
    protected hookAppFn(App: AppInitFn): (config: any) => void;
    protected hookPageFn(Page: PageInitFn): (config: any) => void;
    protected hookComponentFn(Component: ComponentInitFn): (config: any) => void;
    protected _pageLifeCycleHandlers(): (method: string, originalHandler?: LifeCycleHandler<any> | undefined) => (this: any, options: any) => void;
    protected hookSdk(): void;
    protected hookRequest(): void;
    protected shouldIgnoreUrl(url: string): boolean;
    protected hookSetData(page: any): void;
    protected collectDeviceId(): void;
    protected abstract normalizeEnvInfo(systemInfo: any, networkStatus: any): EnvInfo;
    private getContext;
    private currentContext;
    private captureContext;
    private addTask;
    private endTask;
    private endTrack;
    private getTaskTrack;
}

interface RangersOptions {
    Backend: BackendClass;
}
declare class Rangers {
    private readonly version;
    private readonly Backend;
    private client?;
    private readonly defaultConfig;
    private userConfig?;
    constructor(options: RangersOptions);
    /**
     * Init
     * @param config
     */
    init(config?: UserConfig): void;
    /**
     * Config
     * @param config
     */
    config(config?: Partial<MutableConfig>): void;
    /**
     * Report a captured exception
     * @param error
     */
    capture(error: Error): void;
    /**
     * Report a custom event
     * @param event
     */
    report(event: ReportEvent): void;
    /**
     * Add a breadcrumb
     * @param breadcrumb
     */
    addBreadcrumb(type: BreadcrumbType, payload: any): void;
    /**
     * Force the client to send all queued events
     */
    sendNow(): void;
    get context(): {
        set: (name: string, data: any) => any;
        delete: (name: string) => any;
        clear: () => any;
        get: (name: string) => any;
        toObject: () => {
            [x: string]: any;
        };
    };
    private updateClientConfig;
}

declare const rangers: Rangers;

export { BreadcrumbType, ReportEventType, rangers as default };