@jolibox/ads 1.1.19-beta.6

package/README.md

@@ -0,0 +1 @@
+# Jolibox JSSDK Interface

package/dist/afg/adbreak-async-proxy.d.ts

@@ -0,0 +1,36 @@
+import { IAFGAdBreakServerParams } from './type';
+import type { IAbstractAFGProvider, IPlacementInfo, IAdBreakParams } from './ads-interface';
+import type { IAdsContext } from '../type/base';
+export declare class AdBreakAsyncProxy {
+    private context;
+    private continueCallback?;
+    private isBeforeAdCalled;
+    private isBeforeRewardCalled;
+    private isAdDismissedCalled;
+    private isAdViewedCalled;
+    private isAfterAdCalled;
+    private currentProvider?;
+    private currentClientParams?;
+    private adsHasResponse;
+    private videoChecker;
+    constructor(context: IAdsContext);
+    get paramsToTrack(): {
+        provider: string | null;
+        type: "reward" | "preroll" | "start" | "pause" | "next" | "browse" | undefined;
+        name: string | null;
+    };
+    private wrapBeforeAd;
+    private wrapShowAdFn;
+    private wrapBeforeReward;
+    private wrapAdDismissed;
+    private wrapAdViewed;
+    private wrapAfterAd;
+    private wrapAdBreakDone;
+    /**
+     * Manages ad break execution and continuation logic
+     * @param adsProvider The ad provider implementation
+     * @param clientParams Configuration for the ad break
+     * @returns Promise resolving with continuation flag and last placement info
+     */
+    callAdBreakAndContinue<T extends IAFGAdBreakServerParams>(adsProvider: IAbstractAFGProvider, clientParams: IAdBreakParams, serverParam: T): Promise<[boolean, IPlacementInfo]>;
+}

package/dist/afg/ads-action-detection.d.ts

@@ -0,0 +1,8 @@
+import { IAdsContext } from '@/type/base';
+export declare class AdsActionDetection {
+    private context;
+    adBreakIsShowing: boolean;
+    private reportPageJumpOut;
+    private reportPageHide;
+    constructor(context: IAdsContext);
+}

package/dist/afg/ads-interface.d.ts

