@dynatrace/react-native-plugin 2.327.2 → 2.329.1

package/types.d.ts

@@ -235,7 +235,7 @@ interface IDynatraceAction {
      *
      * @example
      * ```ts
-     * import { Dynatrace } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
      *
      * const action = Dynatrace.enterAutoAction('User Login');
      * action.reportError('Page Not Found', 404);
@@ -383,7 +383,7 @@ interface IDynatraceAction {
      * action.reportEvent('Processing Started');
      *
      * // Cancel if running in development or test mode
-     * if (__DEV__ || isTestEnvironment) {
+     * if (__DEV__) {
      *   action.cancel(); // Don't send test data to production monitoring
      * } else {
      *   action.leaveAction(); // Send the action data
@@ -609,10 +609,20 @@ interface IEventModifier {
     /**
      * Event as JSONObject is received and can be modified.
      *
-     * Returning null discards this event and prevents future mutator functions to be executed.
+     * Returning null discards the event and prevents future modifier functions from being executed.
+     *
+     * Certain reserved fields and namespaces cannot be modified in any way (added, removed, or overridden),
+     * while others are open for modification.
+     *
+     * Open for modification:
+     * - url.full
+     * - exception.stack_trace
+     *
+     * Open for modification or can be added:
+     * - event_properties.*
+     * - session_properties.*
      *
-     * Certain reserved fields and namespaces can't be modified in any way (added, removed or overridden),
-     * while others are open for modification. See the public documentation for a detailed list of reserved/open fields.
+     * See the public documentation for a detailed list of reserved/open fields.
      * @param event Event as JSONObject
      * @returns Either the modified event or null if you want to cancel the event
      *
@@ -631,18 +641,37 @@ interface IEventModifier {
     modifyEvent(event: JSONObject): JSONObject | null;
 }
 
-interface IHttpRequestEventBuilder {
+/**
+ * Represents the allowed types for event property values.
+ */
+type EventProperty = string | number | boolean;
+
+/**
+ * Base interface for all events.
+ */
+interface IBaseEvent {
+    /**
+     * Converts the event into a JSON event object.
+     *
+     * @returns The built event as a JSONObject.
+     *
+     * @internal
+     */
+    toJSON(): JSONObject | null;
+}
+
+interface IHttpRequestEventData extends IBaseEvent {
     /**
      * Sets the duration of the HTTP request in milliseconds.
      *
      * @param duration The request duration in milliseconds. Only positive numbers are valid.
-     * @returns The builder instance for method chaining
+     * @returns The event instance for method chaining
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
-     * const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'GET')
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/data', 'GET')
      *   .withDuration(250);
      * Dynatrace.sendHttpRequestEvent(requestEvent);
      * ```
@@ -654,13 +683,13 @@ interface IHttpRequestEventBuilder {
      * Sets the HTTP response status code.
      *
      * @param statusCode The HTTP status code (e.g., 200, 404, 500). Only positive numbers are valid.
-     * @returns The builder instance for method chaining
+     * @returns The event instance for method chaining
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
-     * const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'GET')
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/data', 'GET')
      *   .withStatusCode(200);
      * Dynatrace.sendHttpRequestEvent(requestEvent);
      * ```
@@ -672,13 +701,13 @@ interface IHttpRequestEventBuilder {
      * Sets the HTTP response reason phrase.
      *
      * @param reasonPhrase The reason phrase (e.g., "OK", "Not Found"). Maximum 5000 characters; longer values will be trimmed.
-     * @returns The builder instance for method chaining
+     * @returns The event instance for method chaining
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
-     * const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'GET')
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/data', 'GET')
      *   .withReasonPhrase('OK');
      * Dynatrace.sendHttpRequestEvent(requestEvent);
      * ```
@@ -690,17 +719,21 @@ interface IHttpRequestEventBuilder {
      * Associates an error with the HTTP request event.
      *
      * @param error A standard JavaScript Error object representing the request failure
-     * @returns The builder instance for method chaining
+     * @returns The event instance for method chaining
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
      * try {
      *   // Request code
      * } catch (error) {
-     *   const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'GET')
-     *     .withError(error);
+     *   let requestEvent = new HttpRequestEventData('https://api.example.com/data', 'GET');
+     *
+     *   if (error instanceof Error) {
+     *      requestEvent.withError(error);
+     *   }
+     *
      *   Dynatrace.sendHttpRequestEvent(requestEvent);
      * }
      * ```
@@ -712,13 +745,13 @@ interface IHttpRequestEventBuilder {
      * Sets the number of bytes sent in the request.
      *
      * @param bytesSent The number of bytes sent in the request payload. Only positive numbers are valid.
-     * @returns The builder instance for method chaining
+     * @returns The event instance for method chaining
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
-     * const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'POST')
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/data', 'POST')
      *   .withBytesSent(1024);
      * Dynatrace.sendHttpRequestEvent(requestEvent);
      * ```
@@ -730,13 +763,13 @@ interface IHttpRequestEventBuilder {
      * Sets the number of bytes received in the response.
      *
      * @param bytesReceived The number of bytes received in the response payload. Only positive numbers are valid.
-     * @returns The builder instance for method chaining
+     * @returns The event instance for method chaining
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
-     * const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'GET')
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/data', 'GET')
      *   .withBytesReceived(2048);
      * Dynatrace.sendHttpRequestEvent(requestEvent);
      * ```
@@ -749,13 +782,13 @@ interface IHttpRequestEventBuilder {
      *
      * @param traceparentHeader A valid traceparent header according to the W3C Trace Context specification.
      * Format: `00-<trace-id>-<parent-id>-<trace-flags>` where trace-id is 32 hex digits, parent-id is 16 hex digits.
-     * @returns The builder instance for method chaining
+     * @returns The event instance for method chaining
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
-     * const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'GET')
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/data', 'GET')
      *   .withTraceparentHeader('00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01');
      * Dynatrace.sendHttpRequestEvent(requestEvent);
      * ```
@@ -771,18 +804,19 @@ interface IHttpRequestEventBuilder {
      * **Property Requirements:**
      * - Only properties prefixed with `event_properties.*` are allowed
      * - Maximum of 50 custom properties per event
+     *   - If the limit is exceeded, properties are sorted alphabetically by key and excess properties are dropped deterministically
      * - String properties are limited to 5000 characters (exceeding characters are truncated)
      * - Field names must contain only alphabetic characters, numbers, underscores, and dots
      * - Each dot must be followed by an alphabetic character
      * - Each underscore must be followed by an alphabetic character or number
      *
-     * @returns The builder instance for method chaining
+     * @returns The event instance for method chaining
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
-     * const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'GET')
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/data', 'GET')
      *   .addEventProperty('event_properties.user_id', '12345')
      *   .addEventProperty('event_properties.api_version', 'v2');
      * Dynatrace.sendHttpRequestEvent(requestEvent);
@@ -793,14 +827,12 @@ interface IHttpRequestEventBuilder {
     addEventProperty(key: `event_properties.${string}`, value: EventProperty): this;
 }
 
-type EventProperty = string | number | boolean;
 type TraceparentHeader = `00-${string}-${string}-0${'0' | '1'}`;
 type AllowedRequestMethods = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH' | 'get' | 'head' | 'post' | 'put' | 'delete' | 'connect' | 'options' | 'trace' | 'patch';
-declare class HttpRequestEventBuilder implements IHttpRequestEventBuilder {
+declare class HttpRequestEventData implements IHttpRequestEventData {
     private url;
     private requestMethod;
     private static readonly allowedRequestMethods;
-    private static readonly maxReasonPhraseLength;
     private duration;
     private statusCode?;
     private reasonPhrase?;
@@ -809,22 +841,22 @@ declare class HttpRequestEventBuilder implements IHttpRequestEventBuilder {
     private error?;
     private traceparentHeader?;
     private rawEventProperties;
-    private hasDroppedTraceparent;
-    private hasDroppedCustomProperties;
-    private hasNfnValues;
+    private traceContextHint;
+    private hasDroppedProperties;
     private triedToOverwriteDuration;
     /**
-     * Creates a new HTTP request event builder.
+     * Creates a new HTTP request event.
      *
-     * @param url The request URL. Must be a valid URL according to the WHATWG URL Standard, starting with `http://` or `https://`.
+     * @param url The request URL. Must be a valid URL according to the WHATWG URL Standard, starting with
+     * `http://` or `https://`. Maximum 5000 characters; longer values will be trimmed.
      * @param requestMethod The HTTP request method. Allowed values: GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS,
      * TRACE, PATCH (case-insensitive).
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
-     * const requestEvent = new HttpRequestEventBuilder('https://api.example.com/data', 'GET');
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/data', 'GET');
      * Dynatrace.sendHttpRequestEvent(requestEvent);
      * ```
      *
@@ -839,22 +871,200 @@ declare class HttpRequestEventBuilder implements IHttpRequestEventBuilder {
     withBytesReceived(bytesReceived: number): this;
     withTraceparentHeader(traceparentHeader: TraceparentHeader): this;
     addEventProperty(key: `event_properties.${string}`, value: EventProperty): this;
-    build(): JSONObject | null;
-    private hasValidMandatoryAttriutes;
+    toJSON(): JSONObject | null;
+    private hasValidMandatoryAttributes;
     private isInvalidUrl;
     private sanitizeStatusCode;
-    private sanitizeReasonPhrase;
     private sanitizeDuration;
     private sanitizeBytesSent;
     private sanitizeBytesReceived;
     private isStatusCodeError;
-    private isEventPropertyKey;
-    private includeIfDefined;
-    private includeIfTrue;
     private parseTraceparent;
     private allZeros;
 }
 
+/**
+ * Interface for building events with event properties and duration.
+ *
+ * Events can include custom properties and duration information.
+ * Use implementations of this interface with `Dynatrace.sendEvent()`.
+ *
+ * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
+ */
+interface IEventData extends IBaseEvent {
+    /**
+     * Sets the duration of the event in milliseconds.
+     *
+     * @param duration The event duration in milliseconds. Only positive numbers are valid.
+     * @returns The event instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
+     *
+     * const customEvent = new EventData()
+     *   .addEventProperty('event_properties.operation', 'data_sync')
+     *   .withDuration(250);
+     * Dynatrace.sendEvent(customEvent);
+     * ```
+     */
+    withDuration(duration: number): this;
+    /**
+     * Adds a custom event property to the event.
+     *
+     * Event properties allow you to attach custom key-value pairs to events for better
+     * analysis and filtering in Dynatrace.
+     *
+     * @param key - The property key. Must be prefixed with `event_properties.*`
+     * @param value - The property value (string, number, or boolean). Invalid values will be replaced with null.
+     * @returns The event instance for method chaining
+     *
+     * @remarks
+     * **Property Requirements:**
+     * - Only properties prefixed with `event_properties.*` are allowed
+     * - Maximum of 50 custom properties per event
+     *   - If the limit is exceeded, properties are sorted alphabetically by key and excess properties are dropped deterministically
+     * - String properties are limited to 5000 characters (exceeding characters are truncated)
+     * - Field names must contain only alphabetic characters, numbers, underscores, and dots
+     * - Each dot must be followed by an alphabetic character
+     * - Each underscore must be followed by an alphabetic character or number
+     *
+     * @example
+     * ```typescript
+     * import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
+     *
+     * const customEvent = new EventData()
+     *   .addEventProperty('event_properties.user_id', '12345')
+     *   .addEventProperty('event_properties.action_type', 'purchase')
+     *   .addEventProperty('event_properties.amount', 99.99)
+     *   .addEventProperty('event_properties.is_premium_user', true);
+     * Dynatrace.sendEvent(customEvent);
+     * ```
+     */
+    addEventProperty(key: `event_properties.${string}`, value: EventProperty): this;
+}
+
+declare class EventData implements IEventData {
+    private rawEventProperties;
+    private duration?;
+    addEventProperty(key: `event_properties.${string}`, value: EventProperty): this;
+    withDuration(duration: number): this;
+    toJSON(): JSONObject | null;
+}
+
+/**
+ * Interface for building session property events.
+ *
+ * Session properties are key-value pairs that persist throughout the entire
+ * user session and are attached to all subsequent events in that session.
+ * Use implementations of this interface with `Dynatrace.sendSessionPropertyEvent()`.
+ *
+ * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
+ */
+interface ISessionPropertyEventData extends IBaseEvent {
+    /**
+     * Adds a custom session property to the event.
+     *
+     * Session properties allow you to attach custom key-value pairs that persist throughout
+     * the entire user session. These properties will be automatically attached to all
+     * subsequent events in the current session.
+     *
+     * @param key - The property key. Must be prefixed with `session_properties.*`
+     * @param value - The property value (string, number, or boolean). Invalid values will be replaced with null.
+     * @returns The event instance for method chaining
+     *
+     * @remarks
+     * **Property Requirements:**
+     * - Only properties prefixed with `session_properties.*` are allowed
+     * - Maximum of 50 custom properties per event
+     *   - If the limit is exceeded, properties are sorted alphabetically by key and excess properties are dropped deterministically
+     * - String properties are limited to 5000 characters (exceeding characters are truncated)
+     * - Field names must contain only alphabetic characters, numbers, underscores, and dots
+     * - Each dot must be followed by an alphabetic character
+     * - Each underscore must be followed by an alphabetic character or number
+     *
+     * @example
+     * ```typescript
+     * import { Dynatrace, SessionPropertyEventData } from '@dynatrace/react-native-plugin';
+     *
+     * const sessionPropertyEvent = new SessionPropertyEventData()
+     *   .addSessionProperty('session_properties.user_id', 'user_12345')
+     *   .addSessionProperty('session_properties.user_type', 'premium')
+     *   .addSessionProperty('session_properties.feature_flags_enabled', true)
+     *   .addSessionProperty('session_properties.session_score', 95.5);
+     * Dynatrace.sendSessionPropertyEvent(sessionPropertyEvent);
+     * ```
+     */
+    addSessionProperty(key: `session_properties.${string}`, value: EventProperty): this;
+}
+
+declare class SessionPropertyEventData implements ISessionPropertyEventData {
+    private rawSessionProperties;
+    addSessionProperty(key: `session_properties.${string}`, value: EventProperty): this;
+    toJSON(): JSONObject | null;
+}
+
+/**
+ * Interface for building exception events with event properties.
+ *
+ * This interface defines the contract for creating exception events that can be sent
+ * to Dynatrace. Exception events can include custom properties.
+ * Use implementations of this interface with `Dynatrace.sendExceptionEvent()`.
+ *
+ * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
+ */
+interface IExceptionEventData extends IBaseEvent {
+    /**
+     * Adds a custom event property to the exception event.
+     *
+     * Event properties allow you to attach additional contextual information to the exception.
+     * Properties must follow the naming convention `event_properties.*` and support string,
+     * number, and boolean values.
+     *
+     * @param key The property key. Must start with "event_properties."
+     * @param value The property value (string, number, or boolean)
+     * @returns The event instance for method chaining
+     *
+     * @remarks
+     * **Property Requirements:**
+     * - Only properties prefixed with `event_properties.*` are allowed
+     * - Maximum of 50 custom properties per event
+     *   - If the limit is exceeded, properties are sorted alphabetically by key and excess properties are dropped deterministically
+     * - String properties are limited to 5000 characters (exceeding characters are truncated)
+     * - Field names must contain only alphabetic characters, numbers, underscores, and dots
+     * - Each dot must be followed by an alphabetic character
+     * - Each underscore must be followed by an alphabetic character or number
+     *
+     * @example
+     * ```typescript
+     * import { Dynatrace, ExceptionEventData } from '@dynatrace/react-native-plugin';
+     *
+     * try {
+     *   // Some operation that might throw an error
+     *   throw new Error('Something went wrong');
+     * } catch (error) {
+     *   if (error instanceof Error) {
+     *     const exceptionEvent = new ExceptionEventData(error)
+     *       .addEventProperty('event_properties.exception_type', 'RuntimeError')
+     *       .addEventProperty('event_properties.stack_depth', 15)
+     *       .addEventProperty('event_properties.handled', true);
+     *
+     *     Dynatrace.sendExceptionEvent(exceptionEvent);
+     *   }
+     * }
+     * ```
+     */
+    addEventProperty(key: string, value: EventProperty): this;
+}
+
+declare class ExceptionEventData implements IExceptionEventData {
+    private rawEventProperties;
+    private readonly error;
+    constructor(error: Error);
+    addEventProperty(key: `event_properties.${string}`, value: EventProperty): this;
+    toJSON(): JSONObject | null;
+}
+
 interface IDynatrace$1 {
     /**
      * Adds an event modifier that is executed just before the event is transferred.
@@ -865,6 +1075,14 @@ interface IDynatrace$1 {
      * Certain reserved fields and namespaces cannot be modified in any way (added, removed, or overridden),
      * while others are open for modification.
      *
+     * Open for modification:
+     * - url.full
+     * - exception.stack_trace
+     *
+     * Open for modification or can be added:
+     * - event_properties.*
+     * - session_properties.*
+     *
      * See the public documentation for a detailed list of reserved/open fields.
      *
      * @param eventModifier The modifier function to modify a given JSONObject
@@ -905,65 +1123,53 @@ interface IDynatrace$1 {
     /**
      * Sends an exception event for error tracking and monitoring.
      *
-     * @param {Error} error The error object containing exception information
-     * @param {JSONObject} properties Optional custom properties for the exception event. Must be a valid JSON object
-     * and cannot contain functions, undefined, Infinity, or NaN as values (they will be replaced with null).
-     *
-     * **Property Requirements:**
-     * - Only properties prefixed with `event_properties.*` are allowed
-     * - Additionally, the `duration` property is allowed
-     * - Maximum of 50 custom properties per event
-     * - String properties are limited to 5000 characters (exceeding characters are truncated)
-     * - Field names must contain only alphabetic characters, numbers, underscores, and dots
-     * - Each dot must be followed by an alphabetic character
-     * - Each underscore must be followed by an alphabetic character or number
+     * @param exceptionEventData The exception event data built using ExceptionEventData
      *
      * @example
      * ```ts
-     * import { Dynatrace } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, ExceptionEventData } from '@dynatrace/react-native-plugin';
      *
      * try {
      *   // Code that may throw an error
      *   throw new Error('Something went wrong');
      * } catch (error) {
-     *   Dynatrace.sendExceptionEvent(error, {
-     *     'event_properties.custom_key': 'custom_value',
-     *     'event_properties.error_context': 'user_action'
-     *   });
+     *   if (error instanceof Error) {
+     *     const exceptionEvent = new ExceptionEventData(error)
+     *       .addEventProperty('event_properties.custom_key', 'custom_value')
+     *       .addEventProperty('event_properties.error_context', 'user_action');
+     *
+     *     Dynatrace.sendExceptionEvent(exceptionEvent);
+     *   }
      * }
      * ```
      *
      * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
      */
-    sendExceptionEvent(error: Error, fields?: JSONObject): void;
+    sendExceptionEvent(exceptionEventData: ExceptionEventData): void;
     /**
-     * Sends a custom event with properties in JSON format.
+     * Sends a custom event with event properties and optional duration.
      *
-     * @param {JSONObject} properties Event properties as a valid JSON object. Cannot contain functions, undefined,
-     * Infinity, or NaN as values (they will be replaced with null). Empty objects are valid.
-     *
-     * **Property Requirements:**
-     * - Only properties prefixed with `event_properties.*` are allowed
-     * - Additionally, the `duration` property is allowed
-     * - Maximum of 50 custom properties per event
-     * - String properties are limited to 5000 characters (exceeding characters are truncated)
-     * - Field names must contain only alphabetic characters, numbers, underscores, and dots
-     * - Each dot must be followed by an alphabetic character
-     * - Each underscore must be followed by an alphabetic character or number
+     * @param eventData The event data built using EventData
      *
      * @example
      * ```ts
-     * import { Dynatrace } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
+     *
+     * const customEvent = new EventData()
+     *   .addEventProperty('event_properties.user_action', 'button_click')
+     *   .addEventProperty('event_properties.screen_name', 'checkout')
+     *   .addEventProperty('event_properties.item_count', 3)
+     *   .withDuration(150);
      *
-     * Dynatrace.sendEvent({'event_properties.custom_key':'custom_value'});
+     * Dynatrace.sendEvent(customEvent);
      * ```
      *
      * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
      */
-    sendEvent(properties: JSONObject): void;
+    sendEvent(eventData: EventData): void;
     /**
      * Starts a new view context. All events reported after this call will be associated
-     * with this view until `stopView()` is called or a new view is started.
+     * with this view until a new view is started.
      *
      * **Note:** Only one view context can be active at a time. Starting a new view will
      * automatically stop any currently active view context.
@@ -981,78 +1187,53 @@ interface IDynatrace$1 {
      * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
      */
     startView(name: string): void;
-    /**
-     * Stops the current view context. Events reported after this call will not be
-     * associated with any view until a new view is started.
-     *
-     * @example
-     * ```ts
-     * import { Dynatrace } from '@dynatrace/react-native-plugin';
-     *
-     * Dynatrace.startView('HomeScreen');
-     * // ... user interactions ...
-     * Dynatrace.stopView();
-     * ```
-     *
-     * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
-     */
-    stopView(): void;
     /**
      * Sends a session properties event. Session properties apply to all events in the current session.
      *
      * **Note:** While you can send multiple session properties at once, if you report the same
      * property multiple times, session aggregation will only use one of the values (first or last).
      *
-     * @param {JSONObject} properties Session properties as a valid JSON object. Cannot contain functions,
-     * undefined, Infinity, or NaN as values (they will be replaced with null). Empty objects are valid.
-     *
-     * **Property Requirements:**
-     * - Only properties prefixed with `session_properties.*` are allowed
-     * - Additionally, the `duration` property is allowed
-     * - Maximum of 50 custom properties per event
-     * - String properties are limited to 5000 characters (exceeding characters are truncated)
-     * - Field names must contain only alphabetic characters, numbers, underscores, and dots
-     * - Each dot must be followed by an alphabetic character
-     * - Each underscore must be followed by an alphabetic character or number
+     * @param sessionPropertyEventData The session property event data built using SessionPropertyEventData builder
      *
      * @example
      * ```ts
-     * import { Dynatrace } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, SessionPropertyEventData } from '@dynatrace/react-native-plugin';
      *
      * // Set session-level properties
-     * Dynatrace.sendSessionPropertyEvent({
-     *   'session_properties.user_tier': 'premium',
-     *   'session_properties.app_version': '2.1.0',
-     *   'session_properties.device_type': 'mobile'
-     * });
+     * const sessionEvent = new SessionPropertyEventData()
+     *   .addSessionProperty('session_properties.user_tier', 'premium')
+     *   .addSessionProperty('session_properties.app_version', '2.1.0')
+     *   .addSessionProperty('session_properties.device_type', 'mobile');
+     *
+     * Dynatrace.sendSessionPropertyEvent(sessionEvent);
      * ```
      *
      * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
      */
-    sendSessionPropertyEvent(properties: JSONObject): void;
+    sendSessionPropertyEvent(sessionPropertyEventData: SessionPropertyEventData): void;
     /**
      * Sends an HTTP request event for network activity monitoring.
      *
-     * @param {HttpRequestEventBuilder} httpRequestEventBuilder Builder object containing the HTTP request details
+     * @param {HttpRequestEventData} httpRequestEvent Event object containing the HTTP request details
      *
      * @example
      * ```ts
-     * import { Dynatrace, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+     * import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
      *
      * // Basic HTTP request event
-     * const requestBuilder = new HttpRequestEventBuilder('https://api.example.com/users', 'GET');
-     * Dynatrace.sendHttpRequestEvent(requestBuilder);
+     * const requestEvent = new HttpRequestEventData('https://api.example.com/users', 'GET');
+     * Dynatrace.sendHttpRequestEvent(requestEvent);
      *
      * // HTTP request with additional details
-     * const detailedBuilder = new HttpRequestEventBuilder('https://api.example.com/data', 'POST')
-     *   .setResponseCode(200)
-     *   .setRequestHeaders({ 'Content-Type': 'application/json' });
-     * Dynatrace.sendHttpRequestEvent(detailedBuilder);
+     * const detailedRequest = new HttpRequestEventData('https://api.example.com/data', 'POST')
+     *   .withStatusCode(200)
+     *   .addEventProperty('event_properties.headers.content_type', 'application/json');
+     * Dynatrace.sendHttpRequestEvent(detailedRequest);
      * ```
      *
      * @see https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api
      */
-    sendHttpRequestEvent(httpRequestEventBuilder: HttpRequestEventBuilder): void;
+    sendHttpRequestEvent(httpRequestEvent: HttpRequestEventData): void;
 }
 
 /**
@@ -1130,9 +1311,10 @@ interface IDynatrace extends IDynatrace$1 {
      * @example
      * ```ts
      * import { Dynatrace } from '@dynatrace/react-native-plugin';
+     * import { FunctionComponent } from 'react';
      *
-     * export function MyFunctionalComponent(){
-     * 		// Content of component
+     * export const MyFunctionalComponent: FunctionComponent<{}> = () => {
+     * 		return null;
      * }
      *
      * Dynatrace.withMonitoring(MyFunctionalComponent, "MyFunctionalComponent");
@@ -1224,54 +1406,87 @@ interface IDynatrace extends IDynatrace$1 {
      */
     reportErrorWithStacktrace(errorName: string, reason: string, stacktrace: string, platform?: Platform): void;
     /**
-     * Reports a stacktrace
+     * Reports an error with its complete stacktrace to Dynatrace for monitoring and analysis.
+     * Use this method to capture and report errors with their full stack traces, typically within
+     * try-catch blocks to handle exceptions gracefully while maintaining observability.
      *
-     * @param {string} errorName Name of the error (limited to 250 characters)
-     * @param {string} errorValue Value of the error
-     * @param {string} reason Reason for the error
-     * @param {string} stacktrace Whole stacktrace
-     * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+     * @param errorName Name or type of the error (e.g., 'DatabaseError', 'NetworkError'). Limited to 250 characters.
+     * @param errorValue The error message or value describing what went wrong
+     * @param reason Additional context explaining why the error occurred
+     * @param stacktrace The complete stack trace from the error. Use error.stack or provide a custom trace.
+     * @param platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
      *
      * @example
      * ```ts
      * import { Dynatrace } from '@dynatrace/react-native-plugin';
      *
-     * Dynatrace.reportErrorStacktrace("Error Name", "Error Value", "Reason", "Stacktrace");
+     * try {
+     *   throw new Error('Database connection failed');
+     * } catch (error) {
+     *   if (error instanceof Error) {
+     *     Dynatrace.reportErrorStacktrace(
+     *       'DatabaseError',
+     *       error.message,
+     *       'Failed to connect to remote database',
+     *       error.stack || 'No stack trace available'
+     *     );
+     *   }
+     * }
      * ```
      *
      * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#report-an-error-stacktrace
      */
     reportErrorStacktrace(errorName: string, errorValue: string, reason: string, stacktrace: string, platform?: Platform): void;
     /**
-     * Reports a custom crash
+     * Reports a custom crash event to Dynatrace for critical failures that cause app termination.
+     * Use this to manually report crashes with detailed stack traces when automatic crash detection
+     * is insufficient or when you need to report non-fatal errors as crashes for monitoring purposes.
      *
-     * @param {string} crashName Name of the crash (limited to 250 characters)
-     * @param {string} reason Reason for the crash
-     * @param {string} stacktrace Whole stacktrace
-     * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+     * @param crashName Descriptive name for the crash (e.g., 'OutOfMemoryError', 'UnhandledException'). Limited to 250 characters.
+     * @param reason Brief explanation of why the crash occurred
+     * @param stacktrace Complete stack trace showing the call sequence leading to the crash
+     * @param platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
      *
      * @example
      * ```ts
      * import { Dynatrace } from '@dynatrace/react-native-plugin';
      *
-     * Dynatrace.reportCrash("Crash Name", "Reason", "Stacktrace");
+     * try {
+     *   throw new Error('Fatal memory allocation failure');
+     * } catch (error) {
+     *   if (error instanceof Error) {
+     *     Dynatrace.reportCrash(
+     *       'MemoryError',
+     *       error.message,
+     *       error.stack || 'No stack trace available'
+     *     );
+     *   }
+     * }
      * ```
      *
      * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manually-report-a-crash
      */
     reportCrash(crashName: string, reason: string, stacktrace: string, platform?: Platform): void;
     /**
-     * Reports a crash with an error object (which needs to contain a stacktrace)
+     * Reports a crash using a native JavaScript Error object to Dynatrace.
+     * This is a convenience method that automatically extracts the error message and stack trace
+     * from an Error object, making it easier to report crashes from caught exceptions.
      *
-     * @param {string} crashName Name of the crash (limited to 250 characters)
-     * @param {Error} crash error object
-     * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+     * @param crashName Descriptive name for the crash (e.g., 'UnhandledPromiseRejection'). Limited to 250 characters.
+     * @param crash The Error object containing the stack trace and error details
+     * @param platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
      *
      * @example
      * ```ts
      * import { Dynatrace } from '@dynatrace/react-native-plugin';
      *
-     * Dynatrace.reportCrashWithException("Crash Name", error);
+     * try {
+     *   throw new Error('Critical API endpoint unavailable');
+     * } catch (error) {
+     *   if (error instanceof Error) {
+     *     Dynatrace.reportCrashWithException('APIFailureCrash', error);
+     *   }
+     * }
      * ```
      *
      * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manually-report-a-crash
@@ -1720,7 +1935,7 @@ declare class ConfigurationBuilder {
      *
      * @example
      * ```ts
-     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     * import { ConfigurationBuilder, Dynatrace, LogLevel } from '@dynatrace/react-native-plugin';
      *
      * const config = new ConfigurationBuilder('beaconUrl', 'applicationId')
      *   .withLogLevel(LogLevel.Debug)
@@ -1753,14 +1968,19 @@ interface IDynatraceWebRequestTiming {
      *
      * try {
      *   timing.startWebRequestTiming();
-     *   const axiosResponse = await axios.get(url, {
+     *   const response = await fetch(url, {
      *     headers: {
      *       [timing.getRequestTagHeader()]: tag
      *     }
      *   });
-     *   timing.stopWebRequestTiming(axiosResponse.status, axiosResponse.data);
+     *   const data = await response.text();
+     *   timing.stopWebRequestTiming(response.status, data);
      * } catch (error) {
-     *   timing.stopWebRequestTiming(-1, error.message);
+     *   if (error instanceof Error) {
+     *      timing.stopWebRequestTiming(-1, error.message);
+     *   } else {
+     *      timing.stopWebRequestTiming(-1, (error as any).toString());
+     *   }
      * } finally {
      *   action.leaveAction();
      * }
@@ -1788,14 +2008,18 @@ interface IDynatraceWebRequestTiming {
      *
      * try {
      *   timing.startWebRequestTiming();
-     *   const axiosResponse = await axios.get(url, {
+     *   const response = await fetch(url, {
      *     headers: {
      *       [timing.getRequestTagHeader()]: tag
      *     }
      *   });
-     *   timing.stopWebRequestTiming(axiosResponse.status, axiosResponse.statusText);
+     *   timing.stopWebRequestTiming(response.status, response.statusText);
      * } catch (error) {
-     *   timing.stopWebRequestTiming(-1, error.message);
+     *   if (error instanceof Error) {
+     *      timing.stopWebRequestTiming(-1, error.message);
+     *   } else {
+     *      timing.stopWebRequestTiming(-1, (error as any).toString());
+     *   }
      * } finally {
      *   action.leaveAction();
      * }
@@ -1826,21 +2050,27 @@ interface IDynatraceWebRequestTiming {
      *
      * try {
      *   timing.startWebRequestTiming();
-     *   const axiosResponse = await axios.post(url, requestData, {
+     *   const response = await fetch(url, {
+     *     method: 'POST',
      *     headers: {
      *       [timing.getRequestTagHeader()]: tag,
      *       'Content-Type': 'application/json'
-     *     }
+     *     },
+     *     body: requestData
      *   });
-     *   const responseData = JSON.stringify(axiosResponse.data);
+     *   const responseData = await response.text();
      *   timing.stopWebRequestTimingWithSize(
-     *     axiosResponse.status,
-     *     axiosResponse.statusText,
+     *     response.status,
+     *     response.statusText,
      *     requestData.length,
      *     responseData.length
      *   );
      * } catch (error) {
-     *   timing.stopWebRequestTiming(-1, error.message);
+     *   if (error instanceof Error) {
+     *      timing.stopWebRequestTiming(-1, error.message);
+     *   } else {
+     *      timing.stopWebRequestTiming(-1, (error as any).toString());
+     *   }
      * } finally {
      *   action.leaveAction();
      * }
@@ -1970,5 +2200,5 @@ declare module 'react' {
     }
 }
 
-export { ConfigurationBuilder, DataCollectionLevel, Dynatrace, DynatraceWebRequestTiming, HttpRequestEventBuilder, LogLevel, ManualStartupConfiguration, Platform, UserPrivacyOptions };
+export { ConfigurationBuilder, DataCollectionLevel, Dynatrace, DynatraceWebRequestTiming, EventData, ExceptionEventData, HttpRequestEventData, LogLevel, ManualStartupConfiguration, Platform, SessionPropertyEventData, UserPrivacyOptions };
 export type { IConfiguration, IDynatraceAction, IDynatraceRootAction, IDynatraceWebRequestTiming, IEventModifier, JSONObject };