react-native-applovin-max 9.0.0 → 9.2.0

package/src/nativeAd/NativeAdView.tsx

@@ -1,3 +1,8 @@
+/**
+ * Provides the NativeAdView component, which manages loading and rendering of native ads using the
+ * AppLovin MAX SDK in React Native.
+ */
+
 import * as React from 'react';
 import { forwardRef, useContext, useImperativeHandle, useRef, useState, useEffect, useCallback } from 'react';
 import { findNodeHandle, View } from 'react-native';
@@ -11,8 +16,7 @@ import type { NativeAdViewHandler, NativeAdViewProps } from '../types/NativeAdVi
 import { makeExtraParametersArray, makeLocalExtraParametersArray } from '../Utils';
 
 /**
- * The {@link NativeAdView} component that you use building a native ad. This loads a native ad and
- * renders it with the asset views:
+ * The {@link NativeAdView} component renders a native ad and binds it to asset views:
  *
  * - {@link IconView}
  * - {@link TitleView}
@@ -22,19 +26,21 @@ import { makeExtraParametersArray, makeLocalExtraParametersArray } from '../Util
  * - {@link MediaView}
  * - {@link CallToActionView}
  *
- * {@link NativeAdView} fills each asset view with the data of a native ad as soon as it loads the native
- * ad, but you need to provide the layout and style of the asset views.
- * {@link NativeAdView} can reload a new native ad by using the ref handler.
+ * Each asset view must be manually laid out and styled.
+ * The component automatically populates content once an ad is loaded.
+ * You can reload the ad using the component’s ref via `loadAd()`.
+ *
+ * **Note:** The AppLovin SDK must be initialized before using this component.
  *
  * ### Example:
- * ```js
+ * ```tsx
  * <NativeAdView
  *   ref={nativeAdViewHandler}
  *   adUnitId={adUnitId}
  *   style={styles.nativead}
  *   onAdLoaded={(adInfo: AdInfo) => { ... }}
  * >
- *   <View style={ ... }>
+ *   <View style={...}>
  *     <IconView style={styles.icon} />
  *     <TitleView style={styles.title} />
  *     <AdvertiserView style={styles.advertiser} />
@@ -46,6 +52,9 @@ import { makeExtraParametersArray, makeLocalExtraParametersArray } from '../Util
  *   </View>
  * </NativeAdView>
  * ```
+ *
+ * For a complete implementation example, see:
+ * https://github.com/AppLovin/AppLovin-MAX-React-Native/blob/master/example/src/NativeAdViewExample.tsx
  */
 export const NativeAdView = forwardRef<NativeAdViewHandler, NativeAdViewProps & ViewProps>(function NativeAdView(props, ref) {
     const [isInitialized, setIsInitialized] = useState<boolean>(false);
@@ -72,21 +81,13 @@ export const NativeAdView = forwardRef<NativeAdViewHandler, NativeAdViewProps &
     );
 });
 
