import { getGlobal, type PrebidJS } from './prebidGlobal.js';

import {

deepAccess,

deepClone,

deepEqual,

deepSetValue,

flatten,

generateUUID,

isArray,

isArrayOfNums,

isEmpty,

isFn,

isGptPubadsDefined,

isNumber,

isPlainObject,

logError,

logInfo,

logMessage,

logWarn,

mergeDeep,

transformAdServerTargetingObj,

uniques,

unsupportedBidderMessage

} from './utils.js';

import { listenMessagesFromCreative } from './secureCreatives.js';

import { userSync } from './userSync.js';

import { config } from './config.js';

import { auctionManager } from './auctionManager.js';

import { isBidUsable, targeting } from './targeting.js';

import { hook, wrapHook } from './hook.js';

import { loadSession } from './debugging.js';

import { storageCallbacks } from './storageManager.js';

import adapterManager, { type AliasBidderOptions, type BidRequest, getS2SBidderSet } from './adapterManager.js';

import { BID_STATUS, EVENTS, NATIVE_KEYS } from './constants.js';

import type { Event, EventHandler, EventIDs } from "./events.js";

import * as events from './events.js';

import { type Metrics, newMetrics, useMetrics } from './utils/perfMetrics.js';

import { type Defer, defer, PbPromise } from './utils/promise.js';

import { enrichFPD } from './fpd/enrichment.js';

import { allConsent } from './consentHandler.js';

import {

insertLocatorFrame,

markBidAsRendered,

markWinningBid,

renderAdDirect,

renderIfDeferred

} from './adRendering.js';

import { getHighestCpm } from './utils/reducers.js';

import { fillVideoDefaults, ORTB_VIDEO_PARAMS } from './video.js';

import { ORTB_BANNER_PARAMS } from './banner.js';

import { BANNER, VIDEO } from './mediaTypes.js';

import { delayIfPrerendering } from './utils/prerendering.js';

import { type BidAdapter, type BidderSpec, newBidder } from './adapters/bidderFactory.js';

import { normalizeFPD } from './fpd/normalize.js';

import type { Bid } from "./bidfactory.ts";

import type { AdUnit, AdUnitDefinition, BidderParams } from "./adUnits.ts";

import type { AdUnitCode, BidderCode, ByAdUnit, Identifier, ORTBFragments } from "./types/common.d.ts";

import type { ORTBRequest } from "./types/ortb/request.d.ts";

import type { DeepPartial } from "./types/objects.d.ts";

import type { AnyFunction, Wraps } from "./types/functions.d.ts";

import type { BidderScopedSettings, BidderSettings } from "./bidderSettings.ts";

import { fillAudioDefaults, ORTB_AUDIO_PARAMS } from './audio.ts';

import { getGlobalVarName } from "./buildOptions.ts";

import { yieldAll } from "./utils/yield.ts";

const pbjsInstance = getGlobal();

const { triggerUserSyncs } = userSync;

const { REQUEST_BIDS, SET_TARGETING } = EVENTS;

