react-native-google-mobile-ads 5.0.1 → 6.0.0

package/lib/typescript/ads/InterstitialAd.d.ts

@@ -1,8 +1,8 @@
 import { MobileAd } from './MobileAd';
+import { AdEventType } from '../AdEventType';
 import { AdEventListener } from '../types/AdEventListener';
-import { AdShowOptions } from '../types/AdShowOptions';
+import { AdEventsListener } from '../types/AdEventsListener';
 import { RequestOptions } from '../types/RequestOptions';
-import { MobileAdInterface } from '../types/MobileAd.interface';
 /**
  * A class for interacting and showing Interstitial Ads.
  *
@@ -32,10 +32,8 @@ import { MobileAdInterface } from '../types/MobileAd.interface';
  * ```js
  * import { AdEventType } from 'react-native-google-mobile-ads';
  *
- * interstitial.onAdEvent((type) => {
- *   if (type === AdEventType.LOADED) {
- *     interstitial.show();
- *   }
+ * interstitialAd.addAdEventListener(AdEventType.Loaded, () => {
+ *   interstitialAd.show();
  * });
  *
  * interstitial.load();
@@ -44,7 +42,8 @@ import { MobileAdInterface } from '../types/MobileAd.interface';
  * The advert will be presented to the user, and several more events can be triggered such as the user clicking the
  * advert or closing it.
  */
