@dynatrace/react-native-plugin 2.289.1 → 2.291.2

package/typings/react-native-dynatrace.d.ts

@@ -5,16 +5,37 @@
 */
 
 /**
- * Specifying a platform when you want individual behaviour
+ * Specifying a platform when you want individual behaviour and
+ * commands will only be sent to a certain platform.
  */
 export declare enum Platform {
 	/**
-	 * Android Platform
+	 * If set, the command will only be sent to the Android platform.
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
+	 *
+	 * let myAction = Dynatrace.enterAutoAction("MyButton tapped", Platform.Android);
+	 * //Perform the action and whatever else is needed.
+	 * myAction.leaveAction();
+	 * ```
 	 */
 	Android,
 
 	/**
-	 * iOS Platform
+	 * If set, the command will only be sent to the iOS platform.
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
+	 *
+	 * let myAction = Dynatrace.enterAutoAction("MyButton tapped", Platform.Ios);
+	 * //Perform the action and whatever else is needed.
+	 * myAction.leaveAction();
+	 * ```
 	 */
 	Ios
 }
@@ -24,42 +45,114 @@ export declare enum Platform {
  */
 export declare enum LogLevel {
 	/**
-	 * A lot of diagnostic infos will be printed
+	 * With debug log level, a lot of diagnostic infos will be printed by the plugin.
+	 *
+	 * Usage:
+	 *
+	 * - via `dynatrace.config.js` by setting `react.debug` to `true`
+	 * - via code and manual startup by using the `ConfigurationBuilder`:
+	 *
+	 * ```ts
+	 * import { ConfigurationBuilder, Dynatrace, LogLevel } from '@dynatrace/react-native-plugin';
+	 *
+	 * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+	 * await Dynatrace.start(configurationBuilder.withLogLevel(LogLevel.Debug).buildConfiguration());
+	 * ```
 	 */
 	Debug,
 
 	/**
-	 * Only the necessary infos will be printed
+	 * With info log level, only the necessary infos will be printed by the plugin.
+	 *
+	 * Usage:
+	 * 
+	 * By default `LogLevel.Info` is used, so usually setting this property is not needed.
+	 * 
+	 * - via `dynatrace.config.js` by setting `react.debug` to `false`
+	 * - via code and manual startup by using the `ConfigurationBuilder`:
+	 *
+	 * ```ts
+	 * import { ConfigurationBuilder, Dynatrace, LogLevel } from '@dynatrace/react-native-plugin';
+	 *
+	 * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+	 * await Dynatrace.start(configurationBuilder.withLogLevel(LogLevel.Info).buildConfiguration());
+	 * ```
 	 */
 	Info
 }
 
 /**
- * Enum that represents the different privacy levels.
+ * Enum that represents the different privacy levels. Every level decides about the amount of data,
+ * which is actually collected and sent by the agent.
+ * 
+ * Usage:
+ * 
+ * Using `DataCollectionLevel` is only possible when `UserOptIn` was enabled.
+ * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-opt-in-mode
+ * 
+ * General information:
+ * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ * @see https://docs.dynatrace.com/docs/platform-modules/digital-experience/mobile-applications/additional-configuration/configure-rum-privacy-mobile#data-collection-levels
  */
 export declare enum DataCollectionLevel {
 	/**
-	 * @member {DataCollectionLevel} Off  
-	 * @description Native Agent doesn't capture any monitoring data.
+	 * Monitoring data is not sent.
+	 * - No personal data is sent; all identifiers are randomized on every launch.
+	 * - A single Loading <App> event is sent to track the number of users that opted out.
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, Dynatrace, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.Off, false);
+	 * Dynatrace.applyUserPrivacyOptions(privacyConfig);
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ 	 * @see https://docs.dynatrace.com/docs/platform-modules/digital-experience/mobile-applications/additional-configuration/configure-rum-privacy-mobile#data-collection-levels
 	 */
 	Off,
 
 	/**
-	 * @member {DataCollectionLevel} Performance
-	 * @description Native Agent captures only anonymous performance data.
+	 * Only performance, automatically captured data is sent.
+	 * - No personal data is sent; all identifiers are randomized on every launch.
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, Dynatrace, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.Performance, true);
+	 * Dynatrace.applyUserPrivacyOptions(privacyConfig);
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ 	 * @see https://docs.dynatrace.com/docs/platform-modules/digital-experience/mobile-applications/additional-configuration/configure-rum-privacy-mobile#data-collection-levels
 	 */
 	Performance,
 
 	/**
-	 * @deprecated Replaced by UserBehavior
-	 * @member {DataCollectionLevel} User
-	 * @description Native Agent captures both performance and user data.
+	 * @deprecated Replaced by `DataCollectionLevel.UserBehavior`
 	 */
 	User,
 
 	/**
-	 * @member {DataCollectionLevel} UserBehavior
-	 * @description Native Agent captures both performance and user data.
+	 * Performance data and user data is sent.
+	 * - Personal data is sent; OneAgent recognizes and reports users who revisit in the future.
+	 * - If you haven't configured user tagging and custom event or value reporting, the User behavior level works similarly to the Performance level.
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, Dynatrace, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.UserBehavior, true);
+	 * Dynatrace.applyUserPrivacyOptions(privacyConfig);
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ 	 * @see https://docs.dynatrace.com/docs/platform-modules/digital-experience/mobile-applications/additional-configuration/configure-rum-privacy-mobile#data-collection-levels
 	 */
 	UserBehavior,
 }
@@ -78,10 +171,22 @@ export declare interface JSONObject {
 export declare const Dynatrace: {
 	/**
 	 * Starting the React Native plugin and OneAgent for Android or iOS. This method is only necessary
-	 * in case of manual startup and will be ignored in auto startup scenarios. The start method will
+	 * in case of manual startup and should be ignored in auto startup scenarios. The start method will
 	 * set the error handler for reporting crashes and will apply the provided configuration globally.
 	 *
 	 * @param {IConfiguration} configuration Configuration for a manual startup of the plugin
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+	 * // Use several configuration options like withLogLevel(LogLevel.Debug)
+	 * await Dynatrace.start(configurationBuilder.buildConfiguration());
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
 	 */
 	start(configuration: IConfiguration): Promise<void>;
 
@@ -97,22 +202,27 @@ export declare const Dynatrace: {
 	 * @param Component Functional or Class Component
 	 * @param {string} name The name of the Component
 	 * @returns The Component which was wrapped to be monitored
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * export function MyFunctionalComponent(){
+	 * 		// Content of component
+	 * }
+	 *
+	 * Dynatrace.withMonitoring(MyFunctionalComponent, "MyFunctionalComponent");
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#monitor-a-component
 	 */
 	withMonitoring(Component: React.FunctionComponent<any> | React.ComponentClass<any>, name?: string): React.FunctionComponent<any> | React.ComponentClass<any>
 
 	/**
-	 * Creates an Action which will be automatically handled by the plugin. This means that the
-	 * plugin decides about the hierachy of this action. If there is no open action, the following
-	 * action will be a root action. All other actions created by this method, while a root action
-	 * is open, will be automatically inserted as a child action. Furthermore the plugin will automatically
-	 * link webrequest (if they are not tagged manually) to the open root action.
+	 * Reroutes to `Dynatrace.enterAutoAction`
 	 *
 	 * @deprecated Please use either {@link enterAutoAction}, which is doing the same or alternatively {@link enterManualAction}.
-	 *
-	 * @param {string} name Name of the action, which will be created. This name must not be empty.
-	 * @param {Platform} platform Optional, which means this call will be applied on both platforms (Android & iOS).
-	 * @returns {IDynatraceAction} Action that is created. If name was empty a NullAction will be provided, which will act as normal action,
-	 * but has no functionality.
 	 */
 	enterAction(name: string, platform?: Platform): IDynatraceAction;
 
@@ -127,6 +237,18 @@ export declare const Dynatrace: {
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
 	 * @returns {IDynatraceRootAction} Action that is created. If name was empty a NullRootAction will be provided,
 	 * which will act as normal root action, but has no functionality.
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * let myAction = Dynatrace.enterManualAction("MyButton tapped");
+	 * // Perform the action and whatever else is needed.
+	 * myAction.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#create-custom-actions
 	 */
 	enterManualAction(name: string, platform?: Platform): IDynatraceRootAction;
 
@@ -141,6 +263,18 @@ export declare const Dynatrace: {
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
 	 * @returns {IDynatraceAction} Action that is created. If name was empty a NullAction will be provided,
 	 * which will act as normal action, but has no functionality.
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * let myAction = Dynatrace.enterAutoAction("MyButton tapped");
+	 * // Perform the action and whatever else is needed.
+	 * myAction.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#create-custom-actions
 	 */
 	enterAutoAction(name: string, platform?: Platform): IDynatraceAction;
 
@@ -149,6 +283,16 @@ export declare const Dynatrace: {
 	 * closed and sent to the server.
 	 *
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.endSession();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#end-the-current-user-session
 	 */
 	endSession(platform?: Platform): void;
 
@@ -159,6 +303,16 @@ export declare const Dynatrace: {
 	 * @param {string} user a unique id that allows you to identify the current user.
 	 * If user is null or empty, then the user tag will be removed from the session.
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.identifyUser('User');
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#identify-a-user
 	 */
 	identifyUser(user: string, platform?: Platform): void;
 
@@ -168,6 +322,16 @@ export declare const Dynatrace: {
 	 * @param {Number} latitude latitude data of the position
 	 * @param {Number} longitude longitude data of the position
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.setGPSLocation(48.31518732698596, 14.305245274594471);
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#report-gps-location
 	 */
 	setGPSLocation(latitude: Number, longitude: Number, platform?: Platform): void;
 
@@ -177,6 +341,15 @@ export declare const Dynatrace: {
 	 * Using this function, you can force sending of all collected events regardless of their age.
 	 *
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.flushEvents();
+	 * ```
+	 *
 	 */
 	flushEvents(platform?: Platform): void;
 
@@ -232,6 +405,15 @@ export declare const Dynatrace: {
 	 *
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
 	 * @returns {Promise<UserPrivacyOptions>} current user privacy options
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * let privacyOptions = await Dynatrace.getUserPrivacyOptions();
+	 * ```
+	 *
 	 */
 	getUserPrivacyOptions(platform?: Platform): Promise<UserPrivacyOptions>;
 
@@ -242,6 +424,16 @@ export declare const Dynatrace: {
 	 *
 	 * @param {UserPrivacyOptions} userPrivacyOptions the new privacy settings from the user
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, Dynatrace, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.applyUserPrivacyOptions(new UserPrivacyOptions(DataCollectionLevel.Performance, true));
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
 	 */
 	applyUserPrivacyOptions(userPrivacyOptions: UserPrivacyOptions, platform?: Platform): void;
 
@@ -251,6 +443,16 @@ export declare const Dynatrace: {
 	 * @param {string} errorName Name of the error event
 	 * @param {number} errorCode The code of the error
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.reportError("Page not found", 404);
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#report-values
 	 */
 	reportError(errorName: string, errorCode: number, platform?: Platform): void;
 
@@ -274,6 +476,16 @@ export declare const Dynatrace: {
 	 * @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).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.reportErrorStacktrace("Error Name", "Error Value", "Reason", "Stacktrace");
+	 * ```
+	 *
+	 * @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;
 
@@ -284,6 +496,16 @@ export declare const Dynatrace: {
 	 * @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).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.reportCrash("Crash Name", "Reason", "Stacktrace");
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manually-report-a-crash
 	 */
 	reportCrash(crashName: string, reason: string, stacktrace: string, platform?: Platform): void;
 
@@ -293,6 +515,16 @@ export declare const Dynatrace: {
 	 * @param {string} crashName Name of the crash
 	 * @param {Error} crash error object
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.reportCrashWithException("Crash Name", error);
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manually-report-a-crash
 	 */
 	reportCrashWithException(crashName: string, crash: Error, platform?: Platform);
 
@@ -303,6 +535,18 @@ export declare const Dynatrace: {
 	 *
 	 * @param {Map<string, string>} headers a set of http headers
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const beaconHeaders = new Map<string, string>();
+	 * beaconHeaders.set('headerName', 'headerValue');
+	 * Dynatrace.setBeaconHeaders(beaconHeaders);
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#setting-beacon-headers
 	 */
 	setBeaconHeaders(headers?: Map<string, string> | null, platform?: Platform): void;
 
@@ -324,66 +568,165 @@ export declare const Dynatrace: {
 	 * The resulting event will be populated with attributes parameter,
 	 * and enriched with additional properties, thus also empty objects are valid.
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace, JSONObject } from '@dynatrace/react-native-plugin';
+	 *
+	 * Dynatrace.sendBizEvent('type', { custom : 123 });
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#business-event-capturing
 	 */
 	 sendBizEvent(type: string, attributes?: JSONObject, platform?: Platform): void;
 }
 
 export declare interface IDynatraceAction {
 	/**
-	 * Report an error
+	 * Reports an error as key-value pair with the time at which it occurred.
+	 * This event can be used to report error codes.
 	 *
 	 * @param {string} errorName Name of the error event
 	 * @param {number} errorCode The code of the error
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * action.reportError("Page Not Found", 404);
+	 * action.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#report-values
 	 */
 	reportError(errorName: string, errorCode: number, platform?: Platform): void;
 
 	/**
-	 * Report an event
+	 * Reports the time when a specific event occurred. This event can be used to determine when a user passed
+	 * through a specific part of your application. The reportEvent method is a simple way to track user
+	 * behavior in your application.
 	 *
-	 * @param {string} eventName Name of the event
-	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 * @param eventName Name of the event
+	 * @param platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * action.reportEvent("Event Name");
+	 * action.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#report-values
 	 */
 	reportEvent(eventName: string, platform?: Platform): void;
 
 	/**
-	 * Report a string value
+	 * Reports a key-value pair with the time at which this event occurred. This event can be used to report
+	 * important measurement data.
 	 *
 	 * @param {string} valueName Name of the value
 	 * @param {string} value The string value
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * action.reportStringValue("Value Name", "Value");
+	 * action.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#report-values
 	 */
 	reportStringValue(valueName: string, value: string, platform?: Platform): void;
 
 	/**
-	 * Report a int value
+	 * Reports a key-value pair with the time at which this event occurred. This event can be used to report
+	 * important measurement data.
 	 *
-	 * @param {string} valueName Name of the value
-	 * @param {number} value The int value
-	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 * @param valueName Name of the value
+	 * @param value Integer value
+	 * @param platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * action.reportIntValue("Value Name", 123);
+	 * action.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#report-values
 	 */
 	reportIntValue(valueName: string, value: number, platform?: Platform): void;
 
 	/**
-	 * Report a double value
+	 * Reports a key-value pair with the time at which this event occurred. This event can be used to report
+	 * important measurement data.
 	 *
-	 * @param {string} valueName Name of the value
-	 * @param {number} value The double value
-	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 * @param valueName Name of the value
+	 * @param value Double value
+	 * @param platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * action.reportDoubleValue("Value Name", 123.123);
+	 * action.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#report-values
 	 */
 	reportDoubleValue(valueName: string, value: number, platform?: Platform): void;
 
 	/**
-	 * Leave action
+	 * Completes this action and prepares the data for the next sending interval.
+	 * When an outer/parent action is exited, all nested/child actions are automatically closed.
 	 *
-	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 * @param platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * action.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#create-custom-actions
 	 */
 	leaveAction(platform?: Platform): void;
 
 	/**
-	 * Cancel action
+	 * Cancels this action and discards all associated data
 	 *
-	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 * @param platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * action.cancelAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#cancel-actions
 	 */
 	cancel(platform?: Platform): void;
 
@@ -394,15 +737,43 @@ export declare interface IDynatraceAction {
 	 *
 	 * @param {string} url URL that you want to track
 	 * @returns {Promise<string>} header tag which should be applied onto the request
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * const requestTag = await action.getRequestTag("http://dynatrace.com");
+	 * // Attach requestTag as x-dynatrace header to a request
+	 *
+	 * action.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
 	 */
 	 getRequestTag(url: string): Promise<string>;
 
-	 /**
-	  * If you want to manually link a web request with an action this is 
-	  * the name of the header you need to set.
-	  * 
-	  * @returns {string} name of the header that should be used for tagging a request
-	  */
+	/**
+	 * If you want to manually link a web request with an action this is
+	 * the name of the header you need to set.
+	 *
+	 * @returns {string} name of the header that should be used for tagging a request
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const action = Dynatrace.enterAutoAction("Action Name");
+	 * const requestTagHeader = await action.getRequestTagHeader();
+	 * // Use requestTagHeader as header name
+	 *
+	 * action.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
+	 */
 	 getRequestTagHeader(): string;
 }
 
@@ -417,6 +788,21 @@ export declare interface IDynatraceRootAction extends IDynatraceAction {
 	 * @param {string} actionName - name of action
 	 * @param {Platform} platform Is optional, which means by default this call will be applied on both platforms (Android & iOS).
 	 * @return {IDynatraceAction} created action
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const parentAction = Dynatrace.enterManualAction("Parent Action Name");
+	 * const childAction = parentAction.enterAction("Child Action Name");
+	 * // Do something with actions
+	 *
+	 * childAction.leaveAction();
+	 * parentAction.leaveAction();
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#create-custom-sub-actions
 	 */
 	 enterAction(name: string, platform?: Platform): IDynatraceAction;
 }
@@ -425,16 +811,34 @@ export declare interface IDynatraceRootAction extends IDynatraceAction {
  * The Web request timing interface which can be used to measure a web request manually
  */
  export declare interface IDynatraceWebRequestTiming {
-
-	/**
-	 * Constructor for creating a DynatraceWebRequestTiming
-	 * @param {string} requestTag Request Tag for the action to be linked to
-	 * @param {string} url URL that should be linked
-	 */
-	constructor(requestTag: string, url: string);
-
 	/**
 	 * Start the measurment of the web request. Call this before the request is started.
+	 *
+	 * Usage (with Axios example):
+	 *
+	 * ```ts
+	 * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+	 *
+	 * const action = Dynatrace.enterManualAction("Manual Web Request");
+	 * const tag = await action.getRequestTag(url);
+	 * const timing = new DynatraceWebRequestTiming(url, tag);
+	 *
+	 * try {
+	 * 	timing.startWebRequestTiming();
+	 * 	const axiosResponse = await axios.get(url, {
+	 * 		headers: {
+	 * 			timing.getRequestTagHeader(): tag
+	 * 		}
+	 * 	});
+	 * 	timing.stopWebRequestTiming(axiosResponse.status, axiosResponse.data);
+	 * } catch (error) {
+	 * 	timing.stopWebRequestTiming(-1, error);
+	 * } finally {
+	 * 	action.leaveAction();
+	 * }
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
 	 */
 	startWebRequestTiming(): void;
 
@@ -444,13 +848,91 @@ export declare interface IDynatraceRootAction extends IDynatraceAction {
 	 *
 	 * @param {number} responseCode Status Code of the response e.g. 200
 	 * @param {string} responseMessage Message of the response
+	 *
+	 * Usage (with Axios example):
+	 *
+	 * ```ts
+	 * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+	 * 
+	 * const action = Dynatrace.enterManualAction("Manual Web Request");
+	 * const tag = await action.getRequestTag(url);
+	 * const timing = new DynatraceWebRequestTiming(url, tag);
+	 *
+	 * try {
+	 * 	timing.startWebRequestTiming();
+	 * 	const axiosResponse = await axios.get(url, {
+	 * 		headers: {
+	 * 			timing.getRequestTagHeader(): tag
+	 * 		}
+	 * 	});
+	 * 	timing.stopWebRequestTiming(axiosResponse.status, axiosResponse.data);
+	 * } catch (error) {
+	 * 	timing.stopWebRequestTiming(-1, error);
+	 * } finally {
+	 * 	action.leaveAction();
+	 * }
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
 	 */
 	stopWebRequestTiming(responseCode: number, responseMessage: string): void;
 
+	/**
+     * Stops the measurment of the web request. This needs to be called after the request is executed.
+     * The responseCode and responseMessage will be transfered and shown in the web UI.
+     *
+     * @param {number} responseCode Status Code of the response e.g. 200
+     * @param {string} responseMessage Message of the response
+     * @param requestSize Request size
+     * @param responseSize Response size
+     *
+     * Usage (with Axios example):
+     *
+     * ```ts
+     * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+     *
+     * const action = Dynatrace.enterManualAction("Manual Web Request");
+     * const tag = await action.getRequestTag(url);
+     * const timing = new DynatraceWebRequestTiming(url, tag);
+     *
+     * try {
+     * 	timing.startWebRequestTiming();
+     * 	const axiosResponse = await axios.get(url, {
+     * 		headers: {
+     * 			timing.getRequestTagHeader(): tag
+     * 		}
+     * 	});
+     * 	timing.stopWebRequestTimingWithSize(axiosResponse.status, axiosResponse.data, 122, 63);
+     * } catch (error) {
+     * 	timing.stopWebRequestTiming(-1, error);
+     * } finally {
+     * 	action.leaveAction();
+     * }
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
+     */
+    stopWebRequestTimingWithSize(responseCode: number, responseMessage: string, requestSize: number, responseSize: number): void;
+
 	/**
 	 * Returns the content for the header that is needed in order to track a request
 	 *
 	 * @returns {string} header tag which should be applied onto the request
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+	 * 
+	 * const action = Dynatrace.enterManualAction("Manual Web Request");
+	 * const tag = await action.getRequestTag(url);
+	 * const timing = new DynatraceWebRequestTiming(url, tag);
+	 *
+	 * // Printing the same tag which was used as input for DynatraceWebRequestTiming
+	 * console.log(timing.getRequestTag());
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
 	 */
 	getRequestTag(): string;
 
@@ -458,6 +940,21 @@ export declare interface IDynatraceRootAction extends IDynatraceAction {
 	 * Returns the name for the header that is needed in order to track a request
 	 *
 	 * @returns {string} name of the header that should be used for tagging a request
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+	 *
+	 * const action = Dynatrace.enterManualAction("Manual Web Request");
+	 * const tag = await action.getRequestTag(url);
+	 * const timing = new DynatraceWebRequestTiming(url, tag);
+	 *
+	 * // Printing the header name
+	 * console.log(timing.getRequestTagHeader());
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
 	 */
 	getRequestTagHeader(): string;
 
@@ -466,17 +963,70 @@ export declare interface IDynatraceRootAction extends IDynatraceAction {
 /**
  * Class which gives you the option to measure a web request
  */
-export declare class DynatraceWebRequestTiming {
+export declare class DynatraceWebRequestTiming implements IDynatraceWebRequestTiming{
 
 	/**
-	 * Constructor for creation of a Web Request Timing object
-	 * @param {string} requestTag The request tag used for the timing object.
-	 * @param {string} url The URL of the request that is tagged and timed.
+	 * Constructor for creating a DynatraceWebRequestTiming
+	 *
+	 * @param {string} requestTag Request Tag for the action to be linked to
+	 * @param {string} url URL that should be linked
+	 *
+	 * Usage (with Axios example):
+	 *
+	 * ```ts
+	 * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+	 * 
+	 * const action = Dynatrace.enterManualAction("Manual Web Request");
+	 * const tag = await action.getRequestTag(url);
+	 * const timing = new DynatraceWebRequestTiming(url, tag);
+	 *
+	 * try {
+	 * 	timing.startWebRequestTiming();
+	 * 	const axiosResponse = await axios.get(url, {
+	 * 		headers: {
+	 * 			timing.getRequestTagHeader(): tag
+	 * 		}
+	 * 	});
+	 * 	timing.stopWebRequestTiming(axiosResponse.status, axiosResponse.data);
+	 * } catch (error) {
+	 * 	timing.stopWebRequestTiming(-1, error);
+	 * } finally {
+	 * 	action.leaveAction();
+	 * }
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
 	 */
     constructor(requestTag: string, url: string);
 
 	/**
      * Start the measurment of the web request. Call this before the request is started.
+     *
+     * Usage (with Axios example):
+     *
+     * ```ts
+     * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+     *
+     * const action = Dynatrace.enterManualAction("Manual Web Request");
+     * const tag = await action.getRequestTag(url);
+     * const timing = new DynatraceWebRequestTiming(url, tag);
+     *
+     * try {
+     * 	timing.startWebRequestTiming();
+     * 	const axiosResponse = await axios.get(url, {
+     * 		headers: {
+     * 			timing.getRequestTagHeader(): tag
+     * 		}
+     * 	});
+     * 	timing.stopWebRequestTiming(axiosResponse.status, axiosResponse.data);
+     * } catch (error) {
+     * 	timing.stopWebRequestTiming(-1, error);
+     * } finally {
+     * 	action.leaveAction();
+     * }
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
      */
     startWebRequestTiming(): void;
 
@@ -486,21 +1036,114 @@ export declare class DynatraceWebRequestTiming {
      *
      * @param {number} responseCode Status Code of the response e.g. 200
      * @param {string} responseMessage Message of the response
+     *
+     * Usage (with Axios example):
+     *
+     * ```ts
+     * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+     *
+     * const action = Dynatrace.enterManualAction("Manual Web Request");
+     * const tag = await action.getRequestTag(url);
+     * const timing = new DynatraceWebRequestTiming(url, tag);
+     *
+     * try {
+     * 	timing.startWebRequestTiming();
+     * 	const axiosResponse = await axios.get(url, {
+     * 		headers: {
+     * 			timing.getRequestTagHeader(): tag
+     * 		}
+     * 	});
+     * 	timing.stopWebRequestTiming(axiosResponse.status, axiosResponse.data);
+     * } catch (error) {
+     * 	timing.stopWebRequestTiming(-1, error);
+     * } finally {
+     * 	action.leaveAction();
+     * }
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
      */
     stopWebRequestTiming(responseCode: number, responseMessage: string): void;
 
 	/**
-     * Returns the content for the header that is needed in order to track a request
+     * Stops the measurment of the web request. This needs to be called after the request is executed.
+     * The responseCode and responseMessage will be transfered and shown in the web UI.
+     *
+     * @param {number} responseCode Status Code of the response e.g. 200
+     * @param {string} responseMessage Message of the response
+     * @param requestSize Request size
+     * @param responseSize Response size
+     *
+     * Usage (with Axios example):
+     *
+     * ```ts
+     * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+     *
+     * const action = Dynatrace.enterManualAction("Manual Web Request");
+     * const tag = await action.getRequestTag(url);
+     * const timing = new DynatraceWebRequestTiming(url, tag);
      *
-     * @returns {string} header tag which should be applied onto the request
+     * try {
+     * 	timing.startWebRequestTiming();
+     * 	const axiosResponse = await axios.get(url, {
+     * 		headers: {
+     * 			timing.getRequestTagHeader(): tag
+     * 		}
+     * 	});
+     * 	timing.stopWebRequestTimingWithSize(axiosResponse.status, axiosResponse.data, 122, 63);
+     * } catch (error) {
+     * 	timing.stopWebRequestTiming(-1, error);
+     * } finally {
+     * 	action.leaveAction();
+     * }
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
      */
+    stopWebRequestTimingWithSize(responseCode: number, responseMessage: string, requestSize: number, responseSize: number): void;
+
+	/**
+	 * Returns the content for the header that is needed in order to track a request
+	 *
+	 * @returns {string} header tag which should be applied onto the request
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+	 * 
+	 * const action = Dynatrace.enterManualAction("Manual Web Request");
+	 * const tag = await action.getRequestTag(url);
+	 * const timing = new DynatraceWebRequestTiming(url, tag);
+	 *
+	 * // Printing the same tag which was used as input for DynatraceWebRequestTiming
+	 * console.log(timing.getRequestTag());
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
+	 */
     getRequestTag(): string;
 
 	/**
-     * Returns the name for the header that is needed in order to track a request
-     *
-     * @returns {string} name of the header that should be used for tagging a request
-     */
+	 * Returns the name for the header that is needed in order to track a request
+	 *
+	 * @returns {string} name of the header that should be used for tagging a request
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin'
+	 * 
+	 * const action = Dynatrace.enterManualAction("Manual Web Request");
+	 * const tag = await action.getRequestTag(url);
+	 * const timing = new DynatraceWebRequestTiming(url, tag);
+	 *
+	 * // Printing the header name
+	 * console.log(timing.getRequestTagHeader());
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#manual-web-request-tagging
+	 */
     getRequestTagHeader(): string;
 }
 
@@ -513,35 +1156,89 @@ export declare class UserPrivacyOptions {
 	 * Constructor for creation of a privacy settings object
 	 * @param {DataCollectionLevel} dataCollectionLevel Data collection level.
 	 * @param {boolean} crashReportingOptedIn If crash reporting should be enabled.
-	 */
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.Off, false);
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ 	 */
 	constructor(dataCollectionLevel: DataCollectionLevel, crashReportingOptedIn: boolean);
 
 	/**
 	 * Returns the specified data collection level.
-	 * 
+	 *
 	 * @returns {DataCollectionLevel} the specified data collection level
-	 */
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.Off, false);
+	 * const dataCollectionLevel = privacyConfig.dataCollectionLevel;
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ 	 */
 	get dataCollectionLevel(): DataCollectionLevel;
 
 	/**
 	 * Sets the data collection level specified by the user.
 	 *
 	 * @param {DataCollectionLevel} dataCollectionLevel the specified data collection level from the user
-	 */
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.Off, false);
+	 * privacyConfig.dataCollectionLevel = DataCollectionLevel.Performance;
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ 	 */
 	set dataCollectionLevel(dataCollectionLevel: DataCollectionLevel);
 
 	/**
 	 * Returns the opt-in value for crash reporting.
 	 *
 	 * @return {boolean} the opt-in value for crash reporting
-	 */
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.Off, false);
+	 * const crashReporting = privacyConfig.crashReportingOptedIn;
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ 	 */
 	get crashReportingOptedIn(): boolean;
 
 	/**
 	 * Sets the privacy setting for crash reporting.
 	 *
 	 * @param {boolean} crashReportingOptedIn the opt-in value specified by the user
-	 */
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+	 *
+	 * const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.Off, false);
+	 * privacyConfig.crashReportingOptedIn = true;
+	 * ```
+	 *
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#user-privacy-options
+ 	 */
 	set crashReportingOptedIn(crashReportingOptedIn: boolean);
 }
 
@@ -737,67 +1434,184 @@ export declare class ConfigurationBuilder {
 	 * 
 	 * @param {string} beaconUrl Identifies your environment within Dynatrace. This property is mandatory for manual startup
 	 * @param {string} applicationId Identifies your mobile app. This property is mandatory for manual startup
+	 *
+	 * Usage:
+	 *
+	 * ```ts
+	 * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+	 *
+	 * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+	 * Dynatrace.start(configurationBuilder.buildConfiguration());
+	 * ```
+	 * 
+	 * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
 	 */
 	constructor(beaconUrl: string, applicationId: string);
 
 	/**
-	 * Builder function to handle crash reporting property
-	 *
-	 * @param {boolean} reportCrash Allows reporting React Native crashes.     
-	 */
+     * Builder function to handle crash reporting property. By default this is true. Usually
+	 * this API only needs to be called in case you want to use `withCrashReporting(false)`.
+     *
+     * @param {boolean} reportCrash Allows reporting React Native crashes.
+     *
+     * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.withCrashReporting(true).buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
 	public withCrashReporting(reportCrash: boolean): ConfigurationBuilder;
 
 	/**
-	 * Builder function to handle error handler property
+	 * Builder function to handle error handler property. By default this is true. Usually
+	 * this API only needs to be called in case you want to use `withErrorHandler(false)`.
 	 *
 	 * @param {boolean} errorHandler Allows you to enable or disable the Dynatrace React Native error handler.   
-	 */
+	 *
+     * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.withErrorHandler(true).buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
 	public withErrorHandler(errorHandler: boolean): ConfigurationBuilder;
 
 	/**
-	 * Builder function to handle preventing crash property
+	 * Builder function to handle preventing crash property. By default this is true. Usually
+	 * this API only needs to be called in case you want to use `withReportFatalErrorAsCrash(false)`.
 	 *
-	 * @param {boolean} reportFatalErrorAsCrash If you want to report a fatal error as an error and not as a crash, set this to false.     
-	 */
+	 * @param {boolean} reportFatalErrorAsCrash If you want to report a fatal error as an error and not as a crash, set this to false.    
+	 *
+	 * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.withReportFatalErrorAsCrash(true).buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
     public withReportFatalErrorAsCrash(reportFatalErrorAsCrash: boolean): ConfigurationBuilder;
 
 	/**
-	 * Builder function to handle loglevel property
+	 * Builder function to handle loglevel property. By default this is LogLevel.Info. Usually
+	 * this API only needs to be called in case you want to use `withLogLevel(LogLevel.Debug)`.
 	 *
 	 * @param {LogLevel} logLevel Allows you to choose between `LogLevel.Info` and `LogLevel.Debug`. Debug returns more logs. This is especially important when something is not functioning correctly.
-	 */
+	 *
+	 * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace, LogLevel } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.withLogLevel(LogLevel.Debug).buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
 	public withLogLevel(logLevel: LogLevel): ConfigurationBuilder;
 
 	/**
-	 * Builder function to handle lifecycle update property
+	 * Builder function to handle lifecycle update property. By default this is false. Usually
+	 * this API only needs to be called in case you want to use `withLifecycleUpdate(true)`.
 	 *
 	 * @param {boolean} lifecycleUpdate Decide if you want to see update cycles on lifecycle actions as well. This is per default false as it creates a lot more actions.
-	 */
+	 *
+	 * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.withLifecycleUpdate(false).buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
 	public withLifecycleUpdate(lifecycleUpdate: boolean): ConfigurationBuilder
 
 	/**
-	 * Builder function to handle user opt in property
+	 * Builder function to handle user opt in property. By default this is false. Usually
+	 * this API only needs to be called in case you want to use `withUserOptIn(true)`.
 	 *
 	 * @param {boolean} userOptIn Activates the privacy mode when set to `true`. User consent must be queried and set.
-	 */
+	 *
+	 * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.withUserOptIn(true).buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
 	public withUserOptIn(userOptIn: boolean): ConfigurationBuilder;
 
 	/**
-	 * Builder function to handle action name privacy property
-	 * 
+	 * Builder function to handle action name privacy property. By default this is false. Usually
+	 * this API only needs to be called in case you want to use `withActionNamePrivacy(true)`.
+	 *
 	 * @param {boolean} actionNamePrivacy Activates a privacy mode especially for Touchables and Buttons. Setting this option to true means that a name for the control will no longer be shown, e.g. "Touch on Button". When setting a dtActionName onto the component this setting will be ignored.
-	 */
+	 *
+	 * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.withActionNamePrivacy(true).buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
 	public withActionNamePrivacy(actionNamePrivacy: boolean): ConfigurationBuilder;
 
 	/**
 	 * Builder function to handle bundle name property
 	 *
 	 * @param {string} bundleName Will define the bundle name which will prefix internal action ids.
-	 */
+	 *
+	 * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.withBundleName("bundleName").buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
 	public withBundleName(bundleName: string): ConfigurationBuilder;
 
 	/**
 	 * Build configuration which is used for startup
-	 */
+	 *
+	 * Usage:
+     *
+     * ```ts
+     * import { ConfigurationBuilder, Dynatrace } from '@dynatrace/react-native-plugin';
+     *
+     * const configurationBuilder = new ConfigurationBuilder("beaconUrl", "applicationId");
+     * Dynatrace.start(configurationBuilder.buildConfiguration());
+     * ```
+     *
+     * @see https://www.npmjs.com/package/@dynatrace/react-native-plugin#plugin-startup
+     */
 	public buildConfiguration(): IConfiguration;
 }