@@ -0,0 +1,199 @@
+import { IAFGAdBreakServerParams, IAFGInitServerParams } from './type';
+declare global {
+    interface Window {
+        adsbygoogle: Array<unknown>;
+        JoliTesterBridge?: {
+            log: (message: string) => void;
+        };
+    }
+}
+export interface IAdsInitParams {
+    /**
+     * (OPTIONAL) Game ID provided by Jolibox
+     */
+    gameId?: string;
+}
+export interface IAdConfigParams {
+    /**
+     * (OPTIONAL) Whether ads should always be preloaded before the first call to adBreak()
+     *
+     * The default value of auto leaves the decision up to the Ad Placement API. preloadAdBreaks can be set only once with adConfig(), and further values passed to preloadAdBreaks have no effect.
+     *
+     * Setting preloadAdBreaks after the first call to adBreak() has no effect.
+     */
+    preloadAdBreaks?: 'on' | 'auto';
+    /**
+     * (OPTIONAL) Whether the game is currently playing sound.
+     *
+     * This call specifies whether your game is capable of sound, and whether the sound was enabled (ie unmuted) before the call to adBreak(). This helps the Ad Placement API to select the right kind of ad for your game.
+     *
+     * Call this function as soon as the sound state of your game changes, as the Ad Placement API may have to request new creatives, and this gives it the maximum amount of time to do so.
+     *
+     * The default value is sound on. So most games will need to make a call to adConfig() when they start to declare that they have sound enabled.
+     */
+    sound?: 'on' | 'off';
+    /**
+     * (OPTIONAL) Called when the API has initialized and has finished preloading ads (if you requested preloading using the preloadAdBreaks above).
+     * @returns
+     */
+    onReady?: () => void;
+}
+/**
+ * PlacementInfo object passed by **adBreakDone** function
+ */
+export interface IPlacementInfo {
+    /**
+     * the type argument passed to adBreak()
+     */
+    breakType: string;
+    /**
+     * the name argument passed to adBreak()
+     */
+    breakName?: string;
+    breakFormat: 'interstitial' | 'reward';
+    /**
+     * the status of this placement and can be one of the following values:
+     *
+     * | breakStatus | Reason |
+     * | -------- | ------- |
+     * | 'notReady'	| The Ad Placement API had not initialised |
+     * | 'timeout' | A placement timed out because the Ad Placement API took too long to respond |
+     * | 'invalid' | The placement was invalid and was ignored–for instance there should only be one preroll placement per page load, subsequent prerolls are failed with this status |
+     * | 'error' | There was a JavaScript error in a callback |
+     * | 'noAdPreloaded' |	An ad had not been preloaded yet so this placement was skipped |
+     * | 'frequencyCapped' |	An ad wasn't shown because the frequency cap was applied to this placement |
+     * | 'ignored' |	The user didn't click on a reward prompt before they reached the next placement, that is showAdFn() wasn't called before the next adBreak(). |
+     * | 'other' |	The ad was not shown for another reason. (e.g., The ad was still being fetched, or a previously cached ad was disposed because the screen was resized/rotated.) |
+     * | 'dismissed' |	The user dismissed a rewarded ad before viewing it to completion |
+     * | 'viewed' |	The ad was viewed by the user |
+     */
+    breakStatus: 'notReady' | 'timeout' | 'error' | 'noAdPreloaded' | 'frequencyCapped' | 'ignored' | 'other' | 'dismissed' | 'viewed';
+}
+/**
+ * Parameter when calling adBreak
+ */
+export type IAdBreakParams = IPrerollParams | IInterstitialsParams | IRewardParams;
+/**
+ * Parameter when calling preroll type adBreak
+ */
+export interface IPrerollParams {
+    /**
+     * 'preroll' before the game loads (before UI has rendered)
+     */
+    type: 'preroll';
+    /**
+     * (OPTIONAL) Always called as the last step in an adBreak(), even if there was no ad shown. Function takes as argument a placementInfo object
+     * @param placementInfo
+     * @returns
+     */
+    adBreakDone?: (placementInfo: IPlacementInfo) => void;
+}
+export interface IInterstitialsParams {
+    /**
+     * 'start' before the gameplay starts (after UI has rendered)
+     * 'pause' the player pauses the game
+     * 'next' player navigates to the next level
+     * 'browse' the player explores options outside of the gameplay
+     */
+    type: 'start' | 'pause' | 'next' | 'browse';
+    /**
+     * (OPTIONAL) a name for this particular ad placement within your game. It is an internal identifier, and is not shown to the player. In future releases this identifier may be used to enable additional reporting and optimization features.
+     *
+     * We recommend you name all of your placements.
+     */
+    name?: string;
+    /**
+     * (OPTIONAL) Called before the ad is displayed. The game should pause and mute the sound. These actions must be done synchronously. The ad will be displayed immediately after this callback finishes.
+     *
+     * @returns
+     */
+    beforeAd?: () => void;
+    /**
+     *
+     * @returns (OPTIONAL) Called after the ad is finished (for any reason). For rewarded ads, it is called after either adDismissed or adViewed, depending on player actions. This function should be used to resume game flow. For example, use to unmute the sound and start the next level.
+     */
+    afterAd?: () => void;
+    /**
+     * (OPTIONAL) Always called as the last step in an adBreak(), even if there was no ad shown. Function takes as argument a placementInfo object
+     *
+     * @param placementInfo
+     * @returns
+     */
+    adBreakDone?: (placementInfo: IPlacementInfo) => void;
+}
+export interface IRewardParams {
+    /**
+     * 'reward' a rewarded ad
+     */
+    type: 'reward';
+    /**
+     * (OPTIONAL) a name for this particular ad placement within your game. It is an internal identifier, and is not shown to the player. In future releases this identifier may be used to enable additional reporting and optimization features.
+     *
+     * We recommend you name all of your placements.
+     */
+    name?: string;
+    /**
+     * (OPTIONAL) Called before the ad is displayed. The game should pause and mute the sound. These actions must be done synchronously. The ad will be displayed immediately after this callback finishes.
+     * @returns
+     */
+    beforeAd?: () => void;
+    /**
+     * (OPTIONAL) Called after the ad is finished (for any reason). For rewarded ads, it is called after either adDismissed or adViewed, depending on player actions. This function should be used to resume game flow. For example, use to unmute the sound and start the next level.
+     * @returns
+     */
+    afterAd?: () => void;
+    /**
+     * (OPTIONAL) Always called as the last step in an adBreak(), even if there was no ad shown. Function takes as argument a placementInfo object defined
+     * @param placementInfo
+     * @returns
+     */
+    adBreakDone?: (placementInfo: IPlacementInfo) => void;
+    /**
+     * Called if a rewarded ad is available. The function should take a single argument–showAdFn() which must be called to display the rewarded ad.
+     * @param showAdFn
+     * @returns
+     */
+    beforeReward: (showAdFn: () => void) => void;
+    /**
+     * Called only for rewarded ads when the player dismisses the ad. It is only called if the player dismisses the ad before it completes. In this case the reward should not be granted.
+     * @returns
+     */
+    adDismissed: () => void;
+    /**
+     * Called only for rewarded ads when the player completes the ad and should be granted the reward.
+     * @returns
+     */
+    adViewed: () => void;
+}
+/**
+ * Ad unit format, can be 'rectangle', 'vertical', 'horizontal'
+ */
+export type AdUnitFormat = 'rectangle' | 'vertical' | 'horizontal';
+export interface IAdUnitParams {
+    /**
+     * The element to attach the ad unit to, either an HTMLElement or a string selector. Should be the parent element of the ad unit (<ins> tag).
+     */
+    el: HTMLElement | string;
+    /**
+     * (OPTIONAL) Reserved for future usage. The slot ID of the ad unit. Currently the slot ID is automatically set by the SDK.
+     */
+    slot?: string;
+    /**
+     * (OPTIONAL) Ad format for the ad unit. Can be 'auto' or a single format or an array of formats. Default is 'auto'. If passed as an array, the array will be joined by ', ' and pass to the data-ad-format attribute.
+     */
+    adFormat?: 'auto' | AdUnitFormat | AdUnitFormat[];
+    /**
+     * (OPTIONAL) Whether the ad unit should be full width and responsive. Default is false.
+     */
+    fullWidthResponsive?: 'true' | 'false';
+    /**
+     * (OPTIONAL) Custom style for the ad unit. Default is empty.
+     */
+    style?: string;
+}
+export interface IAbstractAFGProvider<AdInitServerParam extends IAFGInitServerParams = any, AdBreakServerParam extends IAFGAdBreakServerParams = any> {
+    name: string;
+    init(): void;
+    adConfig(params: IAdConfigParams, serverParam: AdInitServerParam): void;
+    adBreak(params: IAdBreakParams, serverParam: AdBreakServerParam): void;
+}

