noibu-react-native 0.2.7 → 0.2.9

package/dist/monitors/http-tools/HTTPDataBundler.d.ts

@@ -0,0 +1,106 @@
+import { Singleton } from '../BaseMonitor';
+import { NoSeq } from '../../types/Metroplex';
+import { RawHttpData } from 'noibu-metroplex-ts-bindings';
+/** Bundles HTTP payloads and headers */
+export declare class HTTPDataBundler extends Singleton {
+    contentTypeReadableRegex: RegExp;
+    hostname: string;
+    initialURLPartsReversed: string[];
+    httpDataCollectionEnabled: boolean;
+    httpDataAllowedRelativeRegex: RegExp | null;
+    httpDataAllowedAbsoluteRegex: RegExp | null;
+    /** Creates an instance of the ClickMonitor instance */
+    constructor();
+    /**
+     * Builds the HTTP payload allowed regexes for full and relative URLs
+     * @param allowedURLs Target list of allowed URLs
+     * @param absolute Use only absolute URLs if true, use only relative URL if false
+     * @returns a regex of allowed URLs
+     */
+    private static buildAllowedRegex;
+    /**
+     * Takes an iterator and returns a map of strings representing headers.
+     * param {object} headersIterable any iterable object
+     * returns a map of strings (as expected by metroplex) representing HTTP
+     * request or response headers
+     */
+    static headersMapFromIterable(headersIterable: Iterable<any[]>): Map<any, any>;
+    /**
+     * Takes a string of headers with 'name: value' and returns
+     * a map of strings representing headers.
+     * headersString is all the headers in one string
+     * returns a map of strings (as expected by metroplex) representing HTTP
+     * request or response headers
+     */
+    static headersMapFromString(headersString: unknown): Map<string, string>;
+    /**
+     * For an XHR object, checks the responseType property and handles the response or
+     * responseText property accordingly to return a string representation of the response.
+     * @returns a string representation of the response, or null if this fails.
+     */
+    static getResponseStringFromXHR(xhr: WrappedXMLHttpRequest): Promise<any>;
+    /** Builds an HTTP Data bundle */
+    bundleHTTPData(url: string, rawRequestHeaders: Map<string, string> | undefined, rawRequestPayload: any, rawResponseHeaders: Map<string, string>, rawResponsePayload: any, method: string, isError: boolean): NoSeq<RawHttpData> | null;
+    /**
+     * Validates a request based on the URL and method. When enabled, will handle
+     * de-duping the requests
+     */
+    isValidRequest(method: unknown): unknown;
+    /**
+     * Checks two things: that the URL is either on the same domain (or an address relative to the
+     * current domain), and also checks that the config http_data_collection flag is enabled.
+     * @param {string} url
+     * @returns boolean indicating whether the URL passed is either relative (in which case it is
+     * inherently on the current domain) or matches the current domain.
+     */
+    shouldContinueForURL(url: any): boolean;
+    /**
+     * Determines if the URL is absolute or relative
+     * returns boolean indicating whether the URL passed is either absolute or relative
+     */
+    static isAbsoluteURL(url: unknown): boolean;
+    /**
+     * Checks whether HTTP payloads can be collected on this URL
+     * returns boolean indicating whether HTTP payloads can be collected on this URL
+     */
+    shouldCollectPayloadForURL(url: any): boolean | undefined;
+    /**
+     * Double checks content length if we couldn't read the headers, and redacts PII
+     * returns the restricted payload
+     */
+    restrictPayload(payload: unknown, url: string, isError: boolean): string;
+    /**
+     * Returns true if the content-length header is of acceptable size.
+     * Too big gets rejected
+     * If the headers are not found, check actual content for length
+     */
+    contentLengthAcceptable(headers: Map<string, string>, isError: boolean): boolean;
+    /**
+     * Returns true if the content type according to the headers is valid for collection.
+     * Also returns assumed true if content type is not stated in headers.
+     * @param {Map} headersMap
+     * @returns boolean true if acceptable to collect
+     */
+    private contentTypeAcceptable;
+    /**
+     * Returns a descriptive string if we have to drop payload based on the length
+     * or type listed in the headers passed. Returns an empty string otherwise.
+     */
+    getReasonPayloadIsDropped(headers: any, isError: boolean): string;
+    /**
+     * Returns content length from the headers, if available.
+     * If headers are not found or length is not a number, return -1
+     */
+    contentLength(headersObject: any): number;
+    /**
+     * Accepts a value that could be any type used as a request payload,
+     * and returns a string representation, or null if this fails.
+     */
+    stringFromRequestBody(value: any, requestHeaders?: Map<string, string>): any;
+    /**
+     * Removes possible PII from headers.
+     * @param {Map} dirtyHeaders a Map of HTTP response or request headers
+     * @returns {Map|null} a map of headers with PII redacted
+     */
+    removePIIHeaders(dirtyHeaders: Map<string, string> | undefined): typeof dirtyHeaders | null;
+}

