react-native-google-mobile-ads 4.1.0

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

@@ -0,0 +1,32 @@
+import { EmitterSubscription } from 'react-native';
+import { RewardedAdEventType } from '../RewardedAdEventType';
+import { AdEventType } from '../AdEventType';
+import { AdEventListener } from '../types/AdEventListener';
+import { RequestOptions } from '../types/RequestOptions';
+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: {
+        body: {
+            type: AdEventType | RewardedAdEventType;
+            error?: {
+                code: string;
+                message: string;
+            };
+            data?: RewardedAdReward;
+        };
+    }): void;
+    _setAdEventHandler(handler: AdEventListener): () => null;
+    get adUnitId(): string;
+    get loaded(): boolean;
+}

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

@@ -0,0 +1,84 @@
+import { MobileAd } from './MobileAd';
+import { AdEventListener } from '../types/AdEventListener';
+import { AdShowOptions } from '../types/AdShowOptions';
+import { RequestOptions } from '../types/RequestOptions';
+import { MobileAdInterface } from '../types/MobileAd.interface';
+/**
+ * A class for interacting and showing Rewarded Ads.
+ *
+ * An Rewarded advert can be pre-loaded and shown at a suitable point in your apps flow, such as at the end of a level
+ * in a game. The content of a rewarded advert can be controlled via your Google Mobile Ads dashboard. Typically users are rewarded
+ * after completing a specific advert action (e.g. watching a video or submitting an option via an interactive form).
+ * Events (such as the user earning a reward or closing a rewarded advert early) are sent back for you to handle accordingly
+ * within your application.
+ *
+ * #### Example
+ *
+ * First create a new Rewarded instance, passing in your Ad Unit ID from the Google Mobile Ads configuration console, and any additional
+ * request options. The example below will present a test advert, and only request a non-personalized ad.
+ *
+ * ```js
+ * import { RewardedAd, TestIds } from 'react-native-google-mobile-ads';
+ *
+ * const rewarded = RewardedAd.createForAdRequest(TestIds.REWARDED, {
+ *     requestNonPersonalizedAdsOnly: true,
+ * });
+ *  ```
+ *
+ * Each advert needs to be loaded from Google Mobile Ads before being shown. It is recommended this is performed before the user
+ * reaches the checkpoint to show the advert, so it's ready to go. Before loading the advert, we need to setup
+ * event listeners to listen for updates from Google Mobile Ads, such as advert loaded or failed to load.
+ *
+ * Event types match the `AdEventType` or `RewardedAdEventType` interface. The potential user reward for rewarded
+ * adverts are passed back to the event handler on advert load and when the user earns the reward.
+ *
+ * ```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.load();
+ *  ```
+ *
+ * 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 {
+    /**
+     * Creates a new RewardedAd instance.
+     *
+     * #### Example
+     *
+     * ```js
+     * import { RewardedAd, RewardedAdEventType, TestIds } from 'react-native-google-mobile-ads';
+     *
+     * const rewardedAd = await RewardedAd.createForAdRequest(TestIds.REWARDED, {
+     *   requestAgent: 'CoolAds',
+     * });
+     *
+     * rewardedAd.onAdEvent((type, error, data) => {
+     *   console.log('New event: ', type, error);
+     *
+     *   if (type === RewardedAdEventType.LOADED) {
+     *     rewardedAd.show();
+     *   }
+     * });
+     *
+     * rewardedAd.load();
+     * ```
+     *
+     * @param adUnitId The Ad Unit ID for the Rewarded Ad. You can find this on your Google Mobile Ads dashboard.
+     * @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>;
+}

package/lib/typescript/common/Base64.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react-native" />
+/// <reference types="node" />
+/**
+ * window.btoa
+ */
+export declare function btoa(input: string): string;
+/**
+ * window.atob
+ */
+export declare function atob(input: string): string;
+/**
+ * Converts a Blob, ArrayBuffer or Uint8Array to a base64 string.
+ */
+export declare function fromData(data: Blob | ArrayBuffer | Uint8Array): Promise<unknown> | null;

package/lib/typescript/common/MutatableParams.d.ts