declare module './prebidGlobal' {

interface PrebidJS {

}

pbjsInstance.bidderSettings = pbjsInstance.bidderSettings || {};

pbjsInstance.libLoaded = true;

pbjsInstance.version = 'v$prebid.version$';

pbjsInstance.adUnits = pbjsInstance.adUnits || [];

pbjsInstance.pageViewIdPerBidder = pbjsInstance.pageViewIdPerBidder || new Map<string | null, string>();

function validateSizes(sizes, targLength?: number) {

export function syncOrtb2(adUnit, mediaType) {

function validateBannerMediaType(adUnit: AdUnit) {

function validateAudioMediaType(adUnit: AdUnit) {

function validateVideoMediaType(adUnit: AdUnit) {

export function validateOrtbFields(adUnit, type, onInvalidParam?) {

function validateNativeMediaType(adUnit: AdUnit) {

function validateAdUnitPos(adUnit, mediaType) {

function validateAdUnit(adUnitDef: AdUnitDefinition): AdUnit {

export const adUnitSetupChecks = {

validateAdUnit,

validateBannerMediaType,

validateSizes

if (FEATURES.NATIVE) {

Object.assign(adUnitSetupChecks, { validateNativeMediaType });

if (FEATURES.VIDEO) {

Object.assign(adUnitSetupChecks, { validateVideoMediaType });

if (FEATURES.AUDIO) {

Object.assign(adUnitSetupChecks, { validateAudioMediaType });

export const checkAdUnitSetup = hook('sync', function (adUnits: AdUnitDefinition[]) {

const validatedAdUnits = [];

adUnits.forEach(adUnitDef => {

const adUnit = validateAdUnit(adUnitDef);

if (adUnit == null) return;

const mediaTypes = adUnit.mediaTypes;

let validatedBanner, validatedVideo, validatedNative, validatedAudio;

if (mediaTypes.banner) {

validatedBanner = validateBannerMediaType(adUnit);

if (mediaTypes.banner.hasOwnProperty('pos')) validatedBanner = validateAdUnitPos(validatedBanner, 'banner');

}

if (FEATURES.VIDEO && mediaTypes.video) {

validatedVideo = validatedBanner ? validateVideoMediaType(validatedBanner) : validateVideoMediaType(adUnit);

if (mediaTypes.video.hasOwnProperty('pos')) validatedVideo = validateAdUnitPos(validatedVideo, 'video');

}

if (FEATURES.NATIVE && mediaTypes.native) {

validatedNative = validatedVideo ? validateNativeMediaType(validatedVideo) : validatedBanner ? validateNativeMediaType(validatedBanner) : validateNativeMediaType(adUnit);

}

if (FEATURES.AUDIO && mediaTypes.audio) {

validatedAudio = validatedNative ? validateAudioMediaType(validatedNative) : validateAudioMediaType(adUnit);

}

const validatedAdUnit = Object.assign({}, validatedBanner, validatedVideo, validatedNative, validatedAudio);

validatedAdUnits.push(validatedAdUnit);

});

return validatedAdUnits;

}, 'checkAdUnitSetup');

function fillAdUnitDefaults(adUnits: AdUnitDefinition[]) {

function logInvocation<T extends AnyFunction>(name: string, fn: T): Wraps<T> {

export function addApiMethod<N extends keyof PrebidJS>(name: N, method: PrebidJS[N], log = true) {

getGlobal()[name] = log ? logInvocation(name, method) as PrebidJS[N] : method;

declare module './prebidGlobal' {

interface PrebidJS {

}

addApiMethod('triggerUserSyncs', triggerUserSyncs);

function getAdserverTargetingForAdUnitCodeStr(adUnitCode: AdUnitCode): string {

addApiMethod('getAdserverTargetingForAdUnitCodeStr', getAdserverTargetingForAdUnitCodeStr);

function getHighestUnusedBidResponseForAdUnitCode(adUnitCode: AdUnitCode): Bid {

addApiMethod('getHighestUnusedBidResponseForAdUnitCode', getHighestUnusedBidResponseForAdUnitCode);

function getAdserverTargetingForAdUnitCode(adUnitCode) {

return getAdserverTargeting(adUnitCode)[adUnitCode];

addApiMethod('getAdserverTargetingForAdUnitCode', getAdserverTargetingForAdUnitCode);

function getAdserverTargeting(adUnitCode?: AdUnitCode | AdUnitCode[]) {

return targeting.getAllTargeting(adUnitCode);

addApiMethod('getAdserverTargeting', getAdserverTargeting);

function getConsentMetadata() {

return allConsent.getConsentMeta()

addApiMethod('getConsentMetadata', getConsentMetadata);

type WrapsInBids<T> = T[] & {

bids: T[]

function wrapInBids(arr) {

function getBids<T>(type): ByAdUnit<WrapsInBids<T>> {

function getNoBids() {

return getBids<BidRequest<BidderCode>>('getNoBids');

addApiMethod('getNoBids', getNoBids);

function getNoBidsForAdUnitCode(adUnitCode: AdUnitCode): WrapsInBids<BidRequest<BidderCode>> {

const bids = auctionManager.getNoBids().filter(bid => bid.adUnitCode === adUnitCode);

return wrapInBids(bids);

addApiMethod('getNoBidsForAdUnitCode', getNoBidsForAdUnitCode);

function getBidResponses() {

return getBids<Bid>('getBidsReceived');

addApiMethod('getBidResponses', getBidResponses);

function getBidResponsesForAdUnitCode(adUnitCode: AdUnitCode): WrapsInBids<Bid> {

const bids = auctionManager.getBidsReceived().filter(bid => bid.adUnitCode === adUnitCode);

return wrapInBids(bids);

addApiMethod('getBidResponsesForAdUnitCode', getBidResponsesForAdUnitCode);

function setTargetingForGPTAsync(adUnit?: AdUnitCode | AdUnitCode[]) {

addApiMethod('setTargetingForGPTAsync', setTargetingForGPTAsync);

function setTargetingForAst(adUnitCodes?: AdUnitCode | AdUnitCode[]) {

addApiMethod('setTargetingForAst', setTargetingForAst);

type RenderAdOptions = {

function renderAd(doc: Document, id: Bid['adId'], options?: RenderAdOptions) {

renderAdDirect(doc, id, options);

addApiMethod('renderAd', renderAd);

function removeAdUnit(adUnitCode?: AdUnitCode) {

addApiMethod('removeAdUnit', removeAdUnit);

export type RequestBidsOptions = {

type RequestBidsResult = {

export type PrivRequestBidsOptions = RequestBidsOptions & {

export type StartAuctionOptions = Omit<PrivRequestBidsOptions, 'ortb2'> & {

ortb2Fragments: ORTBFragments

declare module './hook' {

interface NamedHooks {

requestBids: typeof requestBids;

startAuction: typeof startAuction;

}

interface RequestBids {

(options?: RequestBidsOptions): Promise<RequestBidsResult>;

declare module './events' {

interface Events {

}

export const requestBids = (function() {

function filterAdUnits(adUnits, adUnitCodes) {

}

const delegate = hook('async', function (reqBidOptions: PrivRequestBidsOptions): void {

let { bidsBackHandler, timeout, adUnits, adUnitCodes, labels, auctionId, ttlBuffer, ortb2, metrics, defer } = reqBidOptions ?? {};

const cbTimeout = timeout || config.getConfig('bidderTimeout');

({ included: adUnits, adUnitCodes } = filterAdUnits(adUnits, adUnitCodes));

let ortb2Fragments = {

global: mergeDeep({}, config.getAnyConfig('ortb2') || {}, ortb2 || {}),

bidder: Object.fromEntries(Object.entries<any>(config.getBidderConfig()).map(([bidder, cfg]) => [bidder, deepClone(cfg.ortb2)]).filter(([_, ortb2]) => ortb2 != null))

}

ortb2Fragments = normalizeFPD(ortb2Fragments);