-export declare class InterstitialAd extends MobileAd implements MobileAdInterface {
+export declare class InterstitialAd extends MobileAd {
+    protected static _interstitialRequest: number;
     /**
      * Creates a new InterstitialAd instance.
      *
@@ -57,12 +56,8 @@ export declare class InterstitialAd extends MobileAd implements MobileAdInterfac
      *   requestAgent: 'CoolAds',
      * });
      *
-     * interstitialAd.onAdEvent((type, error) => {
-     *   console.log('New event: ', type, error);
-     *
-     *   if (type === AdEventType.LOADED) {
-     *     interstitialAd.show();
-     *   }
+     * interstitialAd.addAdEventListener(AdEventType.Loaded, () => {
+     *   interstitialAd.show();
      * });
      *
      * interstitialAd.load();
@@ -72,7 +67,6 @@ export declare class InterstitialAd extends MobileAd implements MobileAdInterfac
      * @param requestOptions Optional RequestOptions used to load the ad.
      */
     static createForAdRequest(adUnitId: string, requestOptions?: RequestOptions): InterstitialAd;
-    load(): void;
-    onAdEvent(handler: AdEventListener): () => null;
-    show(showOptions?: AdShowOptions): Promise<void>;
+    addAdEventsListener<T extends AdEventType>(listener: AdEventsListener<T>): () => void;
+    addAdEventListener<T extends AdEventType>(type: T, listener: AdEventListener<T>): () => void;
 }

package/lib/typescript/ads/MobileAd.d.ts

@@ -1,32 +1,50 @@
 import { EmitterSubscription } from 'react-native';
-import { RewardedAdEventType } from '../RewardedAdEventType';
 import { AdEventType } from '../AdEventType';
+import { RewardedAdEventType } from '../RewardedAdEventType';
 import { AdEventListener } from '../types/AdEventListener';
+import { AdEventsListener } from '../types/AdEventsListener';
+import { AdShowOptions } from '../types/AdShowOptions';
 import { RequestOptions } from '../types/RequestOptions';
+import { MobileAdInterface } from '../types/MobileAd.interface';
 import { MobileAdsModuleInterface } from '../types/MobileAdsModule.interface';
 import { RewardedAdReward } from '../types/RewardedAdReward';
-export declare class MobileAd {
-    _type: 'app_open' | 'interstitial' | 'rewarded';
-    _googleMobileAds: MobileAdsModuleInterface;
-    _requestId: number;
-    _adUnitId: string;
-    _requestOptions: RequestOptions;
-    _loaded: boolean;
-    _isLoadCalled: boolean;
-    _onAdEventHandler: AdEventListener | null;
-    _nativeListener: EmitterSubscription;
-    constructor(type: 'app_open' | 'interstitial' | 'rewarded', googleMobileAds: MobileAdsModuleInterface, requestId: number, adUnitId: string, requestOptions: RequestOptions);
-    _handleAdEvent(event: {
+import { GAMAdEventType } from '../GAMAdEventType';
+import { AppEvent } from '../types/AppEvent';
+declare type EventType = AdEventType | RewardedAdEventType | GAMAdEventType;
+export declare abstract class MobileAd implements MobileAdInterface {
+    protected _type: 'app_open' | 'interstitial' | 'rewarded';
+    protected _googleMobileAds: MobileAdsModuleInterface;
+    protected _requestId: number;
+    protected _adUnitId: string;
+    protected _requestOptions: RequestOptions;
+    protected _loaded: boolean;
+    protected _isLoadCalled: boolean;
+    protected _adEventsListeners: Map<number, AdEventsListener<EventType>>;
+    protected _adEventListenersMap: Map<EventType, Map<number, AdEventListener<EventType>>>;
+    protected _adEventsListenerId: number;
+    protected _adEventListenerId: number;
+    protected _nativeListener: EmitterSubscription;
+    protected constructor(type: 'app_open' | 'interstitial' | 'rewarded', googleMobileAds: MobileAdsModuleInterface, requestId: number, adUnitId: string, requestOptions: RequestOptions);
+    protected _handleAdEvent(event: {
         body: {
-            type: AdEventType | RewardedAdEventType;
+            type: EventType;
             error?: {
                 code: string;
                 message: string;
             };
-            data?: RewardedAdReward;
+            data?: RewardedAdReward | AppEvent;
         };
     }): void;
-    _setAdEventHandler(handler: AdEventListener): () => null;
+    protected _addAdEventsListener<T extends EventType>(listener: AdEventsListener<T>): () => void;
+    protected _addAdEventListener<T extends EventType>(type: T, listener: AdEventListener<T>): () => void;
+    protected _getAdEventListeners<T extends EventType>(type: T): Map<number, AdEventListener<T>>;
+    protected get _className(): string;
+    load(): void;
+    show(showOptions?: AdShowOptions): Promise<void>;
+    abstract addAdEventsListener<T extends never>(listener: AdEventsListener<T>): () => void;
+    abstract addAdEventListener<T extends never>(type: T, listener: AdEventListener<T>): void;
+    removeAllListeners(): void;
     get adUnitId(): string;
     get loaded(): boolean;
 }
+export {};

package/lib/typescript/ads/RewardedAd.d.ts

@@ -1,8 +1,9 @@
 import { MobileAd } from './MobileAd';
+import { AdEventType } from '../AdEventType';
+import { RewardedAdEventType } from '../RewardedAdEventType';
 import { AdEventListener } from '../types/AdEventListener';
-import { AdShowOptions } from '../types/AdShowOptions';
+import { AdEventsListener } from '../types/AdEventsListener';
 import { RequestOptions } from '../types/RequestOptions';
-import { MobileAdInterface } from '../types/MobileAd.interface';
 /**
  * A class for interacting and showing Rewarded Ads.
  *
@@ -35,13 +36,11 @@ import { MobileAdInterface } from '../types/MobileAd.interface';
  * ```js
  * import { RewardedAdEventType } from 'react-native-google-mobile-ads';
  *
- * rewarded.onAdEvent((type, error, reward) => {
- *   if (type === RewardedAdEventType.LOADED) {
- *     rewarded.show();
- *   }
- *   if (type === RewardedAdEventType.EARNED_REWARD) {
- *     console.log('User earned reward of ', reward);
- *   }
+ * rewarded.addAdEventListener(RewardedAdEventType.LOADED. () => {
+ *   rewarded.show();
+ * });
+ * rewarded.addAdEventListener(RewardedAdEventType.EARNED_REWARD. (reward) => {
+ *   console.log('User earned reward of ', reward);
  * });
  *
  * rewarded.load();
@@ -50,7 +49,8 @@ import { MobileAdInterface } from '../types/MobileAd.interface';
  * The rewarded advert will be presented to the user, and several more events can be triggered such as the user clicking the
  * advert, closing it or completing the action.
  */
-export declare class RewardedAd extends MobileAd implements MobileAdInterface {
+export declare class RewardedAd extends MobileAd {
+    protected static _rewardedRequest: number;
     /**
      * Creates a new RewardedAd instance.
      *
@@ -63,12 +63,11 @@ export declare class RewardedAd extends MobileAd implements MobileAdInterface {
      *   requestAgent: 'CoolAds',
      * });
      *
-     * rewardedAd.onAdEvent((type, error, data) => {
-     *   console.log('New event: ', type, error);
-     *
-     *   if (type === RewardedAdEventType.LOADED) {
-     *     rewardedAd.show();
-     *   }
+     * rewarded.addAdEventListener(RewardedAdEventType.LOADED. () => {
+     *   rewarded.show();
+     * });
+     * rewarded.addAdEventListener(RewardedAdEventType.EARNED_REWARD. (reward) => {
+     *   console.log('User earned reward of ', reward);
      * });
      *
      * rewardedAd.load();
@@ -78,7 +77,6 @@ export declare class RewardedAd extends MobileAd implements MobileAdInterface {
      * @param requestOptions Optional RequestOptions used to load the ad.
      */
     static createForAdRequest(adUnitId: string, requestOptions?: RequestOptions): RewardedAd;
-    load(): void;
-    onAdEvent(handler: AdEventListener): () => null;
-    show(showOptions?: AdShowOptions): Promise<void>;
+    addAdEventsListener<T extends AdEventType | RewardedAdEventType>(listener: AdEventsListener<T>): () => void;
+    addAdEventListener<T extends AdEventType | RewardedAdEventType>(type: T, listener: AdEventListener<T>): () => void;
 }

package/lib/typescript/hooks/useAppOpenAd.d.ts

@@ -0,0 +1,9 @@
+import { AdHookReturns } from '../types/AdStates';
+import { RequestOptions } from '../types/RequestOptions';
+/**
+ * React Hook for App Open Ad.
+ *
+ * @param adUnitId The Ad Unit ID for the App Open Ad. You can find this on your Google Mobile Ads dashboard. You can destroy ad instance by setting this value to null.
+ * @param requestOptions Optional RequestOptions used to load the ad.
+ */
+export declare function useAppOpenAd(adUnitId: string | null, requestOptions?: RequestOptions): Omit<AdHookReturns, 'reward' | 'isEarnedReward'>;

package/lib/typescript/hooks/useFullScreenAd.d.ts

@@ -0,0 +1,5 @@
+import { AppOpenAd } from '../ads/AppOpenAd';
+import { InterstitialAd } from '../ads/InterstitialAd';
+import { RewardedAd } from '../ads/RewardedAd';
+import { AdHookReturns } from '../types/AdStates';
+export declare function useFullScreenAd<T extends InterstitialAd | RewardedAd | AppOpenAd | null>(ad: T): AdHookReturns;

package/lib/typescript/hooks/useInterstitialAd.d.ts

@@ -0,0 +1,9 @@
+import { AdHookReturns } from '../types/AdStates';
+import { RequestOptions } from '../types/RequestOptions';
+/**
+ * React Hook for Interstitial Ad.
+ *
+ * @param adUnitId The Ad Unit ID for the Interstitial Ad. You can find this on your Google Mobile Ads dashboard. You can destroy ad instance by setting this value to null.
+ * @param requestOptions Optional RequestOptions used to load the ad.
+ */
+export declare function useInterstitialAd(adUnitId: string | null, requestOptions?: RequestOptions): Omit<AdHookReturns, 'reward' | 'isEarnedReward'>;

package/lib/typescript/hooks/useRewardedAd.d.ts

@@ -0,0 +1,9 @@
+import { AdHookReturns } from '../types/AdStates';
+import { RequestOptions } from '../types/RequestOptions';
+/**
+ * React Hook for Rewarded Ad.
+ *
+ * @param adUnitId The Ad Unit ID for the Rewarded Ad. You can find this on your Google Mobile Ads dashboard. You can destroy ad instance by setting this value to null.
+ * @param requestOptions Optional RequestOptions used to load the ad.
+ */
+export declare function useRewardedAd(adUnitId: string | null, requestOptions?: RequestOptions): Omit<AdHookReturns, 'adReward'>;

package/lib/typescript/index.d.ts

@@ -1,14 +1,23 @@
-export declare const SDK_VERSION = "5.0.1";
+export declare const SDK_VERSION = "6.0.0";
 export { default, MobileAds } from './MobileAds';
 export { AdsConsentDebugGeography } from './AdsConsentDebugGeography';
+export { AdsConsentPurposes } from './AdsConsentPurposes';
+export { AdsConsentSpecialFeatures } from './AdsConsentSpecialFeatures';
 export { AdsConsentStatus } from './AdsConsentStatus';
 export { MaxAdContentRating } from './MaxAdContentRating';
 export { TestIds } from './TestIds';
 export { AdEventType } from './AdEventType';
 export { BannerAdSize } from './BannerAdSize';
+export { GAMAdEventType } from './GAMAdEventType';
 export { RewardedAdEventType } from './RewardedAdEventType';
 export { AdsConsent } from './AdsConsent';
 export { AppOpenAd } from './ads/AppOpenAd';
 export { InterstitialAd } from './ads/InterstitialAd';
 export { RewardedAd } from './ads/RewardedAd';
 export { BannerAd } from './ads/BannerAd';
+export { GAMBannerAd } from './ads/GAMBannerAd';
+export { GAMInterstitialAd } from './ads/GAMInterstitialAd';
+export { useAppOpenAd } from './hooks/useAppOpenAd';
+export { useInterstitialAd } from './hooks/useInterstitialAd';
+export { useRewardedAd } from './hooks/useRewardedAd';
+export * from './types';

package/lib/typescript/types/AdEventListener.d.ts

@@ -1,11 +1,7 @@
 import { AdEventType } from '../AdEventType';
-import { RewardedAdReward } from './RewardedAdReward';
+import { GAMAdEventType } from '../GAMAdEventType';
 import { RewardedAdEventType } from '../RewardedAdEventType';
-/**
- * A callback interface for all ad events.
- *
- * @param type The event type, e.g. `AdEventType.LOADED`.
- * @param error An optional JavaScript Error containing the error code and message.
- * @param data Optional data for the event, e.g. reward type and amount
- */
-export declare type AdEventListener = (type: AdEventType | RewardedAdEventType, error?: Error, data?: RewardedAdReward) => void;
+import { AppEvent } from './AppEvent';
+import { RewardedAdReward } from './RewardedAdReward';
+export declare type AdEventPayload<T extends AdEventType | RewardedAdEventType | GAMAdEventType = never> = T extends AdEventType.ERROR ? Error : T extends RewardedAdEventType ? RewardedAdReward : T extends GAMAdEventType ? AppEvent : undefined;
+export declare type AdEventListener<T extends AdEventType | RewardedAdEventType | GAMAdEventType = never> = (payload: AdEventPayload<T>) => void;

package/lib/typescript/types/AdEventsListener.d.ts

@@ -0,0 +1,8 @@
+import { AdEventType } from '../AdEventType';
+import { GAMAdEventType } from '../GAMAdEventType';
+import { RewardedAdEventType } from '../RewardedAdEventType';
+import { AdEventPayload } from './AdEventListener';
+export declare type AdEventsListener<T extends AdEventType | RewardedAdEventType | GAMAdEventType = never> = (eventInfo: {
+    type: T;
+    payload: AdEventPayload<T>;
+}) => void;

package/lib/typescript/types/AdStates.d.ts

@@ -0,0 +1,85 @@
+import { AdShowOptions } from './AdShowOptions';
+import { RewardedAdReward } from './RewardedAdReward';
+export interface AdStates {
+    /**
+     * Whether the ad is loaded and ready to to be shown to the user.
+     */
+    isLoaded: boolean;
+    /**
+     * Whether the ad is opened.
+     */
+    isOpened: boolean;
+    /**
+     * Whether the user clicked the advert.
+     */
+    isClicked: boolean;
+    /**
+     * Whether the user closed the ad and has returned back to your application.
+     */
+    isClosed: boolean;
+    /**
+     * JavaScript Error containing the error code and message thrown by the Ad.
+     */
+    error?: Error;
+    /**
+     * Loaded reward item of the Rewarded Ad.
+     */
+    reward?: RewardedAdReward;
+    /**
+     * Whether the user earned the reward by Rewarded Ad.
+     */
+    isEarnedReward?: boolean;
+}
+export interface AdHookReturns extends AdStates {
+    /**
+     * Whether your ad is showing.
+     * The value is equal with `isOpened && !isClosed`.
+     */
+    isShowing: boolean;
+    /**
+     * Start loading the advert with the provided RequestOptions.
+     * #### Example
+     *
+     * ```jsx
+     * export default function App() {
+     *   const interstitial = useInterstitialAd(TestIds.INTERSTITIAL, {
+     *     requestNonPersonalizedAdsOnly: true,
+     *   });
+     *   useEffect(() => {
+     *     interstitial.load();
+     *   }, [interstitial.load]);
+     * }
+     * ```
+     */
+    load: () => void;
+    /**
+     * Show the loaded advert to the user.
+     *
+     * #### Example
+     *
+     * ```jsx
+     * export default function App() {
+     *   const interstitial = useInterstitialAd(TestIds.INTERSTITIAL, {
+     *     requestNonPersonalizedAdsOnly: true,
+     *   });
+     *   return (
+     *     <View>
+     *       <Button
+     *         title="Navigate to next screen"
+     *         onPress={() => {
+     *           if (interstitial.isLoaded) {
+     *             interstitial.show();
+     *           } else {
+     *             navigation.navigate('NextScreen');
+     *           }
+     *         }}
+     *       />
+     *     </View>
+     *   )
+     * }
+     * ```
+     *
+     * @param showOptions An optional `AdShowOptions` interface.
+     */
+    show: (showOptions?: AdShowOptions) => void;
+}

package/lib/typescript/types/AdsConsent.interface.d.ts

@@ -1,3 +1,4 @@
+import { TCModel } from '@iabtcf/core';
 import { AdsConsentDebugGeography } from '../AdsConsentDebugGeography';
 import { AdsConsentStatus } from '../AdsConsentStatus';
 /**
@@ -55,6 +56,47 @@ export interface AdsConsentInterface {
      * ```
      */
     showForm(): Promise<AdsConsentFormResult>;
+    /**
+     * Returns the value stored under the `IABTCF_TCString` key
+     * in NSUserDefaults (iOS) / SharedPreferences (Android) as
+     * defined by the IAB Europe Transparency & Consent Framework.
+     *
+     * More information available here:
+     * https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework/blob/master/TCFv2/IAB%20Tech%20Lab%20-%20CMP%20API%20v2.md#in-app-details
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent } from '@invertase/react-native-google-ads';
+     *
+     * const tcString = await AdsConsent.getTCString();
+     * ```
+     */
+    getTCString(): Promise<string>;
+    /**
+     * Returns the TC Model of the saved IAB TCF 2.0 String.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent } from '@invertase/react-native-google-ads';
+     *
+     * const tcModel = await AdsConsent.getTCModel();
+     * ```
+     */
+    getTCModel(): Promise<TCModel>;
+    /**
+     * Provides information about a user's consent choices.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent } from '@invertase/react-native-google-ads';
+     *
+     * const { storeAndAccessInformationOnDevice } = await AdsConsent.getUserChoices();
+     * ```
+     */
+    getUserChoices(): Promise<AdsConsentUserChoices>;
     /**
      * Resets the UMP SDK state.
      *
@@ -117,3 +159,177 @@ export interface AdsConsentInfo {
      */
     isConsentFormAvailable: boolean;
 }
+/**
+ * The options used when requesting consent information.
+ *
+ * https://vendor-list.consensu.org/v2/vendor-list.json
+ * https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework
+ */
+export interface AdsConsentUserChoices {
+    /**
+     * Your device can be identified based on a scan of your device's
+     * unique combination of characteristics.
+     *
+     * Vendors can:
+     *   - Create an identifier using data collected via actively scanning a device for
+     *   - specific characteristics, e.g. installed fonts or screen resolution.
+     *   - Use such an identifier to re-identify a device.
+     */
+    activelyScanDeviceCharacteristicsForIdentification: boolean;
+    /**
+     * Market research can be used to learn more about the audiences who visit sites/apps and view ads.
+     *
+     * To apply market research to generate audience insights vendors can:
+     *   - Provide aggregate reporting to advertisers or their representatives about
+     *     the audiences reached by their ads, through panel-based and similarly derived insights.
+     *   - Provide aggregate reporting to publishers about the audiences that were served or
+     *     interacted with content and/or ads on their property by applying
+     *     panel-based and similarly derived insights.
+     *   - Associate offline data with an online user for the purposes of
+     *     market research to generate audience insights if vendors have declared to match and
+     *     combine offline data sources (Feature 1)
+     *   - Combine this information with other information previously collected including from
+     *     across websites and apps.
+     *
+     * Vendors cannot:
+     *   - Measure the performance and effectiveness of ads that a specific user was served or
+     *     interacted with, without a Legal Basis to measure ad performance.
+     *   - Measure which content a specific user was served and how they interacted with it,
+     *     without a Legal Basis to measure content performance.
+     */
+    applyMarketResearchToGenerateAudienceInsights: boolean;
+    /**
+     * A profile can be built about you and your interests to show you personalised ads
+     * that are relevant to you.
+     *
+     * To create a personalised ads profile vendors can:
+     *   - Collect information about a user, including a user's activity, interests,
+     *     demographic information, or location, to create or edit a user profile for use
+     *     in personalised advertising.
+     *   - Combine this information with other information previously collected,
+     *     including from across websites and apps, to create or edit a user profile
+     *     for use in personalised advertising.
+     */
+    createAPersonalisedAdsProfile: boolean;
+    /**
+     * A profile can be built about you and your interests to show you personalised content
+     * that is relevant to you.
+     *
+     * To create a personalised content profile vendors can:
+     *   - Collect information about a user, including a user's activity, interests, visits to
+     *     sites or apps, demographic information, or location, to create or edit a user profile
+     *     for personalising content.
+     *   - Combine this information with other information previously collected,
+     *     including from across websites and apps, to create or edit a user profile for use
+     *     in personalising content.
+     */
+    createAPersonalisedContentProfile: boolean;
+    /**
+     * Your data can be used to improve existing systems and software,
+     * and to develop new products
+     *
+     * To develop new products and improve products vendors can:
+     *   - Use information to improve their existing products with new features and
+     *     to develop new products
+     *   - Create new models and algorithms through machine learning
+     *
+     * Vendors cannot:
+     *   - Conduct any other data processing operation allowed under
+     *     a different purpose under this purpose
+     */
+    developAndImproveProducts: boolean;
+    /**
+     * The performance and effectiveness of ads that you see or interact with can be measured.
+     *
+     * To measure ad performance vendors can:
+     *   - Measure whether and how ads were delivered to and interacted with by a user
+     *   - Provide reporting about ads including their effectiveness and performance
+     *   - Provide reporting about users who interacted with ads using data observed during
+     *     the course of the user's interaction with that ad
+     *   - Provide reporting to publishers about the ads displayed on their property
+     *   - Measure whether an ad is serving in a suitable editorial environment (brand-safe) context
+     *   - Determine the percentage of the ad that had the opportunity to be seen and
+     *     the duration of that opportunity
+     *   - Combine this information with other information previously collected,
+     *     including from across websites and apps
+     *
+     * Vendors cannot:
+     *   - Apply panel- or similarly-derived audience insights data to ad measurement data
+     *     without a Legal Basis to apply market research to generate audience insights (Purpose 9)
+     */
+    measureAdPerformance: boolean;
+    /**
+     * The performance and effectiveness of content that you see or interact with can be measured.
+     *
+     * To measure content performance vendors can:
+     *   - Measure and report on how content was delivered to and interacted with by users.
+     *   - Provide reporting, using directly measurable or known information, about users who
+     *     interacted with the content
+     *   - Combine this information with other information previously collected,
+     *     including from across websites and apps.
+     *
+     * Vendors cannot:
+     *   - Measure whether and how ads (including native ads) were delivered to and
+     *     interacted with by a user.
+     *   - Apply panel- or similarly derived audience insights data to ad measurement
+     *     data without a Legal Basis to apply market research to generate audience insights (Purpose 9)
+     */
+    measureContentPerformance: boolean;
+    /**
+     * Ads can be shown to you based on the content you’re viewing,
+     * the app you’re using, your approximate location, or your device type.
+     *
+     * To do basic ad selection vendors can:
+     *  - Use real-time information about the context in which the ad will be shown,
+     *    to show the ad, including information about the content and the device, such as:
+     *    device type and capabilities, user agent, URL, IP address
+     *  - Use a user’s non-precise geolocation data
+     *  - Control the frequency of ads shown to a user.
+     *  - Sequence the order in which ads are shown to a user.
+     *  - Prevent an ad from serving in an unsuitable editorial (brand-unsafe) context
+     *
+     * Vendors cannot:
+     *  - Create a personalised ads profile using this information for the selection of
+     *    future ads without a separate legal basis to create a personalised ads profile.
+     *  - N.B. Non-precise means only an approximate location involving at least a radius
+     *    of 500 meters is permitted.
+     */
+    selectBasicAds: boolean;
+    /**
+     * Personalised ads can be shown to you based on a profile about you.
+     *
+     * To select personalised ads vendors can:
+     *   - Select personalised ads based on a user profile or other historical user data,
+     *     including a user’s prior activity, interests, visits to sites or apps, location,
+     *     or demographic information.
+     */
+    selectPersonalisedAds: boolean;
+    /**
+     * Personalised content can be shown to you based on a profile about you.
+     *
+     * To select personalised content vendors can:
+     *   - Select personalised content based on a user profile or other historical user data,
+     *     including a user’s prior activity, interests, visits to sites or apps, location,
+     *     or demographic information.
+     */
+    selectPersonalisedContent: boolean;
+    /**
+     * Cookies, device identifiers, or other information can be stored or
+     * accessed on your device for the purposes presented to you.
+     *
+     * Vendors can:
+     *   - Store and access information on the device such as cookies and
+     *     device identifiers presented to a user.
+     */
+    storeAndAccessInformationOnDevice: boolean;
+    /**
+     * Your precise geolocation data can be used in support of one or more purposes.
+     * This means your location can be accurate to within several meters.
+     *
+     * Vendors can:
+     *   - Collect and process precise geolocation data in support of one or more purposes.
+     *   - Precise geolocation means that there are no restrictions on the precision of
+     *     a user's location; this can be accurate to within several meters.
+     */
+    usePreciseGeolocationData: boolean;
+}

package/lib/typescript/types/AppEvent.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An app event received from Google Ad Manager ads.
+ */
+export interface AppEvent {
+    /**
+     * The event name.
+     */
+    name: string;
+    /**
+     * The data received with the app event.
+     */
+    data?: string;
+}