react-native-google-mobile-ads 4.1.0

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

@@ -0,0 +1,286 @@
+import { AdsConsentDebugGeography } from '../AdsConsentDebugGeography';
+import { AdsConsentStatus } from '../AdsConsentStatus';
+/**
+ * Under the Google [EU User Consent Policy](https://www.google.com/about/company/consentstaging.html), you must make certain disclosures to your users in the European Economic Area (EEA)
+ * and obtain their consent to use cookies or other local storage, where legally required, and to use personal data
+ * (such as AdID) to serve ads. This policy reflects the requirements of the EU ePrivacy Directive and the
+ * General Data Protection Regulation (GDPR).
+ *
+ * It is recommended that you determine the status of a user's consent at every app launch. The user consent status is held
+ * on the device until a condition changes which requires the user to consent again, such as a change in publishers.
+ *
+ * For more information, see [here](https://developers.google.com/admob/android/eu-consent#delay_app_measurement_optional).
+ */
+/**
+ * A AdProvider interface returned from `AdsConsent.getProviders`.
+ */
+export interface AdProvider {
+    /**
+     * A provider company ID.
+     */
+    companyId: string;
+    /**
+     * A provider company name.
+     */
+    companyName: string;
+    /**
+     * A fully formed URL for the privacy policy of the provider.
+     */
+    privacyPolicyUrl: string;
+}
+export interface AdsConsentInterface {
+    /**
+     * Requests user consent for a given list of publisher IDs.
+     *
+     * The list of publisher IDs can be obtained from the settings panel on the Google Mobile Ads console. If the list of
+     * publisher IDs has changed since the last time a user provided consent, their consent status will be reset to
+     * 'UNKNOWN' and they must provide consent again.
+     *
+     * If the request fails with the error "Could not parse Event FE preflight response", this means the state of your
+     * Google Mobile Ads account is not complete. Ensure you have validated your account and have setup valid payment
+     * information. This error is also thrown when a Publisher ID is invalid.
+     *
+     * The response from this method provides request location and consent status properties.
+     *
+     * If request location is within the EEA or unknown, and the consent status is also unknown, you
+     * must request consent via the `showForm()` method or your own means.
+     *
+     * If the consent status is not unknown, the user has already previously provided consent for the current publisher
+     * scope.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent } from 'react-native-google-mobile-ads';
+     *
+     * const consent = await AdsConsent.requestInfoUpdate(['pub-6189033257628554']);
+     * console.log('User location within EEA or Unknown:', consent.isRequestLocationInEeaOrUnknown);
+     * console.log('User consent status:', consent.status);
+     * ```
+     *
+     * @param publisherIds A list of publisher IDs found on your Google Mobile Ads dashboard.
+     */
+    requestInfoUpdate(publisherIds: string[]): Promise<AdsConsentInfo>;
+    /**
+     * Shows a Google-rendered user consent form.
+     *
+     * The Google-rendered consent form is a full-screen configurable form that displays over your app content. The form
+     * allows the following configuration options:
+     *
+     *
+     * 1. Consent to view personalized ads (via `withPersonalizedAds`).
+     * 2. Consent to view non-personalized ads (via `withNonPersonalizedAds`).
+     * 3. Use a paid version of the app instead of viewing ads (via `withAdFree`).
+     *
+     * Every consent form requires a privacy policy URL which outlines the usage of your application.
+     *
+     * You should review the consent text carefully: what appears by default is a message that might be appropriate if
+     * you use Google to monetize your app.
+     *
+     * If providing an ad-free version of your app, ensure you handle this once the form has been handled by the user
+     * via the `userPrefersAdFree` property. The users preference on consent is automatically forwarded onto the Google
+     * Mobile SDKs and saved.
+     *
+     * If the user is outside of the EEA, the request form will error.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent, AdsConsentStatus } from 'react-native-google-mobile-ads';
+     *
+     * async function requestConsent() {
+     *   const consent = await AdsConsent.requestInfoUpdate(['pub-6189033257628554']);
+     *
+     *   // Check if user requires consent
+     *   if (consent.isRequestLocationInEeaOrUnknown && consent.status === AdsConsentStatus.UNKNOWN) {
+     *     // Show a Google-rendered form
+     *     const result = await AdsConsent.showForm({
+     *       privacyPolicy: 'https://invertase.io/privacy-policy',
+     *       withPersonalizedAds: true,
+     *       withNonPersonalizedAds: true,
+     *       withAdFree: true,
+     *     });
+     *
+     *     console.log('User accepted personalized: ', result.status === AdsConsentStatus.PERSONALIZED);
+     *     console.log('User accepted non-personalized: ', result.status === AdsConsentStatus.NON_PERSONALIZED);
+     *     console.log('User prefers Ad Free version of app: ', result.userPrefersAdFree);
+     *   }
+     * }
+     *
+     * ```
+     *
+     * @param options An AdsConsentFormOptions interface to control the Google-rendered form.
+     */
+    showForm(options: AdsConsentFormOptions): Promise<AdsConsentFormResult>;
+    /**
+     * Returns a list of ad providers currently in use for the given Google Mobile Ads App ID.
+     *
+     * If requesting consent from the user via your own method, this list of ad providers must be shown to the user
+     * for them to accept consent.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent } from 'react-native-google-mobile-ads';
+     *
+     * const providers = await AdsConsent.getAdProviders();
+     * ```
+     */
+    getAdProviders(): Promise<AdProvider[]>;
+    /**
+     * Sets the debug geography to locally test consent.
+     *
+     * If debugging on an emulator (where location cannot be determined) or outside of the EEA,
+     * it is possible set your own location to test how your app handles different scenarios.
+     *
+     * If using a real device, ensure you have set it as a test device via `addTestDevice()` otherwise this method will have
+     * no effect.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent, AdsConsentDebugGeography } from 'react-native-google-mobile-ads';
+     *
+     * // Set disabled
+     * await AdsConsentDebugGeography.setDebugGeography(AdsConsentDebugGeography.DISABLED);
+     *
+     * // Set within EEA
+     * await AdsConsentDebugGeography.setDebugGeography(AdsConsentDebugGeography.EEA);
+     *
+     * // Set outside EEA
+     * await AdsConsentDebugGeography.setDebugGeography(AdsConsentDebugGeography.NOT_EEA);
+     * ```
+     *
+     * @param geography The debug geography location.
+     */
+    setDebugGeography(geography: AdsConsentDebugGeography): Promise<void>;
+    /**
+     * Manually update the consent status of the user.
+     *
+     * This method is used when providing your own means of user consent. If using the Google-rendered form via `showForm()`,
+     * the consent status is automatically set and calling this method is not required.
+     *
+     * This method can also be used to reset the consent status, by setting it to `AdsConsentStatus.UNKNOWN`, which may be useful in certain circumstances.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent, AdsConsentStatus } from 'react-native-google-mobile-ads';
+     *
+     * // User accepted personalized ads
+     * await AdsConsent.setStatus(AdsConsentStatus.PERSONALIZED);
+     * ```
+     *
+     * @param status The user consent status.
+     */
+    setStatus(status: AdsConsentStatus): Promise<void>;
+    /**
+     * Returns the current consent status of the user.
+     *
+     * > The user consent status may change at any time, therefore don't reuse old values locally and always request the current value at any time consent is required.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent } from 'react-native-google-mobile-ads';
+     *
+     * const status = await AdsConsent.getStatus();
+     * ```
+     */
+    getStatus(): Promise<AdsConsentStatus>;
+    /**
+     * If a publisher is aware that the user is under the age of consent, all ad requests must set TFUA (Tag For Users
+     * Under the Age of consent in Europe). This setting takes effect for all future ad requests.
+     *
+     * Once the TFUA setting is enabled, the Google-rendered consent form will fail to load. All ad requests that include
+     * TFUA will be made ineligible for personalized advertising and remarketing. TFUA disables requests to third-party
+     * ad technology providers, such as ad measurement pixels and third-party ad servers.
+     *
+     * To remove TFUA from ad requests, set the value to `false`.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { AdsConsent } from 'react-native-google-mobile-ads';
+     *
+     * // User is under age of consent
+     * await AdsConsent.setTagForUnderAgeOfConsent(true);
+     * ```
+     *
+     * @param tag The boolean value to tag for under age consent.
+     */
+    setTagForUnderAgeOfConsent(tag: boolean): Promise<void>;
+    /**
+     * If using a real device to test, ensure the device ID is provided to the Google Mobile Ads SDK so any mock debug locations
+     * can take effect.
+     *
+     * Emulators are automatically on the allowlist and should require no action.
+     *
+     * If you are seeing real ad activity from a test device, examine logcat / console
+     * during execution in association with google mobile ads test device documentation to
+     * configure your device correctly.
+     *
+     * @param deviceIds An array of testing device ID.
+     */
+    addTestDevices(deviceIds: string[]): Promise<void>;
+}
+/**
+ * The options used to show on the Google-rendered consent form. At least one of `withAdFree`, `withPersonalizedAds` and `WithNonPersonalizedAds` needs to be set to `true`.
+ */
+export interface AdsConsentFormOptions {
+    /**
+     * A fully formed HTTP or HTTPS privacy policy URL for your application.
+     *
+     * Users will have the option to visit this web page before consenting to ads.
+     */
+    privacyPolicy: string;
+    /**
+     * Set to `true` to provide the option for the user to accept being shown personalized ads, defaults to `false`.
+     */
+    withPersonalizedAds?: boolean;
+    /**
+     * Set to `true` to provide the option for the user to accept being shown non-personalized ads, defaults to `false`.
+     */
+    withNonPersonalizedAds?: boolean;
+    /**
+     * Set to `true` to provide the option for the user to choose an ad-free version of your app, defaults to `false`.
+     *
+     * If the user chooses this option, you must handle it as required (e.g. navigating to a paid version of the app,
+     * or a subscribe view).
+     */
+    withAdFree?: boolean;
+}
+/**
+ * The result of a Google-rendered consent form.
+ */
+export interface AdsConsentFormResult {
+    /**
+     * The consent status of the user after closing the consent form.
+     *
+     * - UNKNOWN: The form was unable to determine the users consent status.
+     * - NON_PERSONALIZED: The user has accepted non-personalized ads.
+     * - PERSONALIZED: The user has accepted personalized ads.
+     */
+    status: AdsConsentStatus;
+    /**
+     * If `true`, the user requested an ad-free version of your application.
+     */
+    userPrefersAdFree: boolean;
+}
+/**
+ * The result of requesting info about a users consent status.
+ */
+export interface AdsConsentInfo {
+    /**
+     * The consent status of the user.
+     *
+     * - UNKNOWN: The consent status is unknown and the user must provide consent to show ads if they are within the EEA or location is also unknown.
+     * - NON_PERSONALIZED: The user has accepted non-personalized ads.
+     * - PERSONALIZED: The user has accepted personalized ads.
+     */
+    status: AdsConsentStatus;
+    /**
+     * If `true` the user is within the EEA or their location could not be determined.
+     */
+    isRequestLocationInEeaOrUnknown: boolean;
+}

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

