diff --git a/src/__tests__/IterableInApp.test.ts b/src/__tests__/IterableInApp.test.ts
index b4a157413..bddb3f3f9 100644
--- a/src/__tests__/IterableInApp.test.ts
+++ b/src/__tests__/IterableInApp.test.ts
@@ -1,7 +1,5 @@
 import { NativeEventEmitter } from 'react-native';
 
-import { IterableLogger } from '../core';
-
 import { MockRNIterableAPI } from '../__mocks__/MockRNIterableAPI';
 
 import {
@@ -21,7 +19,6 @@ import {
 describe('Iterable In App', () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    Iterable.logger = new IterableLogger(new IterableConfig());
   });
 
   test('trackInAppOpen_params_methodCalledWithParams', () => {
@@ -202,9 +199,11 @@ describe('Iterable In App', () => {
     // WHEN the simulated local queue is set to the in-app messages
     MockRNIterableAPI.setMessages(messages);
     // THEN Iterable.inAppManager.getMessages returns the list of in-app messages
-    return await Iterable.inAppManager?.getMessages().then((messagesObtained) => {
-      expect(messagesObtained).toEqual(messages);
-    });
+    return await Iterable.inAppManager
+      ?.getMessages()
+      .then((messagesObtained) => {
+        expect(messagesObtained).toEqual(messages);
+      });
   });
 
   test('showMessage_messageAndConsume_returnsClickedUrl', async () => {
@@ -222,9 +221,11 @@ describe('Iterable In App', () => {
     // WHEN the simulated clicked url is set to the clicked url
     MockRNIterableAPI.setClickedUrl(clickedUrl);
     // THEN Iterable,inAppManager.showMessage returns the simulated clicked url
-    return await Iterable.inAppManager?.showMessage(message, consume).then((url) => {
-      expect(url).toEqual(clickedUrl);
-    });
+    return await Iterable.inAppManager
+      ?.showMessage(message, consume)
+      .then((url) => {
+        expect(url).toEqual(clickedUrl);
+      });
   });
 
   test('removeMessage_params_methodCalledWithParams', () => {
diff --git a/src/core/classes/Iterable.test.ts b/src/core/classes/Iterable.test.ts
index 79c47792c..afc5100dd 100644
--- a/src/core/classes/Iterable.test.ts
+++ b/src/core/classes/Iterable.test.ts
@@ -2,7 +2,6 @@ import { NativeEventEmitter, Platform } from 'react-native';
 
 import { MockLinking } from '../../__mocks__/MockLinking';
 import { MockRNIterableAPI } from '../../__mocks__/MockRNIterableAPI';
-import { IterableLogger } from '..';
 // import from the same location that consumers import from
 import {
   Iterable,
@@ -10,33 +9,25 @@ import {
   IterableActionContext,
   IterableActionSource,
   IterableAttributionInfo,
+  IterableAuthResponse,
   IterableCommerceItem,
   IterableConfig,
   IterableDataRegion,
   IterableEventName,
-  IterableLogLevel,
-  IterableInAppMessage,
   IterableInAppCloseSource,
   IterableInAppDeleteSource,
   IterableInAppLocation,
+  IterableInAppMessage,
+  IterableInAppShowResponse,
   IterableInAppTrigger,
   IterableInAppTriggerType,
-  IterableAuthResponse,
-  IterableInAppShowResponse,
+  IterableLogLevel,
 } from '../..';
 import { TestHelper } from '../../__tests__/TestHelper';
 
-const getDefaultConfig = () => {
-  const config = new IterableConfig();
-  config.logReactNativeSdkCalls = false;
-  return config;
-};
-
 describe('Iterable', () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    const config = getDefaultConfig();
-    Iterable.logger = new IterableLogger(config);
   });
 
   afterEach(() => {
diff --git a/src/core/classes/Iterable.ts b/src/core/classes/Iterable.ts
index a893236b8..ae6aaa112 100644
--- a/src/core/classes/Iterable.ts
+++ b/src/core/classes/Iterable.ts
@@ -24,6 +24,7 @@ import { IterableConfig } from './IterableConfig';
 import { IterableLogger } from './IterableLogger';
 import type { IterableAuthFailure } from '../types/IterableAuthFailure';
 import { IterableAuthManager } from './IterableAuthManager';
+import { IterableApi } from './IterableApi';
 
 const RNEventEmitter = new NativeEventEmitter(RNIterableAPI);
 
@@ -46,12 +47,6 @@ const RNEventEmitter = new NativeEventEmitter(RNIterableAPI);
  */
 /* eslint-enable tsdoc/syntax */
 export class Iterable {
-  /**
-   * Logger for the Iterable SDK
-   * Log level is set with {@link IterableLogLevel}
-   */
-  static logger: IterableLogger = new IterableLogger(new IterableConfig());
-
   /**
    * Current configuration of the Iterable SDK
    */
@@ -139,16 +134,11 @@ export class Iterable {
     config: IterableConfig = new IterableConfig()
   ): Promise<boolean> {
     Iterable.savedConfig = config;
-
-    Iterable.logger = new IterableLogger(Iterable.savedConfig);
-
-    Iterable?.logger?.log('initialize: ' + apiKey);
-
-    this.setupEventHandlers();
+    this.setupIterable(config);
 
     const version = this.getVersionFromPackageJson();
 
-    return RNIterableAPI.initializeWithApiKey(apiKey, config.toDict(), version);
+    return IterableApi.initializeWithApiKey(apiKey, { config, version });
   }
 
   /**
@@ -162,21 +152,31 @@ export class Iterable {
     config: IterableConfig = new IterableConfig(),
     apiEndPoint: string
   ): Promise<boolean> {
-    Iterable.savedConfig = config;
-
-    Iterable.logger = new IterableLogger(Iterable.savedConfig);
-
-    Iterable?.logger?.log('initialize2: ' + apiKey);
+    this.setupIterable(config);
 
-    this.setupEventHandlers();
     const version = this.getVersionFromPackageJson();
 
-    return RNIterableAPI.initialize2WithApiKey(
-      apiKey,
-      config.toDict(),
+    return IterableApi.initialize2WithApiKey(apiKey, {
+      config,
       version,
-      apiEndPoint
-    );
+      apiEndPoint,
+    });
+  }
+
+  /**
+   * @internal
+   * Does basic setup of the Iterable SDK.
+   * @param config - The configuration object for the Iterable SDK
+   */
+  private static setupIterable(config: IterableConfig = new IterableConfig()) {
+    if (config) {
+      Iterable.savedConfig = config;
+
+      IterableLogger.setLoggingEnabled(config.logReactNativeSdkCalls ?? true);
+      IterableLogger.setLogLevel(config.logLevel);
+    }
+
+    this.setupEventHandlers();
   }
 
   /**
@@ -229,9 +229,7 @@ export class Iterable {
    * ```
    */
   static setEmail(email: string | null, authToken?: string | null) {
-    Iterable?.logger?.log('setEmail: ' + email);
-
-    RNIterableAPI.setEmail(email, authToken);
+    IterableApi.setEmail(email, authToken);
   }
 
   /**
@@ -245,9 +243,7 @@ export class Iterable {
    * ```
    */
   static getEmail(): Promise<string | null> {
-    Iterable?.logger?.log('getEmail');
-
-    return RNIterableAPI.getEmail();
+    return IterableApi.getEmail();
   }
 
   /**
@@ -294,9 +290,7 @@ export class Iterable {
    * taken
    */
   static setUserId(userId?: string | null, authToken?: string | null) {
-    Iterable?.logger?.log('setUserId: ' + userId);
-
-    RNIterableAPI.setUserId(userId, authToken);
+    IterableApi.setUserId(userId, authToken);
   }
 
   /**
@@ -310,9 +304,7 @@ export class Iterable {
    * ```
    */
   static getUserId(): Promise<string | null | undefined> {
-    Iterable?.logger?.log('getUserId');
-
-    return RNIterableAPI.getUserId();
+    return IterableApi.getUserId();
   }
 
   /**
@@ -324,9 +316,7 @@ export class Iterable {
    * ```
    */
   static disableDeviceForCurrentUser() {
-    Iterable?.logger?.log('disableDeviceForCurrentUser');
-
-    RNIterableAPI.disableDeviceForCurrentUser();
+    IterableApi.disableDeviceForCurrentUser();
   }
 
   /**
@@ -341,9 +331,7 @@ export class Iterable {
    * ```
    */
   static getLastPushPayload(): Promise<unknown> {
-    Iterable?.logger?.log('getLastPushPayload');
-
-    return RNIterableAPI.getLastPushPayload();
+    return IterableApi.getLastPushPayload();
   }
 
   /**
@@ -369,9 +357,7 @@ export class Iterable {
    * ```
    */
   static getAttributionInfo(): Promise<IterableAttributionInfo | undefined> {
-    Iterable?.logger?.log('getAttributionInfo');
-
-    return RNIterableAPI.getAttributionInfo().then(
+    return IterableApi.getAttributionInfo().then(
       (
         dict: {
           campaignId: number;
@@ -417,13 +403,7 @@ export class Iterable {
    * ```
    */
   static setAttributionInfo(attributionInfo?: IterableAttributionInfo) {
-    Iterable?.logger?.log('setAttributionInfo');
-
-    RNIterableAPI.setAttributionInfo(
-      attributionInfo as unknown as {
-        [key: string]: string | number | boolean;
-      } | null
-    );
+    IterableApi.setAttributionInfo(attributionInfo);
   }
 
   /**
@@ -462,15 +442,13 @@ export class Iterable {
     appAlreadyRunning: boolean,
     dataFields?: unknown
   ) {
-    Iterable?.logger?.log('trackPushOpenWithCampaignId');
-
-    RNIterableAPI.trackPushOpenWithCampaignId(
+    IterableApi.trackPushOpenWithCampaignId({
       campaignId,
       templateId,
-      messageId as string,
+      messageId,
       appAlreadyRunning,
-      dataFields as { [key: string]: string | number | boolean } | undefined
-    );
+      dataFields,
+    });
   }
 
   /**
@@ -500,11 +478,7 @@ export class Iterable {
    * ```
    */
   static updateCart(items: IterableCommerceItem[]) {
-    Iterable?.logger?.log('updateCart');
-
-    RNIterableAPI.updateCart(
-      items as unknown as { [key: string]: string | number | boolean }[]
-    );
+    IterableApi.updateCart(items);
   }
 
   /**
@@ -519,9 +493,7 @@ export class Iterable {
    */
   static wakeApp() {
     if (Platform.OS === 'android') {
-      Iterable?.logger?.log('Attempting to wake the app');
-
-      RNIterableAPI.wakeApp();
+      IterableApi.wakeApp();
     }
   }
 
@@ -554,13 +526,9 @@ export class Iterable {
     items: IterableCommerceItem[],
     dataFields?: unknown
   ) {
-    Iterable?.logger?.log('trackPurchase');
+    IterableLogger?.log('trackPurchase');
 
-    RNIterableAPI.trackPurchase(
-      total,
-      items as unknown as { [key: string]: string | number | boolean }[],
-      dataFields as { [key: string]: string | number | boolean } | undefined
-    );
+    IterableApi.trackPurchase({ total, items, dataFields });
   }
 
   /**
@@ -586,9 +554,13 @@ export class Iterable {
     message: IterableInAppMessage,
     location: IterableInAppLocation
   ) {
-    Iterable?.logger?.log('trackInAppOpen');
-
-    RNIterableAPI.trackInAppOpen(message.messageId, location);
+    if (!message?.messageId) {
+      IterableLogger?.log(
+        `Skipping trackInAppOpen because message ID is required, but received ${message}.`
+      );
+      return;
+    }
+    IterableApi.trackInAppOpen({ message, location });
   }
 
   /**
@@ -617,9 +589,7 @@ export class Iterable {
     location: IterableInAppLocation,
     clickedUrl: string
   ) {
-    Iterable?.logger?.log('trackInAppClick');
-
-    RNIterableAPI.trackInAppClick(message.messageId, location, clickedUrl);
+    IterableApi.trackInAppClick({ message, location, clickedUrl });
   }
 
   /**
@@ -650,14 +620,7 @@ export class Iterable {
     source: IterableInAppCloseSource,
     clickedUrl?: string
   ) {
-    Iterable?.logger?.log('trackInAppClose');
-
-    RNIterableAPI.trackInAppClose(
-      message.messageId,
-      location,
-      source,
-      clickedUrl
-    );
+    IterableApi.trackInAppClose({ message, location, source, clickedUrl });
   }
 
   /**
@@ -701,9 +664,7 @@ export class Iterable {
     location: IterableInAppLocation,
     source: IterableInAppDeleteSource
   ) {
-    Iterable?.logger?.log('inAppConsume');
-
-    RNIterableAPI.inAppConsume(message.messageId, location, source);
+    IterableApi.inAppConsume(message, location, source);
   }
 
   /**
@@ -727,12 +688,7 @@ export class Iterable {
    * ```
    */
   static trackEvent(name: string, dataFields?: unknown) {
-    Iterable?.logger?.log('trackEvent');
-
-    RNIterableAPI.trackEvent(
-      name,
-      dataFields as { [key: string]: string | number | boolean } | undefined
-    );
+    IterableApi.trackEvent({ name, dataFields });
   }
 
   /**
@@ -778,12 +734,7 @@ export class Iterable {
     dataFields: unknown | undefined,
     mergeNestedObjects: boolean
   ) {
-    Iterable?.logger?.log('updateUser');
-
-    RNIterableAPI.updateUser(
-      dataFields as { [key: string]: string | number | boolean },
-      mergeNestedObjects
-    );
+    IterableApi.updateUser(dataFields, mergeNestedObjects);
   }
 
   /**
@@ -804,9 +755,7 @@ export class Iterable {
    * ```
    */
   static updateEmail(email: string, authToken?: string) {
-    Iterable?.logger?.log('updateEmail');
-
-    RNIterableAPI.updateEmail(email, authToken);
+    IterableApi.updateEmail(email, authToken);
   }
 
   /**
@@ -888,9 +837,7 @@ export class Iterable {
    */
   /* eslint-enable tsdoc/syntax */
   static handleAppLink(link: string): Promise<boolean> {
-    Iterable?.logger?.log('handleAppLink');
-
-    return RNIterableAPI.handleAppLink(link);
+    return IterableApi.handleAppLink(link);
   }
 
   /**
@@ -935,16 +882,14 @@ export class Iterable {
     campaignId: number,
     templateId: number
   ) {
-    Iterable?.logger?.log('updateSubscriptions');
-
-    RNIterableAPI.updateSubscriptions(
+    IterableApi.updateSubscriptions({
       emailListIds,
       unsubscribedChannelIds,
       unsubscribedMessageTypeIds,
       subscribedMessageTypeIds,
       campaignId,
-      templateId
-    );
+      templateId,
+    });
   }
 
   /**
@@ -1011,7 +956,7 @@ export class Iterable {
           const message = IterableInAppMessage.fromDict(messageDict);
           // MOB-10423: Check if we can use chain operator (?.) here instead
           const result = Iterable.savedConfig.inAppHandler!(message);
-          RNIterableAPI.setInAppShowResponse(result);
+          IterableApi.setInAppShowResponse(result);
         }
       );
     }
@@ -1047,9 +992,7 @@ export class Iterable {
                     (promiseResult as IterableAuthResponse).failureCallback?.();
                   }
                 } else {
-                  Iterable?.logger?.log(
-                    'No callback received from native layer'
-                  );
+                  IterableLogger?.log('No callback received from native layer');
                 }
               }, 1000);
               // Use unref() to prevent the timeout from keeping the process alive
@@ -1058,12 +1001,12 @@ export class Iterable {
               //If promise only returns string
               Iterable.authManager.passAlongAuthToken(promiseResult as string);
             } else {
-              Iterable?.logger?.log(
+              IterableLogger?.log(
                 'Unexpected promise returned. Auth token expects promise of String or AuthResponse type.'
               );
             }
           })
-          .catch((e) => Iterable?.logger?.log(e));
+          .catch((e) => IterableLogger?.log(e));
       });
 
       RNEventEmitter.addListener(
@@ -1097,7 +1040,7 @@ export class Iterable {
             }
           })
           .catch((reason) => {
-            Iterable?.logger?.log('could not open url: ' + reason);
+            IterableLogger?.log('could not open url: ' + reason);
           });
       }
     }
diff --git a/src/core/classes/IterableApi.ts b/src/core/classes/IterableApi.ts
new file mode 100644
index 000000000..fe2b446a3
--- /dev/null
+++ b/src/core/classes/IterableApi.ts
@@ -0,0 +1,634 @@
+import { Platform } from 'react-native';
+
+import RNIterableAPI from '../../api';
+import type { IterableHtmlInAppContent } from '../../inApp/classes/IterableHtmlInAppContent';
+import type { IterableInAppMessage } from '../../inApp/classes/IterableInAppMessage';
+import type { IterableInAppCloseSource } from '../../inApp/enums/IterableInAppCloseSource';
+import type { IterableInAppDeleteSource } from '../../inApp/enums/IterableInAppDeleteSource';
+import type { IterableInAppLocation } from '../../inApp/enums/IterableInAppLocation';
+import type { IterableInAppShowResponse } from '../../inApp/enums/IterableInAppShowResponse';
+import type { IterableInboxImpressionRowInfo } from '../../inbox/types/IterableInboxImpressionRowInfo';
+import { IterableAttributionInfo } from './IterableAttributionInfo';
+import type { IterableCommerceItem } from './IterableCommerceItem';
+import { IterableConfig } from './IterableConfig';
+import { IterableLogger } from './IterableLogger';
+
+/**
+ * Contains functions that directly interact with the native layer.
+ */
+export class IterableApi {
+  // ====================================================== //
+  // ===================== INITIALIZE ===================== //
+  // ====================================================== //
+
+  /**
+   * Initializes the Iterable React Native SDK in your app's Javascript or Typescript code.
+   *
+   * @param apiKey - The [*mobile* API
+   * key](https://support.iterable.com/hc/en-us/articles/360043464871-API-Keys)
+   * for your application
+   * @param config - Configuration object for the SDK
+   * @param version - Version of the SDK, derived from the package.json file
+   */
+  static initializeWithApiKey(
+    apiKey: string,
+    {
+      config = new IterableConfig(),
+      version,
+    }: {
+      config: IterableConfig;
+      version: string;
+    }
+  ): Promise<boolean> {
+    IterableLogger.log('initializeWithApiKey: ', apiKey);
+    return RNIterableAPI.initializeWithApiKey(apiKey, config.toDict(), version);
+  }
+
+  /**
+   * DO NOT CALL THIS METHOD.
+   * This method is used internally to connect to staging environment.
+   *
+   * @internal
+   */
+  static initialize2WithApiKey(
+    apiKey: string,
+    {
+      config = new IterableConfig(),
+      version,
+      apiEndPoint,
+    }: {
+      config: IterableConfig;
+      version: string;
+      apiEndPoint: string;
+    }
+  ): Promise<boolean> {
+    IterableLogger.log('initialize2WithApiKey: ', apiKey);
+    return RNIterableAPI.initialize2WithApiKey(
+      apiKey,
+      config.toDict(),
+      version,
+      apiEndPoint
+    );
+  }
+
+  // ---- End INITIALIZE ---- //
+
+  // ====================================================== //
+  // ===================== USER MANAGEMENT ================ //
+  // ====================================================== //
+
+  /**
+   * Associate the current user with the passed in email parameter.
+   *
+   * @param email - Email address to associate with
+   * the current user
+   * @param authToken - Valid, pre-fetched JWT the SDK
+   * can use to authenticate API requests, optional - If null/undefined, no JWT
+   * related action will be taken
+   */
+  static setEmail(email: string | null, authToken?: string | null) {
+    IterableLogger.log('setEmail: ', email);
+    return RNIterableAPI.setEmail(email, authToken);
+  }
+
+  /**
+   * Get the email associated with the current user.
+   *
+   * @returns The email associated with the current user
+   */
+  static getEmail() {
+    IterableLogger.log('getEmail');
+    return RNIterableAPI.getEmail();
+  }
+
+  /**
+   * Associate the current user with the passed in `userId` parameter.
+   *
+   * WARNING: specify a user by calling `Iterable.setEmail` or
+   * `Iterable.setUserId`, but **NOT** both.
+   *
+   * @param userId - User ID to associate with the current user
+   * @param authToken - Valid, pre-fetched JWT the SDK
+   * can use to authenticate API requests, optional - If null/undefined, no JWT
+   * related action will be taken
+   */
+  static setUserId(
+    userId: string | null | undefined,
+    authToken?: string | null
+  ) {
+    IterableLogger.log('setUserId: ', userId);
+    return RNIterableAPI.setUserId(userId, authToken);
+  }
+
+  /**
+   * Get the `userId` associated with the current user.
+   */
+  static getUserId() {
+    IterableLogger.log('getUserId');
+    return RNIterableAPI.getUserId();
+  }
+
+  /**
+   * Disable the device for the current user.
+   */
+  static disableDeviceForCurrentUser() {
+    IterableLogger.log('disableDeviceForCurrentUser');
+    return RNIterableAPI.disableDeviceForCurrentUser();
+  }
+
+  /**
+   * Save data to the current user's Iterable profile.
+   *
+   * @param dataFields - The data fields to update
+   * @param mergeNestedObjects - Whether to merge nested objects
+   */
+  static updateUser(dataFields: unknown, mergeNestedObjects: boolean) {
+    IterableLogger.log('updateUser: ', dataFields, mergeNestedObjects);
+    return RNIterableAPI.updateUser(dataFields, mergeNestedObjects);
+  }
+
+  /**
+   * Change the value of the email field on the current user's Iterable profile.
+   *
+   * @param email - The new email to set
+   * @param authToken - The new auth token (JWT) to set with the new email, optional - If null/undefined, no JWT-related action will be taken
+   */
+  static updateEmail(email: string, authToken?: string | null) {
+    IterableLogger.log('updateEmail: ', email, authToken);
+    return RNIterableAPI.updateEmail(email, authToken);
+  }
+
+  // ---- End USER MANAGEMENT ---- //
+
+  // ====================================================== //
+  // ===================== TRACKING ====================== //
+  // ====================================================== //
+
+  /**
+   * Create a `pushOpen` event on the current user's Iterable profile, populating
+   * it with data provided to the method call.
+   *
+   * @param campaignId - The campaign ID
+   * @param templateId - The template ID
+   * @param messageId - The message ID
+   * @param appAlreadyRunning - Whether the app is already running
+   * @param dataFields - The data fields to track
+   */
+  static trackPushOpenWithCampaignId({
+    campaignId,
+    templateId,
+    messageId,
+    appAlreadyRunning,
+    dataFields,
+  }: {
+    campaignId: number;
+    templateId: number;
+    messageId: string | null | undefined;
+    appAlreadyRunning: boolean;
+    dataFields?: unknown;
+  }) {
+    IterableLogger.log(
+      'trackPushOpenWithCampaignId: ',
+      campaignId,
+      templateId,
+      messageId,
+      appAlreadyRunning,
+      dataFields
+    );
+    return RNIterableAPI.trackPushOpenWithCampaignId(
+      campaignId,
+      templateId,
+      messageId,
+      appAlreadyRunning,
+      dataFields
+    );
+  }
+
+  /**
+   * Create a `purchase` event on the current user's Iterable profile, populating
+   * it with data provided to the method call.
+   *
+   * @param total - The total cost of the purchase
+   * @param items - The items included in the purchase
+   * @param dataFields - The data fields to track
+   */
+  static trackPurchase({
+    total,
+    items,
+    dataFields,
+  }: {
+    total: number;
+    items: IterableCommerceItem[];
+    dataFields?: unknown;
+  }) {
+    IterableLogger.log('trackPurchase: ', total, items, dataFields);
+    return RNIterableAPI.trackPurchase(total, items, dataFields);
+  }
+
+  /**
+   * Create an `inAppOpen` event for the specified message on the current user's profile
+   * for manual tracking purposes. Iterable's SDK automatically tracks in-app message opens when you use the
+   * SDK's default rendering.
+   *
+   * @param message - The in-app message (an {@link IterableInAppMessage} object)
+   * @param location - The location of the in-app message (an IterableInAppLocation enum)
+   */
+  static trackInAppOpen({
+    message,
+    location,
+  }: {
+    message: IterableInAppMessage;
+    location: IterableInAppLocation;
+  }) {
+    IterableLogger.log('trackInAppOpen: ', message, location);
+    return RNIterableAPI.trackInAppOpen(message.messageId, location);
+  }
+
+  /**
+   * Create an `inAppClick` event for the specified message on the current user's profile
+   * for manual tracking purposes. Iterable's SDK automatically tracks in-app message clicks when you use the
+   * SDK's default rendering. Click events refer to click events within the in-app message to distinguish
+   * from `inAppOpen` events.
+   *
+   * @param message - The in-app message.
+   * @param location - The location of the in-app message.
+   * @param clickedUrl - The URL clicked by the user.
+   */
+  static trackInAppClick({
+    message,
+    location,
+    clickedUrl,
+  }: {
+    message: IterableInAppMessage;
+    location: IterableInAppLocation;
+    clickedUrl: string;
+  }) {
+    IterableLogger.log('trackInAppClick: ', message, location, clickedUrl);
+    return RNIterableAPI.trackInAppClick(
+      message.messageId,
+      location,
+      clickedUrl
+    );
+  }
+
+  /**
+   * Create an `inAppClose` event for the specified message on the current user's profile
+   * for manual tracking purposes. Iterable's SDK automatically tracks in-app message close events when you use the
+   * SDK's default rendering.
+   *
+   * @param message - The in-app message.
+   * @param location - The location of the in-app message.
+   * @param source - The way the in-app was closed.
+   * @param clickedUrl - The URL clicked by the user.
+   */
+  static trackInAppClose({
+    message,
+    location,
+    source,
+    clickedUrl,
+  }: {
+    message: IterableInAppMessage;
+    location: IterableInAppLocation;
+    source: IterableInAppCloseSource;
+    clickedUrl?: string;
+  }) {
+    IterableLogger.log(
+      'trackInAppClose: ',
+      message,
+      location,
+      source,
+      clickedUrl
+    );
+    return RNIterableAPI.trackInAppClose(
+      message.messageId,
+      location,
+      source,
+      clickedUrl
+    );
+  }
+
+  /**
+   * Create a custom event on the current user's Iterable profile, populating
+   * it with data provided to the method call.
+   *
+   * @param name - The name of the event
+   * @param dataFields - The data fields to track
+   */
+  static trackEvent({
+    name,
+    dataFields,
+  }: {
+    name: string;
+    dataFields?: unknown;
+  }) {
+    IterableLogger.log('trackEvent: ', name, dataFields);
+    return RNIterableAPI.trackEvent(name, dataFields);
+  }
+
+  // ---- End TRACKING ---- //
+
+  // ====================================================== //
+  // ======================= AUTH ======================= //
+  // ====================================================== //
+
+  /**
+   * Pause or resume the automatic retrying of authentication requests.
+   *
+   * @param pauseRetry - Whether to pause or resume the automatic retrying of authentication requests
+   */
+  static pauseAuthRetries(pauseRetry: boolean) {
+    IterableLogger.log('pauseAuthRetries: ', pauseRetry);
+    return RNIterableAPI.pauseAuthRetries(pauseRetry);
+  }
+
+  /**
+   * Pass along an auth token to the SDK.
+   *
+   * @param authToken - The auth token to pass along
+   */
+  static passAlongAuthToken(authToken: string | null | undefined) {
+    IterableLogger.log('passAlongAuthToken: ', authToken);
+    return RNIterableAPI.passAlongAuthToken(authToken);
+  }
+
+  // ---- End AUTH ---- //
+
+  // ====================================================== //
+  // ======================= IN-APP ======================= //
+  // ====================================================== //
+
+  /**
+   * Remove the specified message from the current user's message queue.
+   *
+   * @param message - The in-app message.
+   * @param location - The location of the in-app message.
+   * @param source - The way the in-app was consumed.
+   */
+  static inAppConsume(
+    message: IterableInAppMessage,
+    location: IterableInAppLocation,
+    source: IterableInAppDeleteSource
+  ) {
+    IterableLogger.log('inAppConsume: ', message, location, source);
+    return RNIterableAPI.inAppConsume(message.messageId, location, source);
+  }
+
+  /**
+   * Retrieve the current user's list of in-app messages stored in the local queue.
+   *
+   * @returns A Promise that resolves to an array of in-app messages.
+   */
+  static getInAppMessages(): Promise<IterableInAppMessage[]> {
+    IterableLogger.log('getInAppMessages');
+    return RNIterableAPI.getInAppMessages() as unknown as Promise<
+      IterableInAppMessage[]
+    >;
+  }
+
+  /**
+   * Retrieve the current user's list of in-app messages designated for the
+   * mobile inbox and stored in the local queue.
+   *
+   * @returns A Promise that resolves to an array of messages marked as `saveToInbox`.
+   */
+  static getInboxMessages(): Promise<IterableInAppMessage[]> {
+    IterableLogger.log('getInboxMessages');
+    return RNIterableAPI.getInboxMessages() as unknown as Promise<
+      IterableInAppMessage[]
+    >;
+  }
+
+  /**
+   * Renders an in-app message and consumes it from the user's message queue if necessary.
+   *
+   * If you skip showing an in-app message when it arrives, you can show it at
+   * another time by calling this method.
+   *
+   * @param messageId - The message to show (an {@link IterableInAppMessage} object)
+   * @param consume - Whether or not the message should be consumed from the user's message queue after being shown. This should be defaulted to true.
+   */
+  static showMessage(
+    messageId: string,
+    consume: boolean
+  ): Promise<string | null> {
+    IterableLogger.log('showMessage: ', messageId, consume);
+    return RNIterableAPI.showMessage(messageId, consume);
+  }
+
+  /**
+   * Remove the specified message from the current user's message queue.
+   *
+   * @param messageId - The message to remove.
+   * @param location - The location of the message.
+   * @param source - The way the message was removed.
+   */
+  static removeMessage(
+    messageId: string,
+    location: number,
+    source: number
+  ): void {
+    IterableLogger.log('removeMessage: ', messageId, location, source);
+    return RNIterableAPI.removeMessage(messageId, location, source);
+  }
+
+  /**
+   * Set the read status of the specified message.
+   *
+   * @param messageId - The message to set the read status of.
+   * @param read - Whether the message is read.
+   */
+  static setReadForMessage(messageId: string, read: boolean): void {
+    IterableLogger.log('setReadForMessage: ', messageId, read);
+    return RNIterableAPI.setReadForMessage(messageId, read);
+  }
+
+  /**
+   * Pause or unpause the automatic display of incoming in-app messages
+   *
+   * @param autoDisplayPaused - Whether to pause or unpause the automatic display of incoming in-app messages
+   */
+  static setAutoDisplayPaused(autoDisplayPaused: boolean): void {
+    IterableLogger.log('setAutoDisplayPaused: ', autoDisplayPaused);
+    return RNIterableAPI.setAutoDisplayPaused(autoDisplayPaused);
+  }
+
+  /**
+   * Retrieve HTML in-app content for a specified in-app message.
+   *
+   * @param messageId - The message from which to get HTML content.
+   *
+   * @returns A Promise that resolves to an {@link IterableHtmlInAppContent} object.
+   */
+  static getHtmlInAppContentForMessage(
+    messageId: string
+  ): Promise<IterableHtmlInAppContent> {
+    IterableLogger.log('getHtmlInAppContentForMessage: ', messageId);
+    return RNIterableAPI.getHtmlInAppContentForMessage(messageId);
+  }
+
+  /**
+   * Set the response to an in-app message.
+   *
+   * @param inAppShowResponse - The response to an in-app message.
+   */
+  static setInAppShowResponse(inAppShowResponse: IterableInAppShowResponse) {
+    IterableLogger.log('setInAppShowResponse: ', inAppShowResponse);
+    return RNIterableAPI.setInAppShowResponse(inAppShowResponse);
+  }
+
+  /**
+   * Start a session.
+   *
+   * @param visibleRows - The visible rows.
+   */
+  static startSession(visibleRows: IterableInboxImpressionRowInfo[]) {
+    IterableLogger.log('startSession: ', visibleRows);
+    return RNIterableAPI.startSession(visibleRows);
+  }
+
+  /**
+   * End a session.
+   */
+  static endSession() {
+    IterableLogger.log('endSession');
+    return RNIterableAPI.endSession();
+  }
+
+  /**
+   * Update the visible rows.
+   *
+   * @param visibleRows - The visible rows.
+   */
+  static updateVisibleRows(visibleRows: IterableInboxImpressionRowInfo[] = []) {
+    IterableLogger.log('updateVisibleRows: ', visibleRows);
+    return RNIterableAPI.updateVisibleRows(visibleRows);
+  }
+
+  // ---- End IN-APP ---- //
+
+  // ====================================================== //
+  // ======================= MOSC ======================= //
+  // ====================================================== //
+
+  /**
+   * Update the cart.
+   *
+   * @param items - The items.
+   */
+  static updateCart(items: IterableCommerceItem[]) {
+    IterableLogger.log('updateCart: ', items);
+    return RNIterableAPI.updateCart(items);
+  }
+
+  /**
+   * Wake the app.
+   * ANDROID ONLY
+   */
+  static wakeApp() {
+    if (Platform.OS === 'android') {
+      IterableLogger.log('wakeApp');
+      return RNIterableAPI.wakeApp();
+    }
+  }
+
+  /**
+   * Handle an app link -- this is used to handle deep links.
+   *
+   * @param link - The link.
+   */
+  static handleAppLink(link: string) {
+    IterableLogger.log('handleAppLink: ', link);
+    return RNIterableAPI.handleAppLink(link);
+  }
+
+  /**
+   * Update the subscriptions.
+   *
+   * @param emailListIds - The email list IDs.
+   * @param unsubscribedChannelIds - The unsubscribed channel IDs.
+   * @param unsubscribedMessageTypeIds - The unsubscribed message type IDs.
+   * @param subscribedMessageTypeIds - The subscribed message type IDs.
+   * @param campaignId - The campaign ID.
+   * @param templateId - The template ID.
+   */
+  static updateSubscriptions({
+    emailListIds,
+    unsubscribedChannelIds,
+    unsubscribedMessageTypeIds,
+    subscribedMessageTypeIds,
+    campaignId,
+    templateId,
+  }: {
+    emailListIds: number[] | null;
+    unsubscribedChannelIds: number[] | null;
+    unsubscribedMessageTypeIds: number[] | null;
+    subscribedMessageTypeIds: number[] | null;
+    campaignId: number;
+    templateId: number;
+  }) {
+    IterableLogger.log(
+      'updateSubscriptions: ',
+      emailListIds,
+      unsubscribedChannelIds,
+      unsubscribedMessageTypeIds,
+      subscribedMessageTypeIds,
+      campaignId,
+      templateId
+    );
+    return RNIterableAPI.updateSubscriptions(
+      emailListIds,
+      unsubscribedChannelIds,
+      unsubscribedMessageTypeIds,
+      subscribedMessageTypeIds,
+      campaignId,
+      templateId
+    );
+  }
+
+  /**
+   * Get the last push payload.
+   */
+  static getLastPushPayload() {
+    IterableLogger.log('getLastPushPayload');
+    return RNIterableAPI.getLastPushPayload();
+  }
+
+  /**
+   * Get the attribution info.
+   */
+  static getAttributionInfo() {
+    IterableLogger.log('getAttributionInfo');
+    // FIXME: What if this errors?
+    return RNIterableAPI.getAttributionInfo().then(
+      (
+        dict: {
+          campaignId: number;
+          templateId: number;
+          messageId: string;
+        } | null
+      ) => {
+        if (dict) {
+          return new IterableAttributionInfo(
+            dict.campaignId as number,
+            dict.templateId as number,
+            dict.messageId as string
+          );
+        } else {
+          return undefined;
+        }
+      }
+    );
+  }
+
+  /**
+   * Set the attribution info.
+   *
+   * @param attributionInfo - The attribution info.
+   */
+  static setAttributionInfo(attributionInfo?: IterableAttributionInfo) {
+    IterableLogger.log('setAttributionInfo: ', attributionInfo);
+    return RNIterableAPI.setAttributionInfo(attributionInfo);
+  }
+
+  // ---- End MOSC ---- //
+}
diff --git a/src/core/classes/IterableAuthManager.ts b/src/core/classes/IterableAuthManager.ts
index 9df15c03a..44ece1af0 100644
--- a/src/core/classes/IterableAuthManager.ts
+++ b/src/core/classes/IterableAuthManager.ts
@@ -1,5 +1,5 @@
-import RNIterableAPI from '../../api';
 import { IterableAuthResponse } from './IterableAuthResponse';
+import { IterableApi } from './IterableApi';
 
 /**
  * Manages the authentication for the Iterable SDK.
@@ -22,7 +22,7 @@ export class IterableAuthManager {
    * ```
    */
   pauseAuthRetries(pauseRetry: boolean) {
-    return RNIterableAPI.pauseAuthRetries(pauseRetry);
+    return IterableApi.pauseAuthRetries(pauseRetry);
   }
 
   /**
@@ -39,6 +39,6 @@ export class IterableAuthManager {
   passAlongAuthToken(
     authToken: string | null | undefined
   ): Promise<IterableAuthResponse | string | undefined> {
-    return RNIterableAPI.passAlongAuthToken(authToken);
+    return IterableApi.passAlongAuthToken(authToken);
   }
 }
diff --git a/src/core/classes/IterableLogger.test.ts b/src/core/classes/IterableLogger.test.ts
new file mode 100644
index 000000000..9d35b4552
--- /dev/null
+++ b/src/core/classes/IterableLogger.test.ts
@@ -0,0 +1,398 @@
+import { IterableLogLevel } from '../enums/IterableLogLevel';
+import { IterableLogger } from './IterableLogger';
+
+// Mock console.log to capture log output
+const mockConsoleLog = jest.fn();
+const originalConsoleLog = console.log;
+
+describe('IterableLogger', () => {
+  beforeEach(() => {
+    // Reset to default values before each test
+    IterableLogger.loggingEnabled = true;
+    IterableLogger.logLevel = IterableLogLevel.info;
+
+    // Mock console.log
+    console.log = mockConsoleLog;
+    mockConsoleLog.mockClear();
+  });
+
+  afterEach(() => {
+    // Restore original console.log
+    console.log = originalConsoleLog;
+  });
+
+  describe('Static Properties', () => {
+    test('should have default logging enabled', () => {
+      expect(IterableLogger.loggingEnabled).toBe(true);
+    });
+
+    test('should have default log level as info', () => {
+      expect(IterableLogger.logLevel).toBe(IterableLogLevel.info);
+    });
+
+    test('should allow setting loggingEnabled directly', () => {
+      IterableLogger.loggingEnabled = false;
+      expect(IterableLogger.loggingEnabled).toBe(false);
+    });
+
+    test('should allow setting logLevel directly', () => {
+      IterableLogger.logLevel = IterableLogLevel.error;
+      expect(IterableLogger.logLevel).toBe(IterableLogLevel.error);
+    });
+  });
+
+  describe('setLoggingEnabled', () => {
+    test('should set logging enabled to true when passed true', () => {
+      IterableLogger.setLoggingEnabled(true);
+      expect(IterableLogger.loggingEnabled).toBe(true);
+    });
+
+    test('should set logging enabled to false when passed false', () => {
+      IterableLogger.setLoggingEnabled(false);
+      expect(IterableLogger.loggingEnabled).toBe(false);
+    });
+
+    test('should default to true when passed non-boolean value', () => {
+      IterableLogger.setLoggingEnabled(undefined);
+      expect(IterableLogger.loggingEnabled).toBe(true);
+    });
+
+    test('should default to true when passed null', () => {
+      // @ts-expect-error - null is not a valid value for loggingEnabled
+      IterableLogger.setLoggingEnabled(null);
+      expect(IterableLogger.loggingEnabled).toBe(true);
+    });
+
+    test('should default to true when passed string', () => {
+      // @ts-expect-error - string is not a valid value for loggingEnabled
+      IterableLogger.setLoggingEnabled('true');
+      expect(IterableLogger.loggingEnabled).toBe(true);
+    });
+  });
+
+  describe('setLogLevel', () => {
+    test('should set log level to error when passed error', () => {
+      IterableLogger.setLogLevel(IterableLogLevel.error);
+      expect(IterableLogger.logLevel).toBe(IterableLogLevel.error);
+    });
+
+    test('should set log level to debug when passed debug', () => {
+      IterableLogger.setLogLevel(IterableLogLevel.debug);
+      expect(IterableLogger.logLevel).toBe(IterableLogLevel.debug);
+    });
+
+    test('should set log level to info when passed info', () => {
+      IterableLogger.setLogLevel(IterableLogLevel.info);
+      expect(IterableLogger.logLevel).toBe(IterableLogLevel.info);
+    });
+
+    test('should default to info when passed undefined', () => {
+      IterableLogger.setLogLevel(undefined);
+      expect(IterableLogger.logLevel).toBe(IterableLogLevel.info);
+    });
+  });
+
+  describe('log method', () => {
+    test('should log message when logging is enabled', () => {
+      IterableLogger.log('Test message');
+      expect(mockConsoleLog).toHaveBeenCalledWith('Test message');
+    });
+
+    test('should log message with optional parameters when logging is enabled', () => {
+      IterableLogger.log('Test message', 'param1', 'param2');
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        'Test message',
+        'param1',
+        'param2'
+      );
+    });
+
+    test('should not log when logging is disabled', () => {
+      IterableLogger.loggingEnabled = false;
+      IterableLogger.log('Test message');
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+
+    test('should log undefined message when no message provided', () => {
+      IterableLogger.log();
+      expect(mockConsoleLog).toHaveBeenCalledWith(undefined);
+    });
+
+    test('should log object when object is passed', () => {
+      const testObj = { key: 'value' };
+      IterableLogger.log(testObj);
+      expect(mockConsoleLog).toHaveBeenCalledWith(testObj);
+    });
+  });
+
+  describe('error method', () => {
+    test('should log error message when logging is enabled and log level is error', () => {
+      IterableLogger.logLevel = IterableLogLevel.error;
+      IterableLogger.error('Error message');
+      expect(mockConsoleLog).toHaveBeenCalledWith('ERROR:', 'Error message');
+    });
+
+    test('should log error message with optional parameters', () => {
+      IterableLogger.logLevel = IterableLogLevel.error;
+      IterableLogger.error('Error message', 'param1', 'param2');
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        'ERROR:',
+        'Error message',
+        'param1',
+        'param2'
+      );
+    });
+
+    test('should not log when logging is disabled', () => {
+      IterableLogger.loggingEnabled = false;
+      IterableLogger.logLevel = IterableLogLevel.error;
+      IterableLogger.error('Error message');
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+
+    test('should not log when log level is not error', () => {
+      IterableLogger.logLevel = IterableLogLevel.debug;
+      IterableLogger.error('Error message');
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+
+    test('should not log when log level is info', () => {
+      IterableLogger.logLevel = IterableLogLevel.info;
+      IterableLogger.error('Error message');
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('debug method', () => {
+    test('should log debug message when logging is enabled and log level is debug', () => {
+      IterableLogger.logLevel = IterableLogLevel.debug;
+      IterableLogger.debug('Debug message');
+      expect(mockConsoleLog).toHaveBeenCalledWith('DEBUG:', 'Debug message');
+    });
+
+    test('should log debug message when logging is enabled and log level is error', () => {
+      IterableLogger.logLevel = IterableLogLevel.error;
+      IterableLogger.debug('Debug message');
+      expect(mockConsoleLog).toHaveBeenCalledWith('DEBUG:', 'Debug message');
+    });
+
+    test('should log debug message with optional parameters', () => {
+      IterableLogger.logLevel = IterableLogLevel.debug;
+      IterableLogger.debug('Debug message', 'param1', 'param2');
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        'DEBUG:',
+        'Debug message',
+        'param1',
+        'param2'
+      );
+    });
+
+    test('should not log when logging is disabled', () => {
+      IterableLogger.loggingEnabled = false;
+      IterableLogger.logLevel = IterableLogLevel.debug;
+      IterableLogger.debug('Debug message');
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+
+    test('should not log when log level is info', () => {
+      IterableLogger.logLevel = IterableLogLevel.info;
+      IterableLogger.debug('Debug message');
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('info method', () => {
+    test('should log info message when logging is enabled and log level is info', () => {
+      IterableLogger.logLevel = IterableLogLevel.info;
+      IterableLogger.info('Info message');
+      expect(mockConsoleLog).toHaveBeenCalledWith('INFO:', 'Info message');
+    });
+
+    test('should log info message when logging is enabled and log level is debug', () => {
+      IterableLogger.logLevel = IterableLogLevel.debug;
+      IterableLogger.info('Info message');
+      expect(mockConsoleLog).toHaveBeenCalledWith('INFO:', 'Info message');
+    });
+
+    test('should log info message when logging is enabled and log level is error', () => {
+      IterableLogger.logLevel = IterableLogLevel.error;
+      IterableLogger.info('Info message');
+      expect(mockConsoleLog).toHaveBeenCalledWith('INFO:', 'Info message');
+    });
+
+    test('should log info message with optional parameters', () => {
+      IterableLogger.logLevel = IterableLogLevel.info;
+      IterableLogger.info('Info message', 'param1', 'param2');
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        'INFO:',
+        'Info message',
+        'param1',
+        'param2'
+      );
+    });
+
+    test('should not log when logging is disabled', () => {
+      IterableLogger.loggingEnabled = false;
+      IterableLogger.logLevel = IterableLogLevel.info;
+      IterableLogger.info('Info message');
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Log Level Hierarchy', () => {
+    test('should respect log level hierarchy for error level', () => {
+      IterableLogger.logLevel = IterableLogLevel.error;
+
+      IterableLogger.error('Error message');
+      IterableLogger.debug('Debug message');
+      IterableLogger.info('Info message');
+
+      // When logLevel is error (3), all messages should log
+      // Note: There's a bug in the error method - it only logs when logLevel is exactly error
+      // It should log when logLevel is error OR higher (debug, info)
+      expect(mockConsoleLog).toHaveBeenCalledTimes(3);
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        1,
+        'ERROR:',
+        'Error message'
+      );
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        2,
+        'DEBUG:',
+        'Debug message'
+      );
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        3,
+        'INFO:',
+        'Info message'
+      );
+    });
+
+    test('should respect log level hierarchy for debug level', () => {
+      IterableLogger.logLevel = IterableLogLevel.debug;
+
+      IterableLogger.error('Error message');
+      IterableLogger.debug('Debug message');
+      IterableLogger.info('Info message');
+
+      // When logLevel is debug (1), debug and info should log
+      // Note: There's a bug in the error method - it doesn't log when logLevel is debug
+      // It should log when logLevel is debug OR higher (info)
+      expect(mockConsoleLog).toHaveBeenCalledTimes(2);
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        1,
+        'DEBUG:',
+        'Debug message'
+      );
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        2,
+        'INFO:',
+        'Info message'
+      );
+    });
+
+    test('should respect log level hierarchy for info level', () => {
+      IterableLogger.logLevel = IterableLogLevel.info;
+
+      IterableLogger.error('Error message');
+      IterableLogger.debug('Debug message');
+      IterableLogger.info('Info message');
+
+      // When logLevel is info (2), only info should log
+      // Note: There's a bug in the error method - it doesn't log when logLevel is info
+      // It should log when logLevel is info (highest level)
+      expect(mockConsoleLog).toHaveBeenCalledTimes(1);
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        1,
+        'INFO:',
+        'Info message'
+      );
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle empty string messages', () => {
+      IterableLogger.log('');
+      expect(mockConsoleLog).toHaveBeenCalledWith('');
+    });
+
+    test('should handle null messages', () => {
+      IterableLogger.log(null);
+      expect(mockConsoleLog).toHaveBeenCalledWith(null);
+    });
+
+    test('should handle zero as message', () => {
+      IterableLogger.log(0);
+      expect(mockConsoleLog).toHaveBeenCalledWith(0);
+    });
+
+    test('should handle false as message', () => {
+      IterableLogger.log(false);
+      expect(mockConsoleLog).toHaveBeenCalledWith(false);
+    });
+
+    test('should handle complex objects as messages', () => {
+      const complexObj = {
+        nested: { value: 'test' },
+        array: [1, 2, 3],
+        func: () => 'test',
+      };
+      IterableLogger.log(complexObj);
+      expect(mockConsoleLog).toHaveBeenCalledWith(complexObj);
+    });
+
+    test('should handle multiple optional parameters of different types', () => {
+      IterableLogger.log('Message', 123, true, { key: 'value' }, [1, 2, 3]);
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        'Message',
+        123,
+        true,
+        { key: 'value' },
+        [1, 2, 3]
+      );
+    });
+  });
+
+  describe('Integration Tests', () => {
+    test('should work with real-world usage patterns', () => {
+      // Simulate typical usage
+      IterableLogger.setLoggingEnabled(true);
+      IterableLogger.setLogLevel(IterableLogLevel.info);
+
+      IterableLogger.info('SDK initialized');
+      IterableLogger.debug('Debug info', { userId: '123' });
+      IterableLogger.error('API error', { status: 500 });
+
+      // Note: Due to bug in error method, only info logs when logLevel is info
+      expect(mockConsoleLog).toHaveBeenCalledTimes(1);
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        1,
+        'INFO:',
+        'SDK initialized'
+      );
+    });
+
+    test('should handle rapid state changes', () => {
+      // Test rapid state changes
+      IterableLogger.setLoggingEnabled(false);
+      IterableLogger.log('Should not appear');
+
+      IterableLogger.setLoggingEnabled(true);
+      IterableLogger.setLogLevel(IterableLogLevel.error);
+      IterableLogger.info('Should appear'); // info logs when logLevel is error
+      IterableLogger.error('Should appear');
+
+      expect(mockConsoleLog).toHaveBeenCalledTimes(2);
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        1,
+        'INFO:',
+        'Should appear'
+      );
+      expect(mockConsoleLog).toHaveBeenNthCalledWith(
+        2,
+        'ERROR:',
+        'Should appear'
+      );
+    });
+  });
+});
diff --git a/src/core/classes/IterableLogger.ts b/src/core/classes/IterableLogger.ts
index 3d9854888..21e947df7 100644
--- a/src/core/classes/IterableLogger.ts
+++ b/src/core/classes/IterableLogger.ts
@@ -1,10 +1,15 @@
-import { IterableConfig } from './IterableConfig';
+import { IterableLogLevel } from '../enums/IterableLogLevel';
+
+const DEFAULT_LOG_LEVEL = IterableLogLevel.info;
+const DEFAULT_LOGGING_ENABLED = true;
 
 /**
  * A logger class for the Iterable SDK.
  *
  * This class is responsible for logging messages based on the configuration provided.
  *
+ * TODO: add a logLevel property to the IterableLogger class to control the level of logging.
+ *
  * @remarks
  * The logging behavior is controlled by the `logReactNativeSdkCalls` property
  * in {@link IterableConfig}.
@@ -12,26 +17,50 @@ import { IterableConfig } from './IterableConfig';
  *
  * @example
  * ```typescript
- * const config = new IterableConfig();
- * config.logReactNativeSdkCalls = true;
- * const logger = new IterableLogger(config);
- * logger.log('This is a log message.');
+ * IterableLogger.logLevel = IterableLogLevel.debug;
+ * IterableLogger.loggingEnabled = true;
+ *
+ * // This log will show in the developer console
+ * IterableLogger.log('I will be shown.');
+ *
+ * Iterable.loggingEnabled = false;
+ *
+ * // This log will show in the developer console
+ * IterableLogger.log('I will NOT be shown.');
+ *
  * ```
  */
 export class IterableLogger {
   /**
-   * The configuration settings for the Iterable SDK.
-   * This property is read-only and is initialized with an instance of `IterableConfig`.
+   * Whether logs should show in the developer console.
    */
-  readonly config: IterableConfig;
+  static loggingEnabled = DEFAULT_LOGGING_ENABLED;
 
   /**
-   * Creates an instance of IterableLogger.
+   * The level of logging to show in the developer console.
+   */
+  static logLevel = DEFAULT_LOG_LEVEL;
+
+  /**
+   * Sets whether logs should show in the developer console.
    *
-   * @param config - The configuration object for IterableLogger.
+   * @param loggingEnabled - Whether logs should show in the developer console.
    */
-  constructor(config: IterableConfig) {
-    this.config = config;
+  static setLoggingEnabled(loggingEnabled?: boolean) {
+    IterableLogger.loggingEnabled =
+      typeof loggingEnabled === 'boolean'
+        ? loggingEnabled
+        : DEFAULT_LOGGING_ENABLED;
+  }
+
+  /**
+   * Sets the level of logging to show in the developer console.
+   *
+   * @param logLevel - The level of logging to show in the developer console.
+   */
+  static setLogLevel(logLevel?: IterableLogLevel) {
+    IterableLogger.logLevel =
+      typeof logLevel === 'undefined' ? DEFAULT_LOG_LEVEL : logLevel;
   }
 
   /**
@@ -39,13 +68,49 @@ export class IterableLogger {
    *
    * @param message - The message to be logged.
    */
-  log(message: string) {
-    // default to `true` in the case of unit testing where `Iterable` is not initialized
-    // which is most likely in a debug environment anyways
-    const loggingEnabled = this.config.logReactNativeSdkCalls ?? true;
+  static log(message?: unknown, ...optionalParams: unknown[]) {
+    if (!IterableLogger.loggingEnabled) return;
+
+    console.log(message, ...optionalParams);
+  }
+
+  /**
+   * Logs a message to the console if the log level is error.
+   *
+   * @param message - The message to be logged.
+   */
+  static error(message?: unknown, ...optionalParams: unknown[]) {
+    if (!IterableLogger.loggingEnabled) return;
+    if (IterableLogger.logLevel !== IterableLogLevel.error) return;
+
+    console.log(`ERROR:`, message, ...optionalParams);
+  }
+
+  /**
+   * Logs a message to the console if the log level is debug or lower.
+   *
+   * @param message - The message to be logged.
+   */
+  static debug(message?: unknown, ...optionalParams: unknown[]) {
+    if (!IterableLogger.loggingEnabled) return;
+
+    const shouldLog = [IterableLogLevel.error, IterableLogLevel.debug].includes(
+      IterableLogger.logLevel
+    );
+
+    if (!shouldLog) return;
+
+    console.log(`DEBUG:`, message, ...optionalParams);
+  }
+
+  /**
+   * Logs a message to the console if the log level is info or lower.
+   *
+   * @param message - The message to be logged.
+   */
+  static info(message?: unknown, ...optionalParams: unknown[]) {
+    if (!IterableLogger.loggingEnabled) return;
 
-    if (loggingEnabled) {
-      console.log(message);
-    }
+    console.log(`INFO:`, message, ...optionalParams);
   }
 }
diff --git a/src/core/enums/IterableLogLevel.ts b/src/core/enums/IterableLogLevel.ts
index 04c13ec7b..abb33577d 100644
--- a/src/core/enums/IterableLogLevel.ts
+++ b/src/core/enums/IterableLogLevel.ts
@@ -1,14 +1,23 @@
 /**
- * Enum representing the level of logs will Android and iOS projects be using.
+ * Level of logs for iOS, Android and React Native.
+ *
+ * These levels will control when logs are shown.
  *
  * @see [Android Log Levels](https://source.android.com/docs/core/tests/debug/understanding-logging)
  * @see [iOS Log Levels](https://apple.github.io/swift-log/docs/current/Logging/Structs/Logger/Level.html#/s:7Logging6LoggerV5LevelO4infoyA2EmF)
  */
 export enum IterableLogLevel {
-  /** Appropriate for messages that contain information normally of use only when debugging a program. */
+  /** Show logs only for errors. */
+  error = 3,
+  /**
+   * Show logs for messages that contain information normally of use only when debugging a program.
+   * Also includes {@link IterableLogLevel.error} messages.
+   */
   debug = 1,
-  /** Appropriate for informational messages. */
+  /**
+   * Show logs which include general information about app flow — e.g., lifecycle events
+   * or major state changes. This is the most verbose logging level.
+   *  Also includes {@link IterableLogLevel.error} and {@link IterableLogLevel.debug} messages.
+   */
   info = 2,
-  /** Appropriate for error conditions. */
-  error = 3,
 }
diff --git a/src/inApp/classes/IterableInAppManager.ts b/src/inApp/classes/IterableInAppManager.ts
index f376b35bc..3d6a3cbf8 100644
--- a/src/inApp/classes/IterableInAppManager.ts
+++ b/src/inApp/classes/IterableInAppManager.ts
@@ -1,4 +1,4 @@
-import { RNIterableAPI } from '../../api';
+import { IterableApi } from '../../core/classes/IterableApi';
 import type {
   IterableInAppDeleteSource,
   IterableInAppLocation,
@@ -13,6 +13,20 @@ import { IterableInAppMessage } from './IterableInAppMessage';
  * displaying messages, removing messages, setting read status, and more.
  *
  * The `inAppManager` property of an `Iterable` instance is set to an instance of this class.
+ *
+ * @example
+ * ```typescript
+ * const inAppManager = new IterableInAppManager();
+ *
+ * inAppManager.getMessages().then(messages => {
+ *   console.log('Messages:', messages);
+ * });
+ *
+ * // You can also access an instance on `Iterable.inAppManager.inAppManager`
+ * Iterable.inAppManager.getMessages().then(messages => {
+ *   console.log('Messages:', messages);
+ * });
+ * ```
  */
 export class IterableInAppManager {
   /**
@@ -32,9 +46,7 @@ export class IterableInAppManager {
    * @returns A Promise that resolves to an array of in-app messages.
    */
   getMessages(): Promise<IterableInAppMessage[]> {
-    // Iterable?.logger?.log('InAppManager.getMessages');
-
-    return RNIterableAPI.getInAppMessages() as unknown as Promise<
+    return IterableApi.getInAppMessages() as unknown as Promise<
       IterableInAppMessage[]
     >;
   }
@@ -57,9 +69,7 @@ export class IterableInAppManager {
    * @returns A Promise that resolves to an array of messages marked as `saveToInbox`.
    */
   getInboxMessages(): Promise<IterableInAppMessage[]> {
-    // Iterable?.logger?.log('InAppManager.getInboxMessages');
-
-    return RNIterableAPI.getInboxMessages() as unknown as Promise<
+    return IterableApi.getInboxMessages() as unknown as Promise<
       IterableInAppMessage[]
     >;
   }
@@ -86,9 +96,7 @@ export class IterableInAppManager {
     message: IterableInAppMessage,
     consume: boolean
   ): Promise<string | null> {
-    // Iterable?.logger?.log('InAppManager.show');
-
-    return RNIterableAPI.showMessage(message.messageId, consume);
+    return IterableApi.showMessage(message.messageId, consume);
   }
 
   /**
@@ -114,9 +122,7 @@ export class IterableInAppManager {
     location: IterableInAppLocation,
     source: IterableInAppDeleteSource
   ): void {
-    // Iterable?.logger?.log('InAppManager.remove');
-
-    return RNIterableAPI.removeMessage(message.messageId, location, source);
+    return IterableApi.removeMessage(message.messageId, location, source);
   }
 
   /**
@@ -131,9 +137,7 @@ export class IterableInAppManager {
    * ```
    */
   setReadForMessage(message: IterableInAppMessage, read: boolean) {
-    // Iterable?.logger?.log('InAppManager.setRead');
-
-    RNIterableAPI.setReadForMessage(message.messageId, read);
+    return IterableApi.setReadForMessage(message.messageId, read);
   }
 
   /**
@@ -151,11 +155,7 @@ export class IterableInAppManager {
   getHtmlContentForMessage(
     message: IterableInAppMessage
   ): Promise<IterableHtmlInAppContent> {
-    // Iterable?.logger?.log('InAppManager.getHtmlContentForMessage');
-
-    return RNIterableAPI.getHtmlInAppContentForMessage(
-      message.messageId
-    ) as unknown as Promise<IterableHtmlInAppContent>;
+    return IterableApi.getHtmlInAppContentForMessage(message.messageId);
   }
 
   /**
@@ -173,8 +173,6 @@ export class IterableInAppManager {
    * ```
    */
   setAutoDisplayPaused(paused: boolean) {
-    // Iterable?.logger?.log('InAppManager.setAutoDisplayPaused');
-
-    RNIterableAPI.setAutoDisplayPaused(paused);
+    return IterableApi.setAutoDisplayPaused(paused);
   }
 }
diff --git a/src/inbox/classes/IterableInboxDataModel.ts b/src/inbox/classes/IterableInboxDataModel.ts
index 311f5cc7c..4b81d5b22 100644
--- a/src/inbox/classes/IterableInboxDataModel.ts
+++ b/src/inbox/classes/IterableInboxDataModel.ts
@@ -1,5 +1,4 @@
-import { RNIterableAPI } from '../../api';
-import { Iterable } from '../../core/classes/Iterable';
+import { IterableApi } from '../../core/classes/IterableApi';
 import {
   IterableHtmlInAppContent,
   IterableInAppDeleteSource,
@@ -94,11 +93,7 @@ export class IterableInboxDataModel {
    * @returns  A promise that resolves to the HTML content of the specified message.
    */
   getHtmlContentForMessageId(id: string): Promise<IterableHtmlInAppContent> {
-    Iterable?.logger?.log(
-      'IterableInboxDataModel.getHtmlContentForItem messageId: ' + id
-    );
-
-    return RNIterableAPI.getHtmlInAppContentForMessage(id).then(
+    return IterableApi.getHtmlInAppContentForMessage(id).then(
       (content: IterableHtmlInAppContentRaw) => {
         return IterableHtmlInAppContent.fromDict(content);
       }
@@ -111,9 +106,7 @@ export class IterableInboxDataModel {
    * @param id - The unique identifier of the message to be marked as read.
    */
   setMessageAsRead(id: string) {
-    Iterable?.logger?.log('IterableInboxDataModel.setMessageAsRead');
-
-    RNIterableAPI.setReadForMessage(id, true);
+    return IterableApi.setReadForMessage(id, true);
   }
 
   /**
@@ -123,9 +116,11 @@ export class IterableInboxDataModel {
    * @param deleteSource - The source from which the delete action is initiated.
    */
   deleteItemById(id: string, deleteSource: IterableInAppDeleteSource) {
-    Iterable?.logger?.log('IterableInboxDataModel.deleteItemById');
-
-    RNIterableAPI.removeMessage(id, IterableInAppLocation.inbox, deleteSource);
+    return IterableApi.removeMessage(
+      id,
+      IterableInAppLocation.inbox,
+      deleteSource
+    );
   }
 
   /**
@@ -135,7 +130,7 @@ export class IterableInboxDataModel {
    * If the fetch operation fails, the promise resolves to an empty array.
    */
   async refresh(): Promise<IterableInboxRowViewModel[]> {
-    return RNIterableAPI.getInboxMessages().then(
+    return IterableApi.getInboxMessages().then(
       (messages: IterableInAppMessage[]) => {
         return this.processMessages(messages);
       },
@@ -151,7 +146,7 @@ export class IterableInboxDataModel {
    * @param visibleRows - An array of `IterableInboxImpressionRowInfo` objects representing the rows that are currently visible.
    */
   startSession(visibleRows: IterableInboxImpressionRowInfo[] = []) {
-    RNIterableAPI.startSession(visibleRows as unknown as { [key: string]: string | number | boolean }[]);
+    return IterableApi.startSession(visibleRows);
   }
 
   /**
@@ -162,7 +157,7 @@ export class IterableInboxDataModel {
    */
   async endSession(visibleRows: IterableInboxImpressionRowInfo[] = []) {
     await this.updateVisibleRows(visibleRows);
-    RNIterableAPI.endSession();
+    return IterableApi.endSession();
   }
 
   /**
@@ -178,7 +173,7 @@ export class IterableInboxDataModel {
    *                      Defaults to an empty array if not provided.
    */
   updateVisibleRows(visibleRows: IterableInboxImpressionRowInfo[] = []) {
-    RNIterableAPI.updateVisibleRows(visibleRows as unknown as { [key: string]: string | number | boolean }[]);
+    return IterableApi.updateVisibleRows(visibleRows);
   }
 
   /**