package/dist/monitors/http-tools/HTTPDataBundler.js

@@ -1,11 +1,12 @@
 import { __awaiter } from 'tslib';
-import { SEVERITY, CONTENT_TYPE, PII_REDACTION_REPLACEMENT_STRING } from '../../constants.js';
+import { CONTENT_TYPE, PII_REDACTION_REPLACEMENT_STRING } from '../../constants.js';
 import ClientConfig from '../../api/ClientConfig.js';
 import StoredMetrics from '../../api/StoredMetrics.js';
 import { safeFromEntries, safeEntries } from '../../utils/object.js';
 import { safeTrim, stringifyJSON } from '../../utils/function.js';
 import { removePII } from '../../utils/piiRedactor.js';
 import { Singleton } from '../BaseMonitor.js';
+import { Severity } from 'noibu-metroplex-ts-bindings';
 
 const DEFAULT_WEBSITE_SUBDOMAIN_PATTERN = /^www\d{0,2}$/;
 const CONTENT_LENGTH = 'content-length';
@@ -60,7 +61,7 @@ class HTTPDataBundler extends Singleton {
                 this.initialURLPartsReversed.reverse();
             }
             catch (e) {
-                ClientConfig.getInstance().postInternalError({ msg: `Unable to determine hostname for initial URL`, error: e }, false, SEVERITY.warn);
+                ClientConfig.getInstance().postInternalError({ msg: `Unable to determine hostname for initial URL`, error: e }, false, Severity.WARN);
             }
         }
         this.httpDataCollectionEnabled = !!ClientConfig.getInstance().enableHttpDataCollection;
@@ -165,7 +166,7 @@ class HTTPDataBundler extends Singleton {
                     return text;
                 }
                 catch (e) {
-                    ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify JSON response`, error: e }, false, SEVERITY.warn);
+                    ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify JSON response`, error: e }, false, Severity.WARN);
                     return null;
                 }
             }
@@ -284,7 +285,7 @@ class HTTPDataBundler extends Singleton {
             ClientConfig.getInstance().postInternalError({
                 msg: `restrictPayload received non string payload`,
                 payloadType: typeof payload,
-            }, false, SEVERITY.error);
+            }, false, Severity.ERROR);
             return HTTP_BODY_NULL_STRING;
         }
         if (payload === HTTP_BODY_NULL_STRING ||
@@ -428,7 +429,7 @@ class HTTPDataBundler extends Singleton {
             return stringifyJSON(value);
         }
         catch (e) {
-            ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify request body`, error: e }, false, SEVERITY.warn);
+            ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify request body`, error: e }, false, Severity.WARN);
         }
         return null;
     }

package/dist/monitors/integrations/ReactNativeNavigationIntegration.d.ts

@@ -0,0 +1,17 @@
+import { NavigationDelegate } from 'react-native-navigation/lib/dist/src/NavigationDelegate';
+import { Singleton } from '../BaseMonitor';
+/** react-native-navigation adapter */
+export declare class ReactNativeNavigationIntegration extends Singleton implements NavigationIntegration {
+    private stack;
+    private stackPointers;
+    private registration;
+    /** Attaches provided listeners to the integration */
+    register(navigation: NavigationDelegate, onNavigation: (breadcrumbs: string[]) => void): void;
+    /**
+     * Listens to ComponentWillAppear events, keeps track of visited screens and
+     * pops them if the same page is visited to prevent cycles
+     */
+    private getListener;
+    /** Destructor */
+    protected destroy(): void;
+}

