@luciq/react-native 19.3.0 → 19.4.0-44237-SNAPSHOT

package/src/native/specs/NativeAPM.ts

@@ -0,0 +1,47 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+
+  networkLogAndroid(
+    requestStartTime: number,
+    requestDuration: number,
+    requestHeaders: string,
+    requestBody: string,
+    requestBodySize: number,
+    requestMethod: string,
+    requestUrl: string,
+    requestContentType: string,
+    responseHeaders: string,
+    responseBody: string | null,
+    responseBodySize: number,
+    statusCode: number,
+    responseContentType: string,
+    errorDomain: string,
+    w3cExternalTraceAttributes: UnsafeObject,
+    gqlQueryName: string | null,
+    serverErrorMessage: string | null,
+  ): void;
+
+  setAppLaunchEnabled(isEnabled: boolean): void;
+  endAppLaunch(): void;
+
+  startFlow(name: string): void;
+  endFlow(name: string): void;
+  setFlowAttribute(name: string, key: string, value: string | null): void;
+
+  setAutoUITraceEnabled(isEnabled: boolean): void;
+  startUITrace(name: string): void;
+  endUITrace(): void;
+  lcqSleep(): void;
+
+  setScreenRenderingEnabled(isEnabled: boolean): void;
+
+  syncCustomSpan(name: string, startTimestamp: number, endTimestamp: number): Promise<void>;
+  isCustomSpanEnabled(): Promise<boolean>;
+  isAPMEnabled(): Promise<boolean>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQAPM');

package/src/native/specs/NativeBugReporting.ts

@@ -0,0 +1,53 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  show(type: string, options: string[]): void;
+
+  setInvocationEvents(events: string[]): void;
+  setOptions(options: string[]): void;
+  setExtendedBugReportMode(mode: string): void;
+  setReportTypes(types: string[]): void;
+  setDisclaimerText(text: string): void;
+  setCommentMinimumCharacterCount(limit: number, reportTypes: string[]): void;
+  setFloatingButtonEdge(edge: string, offset: number): void;
+  setVideoRecordingFloatingButtonPosition(buttonPosition: string): void;
+  setEnabledAttachmentTypes(
+    screenshot: boolean,
+    extraScreenshot: boolean,
+    galleryImage: boolean,
+    screenRecording: boolean,
+  ): void;
+
+  setAutoScreenRecordingEnabled(isEnabled: boolean): void;
+  setAutoScreenRecordingDuration(maxDuration: number): void;
+  setViewHierarchyEnabled(isEnabled: boolean): void;
+
+  setShakingThresholdForiPhone(threshold: number): void;
+  setShakingThresholdForiPad(threshold: number): void;
+  setShakingThresholdForAndroid(threshold: number): void;
+
+  setOnInvokeHandler(): void;
+  setDidSelectPromptOptionHandler(): void;
+  setOnSDKDismissedHandler(): void;
+
+  addUserConsent(
+    key: string,
+    description: string,
+    mandatory: boolean,
+    checked: boolean,
+    actionType: string | null,
+  ): void;
+
+  setProactiveReportingConfigurations(
+    enabled: boolean,
+    gapBetweenModals: number,
+    modalDelayAfterDetection: number,
+  ): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQBugReporting');

package/src/native/specs/NativeCrashReporting.ts

@@ -0,0 +1,23 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+
+  sendJSCrash(data: UnsafeObject): Promise<void>;
+
+  sendHandledJSCrash(
+    data: UnsafeObject,
+    userAttributes: UnsafeObject | null,
+    fingerprint: string | null,
+    nonFatalExceptionLevel: string | null,
+  ): Promise<void>;
+
+  setNDKCrashesEnabled(isEnabled: boolean): Promise<void>;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQCrashReporting');

package/src/native/specs/NativeFeatureRequests.ts

@@ -0,0 +1,10 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  show(): void;
+  setEmailFieldRequiredForFeatureRequests(isEmailFieldRequired: boolean, types: string[]): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQFeatureRequests');

package/src/native/specs/NativeLuciq.ts