package/dist/afg/adsense/index.d.ts

@@ -0,0 +1,27 @@
+import type { IAbstractAFGProvider, IAdBreakParams, IAdConfigParams, IAdUnitParams } from '@/afg/ads-interface';
+import type { IAdsContext } from '@/type/base';
+import type { IGoogleAdSenseAdBreakServerParams, IGoogleAdSenseInitServerParams } from './type';
+export * from './type';
+/**
+ * Jolibox Ads SDK
+ */
+export declare class GoogleAdSenseProvider implements IAbstractAFGProvider<IGoogleAdSenseInitServerParams, IGoogleAdSenseAdBreakServerParams> {
+    name: string;
+    private context;
+    private contextInfo;
+    private configured;
+    private initParams;
+    /**
+     * Internal constructor, should not be called directly
+     */
+    constructor(context: IAdsContext, initParams: IGoogleAdSenseInitServerParams['params']);
+    init(): Promise<void>;
+    /**
+     * Internal function to push adsbygoogle array
+     * @param params
+     */
+    private push;
+    adConfig: (params: IAdConfigParams) => void;
+    adBreak: (params: IAdBreakParams) => void;
+    adUnit: (params: IAdUnitParams) => Promise<void>;
+}

package/dist/afg/adsense/type.d.ts

@@ -0,0 +1,14 @@
+export interface IGoogleAdSenseInitServerParams {
+    provider: 'ADSENSE';
+    params: {
+        type: 'ADSENSE' | 'ADMOB';
+        clientId: string;
+        channelId: string;
+        unitId: string;
+        admobInterstitialSlot?: string;
+        admobRewardedSlot?: string;
+    };
+}
+export interface IGoogleAdSenseAdBreakServerParams {
+    provider: 'ADSENSE';
+}

package/dist/afg/channel-policy.d.ts