package/dist/pageVisit/EventDebouncer.d.ts

@@ -0,0 +1,23 @@
+import { Singleton } from '../monitors/BaseMonitor';
+import { EventType, PageVisitEvent, UserStepType } from 'noibu-metroplex-ts-bindings';
+/**
+ * Singleton class responsible for debouncing all events
+ * that are registered
+ */
+export declare class EventDebouncer extends Singleton {
+    private readonly debouncePeriods;
+    private readonly timeouts;
+    private readonly events;
+    /** Creates an instance of EventDebouncer */
+    constructor();
+    /**
+     * Creates an event object with the event and the time it was added then pushes
+     * that event object to the queue of events waiting to be debounced.
+     */
+    debounce(event: Omit<PageVisitEvent, 'occ_at'>): void;
+    /** Debounce function to be executed once the debounce period is completed */
+    sendEvents: (type: EventType | UserStepType) => void;
+    /** Sets up the page hide handler to try to push remaining events in the queues */
+    _setupUnloadHandler(): void;
+    protected destroy(): void;
+}

package/dist/pageVisit/HttpEventManager.d.ts

@@ -0,0 +1,14 @@
+import { NoSeq } from '../types/Metroplex';
+import { PageVisitEventHTTP, RawHttpData } from 'noibu-metroplex-ts-bindings';
+/** Saves the HTTP event to the pageVisit Queue */
+export declare function saveHTTPEvent(httpEvent: Partial<PageVisitEventHTTP>, httpData?: NoSeq<RawHttpData> | null, isGqlError?: boolean): number | undefined;
+/** Determines if a response is a failure */
+export declare function isHttpCodeFailure(code: unknown): boolean;
+/**
+ * Checks if sending data is allowed based on the HTTP status code and count.
+ * status - The HTTP status code to evaluate.
+ * count - The count of events to consider.
+ * isGqlError - Whether the context is considered as a GQL error.
+ * Returns `true` if sending data is allowed, `false` otherwise.
+ */
+export declare function isSendAllowed(status: number, count: number, isGqlError?: boolean): boolean;

package/dist/pageVisit/HttpEventManager.js

@@ -3,9 +3,7 @@ import StoredMetrics from '../api/StoredMetrics.js';
 import MetroplexSocket from '../api/MetroplexSocket.js';
 import { safeTrim, getMaxSubstringAllowed, asString } from '../utils/function.js';
 import { EventDebouncer } from './EventDebouncer.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
-import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { WebsocketMessageType, EventType } from 'noibu-metroplex-ts-bindings';
 
 /** @module PageVisitEventHTTP */
 /** http event manager */

package/dist/pageVisit/PageVisitManager.d.ts

@@ -0,0 +1,31 @@
+import { Singleton } from '../monitors/BaseMonitor';
+import { PageVisitEvent } from 'noibu-metroplex-ts-bindings';
+/**
+ * Singleton class to hold all the information
+ * about the gathered errors throught the session
+ */
+export declare class PageVisitManager extends Singleton {
+    partCounter: number;
+    pvEvents: PageVisitEvent[];
+    pvEventLength: number;
+    visibilityChangedCounter: number;
+    totalPvEventLength: number;
+    /** adds page visit events into the current page visit map and then sends a page visit message
+     */
+    addPageVisitEvents(eventObjects: PageVisitEvent[]): void;
+    /**
+     * adds the page visit event into the current page visit map and then sends a page visit message
+     * returns the key to access this event in the map
+     */
+    addPageVisitEvent(eventObj: Omit<PageVisitEvent, 'occ_at'>): void;
+    /**
+     * adds a new page visit event into the current page visit map and returns the
+     * the key to access this event in the map
+     */
+    _addPageVisitEvent(pvEvent: PageVisitEvent): void;
+    /**
+     * _sendPageVisitMessage will reset the buffer and post the current
+     * content to metroplex
+     */
+    _sendPageVisitMessage(): void;
+}

package/dist/pageVisit/PageVisitManager.js