@@ -0,0 +1,9 @@
+export declare class MutatableParams {
+    _mutatableParams: Record<string, unknown>;
+    _parentInstance: MutatableParams;
+    constructor(parentInstance: MutatableParams);
+    set(param: string, value: unknown): MutatableParams;
+    get(param: string): unknown;
+    toJSON(): Record<string, unknown>;
+    validate(): void;
+}

package/lib/typescript/common/ReferenceBase.d.ts

@@ -0,0 +1,11 @@
+export declare class ReferenceBase {
+    path: string;
+    constructor(_path: string);
+    /**
+     * The last part of a Reference's path (after the last '/')
+     * The key of a root Reference is null.
+     * @type {String}
+     * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#key}
+     */
+    get key(): string | null;
+}

package/lib/typescript/common/deeps.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Deep get a value from an object.
+ * @website https://github.com/Salakar/deeps
+ * @param object
+ * @param path
+ * @param joiner
+ * @returns {*}
+ */
+export declare function deepGet(object: Record<string, unknown>, path: string, joiner?: string): unknown;
+/**
+ * Deep set a value
+ * @param object
+ * @param path
+ * @param value
+ * @param initPaths
+ * @param joiner
+ */
+export declare function deepSet(object: Record<string, unknown>, path: string, value: unknown, initPaths?: boolean, joiner?: string): boolean;

package/lib/typescript/common/id.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generate a firebase id - for use with ref().push(val, cb) - e.g. -KXMr7k2tXUFQqiaZRY4'
+ * @param serverTimeOffset - pass in server time offset from native side
+ * @returns {string}
+ */
+export declare function generateDatabaseId(serverTimeOffset?: number): string;
+/**
+ * Generate a firestore auto id for use with collection/document .add()
+ * @return {string}
+ */
+export declare function generateFirestoreId(): string;

package/lib/typescript/common/index.d.ts

@@ -0,0 +1,28 @@
+import * as Base64 from './Base64';
+export * from './id';
+export * from './path';
+export * from './promise';
+export * from './validate';
+export { Base64 };
+export { ReferenceBase } from './ReferenceBase';
+export declare function getDataUrlParts(dataUrlString: string): {
+    base64String: undefined;
+    mediaType: undefined;
+} | {
+    base64String: string;
+    mediaType: string;
+};
+export declare function once<T>(fn: () => void, context: unknown): (this: T, ...args: []) => void;
+export declare function isError(value: unknown): boolean;
+export declare function hasOwnProperty(target: unknown, property: PropertyKey): boolean;
+/**
+ * Remove a trailing forward slash from a string if it exists
+ *
+ * @param string
+ * @returns {*}
+ */
+export declare function stripTrailingSlash(string: string): string;
+export declare const isIOS: boolean;
+export declare const isAndroid: boolean;
+export declare function tryJSONParse(string: string): any;
+export declare function tryJSONStringify(data: unknown): string | null;

package/lib/typescript/common/path.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Returns the next parent of the path e.g. /foo/bar/car -> /foo/bar
+ */
+export declare function pathParent(path: string): string | null;
+/**
+ * Joins a parent and a child path
+ */
+export declare function pathChild(path: string, childPath: string): string;
+/**
+ * Returns the last component of a path, e.g /foo/bar.jpeg -> bar.jpeg
+ */
+export declare function pathLastComponent(path: string): string;
+/**
+ * Returns all none empty pieces of the path
+ * @param path
+ * @returns {*}
+ */
+export declare function pathPieces(path: string): string[];
+/**
+ * Returns whether a given path is empty
+ * @param path
+ * @returns {boolean}
+ */
+export declare function pathIsEmpty(path: string): boolean;
+/**
+ * Converts a given path to a URL encoded string
+ * @param path
+ * @returns {string|string}
+ */
+export declare function pathToUrlEncodedString(path: string): string;
+export declare const INVALID_PATH_REGEX: RegExp;
+/**
+ * Ensures a given path is a valid Firebase path
+ * @param path
+ * @returns {boolean}
+ */
+export declare function isValidPath(path: unknown): boolean;
+/**
+ * Converts a file path to a standardized string path
+ * @param path
+ * @returns {*}
+ */
+export declare function toFilePath(path: string): string;