@@ -0,0 +1,66 @@
+import { BannerAdSize } from '../BannerAdSize';
+import { RequestOptions } from './RequestOptions';
+/**
+ * An interface for a Banner advert component.
+ *
+ * #### Example
+ *
+ * The `BannerAd` interface is exposed as a React component, allowing you to integrate ads within your existing React
+ * Native code base. The component itself is isolated, meaning any standard `View` props (e.g. `style`) are not
+ * forwarded on. It is recommended you wrap the `BannerAd` within your own `View` if you wish to apply custom props for use-cases
+ * such as positioning.
+ *
+ * ```js
+ * import { BannerAd, BannerAdSize, TestIds } from 'react-native-google-mobile-ads';
+ *
+ * function HomeScreen() {
+ *   return (
+ *     <BannerAd
+ *       unitId={TestIds.BANNER}
+ *       size={BannerAdSize.FULL_BANNER}
+ *       requestOptions={{
+ *         requestNonPersonalizedAdsOnly: true,
+ *       }}
+ *       onAdLoaded={() => {
+ *         console.log('Advert loaded');
+ *       }}
+ *       onAdFailedToLoad={(error) => {
+ *         console.error('Advert failed to load: ', error);
+ *       }}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare type BannerAdProps = {
+    /**
+     * The Google Mobile Ads unit ID for the banner.
+     */
+    unitId: string;
+    /**
+     * The size of the banner. Can be a predefined size via `BannerAdSize` or custom dimensions, e.g. `300x200`.
+     *
+     * Inventory must be available for the banner size specified, otherwise a no-fill error will be sent to `onAdFailedToLoad`.
+     */
+    size: BannerAdSize;
+    /**
+     * The request options for this banner.
+     */
+    requestOptions?: RequestOptions;
+    /**
+     * When an ad has finished loading.
+     */
+    onAdLoaded?: () => void;
+    /**
+     * When an ad has failed to load. Callback contains an Error.
+     */
+    onAdFailedToLoad?: (error: Error) => void;
+    /**
+     * The ad is now visible to the user.
+     */
+    onAdOpened?: () => void;
+    /**
+     * Called when the user is about to return to the app after tapping on an ad.
+     */
+    onAdClosed?: () => void;
+};

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