@@ -4,8 +4,7 @@ import StoredMetrics from '../api/StoredMetrics.js';
 import { noibuLog } from '../utils/log.js';
 import { Singleton } from '../monitors/BaseMonitor.js';
 import { getOccurredNow } from '../utils/date.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
+import { WebsocketMessageType } from 'noibu-metroplex-ts-bindings';
 
 /** @module Pagevisit */
 const MAX_PAGEVISIT_EVENTS = 200;

package/dist/pageVisit/pageVisitEventError.d.ts

@@ -0,0 +1,12 @@
+import { Option, PageVisitEventError } from 'noibu-metroplex-ts-bindings';
+import { EventInput, PageVisitErrorInput } from '../types/PageVisitErrors';
+/**
+ * gets the onURL of a string, defaulting to the location of the webpage
+ */
+export declare function getOnURL(realOnURL: unknown): string;
+/**
+ * determines if an error is a collect error
+ */
+export declare function isErrorCollectedByNoibu(pvError: PageVisitEventError): Promise<false | void>;
+/** Saves the error to the Error queue */
+export declare function saveErrorToPagevisit<T extends PageVisitErrorInput | EventInput>(payload: T, httpDataSeqNum?: Option<number>): void;

package/dist/pageVisit/pageVisitEventError.js

@@ -1,13 +1,9 @@
 import { __awaiter } from 'tslib';
 import { isValidURL, getJSStack, stringifyJSON, getMaxSubstringAllowed, asString } from '../utils/function.js';
-import { SEVERITY } from '../constants.js';
 import ClientConfig from '../api/ClientConfig.js';
 import StoredMetrics from '../api/StoredMetrics.js';
 import { EventDebouncer } from './EventDebouncer.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { PageVisitErrorSource } from '../node_modules/@noibu/metroplex-ts-bindings/dist/PageVisitErrorSource.js';
-import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
-import { ErrorType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/ErrorType.js';
+import { PageVisitErrorSource, EventType, Severity, ErrorType } from 'noibu-metroplex-ts-bindings';
 
 const BLOCKLISTED_DOMAINS = {
     'input.noibu.com': true,
@@ -170,7 +166,7 @@ function isErrorCollectedByNoibu(pvError) {
         // checking if this error originated from the Noibu script
         const msg = getCollectErrorMsg(pvError);
         if (msg) {
-            return ClientConfig.getInstance().postInternalError({ msg, pvError }, false, SEVERITY.error);
+            return ClientConfig.getInstance().postInternalError({ msg, pvError }, false, Severity.ERROR);
         }
         return false;
     });

package/dist/react/ErrorBoundary.d.ts

@@ -0,0 +1,67 @@
+import * as React from 'react';
+export type FallbackRender = (errorData: {
+    error: Error;
+    componentStack: string | null;
+    eventId: string | null;
+    resetError(): void;
+}) => React.ReactElement;
+export type ErrorBoundaryProps = {
+    children?: React.ReactNode | (() => React.ReactNode);
+    /**
+     * Target fallback component that gets rendered when the error boundary encounters an error.
+     *
+     * Can either provide a React Component, or a function that returns React Component as
+     * a valid fallback prop. If a function is provided, the function will be called with
+     * the error, the component stack, and a function that resets the error boundary on error.
+     *
+     */
+    fallback?: React.ReactElement | FallbackRender;
+    /** Called when the error boundary encounters an error */
+    onError?(error: Error, componentStack: string, eventId: string): void;
+    /** Called on componentDidMount() */
+    onMount?(): void;
+    /** Called if resetError() is called from the fallback render props function  */
+    onReset?(error: Error | null, componentStack: string | null, eventId: string | null): void;
+    /** Called on componentWillUnmount() */
+    onUnmount?(error: Error | null, componentStack: string | null, eventId: string | null): void;
+};
+export type ErrorBoundaryState = {
+    componentStack: React.ErrorInfo['componentStack'] | null;
+    error: Error | null;
+    eventId: string | null;
+};
+/**
+ * @description Target ErrorBoundary component that logs errors to Noibu. Requires React >= 16.
+ * @extends {Component<ErrorBoundaryProps, ErrorBoundaryState>}
+ */
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    /**
+     * Lifecycle hook on mount
+     * @returns void
+     */
+    componentDidMount(): void;
+    /**
+     *
+     * Handler for all errors that happen in a wrapped component
+     * @param  {Error&{cause?:Error}} error
+     * @param  {React.ErrorInfo} {componentStack}
+     * @returns void
+     */
+    componentDidCatch(error: Error & {
+        cause?: Error;
+    }, { componentStack }: React.ErrorInfo): void;
+    /**
+     *  * Lifecycle hook on unmount
+     * @returns void
+     */
+    componentWillUnmount(): void;
+    /** Callback from fallback to reset the error boundary */
+    resetErrorBoundary: () => void;
+    /**
+     *
+     * Renders the fallback ui
+     * @returns {React.ReactNode}
+     */
+    render(): React.ReactNode;
+}