@@ -0,0 +1,22 @@
+import type { IAdsContext } from '../type/base';
+export interface IChannelPolicy {
+    /**
+     * The rate at which interstitial ads should be shown.
+     * A value of 1 means always bypass interstitials call, while a value of 0 means always forbid calling interstitials.
+     * A value between 0 and 1 means the interstitial call will be bypassed with a probability of `rate`.
+     */
+    interstitialRate?: number;
+}
+export declare class ChannelPolicy {
+    private configs;
+    private firstRun;
+    private context;
+    private contextInfo;
+    constructor(context: IAdsContext);
+    private init;
+    /**
+     * Should bypass calling interstitial based on the channel policy.
+     * @returns
+     */
+    shouldBypassCallingInterstitial(): boolean;
+}

package/dist/afg/index.d.ts

@@ -0,0 +1,21 @@
+import type { IAdBreakParams, IAdConfigParams, IAdsInitParams, IAdUnitParams } from './ads-interface';
+import type { IAdsContext } from '../type/base';
+export * from './okspin';
+export * from './adsense';
+export * from './ads-interface';
+export declare class JoliboxAdsForGame {
+    private context;
+    private contextInfo;
+    private providers;
+    private channelPolicy;
+    private adsActionDetection;
+    private adsTrackSerializer;
+    private initialized;
+    constructor(context?: IAdsContext<'GAME'>);
+    private getRequestContextData;
+    private getRequestBizParams;
+    init(_config?: IAdsInitParams): Promise<void>;
+    adConfig(params: IAdConfigParams): void;
+    adBreak(params: IAdBreakParams): Promise<void>;
+    adUnit(params: IAdUnitParams): void;
+}

package/dist/afg/okspin/index.d.ts

@@ -0,0 +1,18 @@
+import type { IAbstractAFGProvider, IAdBreakParams, IAdConfigParams } from '../ads-interface';
+import type { IAdsContext } from '../../type/base';
+import type { IOKSpinAdBreakServerParams, IOKSpinInitServerParams } from './type';
+export declare class OKSpinForGameProvider implements IAbstractAFGProvider<IOKSpinInitServerParams, IOKSpinAdBreakServerParams> {
+    name: string;
+    private initialized;
+    private initCompleter;
+    private context;
+    private initParams;
+    private adsOverlay;
+    private adsIsShowing;
+    private lastUnDisplayedAdBreak;
+    private state;
+    constructor(context: IAdsContext, initParams: IOKSpinInitServerParams['params']);
+    init(): Promise<void>;
+    adConfig(params: IAdConfigParams): void;
+    adBreak(params: IAdBreakParams, serverParam: IOKSpinAdBreakServerParams): Promise<void>;
+}

package/dist/afg/okspin/type.d.ts

@@ -0,0 +1,13 @@
+export interface IOKSpinInitServerParams {
+    provider: 'OKSPIN';
+    params: {
+        appk: string;
+    };
+}
+export interface IOKSpinAdBreakServerParams {
+    provider: 'OKSPIN';
+    params: {
+        url: string;
+        countdown?: number;
+    };
+}

package/dist/afg/type.d.ts

@@ -0,0 +1,9 @@
+import type { IGoogleAdSenseInitServerParams, GoogleAdSenseProvider, IGoogleAdSenseAdBreakServerParams } from './adsense';
+import type { OKSpinForGameProvider } from './okspin';
+import type { IOKSpinAdBreakServerParams, IOKSpinInitServerParams } from './okspin/type';
+export type IAFGInitServerParams = IGoogleAdSenseInitServerParams | IOKSpinInitServerParams;
+export type IAFGAdBreakServerParams = IGoogleAdSenseAdBreakServerParams | IOKSpinAdBreakServerParams;
+export interface IAFGProviders {
+    ADSENSE?: GoogleAdSenseProvider;
+    OKSPIN?: OKSpinForGameProvider;
+}

package/dist/afv/adrequest-async-proxy.d.ts