@@ -0,0 +1,137 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  getAllConstants(): UnsafeObject;
+  setEnabled(isEnabled: boolean): void;
+  isBuilt(): Promise<boolean>;
+  init(
+    token: string,
+    invocationEvents: string[],
+    debugLogsLevel: string,
+    useNativeNetworkInterception: boolean,
+    codePushVersion: string | null,
+    appVariant: string | null,
+    options: UnsafeObject | null,
+    overAirVersion: UnsafeObject | null,
+  ): void;
+  show(): void;
+
+  setCodePushVersion(version: string): void;
+  setOverAirVersion(OTAserviceVersion: UnsafeObject): void;
+  setAppVariant(appVariant: string): void;
+  setLCQLogPrintsToConsole(printsToConsole: boolean): void;
+  setSessionProfilerEnabled(isEnabled: boolean): void;
+
+  setLocale(sdkLocale: string): void;
+  setColorTheme(sdkTheme: string): void;
+  setPrimaryColor(color: number | null): void;
+  setString(string: string, key: string): void;
+
+  networkLogAndroid(
+    url: string,
+    requestBody: string,
+    responseBody: string | null,
+    method: string,
+    responseCode: number,
+    requestHeaders: string,
+    responseHeaders: string,
+    duration: number,
+  ): void;
+
+  networkLogIOS(
+    url: string,
+    method: string,
+    requestBody: string | null,
+    requestBodySize: number,
+    responseBody: string | null,
+    responseBodySize: number,
+    responseCode: number,
+    requestHeaders: UnsafeObject,
+    responseHeaders: UnsafeObject,
+    contentType: string,
+    errorDomain: string,
+    errorCode: number,
+    startTime: number,
+    duration: number,
+    gqlQueryName: string | null,
+    serverErrorMessage: string | null,
+    w3cExternalTraceAttributes: UnsafeObject,
+  ): void;
+
+  setNetworkLoggingEnabled(isEnabled: boolean): void;
+  setNetworkLogBodyEnabled(isEnabled: boolean): void;
+
+  setReproStepsConfig(bugMode: string, crashMode: string, sessionReplay: string): void;
+  setTrackUserSteps(isEnabled: boolean): void;
+  reportScreenChange(firstScreen: string): void;
+  reportCurrentViewChange(screenName: string): void;
+  addPrivateView(nativeTag: number | null): void;
+  removePrivateView(nativeTag: number | null): void;
+
+  logVerbose(message: string): void;
+  logInfo(message: string): void;
+  logDebug(message: string): void;
+  logError(message: string): void;
+  logWarn(message: string): void;
+  clearLogs(): void;
+
+  identifyUser(email: string, name: string, id: string | null): void;
+  logOut(): void;
+  logUserEvent(name: string): void;
+  setUserData(data: string): void;
+
+  setUserAttribute(key: string, value: string): void;
+  getUserAttribute(key: string): Promise<string>;
+  removeUserAttribute(key: string): void;
+  getAllUserAttributes(): Promise<UnsafeObject>;
+  clearAllUserAttributes(): void;
+
+  showWelcomeMessageWithMode(mode: string): void;
+  setWelcomeMessageMode(mode: string): void;
+
+  appendTags(tags: string[]): void;
+  resetTags(): void;
+  getTags(): Promise<string[]>;
+
+  addFeatureFlags(featureFlags: UnsafeObject): void;
+  removeFeatureFlags(featureFlags: string[]): void;
+  removeAllFeatureFlags(): void;
+
+  setFileAttachment(filePath: string, fileName: string | null): void;
+
+  setPreSendingHandler(): void;
+  appendTagToReport(tag: string): void;
+  appendConsoleLogToReport(consoleLog: string): void;
+  setUserAttributeToReport(key: string, value: string): void;
+  logDebugToReport(log: string): void;
+  logVerboseToReport(log: string): void;
+  logWarnToReport(log: string): void;
+  logErrorToReport(log: string): void;
+  logInfoToReport(log: string): void;
+  addFileAttachmentWithURLToReport(url: string, filename: string | null): void;
+  addFileAttachmentWithDataToReport(data: string, filename: string | null): void;
+  willRedirectToStore(): void;
+
+  isW3ExternalTraceIDEnabled(): Promise<boolean>;
+  isW3ExternalGeneratedHeaderEnabled(): Promise<boolean>;
+  isW3CaughtHeaderEnabled(): Promise<boolean>;
+
+  registerFeatureFlagsChangeListener(): void;
+  setOnFeaturesUpdatedListener(): void;
+  enableAutoMasking(autoMaskingTypes: string[]): void;
+  getNetworkBodyMaxSize(): Promise<number>;
+
+  setTheme(theme: UnsafeObject): void;
+  setFullscreen(isEnabled: boolean): void;
+
+  setWebViewMonitoringEnabled(isEnabled: boolean): void;
+  setWebViewNetworkTrackingEnabled(isEnabled: boolean): void;
+  setWebViewUserInteractionsTrackingEnabled(isEnabled: boolean): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Luciq');

