cloudx-react-native 3.10.0 → 3.10.1

package/src/CloudXNativeAdViewProvider.tsx

@@ -0,0 +1,149 @@
+/**
+ * Context provider for the manual-render `<CloudXNativeAdView/>` flow.
+ *
+ * The pre-built asset components (title, advertiser, body, CTA, icon,
+ * options, media, star rating) read metadata and refs from this context.
+ * The host `<CloudXNativeAdView/>` owns the `setNativeAd` state setter and
+ * publishes the latest `CloudXNativeAdMetadata` when `onAdLoaded` fires so
+ * pre-built components re-render with the new content.
+ *
+ * Design notes:
+ * - A `starRatingRef` lets the star component participate in the binder
+ *   pipeline (even though the native side treats it as decorative).
+ * - Refs are typed explicitly rather than relying on `any`, so misuse
+ *   surfaces at compile time.
+ * - Adds `registerAssetRole`, called by every pre-built asset component on
+ *   mount. The host `<CloudXNativeAdView/>` passes `onAssetRoleRegistered`
+ *   to detect an asset component mounted while `renderMode` is `'template'`
+ *   — a likely publisher mistake — and warn once.
+ */
+
+import * as React from 'react';
+import { useCallback, useMemo, useRef, useState, createContext } from 'react';
+import type { ReactNode } from 'react';
+import type { Image, Text, View } from 'react-native';
+import type { CloudXNativeAdMetadata } from './types/NativeAd';
+
+type TextRef = React.ElementRef<typeof Text>;
+type ImageRef = React.ElementRef<typeof Image>;
+type ViewRef = React.ElementRef<typeof View>;
+
+/**
+ * Shape exposed to pre-built asset components. Consumers typically destructure
+ * a single ref + the `nativeAd` field; the setter is only used by the host.
+ */
+export type CloudXNativeAdViewContextValue = {
+    titleRef: React.RefObject<TextRef | null>;
+    advertiserRef: React.RefObject<TextRef | null>;
+    bodyRef: React.RefObject<TextRef | null>;
+    callToActionRef: React.RefObject<TextRef | null>;
+    iconRef: React.RefObject<ImageRef | null>;
+    optionsRef: React.RefObject<ViewRef | null>;
+    mediaRef: React.RefObject<ViewRef | null>;
+    starRatingRef: React.RefObject<ViewRef | null>;
+    nativeAd: CloudXNativeAdMetadata | null;
+    setNativeAd: React.Dispatch<React.SetStateAction<CloudXNativeAdMetadata | null>>;
+    /**
+     * Called by each pre-built asset component on mount, naming its asset
+     * role. Returns an unregister function, so an effect can simply
+     * `return registerAssetRole('CloudXTitleView')` and have the role drop
+     * out again when the component unmounts.
+     */
+    registerAssetRole: (role: string) => () => void;
+    /**
+     * Roles whose component is currently mounted. The host intersects this
+     * with the loaded ad's own asset set, so it only waits on a binding the
+     * publisher's layout can actually satisfy.
+     */
+    mountedAssetRoles: React.MutableRefObject<Set<string>>;
+};
+
+/**
+ * Default / no-op type mirror. Consumers that mount a pre-built asset view
+ * outside a `<CloudXNativeAdView/>` fall through this and render empty —
+ * which is preferable to throwing because a publisher might legitimately
+ * mount the UI before an ad is ever loaded.
+ */
+const noopRef = { current: null } as React.RefObject<unknown> as React.RefObject<never>;
+
+export const CloudXNativeAdViewContext = createContext<CloudXNativeAdViewContextValue>({
+    titleRef: noopRef,
+    advertiserRef: noopRef,
+    bodyRef: noopRef,
+    callToActionRef: noopRef,
+    iconRef: noopRef,
+    optionsRef: noopRef,
+    mediaRef: noopRef,
+    starRatingRef: noopRef,
+    nativeAd: null,
+    // eslint-disable-next-line @typescript-eslint/no-empty-function -- default/no-op context value; see comment above.
+    setNativeAd: () => {},
+    registerAssetRole: () => () => {
+        /* default/no-op context value; see comment above */
+    },
+    mountedAssetRoles: { current: new Set<string>() },
+});
+
+type ProviderProps = {
+    children: ReactNode;
+    /**
+     * Invoked when a descendant asset component registers its role. The host
+     * `<CloudXNativeAdView/>` uses this to warn when an asset component is
+     * mounted while `renderMode` is `'template'`.
+     */
+    onAssetRoleRegistered?: (role: string) => void;
+};
+
+/**
+ * Wrap this around the root of a `<CloudXNativeAdView/>` tree so descendant
+ * asset components share refs and ad state.
+ */
+export const CloudXNativeAdViewProvider: React.FC<ProviderProps> = ({ children, onAssetRoleRegistered }) => {
+    const titleRef = useRef<TextRef | null>(null);
+    const advertiserRef = useRef<TextRef | null>(null);
+    const bodyRef = useRef<TextRef | null>(null);
+    const callToActionRef = useRef<TextRef | null>(null);
+    const iconRef = useRef<ImageRef | null>(null);
+    const optionsRef = useRef<ViewRef | null>(null);
+    const mediaRef = useRef<ViewRef | null>(null);
+    const starRatingRef = useRef<ViewRef | null>(null);
+    const [nativeAd, setNativeAd] = useState<CloudXNativeAdMetadata | null>(null);
+
+    // Ref so `registerAssetRole` stays referentially stable across renders
+    // without forcing callers to memoize `onAssetRoleRegistered`.
+    const onAssetRoleRegisteredRef = useRef(onAssetRoleRegistered);
+    onAssetRoleRegisteredRef.current = onAssetRoleRegistered;
+
+    // Mounted roles live in a ref, not state: the host reads them inside its
+    // bind effect and must not re-run that effect (which dispatches native
+    // commands) just because a sibling asset component mounted.
+    const mountedAssetRoles = useRef<Set<string>>(new Set());
+
+    const registerAssetRole = useCallback((role: string) => {
+        mountedAssetRoles.current.add(role);
+        onAssetRoleRegisteredRef.current?.(role);
+        return () => {
+            mountedAssetRoles.current.delete(role);
+        };
+    }, []);
+
+    const value = useMemo<CloudXNativeAdViewContextValue>(
+        () => ({
+            titleRef,
+            advertiserRef,
+            bodyRef,
+            callToActionRef,
+            iconRef,
+            optionsRef,
+            mediaRef,
+            starRatingRef,
+            nativeAd,
+            setNativeAd,
+            registerAssetRole,
+            mountedAssetRoles,
+        }),
+        [nativeAd, registerAssetRole]
+    );
+
+    return <CloudXNativeAdViewContext.Provider value={value}>{children}</CloudXNativeAdViewContext.Provider>;
+};