package/dist/sessionRecorder/SessionRecorder.d.ts

@@ -0,0 +1,50 @@
+import { RecorderEvent } from './nativeSessionRecorderSubscription';
+import { Singleton } from '../monitors/BaseMonitor';
+/** Singleton class to record user sessions */
+export default class SessionRecorder extends Singleton {
+    private eventBuffer;
+    private vfCounter;
+    private didSetupRecorder;
+    private isVideoLengthNegativeInvalid;
+    private lastFragPostTimestamp;
+    private pauseTimeout;
+    private lastRecordedTimestamp;
+    private firstRecordedTimestamp;
+    private recordStopper;
+    private freezingEvents;
+    /** Setups the SessionRecorder instance for usage */
+    constructor();
+    /** Sets up the page hide handler to try to push remaining video events */
+    setupUnloadHandler(): void;
+    /** Sets up the post metrics handler to potentially log a debug message */
+    setupPostMetricsHandler(): void;
+    /** Starts recording the user session */
+    recordUserSession(): Promise<void>;
+    /**
+     * handleNewRRwebEvent will process each upcoming.
+     * rrweb event. It will make sure that the current buffer
+     * is updated with the latest events and post the contents
+     * of the buffer if it exceeds max size
+     */
+    handleRecorderEvent(recorderEvent: RecorderEvent): Promise<void>;
+    /** Compress event */
+    private pack;
+    /** Compresses the snapshot */
+    private static compress;
+    /** builds a log message with debug info */
+    buildDebugMessage(eventName: string, totalVideoTime: number, sessionLength: number): string;
+    /**
+     * handleFragPost communicates with the Metroplex socket
+     * to post video fragments when needed. It also handles
+     * necessary management of the buffer and it's related
+     * variables
+     */
+    handleFragPost(): Promise<void>;
+    /**
+     * unfreeze forcefully resumes recording events in case it was frozen
+     * waiting for user events
+     */
+    unfreeze(): Promise<void>;
+    /** stops recording */
+    private freeze;
+}

package/dist/sessionRecorder/SessionRecorder.js

@@ -4,14 +4,13 @@ import { LogLevel, initialize, subscribeToNativeEvent } from './nativeSessionRec
 import StoredMetrics from '../api/StoredMetrics.js';
 import ClientConfig from '../api/ClientConfig.js';
 import { stringifyJSON } from '../utils/function.js';
-import { SEVERITY, MAX_TIME_FOR_UNSENT_DATA_MILLIS } from '../constants.js';
+import { MAX_TIME_FOR_UNSENT_DATA_MILLIS } from '../constants.js';
 import MetroplexSocket from '../api/MetroplexSocket.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
 import { noibuLog } from '../utils/log.js';
 import { Platform } from 'react-native';
 import { Singleton } from '../monitors/BaseMonitor.js';
-import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
-import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
+import { Severity, WebsocketMessageType } from 'noibu-metroplex-ts-bindings';
 
 // custom event name for posting metrics
 const POST_METRICS_EVENT_NAME = 'noibuPostMetrics';
@@ -78,7 +77,7 @@ class SessionRecorder extends Singleton {
                     eventName,
                     totalVideoTime,
                     sessionLength,
-                }, clientDisabled, SEVERITY.warn);
+                }, clientDisabled, Severity.WARN);
             }
         });
     }