@@ -0,0 +1,14 @@
+import { AdapterStatus } from './AdapterStatus';
+import { RequestConfiguration } from './RequestConfiguration';
+import { RequestOptions } from './RequestOptions';
+import { AdShowOptions } from './AdShowOptions';
+export interface GoogleMobileAdsNativeModule {
+    initialize(): Promise<AdapterStatus[]>;
+    setRequestConfiguration(requestConfiguration?: RequestConfiguration): Promise<void>;
+    appOpenLoad(requestId: number, adUnitId: string, requestOptions: RequestOptions): void;
+    appOpenShow(requestId: number, showOptions?: AdShowOptions): Promise<void>;
+    interstitialLoad(requestId: number, adUnitId: string, requestOptions: RequestOptions): void;
+    interstitialShow(requestId: number, showOptions?: AdShowOptions): Promise<void>;
+    rewardedLoad(requestId: number, adUnitId: string, requestOptions: RequestOptions): void;
+    rewardedShow(requestId: number, adUnitId: string, showOptions?: AdShowOptions): Promise<void>;
+}

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

@@ -0,0 +1,64 @@
+import { AdEventListener } from './AdEventListener';
+import { AdShowOptions } from './AdShowOptions';
+/**
+ * Base class for InterstitialAd, RewardedAd, NativeAd and BannerAd.
+ */
+export interface MobileAdInterface {
+    /**
+     * The Ad Unit ID for this Gogole Mobile Ads ad.
+     */
+    adUnitId: string;
+    /**
+     * Whether the advert is loaded and can be shown.
+     */
+    loaded: boolean;
+    /**
+     * Start loading the advert with the provided RequestOptions.
+     *
+     * It is recommended you setup ad event handlers before calling this method.
+     */
+    load(): void;
+    /**
+     * Listen to ad events. See AdEventTypes for more information.
+     *
+     * Returns an unsubscriber function to stop listening to further events.
+     *
+     * #### Example
+     *
+     * ```js
+     * // Create InterstitialAd/RewardedAd
+     * const advert = InterstitialAd.createForAdRequest('...');
+     *
+     * const unsubscribe = advert.onAdEvent((type) => {
+     *
+     * });
+     *
+     * // Sometime later...
+     * unsubscribe();
+     * ```
+     *
+     * @param listener A listener callback containing a event type, error and data.
+     */
+    onAdEvent(listener: AdEventListener): () => void;
+    /**
+     * Show the loaded advert to the user.
+     *
+     * #### Example
+     *
+     * ```js
+     * // Create InterstitialAd/RewardedAd
+     * const advert = InterstitialAd.createForAdRequest('...');
+     *
+     * advert.onAdEvent((type) => {
+     *   if (type === AdEventType.LOADED) {
+     *     advert.show({
+     *       immersiveModeEnabled: true,
+     *     });
+     *   }
+     * });
+     * ```
+     *
+     * @param showOptions An optional `AdShowOptions` interface.
+     */
+    show(showOptions?: AdShowOptions): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+import { EventEmitter } from 'react-native';
+import { AdapterStatus } from './AdapterStatus';
+import { GoogleMobileAdsNativeModule } from './GoogleMobileAdsNativeModule';
+import { RequestConfiguration } from './RequestConfiguration';
+/**
+ * The Google Mobile Ads service interface.
+ */
+export interface MobileAdsModuleInterface {
+    /**
+     * Initialize the SDK.
+     */
+    initialize(): Promise<AdapterStatus[]>;
+    /**
+     * Sets request options for all future ad requests.
+     *
+     * #### Example
+     *
+     * ```js
+     * import mobileAds, { MaxAdContentRating } from 'react-native-google-mobile-ads';
+     *
+     * await mobileAds().setRequestConfiguration({
+     *   // Update all future requests suitable for parental guidance
+     *   maxAdContentRating: MaxAdContentRating.PG,
+     * });
+     * ```
+     *
+     * @param requestConfiguration An RequestConfiguration interface used on all future Google Mobile Ads ad requests.
+     */
+    setRequestConfiguration(requestConfiguration: RequestConfiguration): Promise<void>;
+    /**
+     * The native module instance for the Google Mobile Ads service.
+     */
+    native: GoogleMobileAdsNativeModule;
+    /**
+     * Returns the shared event emitter instance used for all JS event routing.
+     */
+    emitter: EventEmitter;
+}

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

@@ -0,0 +1,14 @@
+export interface App {
+    name: string;
+}
+export interface Config {
+    version: string;
+    namespace: string;
+    nativeModuleName: string[];
+    nativeEvents: string[];
+}
+export interface ModuleInterface {
+    app: App;
+    _config: Config;
+    _customUrlOrRegion?: string;
+}

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

@@ -0,0 +1,36 @@
+import { MaxAdContentRating } from '../MaxAdContentRating';
+/**
+ * The `RequestConfiguration` used when setting global ad settings via `setRequestConfiguration`.
+ */
+export interface RequestConfiguration {
+    /**
+     * The maximum ad content rating for all ads.  Google Mobile Ads returns ads at or below the specified level.
+     *
+     * Ratings are based on the [digital content label classifications](https://support.google.com/admob/answer/7562142).
+     */
+    maxAdContentRating?: MaxAdContentRating;
+    /**
+     * If `true`, indicates that you want your content treated as child-directed for purposes of COPPA.
+     *
+     * For purposes of the [Children's Online Privacy Protection Act (COPPA)](http://business.ftc.gov/privacy-and-security/children%27s-privacy),
+     * there is a setting called "tag for child-directed treatment". By setting this tag, you certify that this notification
+     * is accurate and you are authorized to act on behalf of the owner of the app. You understand that abuse of this
+     * setting may result in termination of your Google account.
+     */
+    tagForChildDirectedTreatment?: boolean;
+    /**
+     * If `true`, indicates that you want the ad request to be handled in a manner suitable for users under the age of consent.
+     *
+     * You can mark your ad requests to receive treatment for users in the European Economic Area (EEA) under the age of consent.
+     * This feature is designed to help facilitate compliance with the [General Data Protection Regulation (GDPR)](https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679).
+     *
+     * See the [Google Mobile SDK docs](https://developers.google.com/admob/android/targeting#ad_content_filtering) for more information.
+     */
+    tagForUnderAgeOfConsent?: boolean;
+    /**
+     * An array of test device IDs to add to the allowlist.
+     *
+     * If using an emulator, set the device ID to `EMULATOR`.
+     */
+    testDeviceIdentifiers?: string[];
+}

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

@@ -0,0 +1,106 @@
+export interface ServerSideVerificationOptions {
+    /**
+     * User identifier.
+     * If no user identifier is provided by the app, this query parameter will not be present in the SSV callback.
+     */
+    userId?: string;
+    /**
+     * Custom data string.
+     * If no custom data string is provided by the app, this query parameter value will not be present in the SSV callback.
+     */
+    customData?: string;
+}
+/**
+ * The `RequestOptions` interface. Used when passing additional request options before an advert is loaded.
+ */
+export interface RequestOptions {
+    /**
+     * If `true` only non-personalized ads will be loaded.
+     *
+     * Google serves personalized ads by default. This option must be `true` if users who are within the EEA have only
+     * given consent to non-personalized ads.
+     */
+    requestNonPersonalizedAdsOnly?: boolean;
+    /**
+     * Attaches additional properties to an ad request for direct campaign delivery.
+     *
+     * Takes an array of string key/value pairs.
+     *
+     * #### Example
+     *
+     * Attaches `?campaign=abc&user=123` to the ad request:
+     *
+     * ```js
+     * await Interstitial.createForAdRequest('ca-app-pub-3940256099942544/1033173712', {
+     *   networkExtras: {
+     *     campaign: 'abc',
+     *     user: '123',
+     *   },
+     * });
+     */
+    networkExtras?: {
+        [key: string]: string;
+    };
+    /**
+     * An array of keywords to be sent when loading the ad.
+     *
+     * Setting keywords helps deliver more specific ads to a user based on the keywords.
+     *
+     * #### Example
+     *
+     * ```js
+     * await Interstitial.createForAdRequest('ca-app-pub-3940256099942544/1033173712', {
+     *   keywords: ['fashion', 'clothing'],
+     * });
+     * ```
+     */
+    keywords?: string[];
+    /**
+     * Sets a content URL for targeting purposes.
+     *
+     * Max length of 512.
+     */
+    contentUrl?: string;
+    /**
+     * The latitude and longitude location of the user.
+     *
+     * Ensure your app requests location permissions from the user.
+     *
+     * #### Example
+     *
+     * ```js
+     * await Interstitial.createForAdRequest('ca-app-pub-3940256099942544/1033173712', {
+     *   location: [53.481073, -2.237074],
+     * });
+     * ```
+     */
+    location?: [number, number];
+    /**
+     * Sets the location accuracy if the location is set, in meters.
+     *
+     * This option is only applied to iOS devices. On Android, this option has no effect.
+     *
+     * @ios
+     */
+    locationAccuracy?: number;
+    /**
+     * Sets the request agent string to identify the ad request's origin. Third party libraries that reference the Mobile
+     * Ads SDK should call this method to denote the platform from which the ad request originated. For example, if a
+     * third party ad network called "CoolAds network" mediates requests to the Mobile Ads SDK, it should call this
+     * method with "CoolAds".
+     *
+     * #### Example
+     *
+     * ```js
+     * await Interstitial.createForAdRequest('ca-app-pub-3940256099942544/1033173712', {
+     *   requestAgent: 'CoolAds',
+     * });
+     * ```
+     */
+    requestAgent?: string;
+    /**
+     * Server Side Verification(SSV) Options
+     * See [Google Mobile SDK Docs](https://developers.google.com/admob/android/ssv) for more information.
+     */
+    serverSideVerificationOptions?: ServerSideVerificationOptions;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * A `RewardedAdReward` returned from rewarded ads.
+ */
+export interface RewardedAdReward {
+    /**
+     * The reward name, e.g. 'coins', 'diamonds'.
+     */
+    type: string;
+    /**
+     * The number value of the reward, e.g. 10
+     */
+    amount: number;
+}

package/lib/typescript/validateAdRequestConfiguration.d.ts

@@ -0,0 +1,2 @@
+import { RequestConfiguration } from './types/RequestConfiguration';
+export declare function validateAdRequestConfiguration(requestConfiguration: RequestConfiguration): RequestConfiguration;

package/lib/typescript/validateAdRequestOptions.d.ts

@@ -0,0 +1,2 @@
+import { RequestOptions } from './types/RequestOptions';
+export declare function validateAdRequestOptions(options?: RequestOptions): RequestOptions;

package/lib/typescript/validateAdShowOptions.d.ts

@@ -0,0 +1,2 @@
+import { AdShowOptions } from './types/AdShowOptions';
+export declare function validateAdShowOptions(options?: AdShowOptions): AdShowOptions;

package/lib/typescript/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "4.1.0";