package/src/extraParameters.ts

@@ -0,0 +1,65 @@
+import type { NativeExtraParameterEntry } from './specs/CloudXAdViewNativeComponent';
+import type { CloudXAdProps } from './types/AdProps';
+
+const warnIgnoredUndefinedExtraParameter = (keyPath: string): void => {
+    console.warn(
+        `CloudX ad view ignored extra parameter "${keyPath}" because ` +
+            'undefined values are not supported. Use null when a value is intentional.'
+    );
+};
+
+const normalizeExtraParameterValue = (
+    keyPath: string,
+    value: unknown
+): NativeExtraParameterEntry['value'] | undefined => {
+    if (value === undefined) {
+        warnIgnoredUndefinedExtraParameter(keyPath);
+        return undefined;
+    }
+
+    if (Array.isArray(value)) {
+        return value.reduce<unknown[]>((items, item, index) => {
+            const normalized = normalizeExtraParameterValue(`${keyPath}[${index}]`, item);
+            if (normalized !== undefined) {
+                items.push(normalized);
+            }
+            return items;
+        }, []);
+    }
+
+    if (value !== null && typeof value === 'object') {
+        return Object.entries(value as Record<string, unknown>).reduce<Record<string, unknown>>(
+            (object, [childKey, childValue]) => {
+                const normalized = normalizeExtraParameterValue(`${keyPath}.${childKey}`, childValue);
+                if (normalized !== undefined) {
+                    object[childKey] = normalized;
+                }
+                return object;
+            },
+            {}
+        );
+    }
+
+    return value;
+};
+
+export const toNativeExtraParameterEntries = (
+    extraParameters?: CloudXAdProps['extraParameters']
+): ReadonlyArray<NativeExtraParameterEntry> => {
+    if (!extraParameters) {
+        return [];
+    }
+
+    return Object.entries(extraParameters as Record<string, unknown>).reduce<NativeExtraParameterEntry[]>(
+        (entries, [key, value]) => {
+            const normalizedValue = normalizeExtraParameterValue(key, value);
+            if (normalizedValue === undefined) {
+                return entries;
+            }
+
+            entries.push({ key, value: normalizedValue });
+            return entries;
+        },
+        []
+    );
+};