package/lib/typescript/common/promise.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ */
+export declare function promiseDefer(): {
+    promise: Promise<unknown> | null;
+    resolve: (value: unknown) => void;
+    reject: (value: unknown) => void;
+};
+/**
+ * @param promise
+ * @param callback
+ */
+export declare function promiseWithOptionalCallback(promise: Promise<unknown>, callback: (a: unknown, b?: unknown) => void): Promise<unknown>;

package/lib/typescript/common/serialize.d.ts

@@ -0,0 +1,5 @@
+export declare function serializeType(value: unknown): {
+    type: string;
+    value: any;
+};
+export declare function serializeObject(object: unknown): any;

package/lib/typescript/common/validate.d.ts

@@ -0,0 +1,90 @@
+export declare function objectKeyValuesAreStrings(object: Record<string, unknown>): boolean;
+/**
+ * Simple is null check.
+ *
+ * @param value
+ * @returns {boolean}
+ */
+export declare function isNull(value: unknown): boolean;
+/**
+ * Simple is object check.
+ *
+ * @param value
+ * @returns {boolean}
+ */
+export declare function isObject(value: unknown): boolean;
+/**
+ * Simple is date check
+ * https://stackoverflow.com/a/44198641
+ * @param value
+ * @returns {boolean}
+ */
+export declare function isDate(value: number): boolean | 0;
+/**
+ * Simple is function check
+ *
+ * @param value
+ * @returns {*|boolean}
+ */
+export declare function isFunction(value: unknown): boolean;
+/**
+ * Simple is string check
+ * @param value
+ * @return {boolean}
+ */
+export declare function isString(value: unknown): boolean;
+/**
+ * Simple is number check
+ * @param value
+ * @return {boolean}
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Simple finite check
+ * @param value
+ * @returns {boolean}
+ */
+export declare function isFinite(value: unknown): boolean;
+/**
+ * Simple integer check
+ * @param value
+ * @returns {boolean}
+ */
+export declare function isInteger(value: unknown): boolean;
+/**
+ * Simple is boolean check
+ *
+ * @param value
+ * @return {boolean}
+ */
+export declare function isBoolean(value: unknown): boolean;
+/**
+ *
+ * @param value
+ * @returns {arg is Array<unknown>}
+ */
+export declare function isArray(value: unknown): boolean;
+/**
+ *
+ * @param value
+ * @returns {boolean}
+ */
+export declare function isUndefined(value: unknown): value is undefined;
+/**
+ * /^[a-zA-Z0-9_]+$/
+ *
+ * @param value
+ * @returns {boolean}
+ */
+export declare function isAlphaNumericUnderscore(value: string): boolean;
+export declare function isValidUrl(url: string): boolean;
+/**
+ * Array includes
+ *
+ * @param value
+ * @param oneOf
+ * @returns {boolean}
+ */
+export declare function isOneOf(value: unknown, oneOf?: unknown[]): boolean;
+export declare function noop(): void;
+export declare function validateOptionalNativeDependencyExists(firebaseJsonKey: string, apiName: string, nativeFnExists: boolean): void;

package/lib/typescript/index.d.ts

@@ -0,0 +1,14 @@
+export declare const SDK_VERSION = "4.1.0";
+export { default, MobileAds } from './MobileAds';
+export { AdsConsentDebugGeography } from './AdsConsentDebugGeography';
+export { AdsConsentStatus } from './AdsConsentStatus';
+export { MaxAdContentRating } from './MaxAdContentRating';
+export { TestIds } from './TestIds';
+export { AdEventType } from './AdEventType';
+export { BannerAdSize } from './BannerAdSize';
+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';

package/lib/typescript/internal/GoogleMobileAdsNativeEventEmitter.d.ts