@@ -147,7 +146,7 @@ class SessionRecorder extends Singleton {
             // If we don't adjust for time, we assume that the expected video length is
             // the difference between the first recorded timestamp and the last recorded timestamp.
             if (this.firstRecordedTimestamp && timestamp < this.firstRecordedTimestamp) {
-                ClientConfig.getInstance().postInternalError({ msg: `Detected time rewind. Client has been disabled.` }, true, SEVERITY.error, true);
+                ClientConfig.getInstance().postInternalError({ msg: `Detected time rewind. Client has been disabled.` }, true, Severity.ERROR, true);
                 return;
             }
             const packedEvent = yield this.pack(recorderEvent.message);
@@ -216,7 +215,7 @@ class SessionRecorder extends Singleton {
                         totalVideoTime,
                         'start time': this.firstRecordedTimestamp,
                         'end time': this.lastRecordedTimestamp,
-                    }, false, SEVERITY.error);
+                    }, false, Severity.ERROR);
                     this.isVideoLengthNegativeInvalid = true;
                     totalVideoTime = 0;
                 }
@@ -243,7 +242,7 @@ class SessionRecorder extends Singleton {
             }
             catch (err) {
                 // letting collect know we are closing the rrweb listener
-                ClientConfig.getInstance().postInternalError({ msg: `video frag socket closed with err: ${err.message}` }, false, SEVERITY.error);
+                ClientConfig.getInstance().postInternalError({ msg: `video frag socket closed with err: ${err.message}` }, false, Severity.ERROR);
                 // if we detect an error in the frag posting, we stop recording
                 // the video
                 this.freeze();
@@ -270,7 +269,7 @@ class SessionRecorder extends Singleton {
                 this.recordStopper();
             }
             catch (e) {
-                ClientConfig.getInstance().postInternalError({ msg: `Error during handleFragPost in recordStopper: ${e}` }, false, SEVERITY.error);
+                ClientConfig.getInstance().postInternalError({ msg: `Error during handleFragPost in recordStopper: ${e}` }, false, Severity.ERROR);
             }
         }
     }

package/dist/sessionRecorder/nativeSessionRecorderSubscription.d.ts

@@ -0,0 +1,77 @@
+/** The level of logging to show in the device logcat stream. */
+export declare enum LogLevel {
+    Verbose = "Verbose",
+    Debug = "Debug",
+    Info = "Info",
+    Warning = "Warning",
+    Error = "Error",
+    None = "None"
+}
+/**
+ * The configuration that will be used to customize the session recording behaviour.
+ *
+ * @param userId        [OPTIONAL default = null] Target custom identifier for the current user. If passed as null, the user id
+ *                      will be auto generated. The user id in general is sticky across sessions.
+ *                      The provided user id must follow these conditions:
+ *                          1. Cannot be an empty string.
+ *                          2. Should be base36 and smaller than "1Z141Z4".
+ * @param logLevel      [OPTIONAL default = LogLevel.None] The level of logging to show in the device logcat stream.
+ * @param allowMeteredNetworkUsage  [OPTIONAL default = false] Allows uploading session data to the servers on device metered network.
+ * @param enableWebViewCapture    [OPTIONAL default = true] Allows Noibu - Session recorder to capture the web views DOM content.
+ * @param allowedDomains    [OPTIONAL default = ["*"]] The whitelisted domains to allow Noibu - Session recorder to capture their DOM content.
+ *                          If it contains "*" as an element, all domains will be captured.
+ * @param disableOnLowEndDevices [OPTIONAL default = false] Disable Noibu - Session recorder on low-end devices.
+ * @param maximumDailyNetworkUsageInMB [OPTIONAL default = null] Maximum daily network usage for Noibu - Session recorder (null = No limit). When the limit is reached, Noibu - Session recorder will turn on lean mode.
+ */
+export interface SessionRecorderConfig {
+    userId?: string | null;
+    logLevel?: LogLevel;
+    allowMeteredNetworkUsage?: boolean;
+    enableWebViewCapture?: boolean;
+    allowedDomains?: string[];
+    disableOnLowEndDevices?: boolean;
+    maximumDailyNetworkUsageInMB?: number;
+}
+/**
+ * Initializes the Noibu - Session recording SDK if the API level is supported.
+ * param projectId     [REQUIRED] The session recording project id to send data to.
+ * param config   [OPTIONAL] The sessionreplay config, if not provided default values are used.
+ */
+export declare function initialize(projectId: string, config?: SessionRecorderConfig): void;
+/**
+ * Sets a custom user id that can be used to identify the user. It has less
+ * restrictions than the userId parameter. You can pass any string and
+ * you can filter on it on the dashboard side. If you need the most efficient
+ * filtering on the dashboard, use the userId parameter if possible.
+ * <p>
+ * Note: custom user id cannot be null or empty, or consists only of whitespaces.
+ * </p>
+ * @param customUserId   The custom user id to set.
+ */
+export declare function setCustomUserId(customUserId: string): void;
+/**
+ * Sets a custom session id that can be used to identify the session.
+ * <p>
+ * Note: custom session id cannot be null or empty, or consists only of whitespaces.
+ * </p>
+ * @param customSessionId   The custom session id to set.
+ */
+export declare function setCustomSessionId(customSessionId: string): void;
+export type RecorderEvent = import('./types').RecorderEvent;
+export type UnsubscribeFn = import('./types').UnsubscribeFn;
+/**
+ * Subscribes to a native event emitted by the Noibu Session Recorder.
+ *
+ * This function listens for the `noibuRecordingEvent` emitted from the native layer (only on Android)
+ * and invokes the provided callback whenever the event occurs. If the platform is not Android,
+ * the function will do nothing and return a no-op unsubscribe function.
+ *
+ * @param {function(RecorderEvent): void} callback - Target callback function that will be invoked with
+ * the event data whenever the `noibuRecordingEvent` is emitted.
+ *
+ * @returns {UnsubscribeFn} Target function to unsubscribe from the event. On Android, this will remove
+ * the event listener. On other platforms, it will be a no-op.
+ *
+ * @throws {Error} If the Noibu Session Recorder is not initialized before calling this function.
+ */
+export declare function subscribeToNativeEvent(callback: (event: RecorderEvent) => void): UnsubscribeFn;