package/src/hooks.ts

@@ -54,6 +54,16 @@ export function useCloudXInterstitial(adUnitId: string): CloudXInterstitialHookR
 
     useEffect(() => {
         mountedRef.current = true;
+
+        // A changed adUnitId must not keep reporting the previous unit's
+        // result: without this, isLoaded stays true for an ad unit that
+        // has not loaded until the new unit happens to emit. isLoading is
+        // reset too, because the cleanup below destroys the in-flight
+        // request and no load/fail event for it will ever arrive.
+        setIsLoaded(false);
+        setIsLoading(false);
+        setError(null);
+
         const subs: EventSubscription[] = [];
 
         subs.push(
@@ -153,6 +163,16 @@ export function useCloudXAppOpen(adUnitId: string): CloudXAppOpenHookResult {
 
     useEffect(() => {
         mountedRef.current = true;
+
+        // A changed adUnitId must not keep reporting the previous unit's
+        // result: without this, isLoaded stays true for an ad unit that
+        // has not loaded until the new unit happens to emit. isLoading is
+        // reset too, because the cleanup below destroys the in-flight
+        // request and no load/fail event for it will ever arrive.
+        setIsLoaded(false);
+        setIsLoading(false);
+        setError(null);
+
         const subs: EventSubscription[] = [];
 
         subs.push(
@@ -254,6 +274,17 @@ export function useCloudXRewarded(adUnitId: string): CloudXRewardedHookResult {
 
     useEffect(() => {
         mountedRef.current = true;
+
+        // A changed adUnitId must not keep reporting the previous unit's
+        // result: without this, isLoaded stays true for an ad unit that
+        // has not loaded until the new unit happens to emit. isLoading is
+        // reset too, because the cleanup below destroys the in-flight
+        // request and no load/fail event for it will ever arrive.
+        setIsLoaded(false);
+        setIsLoading(false);
+        setError(null);
+        setRewardEarned(false);
+
         const subs: EventSubscription[] = [];
 
         subs.push(
@@ -362,6 +393,13 @@ export function useCloudXBanner(adUnitId: string): CloudXBannerHookResult {
 
     useEffect(() => {
         mountedRef.current = true;
+
+        // A changed adUnitId must not keep reporting the previous unit's
+        // result: without this, isLoaded stays true for an ad unit that
+        // has not loaded until the new unit happens to emit.
+        setIsLoaded(false);
+        setError(null);
+
         const subs: EventSubscription[] = [];
 
         subs.push(

package/src/index.ts

@@ -19,6 +19,25 @@ export { CloudXAdPosition } from './CloudXAdPosition';
 // Ad View Components (in-tree; layer correctly under app overlays)
 export { CloudXBannerView } from './CloudXBannerView';
 export { CloudXMRECView } from './CloudXMRECView';
+export { CloudXNativeAdView } from './CloudXNativeAdView';
+export {
+    CloudXTitleView,
+    CloudXAdvertiserView,
+    CloudXBodyView,
+    CloudXCallToActionView,
+    CloudXIconView,
+    CloudXOptionsView,
+    CloudXMediaView,
+    CloudXStarRatingView,
+} from './CloudXNativeAdViewComponents';
+// Exposed so publishers can build fully custom manual layouts that consume
+// the loaded-ad context outside the bundled asset components.
+// The provider, its context and the context value type are deliberately NOT
+// public. The host `<CloudXNativeAdView/>` always mounts its own provider: one
+// mounted outside it is ignored, and one mounted inside it breaks binding for
+// the asset components beneath. Exporting the value type would also freeze
+// `setNativeAd` and every asset ref as public API. Widening this surface later
+// is additive; removing it after release would be a breaking change.
 export type { CloudXAdViewProps, CloudXAdViewFormat } from './CloudXAdViewBase';
 
 // Error Codes
@@ -70,7 +89,12 @@ export type {
     CloudXAdEventListener,
     CloudXExtraParameterValue,
     CloudXExtraParameters,
+    CloudXNativeAdMetadata,
+    CloudXNativeAdViewHandle,
+    CloudXNativeAdViewProps,
+    CloudXLocalExtraParameters,
 } from './types';
+export { CloudXNativeTemplate } from './types';
 
 // Log level constants
 export const CloudXLogLevel = {

package/src/specs/CloudXNativeAdViewNativeComponent.ts

@@ -0,0 +1,137 @@
+import type * as React from 'react';
+import type { HostComponent, ViewProps } from 'react-native';
+import type {
+    Double,
+    Int32,
+    DirectEventHandler,
+    UnsafeMixed,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+
+/**
+ * Payload for native-ad lifecycle events (load, click, revenue).
+ *
+ * Codegen cannot express `Record<string, string>`, so the SDK-owned ad values
+ * are delivered as a JSON-encoded string in `adValuesJson` (mirroring
+ * CloudXAdViewNativeComponent) and re-parsed into a map by the JS wrapper.
+ * The loaded native ad's own metadata (title, media, icon, etc.) is likewise
+ * delivered as a JSON-encoded string in `nativeAdJson`, since codegen cannot
+ * express the native ad's heterogeneous field set as typed props.
+ */
+export type CloudXNativeAdInfoEvent = Readonly<{
+    adUnitId: string;
+    adFormat: string;
+    networkName: string;
+    networkPlacement?: string | null;
+    placement?: string | null;
+    creativeId?: string | null;
+    revenue: Double;
+    adValuesJson?: string | null;
+    nativeAdJson?: string | null;
+}>;
+
+/**
+ * Payload for native-ad load/display-failure events.
+ */
+export type CloudXNativeAdLoadFailedEvent = Readonly<{
+    adUnitId: string;
+    code: Double;
+    message?: string | null;
+}>;
+
+export type NativeExtraParameterEntry = Readonly<{
+    key: string;
+    value: UnsafeMixed;
+}>;
+
+/**
+ * Props for the native CloudXNativeAdView component.
+ *
+ * Mirrors the in-tree CloudXAdView (banner/MREC) component: the ad renders as
+ * an ordinary React Native view so publisher overlays layer above it via
+ * normal RN z-ordering.
+ */
+export interface NativeProps extends ViewProps {
+    /** Ad unit ID used to load the ad. */
+    adUnitId: string;
+
+    /**
+     * Publisher-selected template name (e.g. "small_template",
+     * "medium_template"). Named `templateName`, not `template` — codegen
+     * emits the prop as a literal `std::string template` struct member on
+     * the generated Props class, and `template` is a reserved word in C++,
+     * so that spelling fails to compile. The Old Architecture manager also
+     * accepts the legacy `template` prop name and aliases it internally for
+     * publisher compatibility.
+     */
+    templateName?: string | null;
+
+    /** Optional placement name for reporting. */
+    placement?: string | null;
+
+    /** Optional custom data string. */
+    customData?: string | null;
+
+    /** Extra parameters applied to the underlying native ad loader. */
+    extraParameters?: ReadonlyArray<NativeExtraParameterEntry>;
+
+    /** Local-only extra parameters applied to the underlying native ad loader. */
+    localExtraParameters?: ReadonlyArray<NativeExtraParameterEntry>;
+
+    /** Disables the video full-screen affordance when true. */
+    disableVideoFullScreen?: boolean;
+
+    /** Starts video creatives unmuted when true. */
+    startVideoUnmuted?: boolean;
+
+    /** Hides video media controls when true. */
+    hideVideoMediaControls?: boolean;
+
+    /**
+     * When true, the host skips template rendering and lets the JS layer
+     * drive layout through the `updateAssetView` + `renderNativeAd` commands.
+     */
+    manualRender?: boolean;
+
+    /** Called when an ad is successfully loaded. */
+    onAdLoadedEvent: DirectEventHandler<CloudXNativeAdInfoEvent>;
+
+    /** Called when the SDK fails to load an ad. */
+    onAdLoadFailedEvent: DirectEventHandler<CloudXNativeAdLoadFailedEvent>;
+
+    /** Called when the ad fails to render/display (e.g. manual render before load). */
+    onAdDisplayFailedEvent: DirectEventHandler<CloudXNativeAdLoadFailedEvent>;
+
+    /** Called when the ad is clicked. */
+    onAdClickedEvent: DirectEventHandler<CloudXNativeAdInfoEvent>;
+
+    /** Called when the loaded ad expires. */
+    onAdExpiredEvent: DirectEventHandler<CloudXNativeAdInfoEvent>;
+
+    /** Called when the ad is closed. */
+    onAdClosedEvent: DirectEventHandler<CloudXNativeAdInfoEvent>;
+
+    /** Called when ad revenue is paid. */
+    onAdRevenuePaidEvent: DirectEventHandler<CloudXNativeAdInfoEvent>;
+}
+
+export interface NativeCommands {
+    loadAd: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+    destroyAd: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+    updateAssetView: (
+        viewRef: React.ElementRef<HostComponent<NativeProps>>,
+        assetViewTag: Int32,
+        assetName: string
+    ) => void;
+    renderNativeAd: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+    supportedCommands: ['loadAd', 'destroyAd', 'updateAssetView', 'renderNativeAd'],
+});
+
+/**
+ * Native in-tree view component backing the publisher-facing native ad view.
+ */
+export default codegenNativeComponent<NativeProps>('CloudXNativeAdView') as HostComponent<NativeProps>;

package/src/types/AdInfo.ts

@@ -1,4 +1,5 @@
 import type { CloudXErrorCode } from '../CloudXErrorCode';
+import type { CloudXNativeAdMetadata } from './NativeAd';
 
 /**
  * Represents a successfully loaded ad served by CloudX.
@@ -7,7 +8,7 @@ export type CloudXAdInfo = {
     /** The ad unit ID for this ad. */
     adUnitId: string;
 
-    /** The format of the ad (e.g., "BANNER", "MREC", "INTERSTITIAL", "REWARDED"). */
+    /** The format of the ad (e.g., "BANNER", "MREC", "INTERSTITIAL", "REWARDED", "NATIVE"). */
     adFormat: string;
 
     /** The name of the ad network that served the ad. */
@@ -27,6 +28,9 @@ export type CloudXAdInfo = {
 
     /** SDK-owned metadata values associated with this loaded ad. */
     adValues: Record<string, string>;
+
+    /** Structured native-ad metadata when the loaded creative is a native ad. */
+    nativeAd?: CloudXNativeAdMetadata | null;
 };
 
 /**

package/src/types/NativeAd.ts

@@ -0,0 +1,125 @@
+import type { ViewProps } from 'react-native';
+import type { CloudXAdDisplayFailedInfo, CloudXAdInfo } from './AdInfo';
+import type { CloudXAdProps } from './AdProps';
+import type { CloudXExtraParameterValue } from './ExtraParameters';
+
+/**
+ * Built-in native ad template variants rendered by the SDK's view component.
+ *
+ * All four variants have a distinct bundled layout on both iOS and Android,
+ * and unknown values fall back to `MEDIUM` on both.
+ *
+ * On both platforms this prop selects the **local layout only**. Neither
+ * bid request carries the selection, so the server sizes the creative's
+ * assets for `medium` whatever is chosen here:
+ *
+ * - iOS: `CLXNativeAdLoader` builds its publisher with
+ *   `CLXNativeTemplateDefault`, which is `CLXNativeTemplateMedium`.
+ *   `CLXBidSignals` would thread a non-default template, but the loader
+ *   never supplies one.
+ * - Android: `BidSignalsProvider` writes `nativeRequirements.template`
+ *   as a fixed `"medium"`, pending a public template-selection API.
+ *
+ * A creative rendered in a non-`MEDIUM` layout therefore carries assets cut
+ * for `MEDIUM` — most visible with `VERTICAL_MEDIA`, the full-screen shape.
+ * Tracked as CXD-5385.
+ */
+export enum CloudXNativeTemplate {
+    /** 320x90 compact template: icon, title, advertiser, CTA. */
+    SMALL = 'small_template',
+
+    /** 320x250 template. */
+    MEDIUM = 'medium_template',
+
+    /** 320x300 media-forward template. */
+    MEDIA_BANNER = 'media_banner_template',
+
+    /**
+     * Full-screen vertical template sized to the available bounds.
+     * Intended for feed-style vertical experiences. Bundled layout on both
+     * iOS and Android.
+     */
+    VERTICAL_MEDIA = 'vertical_media_template',
+}
+
+/**
+ * Type-safe asset identifiers for custom native-ad binding.
+ */
+export enum CloudXNativeAssetType {
+    TITLE = 'TitleView',
+    ADVERTISER = 'AdvertiserView',
+    BODY = 'BodyView',
+    CALL_TO_ACTION = 'CallToActionView',
+    ICON = 'IconView',
+    OPTIONS = 'OptionsView',
+    MEDIA = 'MediaView',
+    STAR_RATING = 'StarRatingView',
+}
+
+/**
+ * Structured metadata for a single loaded native ad.
+ *
+ * Surfaced on the `onAdLoaded` callback as `CloudXAdInfo.nativeAd`.
+ */
+export type CloudXNativeAdMetadata = {
+    title?: string | null;
+    advertiser?: string | null;
+    body?: string | null;
+    callToAction?: string | null;
+    starRating?: number | null;
+    mediaContentAspectRatio?: number;
+    isIconImageAvailable: boolean;
+    isOptionsViewAvailable: boolean;
+    isMediaViewAvailable: boolean;
+    url?: string | null;
+    imageSource?: string | null;
+    isVideoContent: boolean;
+    videoDuration: number;
+    isExpired: boolean;
+};
+
+// Shares one value type with `extraParameters`: both native setters accept any
+// value, so narrowing one of the two sibling props was an accidental restriction.
+export type CloudXLocalExtraParameters = {
+    [key: string]: CloudXExtraParameterValue;
+};
+
+/**
+ * Props for the native-ad view component.
+ *
+ * Callbacks inherited from {@link CloudXAdProps} (`onAdLoaded`, `onAdLoadFailed`,
+ * `onAdClicked`, `onAdRevenuePaid`) receive unwrapped payloads, not synthetic events.
+ */
+export type CloudXNativeAdViewProps = CloudXAdProps &
+    ViewProps & {
+        template?: CloudXNativeTemplate;
+        localExtraParameters?: CloudXLocalExtraParameters;
+        disableVideoFullScreen?: boolean;
+        startVideoUnmuted?: boolean;
+        hideVideoMediaControls?: boolean;
+        /** Selects between the SDK's bundled template layouts and manual asset binding. */
+        renderMode?: 'template' | 'manual';
+        /**
+         * Called when a loaded ad subsequently fails to display or track.
+         *
+         * Emitted on both platforms. Android fires it for post-load
+         * adapter/render errors and when click/impression registration fails in
+         * manual mode. iOS fires it on the three manual-mode failure paths:
+         * render requested before load, expired ad, and registration refused.
+         */
+        onAdDisplayFailed?: (errorInfo: CloudXAdDisplayFailedInfo) => void;
+        onAdExpired?: (adInfo: CloudXAdInfo) => void;
+        onAdClosed?: (adInfo: CloudXAdInfo) => void;
+    };
+
+export type CloudXNativeAdViewHandle = {
+    /**
+     * Requests a load. This does NOT force a new auction: both native SDKs
+     * re-serve the ad they already hold while it is neither expired nor
+     * destroyed, including after its impression. Changed targeting is
+     * therefore not picked up. Call `destroyAd()` first for a fresh ad.
+     */
+    loadAd: () => void;
+    /** Releases the native ad and its resources. */
+    destroyAd: () => void;
+};

package/src/types/index.ts

@@ -25,3 +25,10 @@ export type { CloudXMRECAdType } from './MRECAd';
 export type { CloudXAdProps } from './AdProps';
 export type { CloudXAdEventObject, CloudXAdEventListener } from './AdEvent';
 export type { CloudXExtraParameterValue, CloudXExtraParameters } from './ExtraParameters';
+export type {
+    CloudXNativeAdMetadata,
+    CloudXNativeAdViewHandle,
+    CloudXNativeAdViewProps,
+    CloudXLocalExtraParameters,
+} from './NativeAd';
+export { CloudXNativeTemplate, CloudXNativeAssetType } from './NativeAd';