@@ -0,0 +1,18 @@
+import type { IAdsContext } from '../type/base';
+import type { IAbstractAFVProvider, IRequestAdParams, WrappedError } from './ads-interface';
+import type { IAFVRequestAdServerParams } from './type';
+export declare class AdRequestAsyncProxy {
+    private context;
+    private currentProvider?;
+    private continueCallback?;
+    constructor(context: IAdsContext);
+    get paramsToTrack(): {
+        provider: string | null;
+    };
+    private wrapAdRequested;
+    private wrapAdLoaded;
+    private wrapAdPlaying;
+    private wrapAdCompleted;
+    private wrapAdError;
+    callAdRequestAndContinue(adsProvider: IAbstractAFVProvider, params: IRequestAdParams<any>, serverParams: IAFVRequestAdServerParams): Promise<[boolean, WrappedError<"GOOGLE_IMA_ERROR" | "JOLIBOX_IMA_ERROR", Error | import("./ima/ima").google.ima.AdError> | null]>;
+}

package/dist/afv/ads-interface.d.ts

@@ -0,0 +1,23 @@
+import { google } from './ima/ima';
+import type { IAFVInitServerParams, IAFVRequestAdServerParams } from './type';
+type WrappedErrorType = 'GOOGLE_IMA_ERROR' | 'JOLIBOX_IMA_ERROR';
+export declare class WrappedError<T extends WrappedErrorType = WrappedErrorType, R extends T extends 'GOOGLE_IMA_ERROR' ? google.ima.AdError : Error = T extends 'GOOGLE_IMA_ERROR' ? google.ima.AdError : Error> extends Error {
+    name: 'AFVRequestError';
+    type: T;
+    raw: R;
+    constructor(error: R, type: T);
+    static from(error: Error | google.ima.AdError, type: WrappedErrorType): WrappedError<"GOOGLE_IMA_ERROR", google.ima.AdError> | WrappedError<"JOLIBOX_IMA_ERROR", Error>;
+}
+export interface IRequestAdParams<AdEvent = any> {
+    onAdRequested?: () => void;
+    onAdLoaded?: (event: AdEvent) => void;
+    onAdPlaying?: (event: AdEvent) => void;
+    onAdCompleted?: (event: AdEvent) => void;
+    onAdError?: (error: WrappedError<'GOOGLE_IMA_ERROR' | 'JOLIBOX_IMA_ERROR', google.ima.AdError | Error>) => void;
+}
+export interface IAbstractAFVProvider<AdEvent = any, AdInitServerParams extends IAFVInitServerParams = any, AdRequestServerParams extends IAFVRequestAdServerParams = any> {
+    name: string;
+    init: (serverParams: AdInitServerParams) => Promise<void>;
+    requestAd: (clientParams: IRequestAdParams<AdEvent>, serverParam: AdRequestServerParams) => void;
+}
+export {};

package/dist/afv/ima/components/ads-overlay.d.ts

@@ -0,0 +1,14 @@
+export declare const createState: () => {
+    visible: import("@preact/signals").Signal<boolean>;
+    canRetry: import("@preact/signals").Signal<boolean>;
+    retry: import("@preact/signals").Signal<(() => void) | null>;
+    videoRef: import("react").RefObject<HTMLVideoElement>;
+    adContainerRef: import("react").RefObject<HTMLDivElement>;
+};
+type State = ReturnType<typeof createState>;
+interface IProps {
+    onReady: () => void;
+    state: State;
+}
+export declare const JoliboxIMAOverlay: ({ onReady, state }: IProps) => JSX.Element;
+export {};

package/dist/afv/ima/ima-impl.d.ts