package/src/native/specs/NativeNetworkLogger.ts

@@ -0,0 +1,31 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  isNativeInterceptionEnabled(): boolean;
+
+  registerNetworkLogsListener(type: string | null): void;
+
+  updateNetworkLogSnapshot(
+    url: string,
+    callbackID: string,
+    requestBody: string | null,
+    responseBody: string | null,
+    responseCode: number,
+    requestHeaders: UnsafeObject,
+    responseHeaders: UnsafeObject,
+  ): void;
+
+  hasAPMNetworkPlugin(): Promise<boolean>;
+  resetNetworkLogsListener(): void;
+
+  setNetworkLoggingRequestFilterPredicateIOS(id: string, value: boolean): void;
+  forceStartNetworkLoggingIOS(): void;
+  forceStopNetworkLoggingIOS(): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQNetworkLogger');

package/src/native/specs/NativeReplies.ts

@@ -0,0 +1,27 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  show(): void;
+  hasChats(): Promise<boolean>;
+  getUnreadRepliesCount(): Promise<number>;
+
+  setOnNewReplyReceivedHandler(): void;
+
+  setPushNotificationsEnabled(isEnabled: boolean): void;
+  setInAppNotificationEnabled(isEnabled: boolean): void;
+
+  setInAppNotificationSound(isEnabled: boolean): void;
+  setPushNotificationRegistrationToken(token: string): void;
+  showNotification(data: UnsafeObject): void;
+  setNotificationIcon(resourceId: number): void;
+  setPushNotificationChannelId(id: string): void;
+  setSystemReplyNotificationSoundEnabled(isEnabled: boolean): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQReplies');

package/src/native/specs/NativeSessionReplay.ts

@@ -0,0 +1,20 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  setNetworkLogsEnabled(isEnabled: boolean): void;
+  setLuciqLogsEnabled(isEnabled: boolean): void;
+  setUserStepsEnabled(isEnabled: boolean): void;
+  getSessionReplayLink(): Promise<string>;
+  setSyncCallback(): Promise<void>;
+  evaluateSync(shouldSync: boolean): void;
+  setCapturingMode(mode: string): void;
+  setScreenshotQuality(quality: string): void;
+  setScreenshotCaptureInterval(intervalMs: number): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQSessionReplay');

package/src/native/specs/NativeSurveys.ts

@@ -0,0 +1,23 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  setAutoShowingEnabled(autoShowingSurveysEnabled: boolean): void;
+  showSurvey(surveyToken: string): void;
+  showSurveysIfAvailable(): void;
+  getAvailableSurveys(): Promise<UnsafeObject[]>;
+  hasRespondedToSurvey(surveyToken: string): Promise<boolean>;
+
+  setShouldShowWelcomeScreen(shouldShowWelcomeScreen: boolean): void;
+  setAppStoreURL(appStoreURL: string): void;
+
+  setOnShowHandler(): void;
+  setOnDismissHandler(): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQSurveys');

package/src/utils/Enums.ts