+/**
+ * Extracts native ad info from a synthetic event and invokes the provided callback, if any.
+ * Ensures optional native ad fields have fallback defaults.
+ */
 const handleNativeAdViewEvent = <T extends AdInfoEvent | AdLoadFailedEvent>(event: NativeSyntheticEvent<T>, callback?: (adInfo: T) => void) => {
     if (!callback) return;
-
-    let adInfo: any = { ...event.nativeEvent };
-
-    if ('nativeAd' in event.nativeEvent) {
-        adInfo.nativeAd = {
-            ...event.nativeEvent.nativeAd,
-            isIconImageAvailable: event.nativeEvent.nativeAd?.isIconImageAvailable ?? false,
-            isOptionsViewAvailable: event.nativeEvent.nativeAd?.isOptionsViewAvailable ?? false,
-            isMediaViewAvailable: event.nativeEvent.nativeAd?.isMediaViewAvailable ?? false,
-        };
-    }
-
-    callback(adInfo);
+    callback(event.nativeEvent);
 };
 
 const NativeAdViewImpl = forwardRef<NativeAdViewHandler, NativeAdViewProps & ViewProps>(function NativeAdViewImpl(
@@ -98,13 +99,16 @@ const NativeAdViewImpl = forwardRef<NativeAdViewHandler, NativeAdViewProps & Vie
 
     const nativeAdViewRef = useRef<React.ElementRef<typeof NativeAdViewComponent> | undefined>();
 
-    // Load a new ad
+    // Triggers a native ad load via the native command
     const loadAd = useCallback(() => {
         nativeAdViewRef.current && Commands.loadAd(nativeAdViewRef.current);
     }, []);
 
     useImperativeHandle(ref, () => ({ loadAd }), [loadAd]);
 
+    /**
+     * Updates the native asset view binding for a given view type (e.g., TitleView, MediaView).
+     */
     const updateAssetView = useCallback((assetViewRef: React.RefObject<View>, type: string) => {
         if (!nativeAdViewRef.current || !assetViewRef.current) return;
 
@@ -114,6 +118,12 @@ const NativeAdViewImpl = forwardRef<NativeAdViewHandler, NativeAdViewProps & Vie
         }
     }, []);
 
+    /**
+     * Handles native ad load event:
+     * - Updates context with the new native ad data
+     * - Notifies native module of updated asset view mappings
+     * - Triggers native rendering after all asset views are registered
+     */
     const onAdLoadedEvent = useCallback(
         (event: NativeSyntheticEvent<AdInfoEvent>) => {
             const nativeAdImpl = event.nativeEvent.nativeAdImpl;

package/src/nativeAd/NativeAdViewComponents.tsx

@@ -1,9 +1,28 @@
+/**
+ * Provides pre-styled React Native components for each native ad asset view:
+ *
+ * - TitleView
+ * - AdvertiserView
+ * - BodyView
+ * - CallToActionView
+ * - IconView
+ * - OptionsView
+ * - MediaView
+ * - StarRatingView
+ *
+ * Each component pulls ad content and view refs from NativeAdView context,
+ * and must be rendered inside a {@link NativeAdView}.
+ */
+
 import * as React from 'react';
 import { useContext, useMemo } from 'react';
 import { Text, Image, View, TouchableOpacity, StyleSheet, Platform } from 'react-native';
-import type { ViewProps, ImageProps, TextStyle, TextProps } from 'react-native';
+import type { ViewProps, ImageProps, TextProps } from 'react-native';
 import { NativeAdViewContext } from './NativeAdViewProvider';
 
+/**
+ * Renders the native ad’s title.
+ */
 export const TitleView = (props: TextProps) => {
     const { titleRef, nativeAd } = useContext(NativeAdViewContext);
     return (
@@ -13,6 +32,9 @@ export const TitleView = (props: TextProps) => {
     );
 };
 
+/**
+ * Renders the advertiser name.
+ */
 export const AdvertiserView = (props: TextProps) => {
     const { advertiserRef, nativeAd } = useContext(NativeAdViewContext);
     return (
@@ -22,6 +44,9 @@ export const AdvertiserView = (props: TextProps) => {
     );
 };
 
+/**
+ * Renders the ad’s body text (description).
+ */
 export const BodyView = (props: TextProps) => {
     const { bodyRef, nativeAd } = useContext(NativeAdViewContext);
     return (
@@ -31,31 +56,39 @@ export const BodyView = (props: TextProps) => {
     );
 };
 
+/**
+ * Renders the call-to-action label.
+ * On iOS, wraps the text with a TouchableOpacity for better click behavior.
+ */
 export const CallToActionView = (props: TextProps) => {
     const { callToActionRef, nativeAd } = useContext(NativeAdViewContext);
-    // TouchableOpacity disables clicking on certain Android devices.
+
     if (Platform.OS === 'android') {
         return (
             <Text {...props} ref={callToActionRef}>
                 {nativeAd.callToAction ?? ''}
             </Text>
         );
-    } else {
-        return (
-            <TouchableOpacity>
-                <Text {...props} ref={callToActionRef}>
-                    {nativeAd.callToAction ?? ''}
-                </Text>
-            </TouchableOpacity>
-        );
     }
+
+    return (
+        <TouchableOpacity>
+            <Text {...props} ref={callToActionRef}>
+                {nativeAd.callToAction ?? ''}
+            </Text>
+        </TouchableOpacity>
+    );
 };
 
+/**
+ * Renders the icon image for the native ad.
+ * Falls back to a blank placeholder if not available.
+ */
 export const IconView = (props: Omit<ImageProps, 'source'>) => {
     const { imageRef, nativeAd } = useContext(NativeAdViewContext);
     const defaultIcon = require('./img/blank_icon.png');
 
-    const imageSource = (() => {
+    const imageSource = useMemo(() => {
         if (nativeAd?.url) {
             return { uri: nativeAd.url };
         }
@@ -63,60 +96,86 @@ export const IconView = (props: Omit<ImageProps, 'source'>) => {
             return { uri: `data:image/jpeg;base64,${nativeAd.imageSource}` };
         }
         return defaultIcon;
-    })();
+    }, [nativeAd.url, nativeAd.imageSource, defaultIcon]);
 
     return <Image {...props} ref={imageRef} source={imageSource} />;
 };
 
+/**
+ * Renders the native ad’s options view.
+ */
 export const OptionsView = (props: ViewProps) => {
     const { optionViewRef } = useContext(NativeAdViewContext);
     return <View {...props} ref={optionViewRef} />;
 };
 
+/**
+ * Renders the native ad’s media content.
+ */
 export const MediaView = (props: ViewProps) => {
     const { mediaViewRef } = useContext(NativeAdViewContext);
     return <View {...props} ref={mediaViewRef} />;
 };
 
-export const StarRatingView = (props: ViewProps) => {
-    const { style, ...restProps } = props;
-    const maxStarCount = 5;
-    const starTextStyle = useMemo(() => StyleSheet.flatten(style) as TextStyle, [style]);
-    const starColor = starTextStyle.color ?? '#ffe234';
-    const starSize = starTextStyle.fontSize ?? 10;
+/**
+ * Props for the {@link StarRatingView} component, which displays a star rating
+ * using Unicode stars (★ and ☆) styled with color, shadow, and size.
+ */
+type StarRatingViewProps = ViewProps & {
+    /**
+     * The color used for filled (active) stars.
+     * Defaults to gold (#ffe234).
+     */
+    color?: string;
+
+    /**
+     * The color used for empty (inactive) stars.
+     * Defaults to light gray (#dedede).
+     */
+    shadowColor?: string;
+
+    /**
+     * The size of each star, which also determines their visual size.
+     * Defaults to 10.
+     */
+    size?: number;
+};
+
+/**
+ * Renders the star rating of the ad, using Unicode stars (★ and ☆).
+ * Filled stars are rendered over hollow stars using a clipped view.
+ */
+export const StarRatingView = ({ color = '#ffe234', shadowColor = '#dedede', size = 10, style }: StarRatingViewProps) => {
     const { nativeAd } = useContext(NativeAdViewContext);
+    const maxStarCount = 5;
+
+    const containerStyle = useMemo(() => StyleSheet.flatten([style, styles.starRatingContainer]), [style]);
 
-    // Memoize the star rendering process
     const stars = useMemo(() => {
-        if (!nativeAd.starRating) {
-            return Array.from({ length: maxStarCount }).map((_, index) => (
-                <Text key={index} style={{ fontSize: starSize }}>
-                    {' '}
-                </Text>
-            ));
-        }
+        const starRating = Math.max(0, Math.min(maxStarCount, nativeAd.starRating ?? 0));
 
         return Array.from({ length: maxStarCount }).map((_, index) => {
-            const starRating = nativeAd.starRating!;
-            const width = (starRating - index) * starSize;
+            const isFull = starRating > index;
+            const width = Math.min(size, Math.max(0, (starRating - index) * size));
+
             return (
                 <View key={index}>
-                    <Text style={{ fontSize: starSize, color: starColor }}>{String.fromCodePoint(0x2606)}</Text>
-                    {starRating > index && (
-                        <View style={[{ width: width }, styles.starRating]}>
-                            <Text style={{ fontSize: starSize, color: starColor }}>{String.fromCodePoint(0x2605)}</Text>
+                    <Text style={{ fontSize: size, color: isFull ? color : shadowColor }}>{String.fromCodePoint(0x2606)}</Text>
+                    {isFull && (
+                        <View style={[{ width }, styles.starRating]}>
+                            <Text style={{ fontSize: size, color }}>{String.fromCodePoint(0x2605)}</Text>
                         </View>
                     )}
                 </View>
             );
         });
-    }, [nativeAd.starRating, starColor, starSize]);
+    }, [nativeAd.starRating, color, shadowColor, size]);
 
-    return (
-        <View {...restProps} style={[style, styles.starRatingContainer]}>
-            {stars}
-        </View>
-    );
+    if (!nativeAd.starRating) {
+        return <View style={containerStyle} />;
+    }
+
+    return <View style={containerStyle}>{stars}</View>;
 };
 
 const styles = StyleSheet.create({

package/src/nativeAd/NativeAdViewProvider.tsx

@@ -1,3 +1,8 @@
+/**
+ * Provides context and state management for NativeAdView and its child asset views.
+ * Shares asset view refs and native ad data between internal components and the native SDK.
+ */
+
 import * as React from 'react';
 import { useState, createContext, useRef } from 'react';
 import type { ReactNode } from 'react';
@@ -5,12 +10,20 @@ import type { Image, NativeMethods, Text, View } from 'react-native';
 import type { NativeAd } from '../types/NativeAd';
 import type { NativeProps } from '../specs/AppLovinMAXNativeAdViewNativeComponent';
 
+/**
+ * Native component type for the rendered NativeAdView.
+ */
 export type NativeAdViewType = React.Component<NativeProps> & NativeMethods;
 
+// Ref types for native views
 type TextRef = React.ElementRef<typeof Text>;
 type ImageRef = React.ElementRef<typeof Image>;
 type ViewRef = React.ElementRef<typeof View>;
 
+/**
+ * Context type used internally by NativeAdView.
+ * Stores references to asset views and the current native ad data.
+ */
 export type NativeAdViewContextType = {
     titleRef: React.RefObject<TextRef>;
     advertiserRef: React.RefObject<TextRef>;
@@ -23,11 +36,15 @@ export type NativeAdViewContextType = {
     setNativeAd: React.Dispatch<React.SetStateAction<NativeAd>>;
 };
 
+// Default for an uninitialized native ad
 const defaultNativeAd: NativeAd = {
     isOptionsViewAvailable: false,
     isMediaViewAvailable: false,
 };
 
+/**
+ * Internal context used by NativeAdView to provide access to asset view refs and native ad data.
+ */
 export const NativeAdViewContext = createContext<NativeAdViewContextType>({
     titleRef: { current: null },
     advertiserRef: { current: null },
@@ -40,6 +57,9 @@ export const NativeAdViewContext = createContext<NativeAdViewContextType>({
     setNativeAd: () => {},
 });
 
+/**
+ * React provider that wraps components requiring access to NativeAdViewContext.
+ */
 export const NativeAdViewProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
     const titleRef = useRef<TextRef | null>(null);
     const advertiserRef = useRef<TextRef | null>(null);
@@ -50,6 +70,9 @@ export const NativeAdViewProvider: React.FC<{ children: ReactNode }> = ({ childr
     const mediaViewRef = useRef<ViewRef | null>(null);
     const [nativeAd, setNativeAd] = useState<NativeAd>(defaultNativeAd);
 
+    /**
+     * Memoized context value to avoid unnecessary renders.
+     */
     const providerValue = React.useMemo(
         () => ({
             titleRef,

package/src/specs/AppLovinMAXAdViewNativeComponent.ts

@@ -3,6 +3,9 @@ import type { Double, DirectEventHandler, WithDefault } from 'react-native/Libra
 import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
 import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
 
+/**
+ * Payload for ad lifecycle events (e.g. load, display, click).
+ */
 export type AdInfoEvent = Readonly<{
     adUnitId: string;
     adFormat: string;
@@ -21,6 +24,9 @@ export type AdInfoEvent = Readonly<{
     }>;
 }>;
 
+/**
+ * Payload for ad load failure events.
+ */
 export type AdLoadFailedEvent = Readonly<{
     adUnitId: string;
     adViewId?: Double;
@@ -31,6 +37,9 @@ export type AdLoadFailedEvent = Readonly<{
     adLoadFailureInfo?: string | null;
 }>;
 
+/**
+ * Payload for ad display failure events.
+ */
 export type AdDisplayFailedEvent = Readonly<{
     adUnitId: string;
     adFormat: string;
@@ -53,44 +62,96 @@ export type AdDisplayFailedEvent = Readonly<{
     mediatedNetworkErrorMessage: string;
 }>;
 
+/**
+ * Props passed to the {@link AppLovinMAXAdView} native component.
+ */
 export interface NativeProps extends ViewProps {
+    /** Ad unit ID used to load the ad. */
     adUnitId: string;
+
+    /** Ad format (e.g., "BANNER", "MREC"). */
     adFormat?: string;
+
+    /** Unique identifier for this ad view. Defaults to 0. */
     adViewId?: WithDefault<Double, 0>;
+
+    /** Optional placement name for ad tracking. */
     placement?: string | null;
+
+    /** Optional custom data associated with the ad. */
     customData?: string | null;
+
+    /** Enables adaptive banner sizing. Defaults to `true`. */
     adaptiveBannerEnabled?: WithDefault<boolean, true>;
+
+    /** Enables automatic refresh of the ad. Defaults to `true`. */
     autoRefresh?: WithDefault<boolean, true>;
+
+    /** Whether to automatically load the ad on mount. Defaults to `true`. */
     loadOnMount?: WithDefault<boolean, true>;
+
+    /** Extra key-value string parameters passed to the SDK. */
     extraParameters?: ReadonlyArray<{
         key: string;
         value: string | null;
     }>;
+
+    /** Local string parameters passed to the mediation adapter. */
     strLocalExtraParameters?: ReadonlyArray<{
         key: string;
         value: string | null;
     }>;
+
+    /** Local boolean parameters passed to the mediation adapter. */
     boolLocalExtraParameters?: ReadonlyArray<{
         key: string;
         value: boolean | null;
     }>;
+
+    /** Called when an ad is successfully loaded. */
     onAdLoadedEvent: DirectEventHandler<AdInfoEvent>;
+
+    /** Called when an ad fails to load. */
     onAdLoadFailedEvent: DirectEventHandler<AdLoadFailedEvent>;
+
+    /** Called when an ad fails to display. */
     onAdDisplayFailedEvent: DirectEventHandler<AdDisplayFailedEvent>;
+
+    /** Called when the ad is clicked. */
     onAdClickedEvent: DirectEventHandler<AdInfoEvent>;
+
+    /** Called when the ad expands. */
     onAdExpandedEvent: DirectEventHandler<AdInfoEvent>;
+
+    /** Called when the ad collapses. */
     onAdCollapsedEvent: DirectEventHandler<AdInfoEvent>;
+
+    /** Called when ad revenue is reported. */
     onAdRevenuePaidEvent: DirectEventHandler<AdInfoEvent>;
 }
 
 type AppLovinMAXAdViewNativeComponentType = HostComponent<NativeProps>;
 
+/**
+ * Native commands callable from JS for managing {@link AppLovinMAXAdView}.
+ */
 interface NativeCommands {
-    loadAd: (viewRef: React.ElementRef<AppLovinMAXAdViewNativeComponentType>) => void;
+    /**
+     * Manually starts loading a new ad when `loadOnMount` is `false`.
+     *
+     * @param viewRef - Reference to the native ad view component.
+     */
+    loadAd(viewRef: React.ElementRef<AppLovinMAXAdViewNativeComponentType>): void;
 }
 
+/**
+ * JS interface to ad view commands for {@link AppLovinMAXAdView}.
+ */
 export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
     supportedCommands: ['loadAd'],
 });
 
+/**
+ * Native view component for displaying a banner or MREC ad.
+ */
 export default codegenNativeComponent<NativeProps>('AppLovinMAXAdView') as HostComponent<NativeProps>;

package/src/specs/AppLovinMAXNativeAdViewNativeComponent.ts

@@ -3,6 +3,9 @@ import type { Double, DirectEventHandler } from 'react-native/Libraries/Types/Co
 import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
 import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
 
+/**
+ * Payload for native ad lifecycle events (e.g., load, click, revenue).
+ */
 export type AdInfoEvent = Readonly<{
     adUnitId: string;
     adFormat: string;
@@ -18,6 +21,10 @@ export type AdInfoEvent = Readonly<{
         width: Double;
         height: Double;
     }>;
+
+    /**
+     * Optional native ad content for display in asset views.
+     */
     nativeAd?: Readonly<{
         title?: string;
         advertiser?: string;
@@ -29,6 +36,10 @@ export type AdInfoEvent = Readonly<{
         isOptionsViewAvailable: boolean;
         isMediaViewAvailable: boolean;
     }>;
+
+    /**
+     * Full internal native ad payload used for runtime rendering and view mapping.
+     */
     nativeAdImpl: Readonly<{
         title?: string | null;
         advertiser?: string | null;
@@ -43,6 +54,9 @@ export type AdInfoEvent = Readonly<{
     }>;
 }>;
 
+/**
+ * Payload for native ad load failure events.
+ */
 export type AdLoadFailedEvent = Readonly<{
     adUnitId: string;
     code: Double;
@@ -52,38 +66,88 @@ export type AdLoadFailedEvent = Readonly<{
     adLoadFailureInfo?: string | null;
 }>;
 
+/**
+ * Props passed to the {@link AppLovinMAXNativeAdView} native component.
+ */
 export interface NativeProps extends ViewProps {
+    /** Ad unit ID used to load the ad. */
     adUnitId: string;
+
+    /** Optional placement name for ad tracking. */
     placement?: string | null;
+
+    /** Optional custom data associated with the ad. */
     customData?: string | null;
+
+    /** Extra key-value string parameters passed to the SDK. */
     extraParameters?: ReadonlyArray<{
         key: string;
         value: string | null;
-    }> | null;
+    }>;
+
+    /** Local string parameters passed to the mediation adapter. */
     strLocalExtraParameters?: ReadonlyArray<{
         key: string;
         value: string | null;
-    }> | null;
+    }>;
+
+    /** Local boolean parameters passed to the mediation adapter. */
     boolLocalExtraParameters?: ReadonlyArray<{
         key: string;
         value: boolean | null;
-    }> | null;
+    }>;
+
+    /** Called when a native ad is successfully loaded. */
     onAdLoadedEvent: DirectEventHandler<AdInfoEvent>;
+
+    /** Called when ad loading fails. */
     onAdLoadFailedEvent: DirectEventHandler<AdLoadFailedEvent>;
+
+    /** Called when the ad is clicked. */
     onAdClickedEvent: DirectEventHandler<AdInfoEvent>;
+
+    /** Called when ad revenue is reported. */
     onAdRevenuePaidEvent: DirectEventHandler<AdInfoEvent>;
 }
 
 type AppLovinMAXNativeAdViewNativeComponentType = HostComponent<NativeProps>;
 
+/**
+ * Native commands callable from JS for managing {@link NativeAdView}.
+ */
 interface NativeCommands {
-    loadAd: (viewRef: React.ElementRef<AppLovinMAXNativeAdViewNativeComponentType>) => void;
-    updateAssetView: (viewRef: React.ElementRef<AppLovinMAXNativeAdViewNativeComponentType>, assetViewTag: Double, assetViewName: string) => void;
-    renderNativeAd: (viewRef: React.ElementRef<AppLovinMAXNativeAdViewNativeComponentType>) => void;
+    /**
+     * Manually loads a new native ad.
+     *
+     * @param viewRef - Reference to the native ad view.
+     */
+    loadAd(viewRef: React.ElementRef<AppLovinMAXNativeAdViewNativeComponentType>): void;
+
+    /**
+     * Binds a React Native child view to a native asset (e.g. TitleView, IconView).
+     *
+     * @param viewRef - Reference to the native ad view.
+     * @param assetViewTag - React tag for the asset view (via `findNodeHandle()`).
+     * @param assetViewName - Name of the asset (e.g., "MediaView", "CallToActionView").
+     */
+    updateAssetView(viewRef: React.ElementRef<AppLovinMAXNativeAdViewNativeComponentType>, assetViewTag: Double, assetViewName: string): void;
+
+    /**
+     * Instructs the native view to render the bound native ad after all asset views are set.
+     *
+     * @param viewRef - Reference to the native ad view.
+     */
+    renderNativeAd(viewRef: React.ElementRef<AppLovinMAXNativeAdViewNativeComponentType>): void;
 }
 
+/**
+ * JS interface to native ad view commands for {@link AppLovinMAXNativeAdView}.
+ */
 export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
     supportedCommands: ['loadAd', 'updateAssetView', 'renderNativeAd'],
 });
 
+/**
+ * Native component for rendering a custom native ad layout using bound asset views.
+ */
 export default codegenNativeComponent<NativeProps>('AppLovinMAXNativeAdView') as HostComponent<NativeProps>;