@@ -0,0 +1,200 @@
+import type { IRequestAdParams } from '../ads-interface';
+import type { google } from './ima';
+import type { IGoogleIMARequestAdServerParams } from './type';
+declare global {
+    interface Window {
+        google: typeof google;
+    }
+}
+export declare class GoogleIMAImpl {
+    adsLoader?: google.ima.AdsLoader;
+    adDisplayContainer?: google.ima.AdDisplayContainer;
+    isAdPlaying: boolean;
+    isContentFinished: boolean;
+    videoContent: HTMLVideoElement;
+    adContainer: HTMLElement;
+    adsManager?: google.ima.AdsManager;
+    intervalTimer?: number;
+    completed: boolean;
+    adTagUrl: string;
+    notifyRequestAd?: () => void;
+    notifyLoaded?: (event: google.ima.AdEvent) => void;
+    notifyPlayingAd?: (event: google.ima.AdEvent) => void;
+    notifyCompleted?: (event: google.ima.AdEvent) => void;
+    notifyError?: (error: google.ima.AdError) => void;
+    constructor(adTagUrl: string, videoContent: HTMLVideoElement, adContainer: HTMLElement);
+    destroy: () => void;
+    /**
+     * Sets up IMA ad display container, ads loader, and makes an ad request.
+     */
+    requestAds: (clientParams: IRequestAdParams<google.ima.AdEvent>, serverParams: IGoogleIMARequestAdServerParams) => Promise<void>;
+    /**
+     * Sets the 'adContainer' div as the IMA ad display container.
+     */
+    createAdDisplayContainer: () => void;
+    /**
+     * Loads the video content and initializes IMA ad playback.
+     */
+    playAds: () => void;
+    /**
+     * Handles the ad manager loading and sets ad event listeners.
+     * @param {!google.ima.AdsManagerLoadedEvent} adsManagerLoadedEvent
+     */
+    onAdsManagerLoaded: (adsManagerLoadedEvent: google.ima.AdsManagerLoadedEvent) => void;
+    /**
+     * Handles actions taken in response to ad events.
+     * @param {!google.ima.AdEvent} adEvent
+     */
+    onAdEvent: (adEvent: google.ima.AdEvent) => void;
+    /**
+     * Handles ad errors.
+     * @param {!google.ima.AdErrorEvent} adErrorEvent
+     */
+    onAdError: (adErrorEvent: google.ima.AdErrorEvent) => void;
+    /**
+     * Pauses video content and sets up ad UI.
+     */
+    onContentPauseRequested: () => void;
+    /**
+     * Resumes video content and removes ad UI.
+     */
+    onContentResumeRequested: () => void;
+}
+export declare enum ErrorCode {
+    /**
+     * There was a problem requesting ads from the server. VAST error code 1012
+     */
+    ADS_REQUEST_NETWORK_ERROR = 1012,
+    /**
+     * There was an error with asset fallback. VAST error code 1021
+     */
+    ASSET_FALLBACK_FAILED = 1021,
+    /**
+     * The browser prevented playback initiated without user interaction. VAST error code 1205
+     */
+    AUTOPLAY_DISALLOWED = 1205,
+    /**
+     * A companion ad failed to load or render. VAST error code 603
+     */
+    COMPANION_AD_LOADING_FAILED = 603,
+    /**
+     * Unable to display one or more required companions. The master ad is discarded since the required companions could not be displayed. VAST error code 602
+     */
+    COMPANION_REQUIRED_ERROR = 602,
+    /**
+     * There was a problem requesting ads from the server. VAST error code 1005
+     */
+    FAILED_TO_REQUEST_ADS = 1005,
+    /**
+     * The ad tag url specified was invalid. It needs to be properly encoded. VAST error code 1013
+     */
+    INVALID_AD_TAG = 1013,
+    /**
+     * An invalid AdX extension was found. VAST error code 1105
+     */
+    INVALID_ADX_EXTENSION = 1105,
+    /**
+     * Invalid arguments were provided to SDK methods. VAST error code 1101
+     */
+    INVALID_ARGUMENTS = 1101,
+    /**
+     * Unable to display NonLinear ad because creative dimensions do not align with creative display area (i.e. creative dimension too large). VAST error code 501
+     */
+    NONLINEAR_DIMENSIONS_ERROR = 501,
+    /**
+     * An overlay ad failed to load. VAST error code 502
+     */
+    OVERLAY_AD_LOADING_FAILED = 502,
+    /**
+     * An overlay ad failed to render. VAST error code 500
+     */
+    OVERLAY_AD_PLAYING_FAILED = 500,
+    /**
+     * There was an error with stream initialization during server side ad insertion. VAST error code 1020
+     */
+    STREAM_INITIALIZATION_FAILED = 1020,
+    /**
+     * The ad response was not understood and cannot be parsed. VAST error code 1010
+     */
+    UNKNOWN_AD_RESPONSE = 1010,
+    /**
+     * An unexpected error occurred and the cause is not known. Refer to the inner error for more information. VAST error code 900
+     */
+    UNKNOWN_ERROR = 900,
+    /**
+     * Locale specified for the SDK is not supported. VAST error code 1011
+     */
+    UNSUPPORTED_LOCALE = 1011,
+    /**
+     * No assets were found in the VAST ad response. VAST error code 1007
+     */
+    VAST_ASSET_NOT_FOUND = 1007,
+    /**
+     * Empty VAST response. VAST error code 1009
+     */
+    VAST_EMPTY_RESPONSE = 1009,
+    /**
+     * Assets were found in the VAST ad response for linear ad, but none of them matched the video player's capabilities. VAST error code 403
+     */
+    VAST_LINEAR_ASSET_MISMATCH = 403,
+    /**
+     * The VAST URI provided, or a VAST URI provided in a subsequent wrapper element, was either unavailable or reached a timeout, as defined by the video player. The timeout is 5 seconds for initial VAST requests and each subsequent wrapper. VAST error code 301
+     */
+    VAST_LOAD_TIMEOUT = 301,
+    /**
+     * The ad response was not recognized as a valid VAST ad. VAST error code 100
+     */
+    VAST_MALFORMED_RESPONSE = 100,
+    /**
+     * Failed to load media assets from a VAST response. The default timeout for media loading is 8 seconds. VAST error code 402
+     */
+    VAST_MEDIA_LOAD_TIMEOUT = 402,
+    /**
+     * No Ads VAST response after one or more wrappers. VAST error code 303
+     */
+    VAST_NO_ADS_AFTER_WRAPPER = 303,
+    /**
+     * Assets were found in the VAST ad response for nonlinear ad, but none of them matched the video player's capabilities. VAST error code 503
+     */
+    VAST_NONLINEAR_ASSET_MISMATCH = 503,
+    /**
+     * Problem displaying MediaFile. Currently used if video playback is stopped due to poor playback quality. VAST error code 405
+     */
+    VAST_PROBLEM_DISPLAYING_MEDIA_FILE = 405,
+    /**
+     * VAST schema validation error. VAST error code 101
+     */
+    VAST_SCHEMA_VALIDATION_ERROR = 101,
+    /**
+     * The maximum number of VAST wrapper redirects has been reached. VAST error code 302
+     */
+    VAST_TOO_MANY_REDIRECTS = 302,
+    /**
+     * Trafficking error. Video player received an ad type that it was not expecting and/or cannot display. VAST error code 200
+     */
+    VAST_TRAFFICKING_ERROR = 200,
+    /**
+     * VAST duration is different from the actual media file duration. VAST error code 202
+     */
+    VAST_UNEXPECTED_DURATION_ERROR = 202,
+    /**
+     * Ad linearity is different from what the video player is expecting. VAST error code 201
+     */
+    VAST_UNEXPECTED_LINEARITY = 201,
+    /**
+     * The ad response contained an unsupported VAST version. VAST error code 102
+     */
+    VAST_UNSUPPORTED_VERSION = 102,
+    /**
+     * General VAST wrapper error. VAST error code 300
+     */
+    VAST_WRAPPER_ERROR = 300,
+    /**
+     * There was an error playing the video ad. VAST error code 400
+     */
+    VIDEO_PLAY_ERROR = 400,
+    /**
+     * A VPAID error occurred. Refer to the inner error for more information. VAST error code 901
+     */
+    VPAID_ERROR = 901
+}

package/dist/afv/ima/index.d.ts

@@ -0,0 +1,15 @@
+import type { IGoogleIMAInitServerParams, IGoogleIMARequestAdServerParams } from './type';
+import type { google } from './ima';
+import type { IAdsContext } from '@/type/base';
+import { type IAbstractAFVProvider, type IRequestAdParams } from '../ads-interface';
+export declare class GoogleIMAProvider implements IAbstractAFVProvider<google.ima.AdEvent> {
+    name: string;
+    private context;
+    private adsOverlay;
+    private initialized;
+    private ima;
+    private state;
+    constructor(context: IAdsContext);
+    init: (params: IGoogleIMAInitServerParams) => Promise<void>;
+    requestAd: (clientParams: IRequestAdParams<google.ima.AdEvent>, serverParams: IGoogleIMARequestAdServerParams) => void;
+}

package/dist/afv/ima/type.d.ts

@@ -0,0 +1,10 @@
+export interface IGoogleIMAInitServerParams {
+    provider: 'GOOGLE_IMA';
+    params: {
+        adTagUrl: string;
+    };
+}
+export interface IGoogleIMARequestAdServerParams {
+    provider: 'GOOGLE_IMA';
+    params: Record<string, string>;
+}