@@ -0,0 +1,12 @@
+import { NativeEventEmitter, EmitterSubscription } from 'react-native';
+declare class GANativeEventEmitter extends NativeEventEmitter {
+    ready: boolean;
+    constructor();
+    addListener(eventType: string, listener: (event: {
+        appName?: string;
+    }) => void, context?: Record<string, unknown>): EmitterSubscription;
+    removeAllListeners(eventType: string): void;
+    removeSubscription(subscription: EmitterSubscription): void;
+}
+export declare const GoogleMobileAdsNativeEventEmitter: GANativeEventEmitter;
+export {};

package/lib/typescript/internal/Module.d.ts

@@ -0,0 +1,13 @@
+import { App, Config } from '../types/Module.interface';
+import { GoogleMobileAdsNativeModule } from '../types/GoogleMobileAdsNativeModule';
+export declare class AppModule {
+    _app: App;
+    _nativeModule: unknown;
+    _config: Config;
+    static __extended__: {};
+    constructor(app: App, config: Config);
+    get app(): App;
+    get emitter(): import("react-native").EventEmitter;
+    eventNameForApp(...args: string[]): string;
+    get native(): GoogleMobileAdsNativeModule;
+}

package/lib/typescript/internal/NativeError.d.ts

@@ -0,0 +1,26 @@
+export declare class NativeError extends Error {
+    namespace: string;
+    code: string;
+    message: string;
+    jsStack: string;
+    userInfo: {
+        code: string;
+        message: string;
+    };
+    static fromEvent(errorEvent: {
+        code: string;
+        message: string;
+    }, namespace: string, stack?: string): NativeError;
+    constructor(nativeError: {
+        userInfo: {
+            code: string;
+            message: string;
+        };
+    }, jsStack: string, namespace: string);
+    /**
+     * Build a stack trace that includes JS stack prior to calling the native method.
+     *
+     * @returns {string}
+     */
+    static getStackWithMessage(message: string, jsStack: string): string;
+}

package/lib/typescript/internal/SharedEventEmitter.d.ts

@@ -0,0 +1,2 @@
+import { EventEmitter } from 'react-native';
+export declare const SharedEventEmitter: EventEmitter;

package/lib/typescript/internal/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const APP_NATIVE_MODULE = "RNFBAppModule";
+export declare const DEFAULT_APP_NAME = "[DEFAULT]";
+export declare const KNOWN_NAMESPACES: string[];

package/lib/typescript/internal/index.d.ts

@@ -0,0 +1,4 @@
+export { AppModule as Module } from './Module';
+export { NativeError } from './NativeError';
+export * from './registry/nativeModule';
+export { SharedEventEmitter } from './SharedEventEmitter';

package/lib/typescript/internal/registry/nativeModule.d.ts

@@ -0,0 +1,15 @@
+import { ModuleInterface } from '../../types/Module.interface';
+/**
+ * Gets a wrapped native module instance for the provided module.
+ * Will attempt to create a new instance if non previously created.
+ *
+ * @param module
+ * @returns {*}
+ */
+export declare function getNativeModule(module: ModuleInterface): unknown;
+/**
+ * Custom wrapped app module as it does not have it's own FirebaseModule based class.
+ *
+ * @returns {*}
+ */
+export declare function getAppModule(): unknown;

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

@@ -0,0 +1,11 @@
+import { AdEventType } from '../AdEventType';
+import { RewardedAdReward } from './RewardedAdReward';
+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;

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

@@ -0,0 +1,12 @@
+/**
+ * A `AdShowOptions` interface used when showing an ad.
+ */
+export interface AdShowOptions {
+    /**
+     * - On Android, enables [immersive mode](https://developer.android.com/training/system-ui/immersive).
+     * - On iOS, this has no effect on how the ad is shown.
+     *
+     * @android
+     */
+    immersiveModeEnabled?: boolean;
+}

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

@@ -0,0 +1,18 @@
+export declare enum InitializationState {
+    /**
+     * The mediation adapter is less likely to fill ad requests.
+     */
+    AdapterInitializationStateNotReady = 0,
+    /**
+     * The mediation adapter is ready to service ad requests.
+     */
+    AdapterInitializationStateReady = 1
+}
+/**
+ * An immutable snapshot of a mediation adapter's initialization status.
+ */
+export declare type AdapterStatus = {
+    name: string;
+    description: string;
+    status: InitializationState;
+};