package/dist/sessionRecorder/types.d.ts

@@ -0,0 +1,91 @@
+type Color = {
+    a: number;
+    b: number;
+    r: number;
+    g: number;
+};
+type Paint = {
+    strokeJoin: number;
+    strokeWidth: number;
+    strokeCap: number;
+    color: Color;
+    dither: boolean;
+    blendMode: number;
+    style: number;
+    antiAlias: boolean;
+    strokeMiter: number;
+};
+type Rect = {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+};
+type Command = {
+    name?: string;
+    id?: number;
+    type: string;
+    isClipRectSource?: boolean;
+    rect?: Rect;
+    paintIndex?: number;
+    op?: number;
+    antiAlias?: boolean;
+    matrix?: number[];
+};
+type ViewNode = {
+    viewX: number;
+    visible: boolean;
+    processedText$delegate: {
+        _value: any;
+        initializer: any;
+    };
+    viewY: number;
+    viewWidth: number;
+    clickable: boolean;
+    viewHeight: number;
+    isMasked: boolean;
+    type: string;
+    renderNodeId: number;
+    isWebView: boolean;
+    ignoreClicks: boolean;
+    children: ViewNode[];
+    width: number;
+    x: number;
+    y: number;
+    id: number;
+    text: string;
+    height: number;
+    backgroundColor?: number;
+};
+type ViewHierarchy = {
+    root: ViewNode;
+    visibleFragments: any[];
+    timestamp: number;
+};
+type SubPicture = {
+    subPictures: any[];
+    images: any[];
+    screenWidth: number;
+    textBlobs: any[];
+    density: number;
+    vertices: any[];
+    screenHeight: number;
+    activityName: string;
+    paints: Paint[];
+    typefaces: any[];
+    viewHierarchy: ViewHierarchy;
+    paths: any[];
+    activityHashCode: number;
+    commands: Command[];
+    timestamp: number;
+};
+export type RecorderEvent = {
+    message: NativeFrames;
+};
+export type NativeFrames = {
+    p: (number | boolean | SubPicture)[][];
+    a: (number[] | (number | string | string[])[])[];
+    e: (string | number)[];
+};
+export type UnsubscribeFn = () => void;
+export {};