@capillarytech/react-native-hydra-lib 1.7.0-beta.1

package/src/NativeHydraLib.ts

@@ -0,0 +1,81 @@
+import type { TurboModule } from 'react-native';
+import { NativeModules, TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  //HydraCore Methods
+  setHydraAccountConfig(hydraAccountConfig: Object): Promise<boolean>;
+  setFirebaseRemoteConfigKeys(remoteConfigKeys: Object): Promise<boolean>;
+  updateGeoConfig(geoConfig: Object): Promise<boolean>;
+  signUp(userDetails: Object, customData: Object | null): Promise<boolean>;
+  signIn(userDetails: Object, customData: Object | null): Promise<boolean>;
+  updateUser(
+    userDetails: Object,
+    customData: Object | null,
+    subscriptions: Object[] | null
+  ): Promise<boolean>;
+  signOut(customerId: string): Promise<boolean>;
+  updatePushPreferences(
+    customerId: string,
+    preferences: Object
+  ): Promise<boolean>;
+  reportUserEvent(
+    eventName: string,
+    attributes: Object | null
+  ): Promise<boolean>;
+  isSdkInitialized(): Promise<boolean>;
+  getCurrentUserState(): Promise<string | null>;
+  getVisitorDetails(): Promise<Object | null>;
+  isVisitorFlowEnabled(): Promise<boolean>;
+
+  //Gamification Methods
+  gamificationScreenAppeared(screenName: string): Promise<void>;
+  gamificationScreenDisappeared(screenName: string): Promise<void>;
+  setCapToken(token: string): Promise<void>;
+  //Hydra Methods
+  identify(userDetails: Object, customData: Object | null): Promise<boolean>;
+  track(eventName: string, attributes: Object | null): Promise<boolean>;
+  reset(customerId: string): Promise<boolean>;
+
+  //HydraPushNotification Methods
+  openExternalUrl(url: string): Promise<void>;
+  getFCMToken(): Promise<string>;
+  requestPermission(): Promise<boolean>;
+
+  //HydraInboxUI Methods
+  showNotificationCenter(): Promise<void>;
+  hideNotificationCenterIfShowing(): Promise<void>;
+
+  //HydraInbox Methods
+  getInboxMessages(): Promise<Object[]>;
+  getUnreadInboxMessagesCount(): Promise<number>;
+  markInboxMessageAsRead(inboxMessage: Object): Promise<boolean>;
+  deleteInboxMessage(inboxMessage: Object): Promise<boolean>;
+  deleteAllInboxMessages(): Promise<boolean>;
+
+  //HydraInAppMessage Methods
+  selfHandledInAppResponse(message: Object, handled: boolean): Promise<void>;
+  reportMessageClicked(message: Object): Promise<void>;
+  reportMessageRating(message: Object, rating: number): Promise<void>;
+  reportMessageFeedback(
+    message: Object,
+    feedback: string,
+    feedbackOptions: number[]
+  ): Promise<void>;
+  reportMessageDismissed(message: Object): Promise<void>;
+  //HydraNativeEventEmitter Methods
+  addListener(eventName: string): void;
+  removeListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+declare global {
+  var __turboModuleProxy: any;
+}
+
+const isTurboModuleEnabled = global.__turboModuleProxy != null;
+
+const NativeHydraLib: Spec = isTurboModuleEnabled
+  ? TurboModuleRegistry.getEnforcing<Spec>('HydraLib')
+  : NativeModules.HydraLib;
+
+export default NativeHydraLib;

package/src/components/GamificationBannerView.tsx

@@ -0,0 +1,10 @@
+import type { ViewProps } from 'react-native';
+import NativeHydraBannerView from '../GamificationBannerViewNativeComponent';
+
+export interface GamificationBannerViewProps extends ViewProps {
+  bannerId: string;
+}
+
+export function GamificationBannerView(props: GamificationBannerViewProps) {
+  return <NativeHydraBannerView {...props} />;
+}

package/src/components/GamificationEmbedView.tsx

@@ -0,0 +1,10 @@
+import type { ViewProps } from 'react-native';
+import NativeHydraEmbedView from '../GamificationEmbedViewNativeComponent';
+
+export interface GamificationEmbedViewProps extends ViewProps {
+  embedId: string;
+}
+
+export function GamificationEmbedView(props: GamificationEmbedViewProps) {
+  return <NativeHydraEmbedView {...props} />;
+}

package/src/components/GamificationLoyaltyView.tsx

@@ -0,0 +1,10 @@
+import type { ViewProps } from 'react-native';
+import NativeHydraLoyaltyView from '../GamificationLoyaltyViewNativeComponent';
+
+export interface GamificationLoyaltyViewProps extends ViewProps {
+  loyaltyId: string;
+}
+
+export function GamificationLoyaltyView(props: GamificationLoyaltyViewProps) {
+  return <NativeHydraLoyaltyView {...props} />;
+}

package/src/hydra-apis/Hydra.ts

@@ -0,0 +1,52 @@
+import type { HydraUserDetails } from '../models/HydraUserDetails';
+import { HydraVisitorInfo } from '../models/HydraVisitorInfo';
+import { UserState } from '../models/UserState';
+import NativeHydraLib from '../NativeHydraLib';
+
+export class Hydra {
+  static identify(
+    userDetails: HydraUserDetails,
+    customAttributes: Record<string, any> | null = null
+  ): Promise<boolean> {
+    return NativeHydraLib.identify(userDetails.toJson(), customAttributes);
+  }
+
+  static track(
+    eventName: string,
+    attributes: Record<string, any> | null = null
+  ): Promise<boolean> {
+    return NativeHydraLib.track(eventName, attributes);
+  }
+
+  static reset(customerId: string): Promise<boolean> {
+    return NativeHydraLib.reset(customerId);
+  }
+
+  static async getCurrentUserState(): Promise<UserState | null> {
+    const stateString = await NativeHydraLib.getCurrentUserState();
+    return UserState.fromString(stateString);
+  }
+
+  static async getVisitorDetails(): Promise<HydraVisitorInfo | null> {
+    const visitorData = await NativeHydraLib.getVisitorDetails();
+    return HydraVisitorInfo.fromJson(visitorData);
+  }
+
+  static async isVisitorFlowEnabled(): Promise<boolean> {
+    return await NativeHydraLib.isVisitorFlowEnabled();
+  }
+
+  static async gamificationScreenAppeared(screenName: string): Promise<void> {
+    return await NativeHydraLib.gamificationScreenAppeared(screenName);
+  }
+
+  static async gamificationScreenDisappeared(
+    screenName: string
+  ): Promise<void> {
+    return await NativeHydraLib.gamificationScreenDisappeared(screenName);
+  }
+
+  static setCapToken(token: string): Promise<void> {
+    return NativeHydraLib.setCapToken(token);
+  }
+}

package/src/hydra-apis/HydraCore.ts

@@ -0,0 +1,76 @@
+import type { HydraAccountConfig } from '../models/HydraAccountConfig';
+import type { HydraFirebaseRemoteConfigKeys } from '../models/HydraFirebaseRemoteConfigKeys';
+import type { HydraGeoConfig } from '../models/HydraGeoConfig';
+import type { HydraPushPreferences } from '../models/HydraPushPreferences';
+import type { HydraUserDetails } from '../models/HydraUserDetails';
+import NativeHydraLib from '../NativeHydraLib';
+
+export class HydraCore {
+  static setHydraAccountConfig(
+    hydraAccountConfig: HydraAccountConfig
+  ): Promise<boolean> {
+    return NativeHydraLib.setHydraAccountConfig(hydraAccountConfig.toJson());
+  }
+
+  static setFirebaseRemoteConfigKeys(
+    remoteConfigKeys: HydraFirebaseRemoteConfigKeys
+  ): Promise<boolean> {
+    return NativeHydraLib.setFirebaseRemoteConfigKeys(
+      remoteConfigKeys.toJson()
+    );
+  }
+  static updateGeoConfig(geoConfig: HydraGeoConfig): Promise<boolean> {
+    return NativeHydraLib.updateGeoConfig(geoConfig.toJson());
+  }
+
+  static updatePushPreferences(
+    customerId: string,
+    preferences: HydraPushPreferences
+  ): Promise<boolean> {
+    return NativeHydraLib.updatePushPreferences(
+      customerId,
+      preferences.toJson()
+    );
+  }
+
+  static signUp(
+    userDetails: HydraUserDetails,
+    customAttributes: Record<string, any> | null = null
+  ): Promise<boolean> {
+    return NativeHydraLib.signUp(userDetails.toJson(), customAttributes);
+  }
+
+  static signIn(
+    userDetails: HydraUserDetails,
+    customAttributes: Record<string, any> | null = null
+  ): Promise<boolean> {
+    return NativeHydraLib.signIn(userDetails.toJson(), customAttributes);
+  }
+
+  static updateUser(
+    userDetails: HydraUserDetails,
+    customAttributes: Record<string, any> | null = null,
+    subscriptions: Object[] | null = null
+  ): Promise<boolean> {
+    return NativeHydraLib.updateUser(
+      userDetails.toJson(),
+      customAttributes,
+      subscriptions
+    );
+  }
+
+  static signOut(customerId: string): Promise<boolean> {
+    return NativeHydraLib.signOut(customerId);
+  }
+
+  static reportUserEvent(
+    eventName: string,
+    attributes: Record<string, any> | null = null
+  ): Promise<boolean> {
+    return NativeHydraLib.reportUserEvent(eventName, attributes);
+  }
+
+  static isSdkInitialized(): Promise<boolean> {
+    return NativeHydraLib.isSdkInitialized();
+  }
+}

package/src/hydra-apis/HydraInAppMessaging.ts

@@ -0,0 +1,25 @@
+import type { HydraInAppMessage } from '../models/HydraInAppMessage/HydraInAppMessage';
+import NativeHydraLib from '../NativeHydraLib';
+
+export class HydraInAppMessaging {
+  static reportMessageClicked(message: HydraInAppMessage) {
+    NativeHydraLib.reportMessageClicked(message.toJson());
+  }
+  static reportMessageDismissed(message: HydraInAppMessage) {
+    NativeHydraLib.reportMessageDismissed(message.toJson());
+  }
+  static reportMessageFeedback(
+    message: HydraInAppMessage,
+    feedback: string,
+    feedbackOptionIndices: number[]
+  ) {
+    NativeHydraLib.reportMessageFeedback(
+      message.toJson(),
+      feedback,
+      feedbackOptionIndices
+    );
+  }
+  static reportMessageRating(message: HydraInAppMessage, rating: number) {
+    NativeHydraLib.reportMessageRating(message.toJson(), rating);
+  }
+}

package/src/hydra-apis/HydraInbox.ts

@@ -0,0 +1,33 @@
+import NativeHydraLib from '../NativeHydraLib';
+import { HydraNotification } from '../models/HydraNotification/HydraNotification';
+export class HydraInbox {
+  static async getInboxMessages(): Promise<HydraNotification[]> {
+    const messages: Record<string, any>[] =
+      await NativeHydraLib.getInboxMessages();
+    return messages.map(
+      (message: Record<string, any>) => new HydraNotification(message)
+    );
+  }
+
+  static getUnreadMessagesCount(): Promise<number> {
+    return NativeHydraLib.getUnreadInboxMessagesCount();
+  }
+
+  static markInboxMessageAsRead(
+    hydraNotification: HydraNotification
+  ): Promise<boolean> {
+    return NativeHydraLib.markInboxMessageAsRead(
+      hydraNotification.toJson(true)
+    );
+  }
+
+  static deleteInboxMessage(
+    hydraNotification: HydraNotification
+  ): Promise<boolean> {
+    return NativeHydraLib.deleteInboxMessage(hydraNotification.toJson());
+  }
+
+  static deleteAllInboxMessages(): Promise<boolean> {
+    return NativeHydraLib.deleteAllInboxMessages();
+  }
+}

package/src/hydra-apis/HydraInboxUI.ts

@@ -0,0 +1,10 @@
+import NativeHydraLib from '../NativeHydraLib';
+
+export class HydraInboxUI {
+  static showNotificationCenter(): Promise<void> {
+    return NativeHydraLib.showNotificationCenter();
+  }
+  static hideNotificationCenterIfShowing(): Promise<void> {
+    return NativeHydraLib.hideNotificationCenterIfShowing();
+  }
+}

package/src/hydra-apis/HydraNativeEventEmitter.ts

@@ -0,0 +1,216 @@
+import { NativeEventEmitter, type EmitterSubscription } from 'react-native';
+import NativeHydraLib from '../NativeHydraLib';
+import { HydraNativeEvent } from '../models/HydraNativeEvent';
+import { HydraNotification } from '../models/HydraNotification/HydraNotification';
+import { NonHydraNotification } from '../models/NonHydraNotification';
+import { HydraNotificationCta } from '../models/HydraNotification/HydraNotificationCta';
+import { HydraInAppMessage } from '../models/HydraInAppMessage/HydraInAppMessage';
+import { UserState } from '../models/UserState';
+
+type EventListenerSubscriptionMap = Record<string, EmitterSubscription[]>;
+
+export class HydraNativeEventEmitter {
+  private static instance: HydraNativeEventEmitter;
+
+  private emitter: NativeEventEmitter;
+  private eventListenerSubscriptionMap: EventListenerSubscriptionMap = {};
+  private constructor() {
+    this.emitter = new NativeEventEmitter(NativeHydraLib);
+  }
+
+  static getInstance(): HydraNativeEventEmitter {
+    if (!HydraNativeEventEmitter.instance) {
+      HydraNativeEventEmitter.instance = new HydraNativeEventEmitter();
+    }
+    return HydraNativeEventEmitter.instance;
+  }
+
+  addHydraSdkInitializationResultListener(
+    listener: (success: boolean, errorMessage: string | null) => void
+  ) {
+    return this.addListener(
+      HydraNativeEvent.onHydraSdkInitializationResult,
+      (eventData) => {
+        listener(eventData['success'], eventData['errorMessage']);
+      }
+    );
+  }
+
+  addTokenAvailableListener(listener: (token: string) => void) {
+    return this.addListener(HydraNativeEvent.onTokenAvailable, (eventData) => {
+      listener(eventData);
+    });
+  }
+
+  addNonHydraNotificationReceivedListener(
+    listener: (notification: NonHydraNotification) => void
+  ) {
+    return this.addListener(
+      HydraNativeEvent.onNonHydraNotificationReceived,
+      (eventData) => {
+        listener(new NonHydraNotification(eventData));
+      }
+    );
+  }
+
+  addNonHydraNotificationClickedListener(
+    listener: (notification: NonHydraNotification) => void
+  ) {
+    return this.addListener(
+      HydraNativeEvent.onNonHydraNotificationClicked,
+      (eventData) => {
+        listener(new NonHydraNotification(eventData));
+      }
+    );
+  }
+
+  addHydraNotificationReceivedListener(
+    listener: (notification: HydraNotification) => void
+  ) {
+    return this.addListener(
+      HydraNativeEvent.onHydraNotificationReceived,
+      (eventData) => {
+        listener(new HydraNotification(eventData));
+      }
+    );
+  }
+
+  addHydraNotificationClickedListener(
+    listener: (
+      notification: HydraNotification | null,
+      cta: HydraNotificationCta | null
+    ) => void
+  ) {
+    return this.addListener(
+      HydraNativeEvent.onHydraNotificationClicked,
+      (eventData) => {
+        listener(
+          eventData['payload']
+            ? new HydraNotification(eventData['payload'])
+            : null,
+          eventData['cta'] ? new HydraNotificationCta(eventData['cta']) : null
+        );
+      }
+    );
+  }
+
+  addHydraNotificationShownListener(
+    listener: (notification: HydraNotification) => void
+  ) {
+    return this.addListener(
+      HydraNativeEvent.onHydraNotificationShown,
+      (eventData) => {
+        listener(new HydraNotification(eventData));
+      }
+    );
+  }
+
+  addHydraNotificationDismissedListener(
+    listener: (notification: HydraNotification) => void
+  ) {
+    return this.addListener(
+      HydraNativeEvent.onHydraNotificationDismissed,
+      (eventData) => {
+        listener(new HydraNotification(eventData));
+      }
+    );
+  }
+
+  addHandleCustomActionListener(listener: (payload: string) => void) {
+    return this.addListener(
+      HydraNativeEvent.handleCustomAction,
+      (eventData) => {
+        listener(eventData);
+      }
+    );
+  }
+
+  addNotificationCenterDismissedListener(listener: () => void) {
+    return this.addListener(
+      HydraNativeEvent.onNotificationCenterDismissed,
+      listener
+    );
+  }
+
+  addInboxUpdatedListener(listener: () => void) {
+    return this.addListener(HydraNativeEvent.onInboxUpdated, listener);
+  }
+
+  addHydraInAppMessageListener(
+    listener: (message: HydraInAppMessage) => boolean
+  ) {
+    return this.addListener(
+      HydraNativeEvent.onHydraInAppMessage,
+      (eventData) => {
+        const handled = listener(new HydraInAppMessage(eventData));
+        console.log('>>>>>>>>>> message handled by the app = ', handled);
+        NativeHydraLib.selfHandledInAppResponse(eventData, handled);
+      }
+    );
+  }
+
+  setConfigFetchedCallback(listener: (isVisitorFlowEnabled: boolean) => void) {
+    return this.addListener(HydraNativeEvent.onConfigFetchedCallback, listener);
+  }
+
+  setLegacyFlowReadyCallback(listener: () => void) {
+    return this.addListener(HydraNativeEvent.onLegacyFlowReady, listener);
+  }
+
+  setVisitorSessionReadyCallback(listener: () => void) {
+    return this.addListener(HydraNativeEvent.onVisitorSessionReady, listener);
+  }
+
+  setUserStateChangedCallback(listener: (userState: UserState | null) => void) {
+    return this.addListener(HydraNativeEvent.onUserStateChanged, (eventData) => {
+      listener(UserState.fromString(eventData));
+    });
+  }
+
+  addGamificationViewHeightChangedListener(listener: (height: number, entryPointId: string) => void) {
+    return this.addListener(
+      HydraNativeEvent.onGamificationViewHeightChanged,
+      (eventData) => {
+        listener(eventData['height'], eventData['entryPointId']);
+      }
+    );
+  }
+
+  addListener(eventType: HydraNativeEvent, listener: (event: any) => void) {
+    const subscription = this.emitter.addListener(eventType, listener);
+    if (this.eventListenerSubscriptionMap[eventType] === undefined) {
+      this.eventListenerSubscriptionMap[eventType] = [subscription];
+    } else {
+      this.eventListenerSubscriptionMap[eventType].push(subscription);
+    }
+    return subscription;
+  }
+
+  removeListener(emitterSubscription: EmitterSubscription) {
+    const eventType = Object.keys(this.eventListenerSubscriptionMap).find(
+      (eventType) =>
+        this.eventListenerSubscriptionMap[eventType]?.includes(
+          emitterSubscription
+        )
+    );
+    if (eventType !== undefined) {
+      const remainingSubscriptions = this.eventListenerSubscriptionMap[
+        eventType
+      ]?.filter((subscription) => subscription !== emitterSubscription);
+
+      if (remainingSubscriptions && remainingSubscriptions.length > 0) {
+        this.eventListenerSubscriptionMap[eventType] = remainingSubscriptions;
+      } else {
+        delete this.eventListenerSubscriptionMap[eventType];
+        NativeHydraLib.removeListener(eventType);
+      }
+    }
+    emitterSubscription.remove();
+  }
+
+  removeAllListeners(eventType: HydraNativeEvent) {
+    this.emitter.removeAllListeners(eventType);
+    NativeHydraLib.removeListener(eventType);
+    delete this.eventListenerSubscriptionMap[eventType];
+  }
+}

package/src/hydra-apis/HydraPushNotification.ts

@@ -0,0 +1,15 @@
+import NativeHydraLib from '../NativeHydraLib';
+
+export class HydraPushNotification {
+  static openExternalUrl(url: string): Promise<void> {
+    return NativeHydraLib.openExternalUrl(url);
+  }
+
+  static getFCMToken(): Promise<string> {
+    return NativeHydraLib.getFCMToken();
+  }
+
+  static requestPermission(): Promise<boolean> {
+    return NativeHydraLib.requestPermission();
+  }
+}

package/src/index.tsx

@@ -0,0 +1,71 @@
+import { Hydra } from './hydra-apis/Hydra';
+import { HydraCore } from './hydra-apis/HydraCore';
+import { HydraInbox } from './hydra-apis/HydraInbox';
+import { HydraInboxUI } from './hydra-apis/HydraInboxUI';
+import { HydraNativeEventEmitter } from './hydra-apis/HydraNativeEventEmitter';
+import { HydraPushNotification } from './hydra-apis/HydraPushNotification';
+
+import { HydraAccountConfig } from './models/HydraAccountConfig';
+import { HydraFirebaseRemoteConfigKeys } from './models/HydraFirebaseRemoteConfigKeys';
+import { HydraGeoConfig } from './models/HydraGeoConfig';
+import { HydraLogLevel } from './models/HydraLogLevel';
+import { HydraNativeEvent } from './models/HydraNativeEvent';
+import { HydraPushPreferences } from './models/HydraPushPreferences';
+import { HydraUserDetails } from './models/HydraUserDetails';
+import { NonHydraNotification } from './models/NonHydraNotification';
+import { UserState } from './models/UserState';
+import { HydraVisitorInfo } from './models/HydraVisitorInfo';
+
+import { HydraNotification } from './models/HydraNotification/HydraNotification';
+import { HydraNotificationBody } from './models/HydraNotification/HydraNotificationBody';
+import { HydraNotificationCta } from './models/HydraNotification/HydraNotificationCta';
+import { HydraNotificationCtaType } from './models/HydraNotification/HydraNotificationCtaType';
+import { HydraNotificationExpandedDetails } from './models/HydraNotification/HydraNotificationExpandedDetails';
+import { HydraNotificationGateway } from './models/HydraNotification/HydraNotificationGateway';
+import { HydraInAppMessage } from './models/HydraInAppMessage/HydraInAppMessage';
+import { HydraInAppMessaging } from './hydra-apis/HydraInAppMessaging';
+import { HydraInAppTextComponent } from './models/HydraInAppMessage/HydraInAppTextComponent';
+import { HydraInAppButtonComponent } from './models/HydraInAppMessage/HydraInAppButtonComponent';
+import { HydraInAppComponentStyle } from './models/HydraInAppMessage/HydraInAppComponentStyle';
+import { HydraInAppFeedbackSelectionType } from './models/HydraInAppMessage/HydraInAppFeedbackSelectionType';
+import { HydraInAppTemplateType } from './models/HydraInAppMessage/HydraInAppTemplateType';
+import { GamificationBannerView } from './components/GamificationBannerView';
+import { GamificationEmbedView } from './components/GamificationEmbedView';
+import { GamificationLoyaltyView } from './components/GamificationLoyaltyView';
+export type { GamificationBannerViewProps } from './components/GamificationBannerView';
+export type { GamificationEmbedViewProps } from './components/GamificationEmbedView';
+export type { GamificationLoyaltyViewProps } from './components/GamificationLoyaltyView';
+export {
+  Hydra,
+  HydraCore,
+  HydraInAppMessaging,
+  HydraInbox,
+  HydraInboxUI,
+  HydraNativeEventEmitter,
+  HydraPushNotification,
+  HydraAccountConfig,
+  HydraFirebaseRemoteConfigKeys,
+  HydraGeoConfig,
+  HydraLogLevel,
+  HydraNativeEvent,
+  HydraPushPreferences,
+  HydraUserDetails,
+  NonHydraNotification,
+  UserState,
+  HydraVisitorInfo,
+  HydraNotification,
+  HydraNotificationBody,
+  HydraNotificationCta,
+  HydraNotificationCtaType,
+  HydraNotificationExpandedDetails,
+  HydraNotificationGateway,
+  HydraInAppButtonComponent,
+  HydraInAppComponentStyle,
+  HydraInAppFeedbackSelectionType,
+  HydraInAppMessage,
+  HydraInAppTemplateType,
+  HydraInAppTextComponent,
+  GamificationBannerView,
+  GamificationEmbedView,
+  GamificationLoyaltyView,
+};

package/src/models/HydraAccountConfig.ts

@@ -0,0 +1,45 @@
+import { HydraLogLevel } from './HydraLogLevel';
+
+export class HydraAccountConfig {
+  readonly accountId: string;
+  readonly baseUrl: string;
+  readonly sslPublicKey: string;
+  readonly remoteDebugLevel: HydraLogLevel;
+  readonly orgId?: string;
+  readonly gamificationKey?: string;
+  readonly gamificationRegion?: string;
+  readonly gamificationBaseUrl?: string;
+
+  constructor(
+    accountId: string,
+    baseUrl: string,
+    sslPublicKey: string,
+    remoteDebugLevel: HydraLogLevel = HydraLogLevel.off,
+    orgId?: string,
+    gamificationKey?: string,
+    gamificationRegion?: string,
+    gamificationBaseUrl?: string
+  ) {
+    this.accountId = accountId;
+    this.baseUrl = baseUrl;
+    this.sslPublicKey = sslPublicKey;
+    this.remoteDebugLevel = remoteDebugLevel;
+    this.orgId = orgId;
+    this.gamificationKey = gamificationKey;
+    this.gamificationRegion = gamificationRegion;
+    this.gamificationBaseUrl = gamificationBaseUrl;
+  }
+
+  toJson(): Record<string, any> {
+    return {
+      accountId: this.accountId,
+      baseUrl: this.baseUrl,
+      sslPublicKey: this.sslPublicKey,
+      remoteDebugLevel: this.remoteDebugLevel,
+      ...(this.orgId !== undefined && { orgId: this.orgId }),
+      ...(this.gamificationKey !== undefined && { gamificationKey: this.gamificationKey }),
+      ...(this.gamificationRegion !== undefined && { gamificationRegion: this.gamificationRegion }),
+      ...(this.gamificationBaseUrl !== undefined && { gamificationBaseUrl: this.gamificationBaseUrl }),
+    };
+  }
+}