@@ -1,6 +1,9 @@
 import { NativeLuciq } from '../native/NativeLuciq';
 
-const constants = NativeLuciq.getConstants();
+const constants =
+  typeof NativeLuciq.getConstants === 'function'
+    ? NativeLuciq.getConstants()
+    : (NativeLuciq as any).getAllConstants();
 
 /**
  * Verbosity level of the SDK debug logs. This has nothing to do with `Luciq.log`,

package/src/utils/LuciqUtils.ts

@@ -164,14 +164,9 @@ export const stringifyIfNotString = (input: unknown) => {
  */
 export async function sendCrashReport(
   error: ExtendedError,
-  remoteSenderCallback: (json: CrashData | string) => Promise<void>,
+  remoteSenderCallback: (json: CrashData) => Promise<void>,
 ) {
   const jsonObject = getCrashDataFromError(error);
-
-  if (Platform.OS === 'android') {
-    return remoteSenderCallback(JSON.stringify(jsonObject));
-  }
-
   return remoteSenderCallback(jsonObject);
 }
 /**

package/ios/RNLuciq/LuciqBugReportingBridge.m

@@ -1,249 +0,0 @@
-//
-//  LuciqBugReportingBridge.m
-//  RNLuciq
-//
-//  Created by Salma Ali on 7/30/19.
-//  Copyright © 2019 luciq. All rights reserved.
-//
-
-#import "LuciqBugReportingBridge.h"
-#import <LuciqSDK/LCQBugReporting.h>
-#import <asl.h>
-#import <React/RCTLog.h>
-#import <os/log.h>
-#import <React/RCTUIManager.h>
-
-@implementation LuciqBugReportingBridge
-
-- (dispatch_queue_t)methodQueue {
-    return dispatch_get_main_queue();
-}
-
-+ (BOOL)requiresMainQueueSetup
-{
-    return NO;
-}
-
-- (NSArray<NSString *> *)supportedEvents {
-    return @[
-             @"LCQpreInvocationHandler",
-             @"LCQpostInvocationHandler",
-             @"LCQDidSelectPromptOptionHandler",
-             ];
-}
-
-RCT_EXPORT_MODULE(LCQBugReporting)
-
-RCT_EXPORT_METHOD(setEnabled:(BOOL) isEnabled) {
-    LCQBugReporting.enabled = isEnabled;
-}
-
-RCT_EXPORT_METHOD(setAutoScreenRecordingEnabled:(BOOL)enabled) {
-    LCQBugReporting.autoScreenRecordingEnabled = enabled;
-}
-
-RCT_EXPORT_METHOD(setAutoScreenRecordingDuration:(CGFloat)duration) {
-    LCQBugReporting.autoScreenRecordingDuration = duration;
-}
-
-RCT_EXPORT_METHOD(setOnInvokeHandler:(RCTResponseSenderBlock)callBack) {
-    if (callBack != nil) {
-        LCQBugReporting.willInvokeHandler = ^{
-            [self sendEventWithName:@"LCQpreInvocationHandler" body:nil];
-        };
-    } else {
-        LCQBugReporting.willInvokeHandler = nil;
-    }
-}
-
-RCT_EXPORT_METHOD(setOnSDKDismissedHandler:(RCTResponseSenderBlock)callBack) {
-    if (callBack != nil) {
-        LCQBugReporting.didDismissHandler = ^(LCQDismissType dismissType, LCQReportCategory reportType) {
-
-            //parse dismiss type enum
-            NSString* dismissTypeString;
-            if (dismissType == LCQDismissTypeCancel) {
-                dismissTypeString = @"CANCEL";
-            } else if (dismissType == LCQDismissTypeSubmit) {
-                dismissTypeString = @"SUBMIT";
-            } else if (dismissType == LCQDismissTypeAddAttachment) {
-                dismissTypeString = @"ADD_ATTACHMENT";
-            }
-
-            //parse report type enum
-            NSString* reportTypeString;
-            if (reportType == LCQReportCategoryBug) {
-                reportTypeString = @"bug";
-            } else if (reportType == LCQReportCategoryFeedback) {
-                reportTypeString = @"feedback";
-            } else {
-                reportTypeString = @"other";
-            }
-            NSDictionary *result = @{ @"dismissType": dismissTypeString,
-                                      @"reportType": reportTypeString};
-            [self sendEventWithName:@"LCQpostInvocationHandler" body: result];
-        };
-    } else {
-        LCQBugReporting.didDismissHandler = nil;
-    }
-}
-
-RCT_EXPORT_METHOD(setDidSelectPromptOptionHandler:(RCTResponseSenderBlock)callBack) {
-    if (callBack != nil) {
-
-        LCQBugReporting.didSelectPromptOptionHandler = ^(LCQPromptOption promptOption) {
-
-            NSString *promptOptionString;
-            if (promptOption == LCQPromptOptionBug) {
-                promptOptionString = @"bug";
-            } else if (promptOption == LCQBugReportingTypeFeedback) {
-                promptOptionString = @"feedback";
-            } else if (promptOption == LCQPromptOptionChat) {
-                promptOptionString = @"chat";
-            } else {
-                promptOptionString = @"none";
-            }
-
-            [self sendEventWithName:@"LCQDidSelectPromptOptionHandler" body:@{
-                                                                              @"promptOption": promptOptionString
-                                                                              }];
-        };
-    } else {
-        LCQBugReporting.didSelectPromptOptionHandler = nil;
-    }
-}
-
-RCT_EXPORT_METHOD(setInvocationEvents:(NSArray*)invocationEventsArray) {
-    LCQInvocationEvent invocationEvents = 0;
-    for (NSNumber *boxedValue in invocationEventsArray) {
-        invocationEvents |= [boxedValue intValue];
-    }
-    LCQBugReporting.invocationEvents = invocationEvents;
-}
-
-RCT_EXPORT_METHOD(setOptions:(NSArray*)invocationOptionsArray) {
-    LCQBugReportingOption invocationOptions = 0;
-
-    for (NSNumber *boxedValue in invocationOptionsArray) {
-        invocationOptions |= [boxedValue intValue];
-    }
-
-    LCQBugReporting.bugReportingOptions = invocationOptions;
-}
-
-RCT_EXPORT_METHOD(setFloatingButtonEdge:(CGRectEdge)floatingButtonEdge withTopOffset:(double)floatingButtonOffsetFromTop) {
-    LCQBugReporting.floatingButtonEdge = floatingButtonEdge;
-    LCQBugReporting.floatingButtonTopOffset = floatingButtonOffsetFromTop;
-}
-
-RCT_EXPORT_METHOD(setExtendedBugReportMode:(LCQExtendedBugReportMode)extendedBugReportMode) {
-    LCQBugReporting.extendedBugReportMode = extendedBugReportMode;
-}
-
-RCT_EXPORT_METHOD(setEnabledAttachmentTypes:(BOOL)screenShot
-                  extraScreenShot:(BOOL)extraScreenShot
-                  galleryImage:(BOOL)galleryImage
-                  screenRecording:(BOOL)screenRecording) {
-    LCQAttachmentType attachmentTypes = 0;
-    if(screenShot) {
-        attachmentTypes = LCQAttachmentTypeScreenShot;
-    }
-    if(extraScreenShot) {
-        attachmentTypes |= LCQAttachmentTypeExtraScreenShot;
-    }
-    if(galleryImage) {
-        attachmentTypes |= LCQAttachmentTypeGalleryImage;
-    }
-    if(screenRecording) {
-        attachmentTypes |= LCQAttachmentTypeScreenRecording;
-    }
-
-    LCQBugReporting.enabledAttachmentTypes = attachmentTypes;
-}
-
-RCT_EXPORT_METHOD(setViewHierarchyEnabled:(BOOL)viewHirearchyEnabled) {
-    LCQBugReporting.shouldCaptureViewHierarchy = viewHirearchyEnabled;
-}
-
-RCT_EXPORT_METHOD(setVideoRecordingFloatingButtonPosition:(LCQPosition)position) {
-    LCQBugReporting.videoRecordingFloatingButtonPosition = position;
-}
-
-RCT_EXPORT_METHOD(setReportTypes:(NSArray*) types ) {
-    LCQBugReportingReportType reportTypes = 0;
-    for (NSNumber *boxedValue in types) {
-        reportTypes |= [boxedValue intValue];
-    }
-    [LCQBugReporting setPromptOptionsEnabledReportTypes: reportTypes];
-}
-
-RCT_EXPORT_METHOD(show:(LCQBugReportingReportType)type options:(NSArray*) options) {
-    LCQBugReportingOption parsedOptions = 0;
-    for (NSNumber *boxedValue in options) {
-        parsedOptions |= [boxedValue intValue];
-    }
-    NSArray* args = @[@(type), @(parsedOptions)];
-    [[NSRunLoop mainRunLoop] performSelector:@selector(showBugReportingWithReportTypeAndOptionsHelper:) target:self argument:args order:0 modes:@[NSDefaultRunLoopMode]];
-}
-
-- (void) showBugReportingWithReportTypeAndOptionsHelper:(NSArray*)args {
-    LCQBugReportingReportType parsedreportType = [args[0] intValue];
-    LCQBugReportingOption parsedOptions = [args[1] intValue];
-    [LCQBugReporting showWithReportType:parsedreportType options:parsedOptions];
-}
-
-RCT_EXPORT_METHOD(setShakingThresholdForiPhone:(double)iPhoneShakingThreshold) {
-    LCQBugReporting.shakingThresholdForiPhone = iPhoneShakingThreshold;
-}
-
-RCT_EXPORT_METHOD(setShakingThresholdForiPad:(double)iPadShakingThreshold) {
-    LCQBugReporting.shakingThresholdForiPad = iPadShakingThreshold;
-}
-
-RCT_EXPORT_METHOD(setDisclaimerText:(NSString*)text) {
-   [LCQBugReporting setDisclaimerText:text];
-}
-
-RCT_EXPORT_METHOD(setCommentMinimumCharacterCount:(nonnull NSNumber *)limit reportTypes:(NSArray *)reportTypes) {
-    LCQBugReportingType parsedReportTypes = 0;
-    if (![reportTypes count]) {
-        parsedReportTypes = @(LCQBugReportingTypeBug).integerValue | @(LCQBugReportingTypeFeedback).integerValue | @(LCQBugReportingTypeQuestion).integerValue;
-    }
-    else {
-        for (NSNumber *reportType in reportTypes) {
-            parsedReportTypes |= [reportType intValue];
-        }
-    }
-   [LCQBugReporting setCommentMinimumCharacterCount:[limit integerValue] forBugReportType:parsedReportTypes];
-}
-
-RCT_EXPORT_METHOD(addUserConsent:(NSString *)key
-                  description:(NSString *)description
-                  mandatory:(BOOL)mandatory
-                  checked:(BOOL)checked
-                  actionType:(id)actionType) {
-    LCQConsentAction mappedActionType = (LCQConsentAction)[actionType integerValue];
-
-    [LCQBugReporting addUserConsentWithKey:key
-                               description:description
-                                 mandatory:mandatory
-                                   checked:checked
-                                actionType:mappedActionType];
-}
-
-RCT_EXPORT_METHOD(setProactiveReportingConfigurations:(BOOL)enabled gap:(nonnull NSNumber* )gap model:(nonnull NSNumber* )modal) {
-    LCQProactiveReportingConfigurations *configurations = [[LCQProactiveReportingConfigurations alloc] init];
-    configurations.enabled = enabled; //Enable/disable
-    configurations.gapBetweenModals = gap; // Time in seconds
-    configurations.modalDelayAfterDetection = modal; // Time in seconds
-   [LCQBugReporting setProactiveReportingConfigurations:configurations];
-}
-
-
-@synthesize description;
-
-@synthesize hash;
-
-@synthesize superclass;
-
-@end