@schibsted/advertory 2.44.0-test-art-4

package/core/aftonbladet/es/index.d.ts

@@ -0,0 +1,701 @@
+import { Identity } from '@schibsted/account-sdk-browser';
+
+type AstCommand = () => void;
+type AstAdType = 'banner' | 'video' | 'native' | 'outstream';
+interface AstBanner {
+    content: string;
+    height: number;
+    width: number;
+}
+interface AstNativeImage {
+    height: number;
+    width: number;
+    url: string;
+    prevent_crop: boolean;
+}
+interface AstNativeVideo {
+    content: string;
+}
+interface AstNative {
+    title: string;
+    sponsoredBy: string;
+    desc2?: string;
+    clickUrl: string;
+    clickTrackers: Array<string>;
+    clickFallbackUrl?: string;
+    displayUrl?: string;
+    downloads?: Array<string>;
+    cta?: string;
+    address?: string;
+    body: string;
+    main_media?: {
+        url: string;
+    };
+    image: AstNativeImage;
+    icon: AstNativeIcon;
+    impressionTrackers?: Array<string>;
+    javascriptTrackers?: Array<string>;
+    likes?: number;
+    phone?: string;
+    price?: string;
+    privacyLink?: string;
+    rating?: number;
+    saleprice?: number;
+    fullText?: string;
+    type?: string;
+    custom?: {
+        type: string;
+    };
+    video?: AstNativeVideo;
+    customTitle1?: string;
+    customTitle2?: string;
+    customTitle3?: string;
+    customTitle4?: string;
+    description?: string;
+    customIcon2: AstNativeIcon;
+}
+interface AstAdObj {
+    adType: AstAdType;
+    height: number;
+    source: string;
+    targetId: string;
+    width: number;
+    native?: AstNative;
+    desc2?: string;
+    image?: object;
+    tagId?: number;
+    cpm?: object;
+    buyerMemberId?: number;
+    impressionTrackersFired?: boolean;
+    auctionId?: string;
+    creativeId?: number;
+    banner?: AstBanner;
+    subtype?: string;
+    renderer_url?: string;
+    bidderId?: number | undefined;
+}
+interface AstAdError {
+    code: number;
+    errMessage: string;
+    exception: Error;
+    targetId: string;
+}
+interface AstTagObj {
+    targetId: string;
+}
+type AstEventType = 'adRequested' | 'adAvailable' | 'adBadRequest' | 'adLoaded' | 'adNoBid' | 'adRequestFailure' | 'adError' | 'adCollapse' | 'adNoBidMediated' | 'adLoadedMediated';
+interface AstOnEventFunction {
+    (eventType: 'adRequested', eventHandler: AstCommand, targetId?: string): void;
+    (eventType: 'adAvailable', eventHandler: (adObj: AstAdObj) => void, targetId?: string): void;
+    (eventType: 'adLoaded', eventHandler: (adObj: AstAdObj) => void, targetId?: string): void;
+    (eventType: 'adNoBid', eventHandler: (adObj: AstAdObj) => void, targetId?: string): void;
+    (eventType: 'adCollapse', eventHandler: AstCommand, targetId?: string): void;
+    (eventType: 'adRequestFailure', eventHandler: (adError: AstAdError) => void, targetId?: string): void;
+    (eventType: 'adBadRequest', eventHandler: (adError: AstAdError) => void, targetId?: string): void;
+    (eventType: 'adError', eventHandler: (adError: AstAdError, adObj: AstAdObj) => void, targetId?: string): void;
+    (eventType: 'adLoadedMediated', eventHandler: (adObj: AstAdObj) => void, targetId?: string): void;
+    (eventType: 'adNoBidMediated', eventHandler: (adObj: AstAdObj) => void, targetId?: string): void;
+}
+interface AstNativeItem {
+    required: boolean;
+}
+type AstKeywordValue = Array<string> | string | number | Array<number> | undefined;
+type AstKeywords = Record<string, AstKeywordValue> & {
+    'se-generic-adformat'?: Array<string>;
+    'se-generic-targetid'?: Array<string>;
+    'se-sch-supply_type'?: Array<string>;
+    'no-sno-adformat'?: Array<string>;
+    'no-sno-targetid'?: Array<string>;
+    'aa-sch-dynamic-outstream'?: Array<string>;
+};
+interface AstRendererOptions {
+    disableCollapse?: {
+        hideControlBar: boolean;
+        enabled: boolean;
+        replay: boolean;
+    };
+    playerSkin?: {
+        videoBackgroundColor: string;
+    };
+    safeFrameAutoInitialSize?: boolean;
+    aspectRatio?: string;
+    enableInlineVideoForIos?: boolean;
+    autoInitialSize?: boolean;
+    maxHeight?: MaxHeightParams;
+    fixedSizePlayer?: boolean;
+}
+interface MaxHeightParams {
+    enabled: boolean;
+    height: number;
+}
+interface AstNativeParams {
+    customTitle1: AstNativeItem;
+    customTitle2: AstNativeItem;
+    customTitle3: AstNativeItem;
+    customTitle4: AstNativeItem;
+    title: AstNativeItem;
+    body: AstNativeItem;
+    image: AstNativeItem;
+    icon: AstNativeItem;
+    sponsoredBy: AstNativeItem;
+    cta: AstNativeItem;
+    clickUrl: AstNativeItem;
+    desc2: AstNativeItem;
+    rating?: AstNativeItem;
+    displayUrl: AstNativeItem;
+    likes?: AstNativeItem;
+    downloads?: AstNativeItem;
+    price?: AstNativeItem;
+    saleprice?: AstNativeItem;
+    phone?: AstNativeItem;
+    address?: AstNativeItem;
+    description: AstNativeItem;
+    video?: AstNativeItem;
+    customIcon2?: AstNativeItem;
+}
+interface AstDefineTagParams {
+    invCode: string;
+    targetId: string;
+    sizes: Array<Array<number>>;
+    keywords?: AstKeywords;
+    rendererOptions?: AstRendererOptions;
+    native?: AstNativeParams;
+    allowedFormats?: Array<AstAdType>;
+    enableSafeFrame?: boolean;
+    externalImpId?: string;
+    resizeAdParentDiv?: boolean;
+    safeframeConfig?: SafeFrameConfig;
+    dynamicSizeWidthCheck?: boolean;
+}
+interface SafeFrameConfig {
+    allowExpansionByPush?: boolean;
+    allowExpansionByOverlay?: boolean;
+}
+interface EidsUserSource {
+    id: string;
+    source: string;
+}
+interface AstUserIds {
+    type: string;
+    eids: Array<EidsUserSource>;
+}
+interface AstUser {
+    externalUid?: string;
+    dnt?: boolean;
+    userIds?: Array<AstUserIds>;
+}
+interface AstTrackingManagement {
+    native?: {
+        loadViewabilityScriptAt?: 'adresponse' | 'impression';
+    };
+}
+interface AstRenderingManagement {
+    sandboxAdIframe: boolean;
+    sandboxAttributes: Array<string>;
+}
+interface AstPageOptions {
+    keywords: Record<string, AstKeywordValue>;
+    enableSafeFrame?: boolean;
+    disablePsa?: boolean;
+    user?: AstUser;
+    member?: number;
+    trackingManagement?: AstTrackingManagement;
+    renderingManagement?: AstRenderingManagement;
+}
+interface AstApnTagRequests {
+    user?: AstUser;
+    keywords: AstKeywords;
+    member: number;
+    tags: Record<string, {
+        adResponse: {
+            ads: Array<{
+                rtb: {
+                    banner: AstBanner;
+                    native: AstNative;
+                };
+            }>;
+        };
+        uuid?: string;
+        invCode?: string;
+    }>;
+}
+interface AstApnTag {
+    anq: Array<AstCommand>;
+    defineTag: (params: AstDefineTagParams) => AstTagObj;
+    showTag: (targetId: string) => void;
+    onEvent: AstOnEventFunction;
+    offEvent: (eventType: AstEventType, targetId: string) => void;
+    refresh: (targetIds: Array<string>) => void;
+    modifyTag: (targetId: string, params: Partial<AstDefineTagParams>) => void;
+    loadTags: (targetIds?: Array<string>) => void;
+    emitEvent: (targetId: string, eventName: string) => void;
+    setPageOpts: (params: AstPageOptions) => void;
+    resizeAd: (targetId: string, size: Array<string | number>, config?: {
+        resizeAdParentDiv?: boolean;
+    }) => void;
+    getAstVersion: () => string;
+    setEndpoint: (endpoint: string, freezeIbUrl: boolean) => void;
+    requests?: AstApnTagRequests;
+    fireImpressionTrackers: (nativeObject: AstAdObj) => void;
+    setKeywords: (ids: Array<string>, keywords: AstKeywords, options: {
+        overrideKeyValue: boolean;
+    }) => void;
+    clearRequest: (targetIds?: Array<string> | string) => void;
+}
+interface AstNativeIcon {
+    url: string;
+    height?: number;
+    width?: number;
+    prevent_crop?: boolean;
+}
+
+declare const DeviceTypes: {
+    readonly MOBILE: "mobile";
+    readonly TABLET: "tablet";
+    readonly DESKTOP: "desktop";
+};
+type DeviceType = (typeof DeviceTypes)[keyof typeof DeviceTypes];
+
+declare const Countries: {
+    readonly NO: "no";
+    readonly SE: "se";
+};
+type Country = (typeof Countries)[keyof typeof Countries];
+
+declare const PageTypes: {
+    readonly FRONT: "front";
+    readonly ARTICLE: "article";
+    readonly SECTION: "section";
+    readonly COLLECTION: "collection";
+    readonly OTHER: "other";
+};
+type PageType = (typeof PageTypes)[keyof typeof PageTypes];
+
+interface AdvertisingIdentifiers {
+    xandr?: {
+        ppId1?: string;
+        ppId2?: string;
+    };
+}
+interface TrackerInstance {
+    getAdvertisingIdentifiers: () => Promise<AdvertisingIdentifiers>;
+    getUserId: () => Promise<undefined | string | number>;
+    getEnvironmentId: () => Promise<undefined | string>;
+    getActor: () => Promise<undefined | unknown>;
+    state?: {
+        pageViewId?: string;
+    };
+}
+interface PulseInstance {
+    pulseTracker: TrackerInstance;
+    getSDK: () => Promise<TrackerInstance>;
+    trackElementView?: (eventInput: unknown) => Promise<void>;
+    trackElementClick?: (eventInput: unknown) => Promise<void>;
+    trackClickUIElement?: (eventInput: unknown) => Promise<void>;
+    trackViewUIElement?: (eventInput: unknown) => Promise<void>;
+}
+interface Tracker {
+    clientId: string;
+    instance: TrackerInstance;
+}
+interface Pulse {
+    clientId: string;
+    instance: PulseInstance;
+}
+
+type MarginPriority = 'high' | 'normal' | 'low';
+interface PrioEntry {
+    renderMargin: number;
+    refreshMargin: number;
+}
+interface PrioPreloadMarginMap {
+    high?: Partial<PrioEntry>;
+    normal?: Partial<PrioEntry>;
+    low?: Partial<PrioEntry>;
+}
+
+type DistributionTypes = 'REALESTATE' | 'REALESTATE_RETARGET' | 'REALESTATE_LEISURE' | 'REALESTATE_LEISURE_RETARGET' | 'REALESTATE_PROJECT' | 'REALESTATE_PROJECT_RETARGET' | 'CAR' | 'JOB';
+interface BlinkConstructorOptions {
+    remote?: string;
+    id?: string;
+    hashed_email?: string;
+    theme?: string;
+}
+interface BlinkInstance {
+    inject: (options: unknown) => Promise<unknown>;
+}
+type BlinkConstructor = new (options: BlinkConstructorOptions) => BlinkInstance;
+
+declare const Newsrooms: {
+    readonly SVD: "svd";
+    readonly VG: "vg";
+    readonly GODARE: "godare";
+    readonly AFTENPOSTEN: "aftenposten";
+    readonly SA: "sa";
+    readonly BT: "bt";
+    readonly AFTONBLADET: "aftonbladet";
+    readonly E24: "e24";
+    readonly MINMOTE: "minmote";
+    readonly PENT: "pent";
+    readonly GODT: "godt";
+    readonly TEK: "tekno";
+    readonly KLART: "klart";
+    readonly POLARIS: "polaris";
+};
+type Newsroom = (typeof Newsrooms)[keyof typeof Newsrooms];
+
+interface SiteConfig {
+    publisher: string;
+    country: Country;
+    astUrl?: string;
+    gptUrl?: string;
+    testMember?: number;
+    pageType: PageType;
+    pageOptions: AstPageOptions;
+    placements: Placements;
+    keywordsConfig?: KeywordsConfig;
+    deviceType: DeviceType;
+    isMobileApp?: boolean;
+    glimr?: GlimrConfig;
+    tcf?: TCFConfig;
+    prebid?: PrebidConfig;
+    tracker?: Tracker;
+    pulse?: Pulse;
+    finnBlink?: FinnBlinkConfig;
+    wallpaper?: WallpaperConfig;
+    fullscreenScroll?: FullscreenScrollConfig;
+    appearanceConfig: AppearanceConfig;
+    queryConfig?: QueryConfig;
+    refreshConfig?: RefreshConfig;
+    preloadMarginsConfig?: Record<DeviceType, PrioPreloadMarginMap>;
+    takeover?: TakeoverConfig;
+    brandmetrics?: BrandmetricsConfig;
+    gdpr?: GdprConfig;
+    brandboard?: BrandboardConfig;
+    norstat?: NorstatConfig;
+    siteSpecificConfig?: SiteSpecificConfig;
+    sponsorstripe?: SponsorstripeConfig;
+    privacyBroker?: PrivacyBrokerConfig;
+    drEdition?: DrEditionConfig;
+    forwardExternalImpId?: boolean;
+    requestSize?: number;
+    nativeTrackingConfig?: NativeTrackingConfig;
+    sandboxAdIframeEnabled?: boolean;
+    pageSectionsSelectors?: PageSectionsSelectors;
+    editableConfiguration?: {
+        useS3Config?: boolean;
+        pageTypeToFetch?: string;
+    };
+}
+interface NativeTrackingConfig {
+    nativeTrackingEnabled?: boolean;
+    fireImpressionsBasedOnAppearanceThreshold?: boolean;
+}
+interface SiteSpecificConfig {
+    publisherClassName?: Newsroom;
+    fullWidthFormatClassName?: 'netboard' | 'panorama';
+    classesToRemoveOnRefresh?: Array<string>;
+}
+interface Placement {
+    id: string;
+    sizes: Array<Array<number>>;
+    allowedFormats: Array<AstAdType>;
+    invCode: string;
+    keywords: any;
+    refresh?: boolean;
+    bfCacheRefresh?: boolean;
+    priority?: MarginPriority;
+    ssa?: boolean;
+    threshold?: number;
+    finnBlink?: FinnBlinkPlacementConfig;
+    nativeCustomProperties?: Array<string>;
+    minViewWidth?: number;
+    dynamicSizeWidthCheck?: boolean;
+    safeframeConfig?: SafeFrameConfig;
+    resizeAdParentDiv?: boolean;
+    positionConfig?: Array<PositionConfig>;
+    drEdition?: DrEditionPlacementConfig;
+    isBackfill?: boolean;
+}
+interface Placements {
+    desktop: Array<Placement>;
+    tablet: Array<Placement>;
+    mobile: Array<Placement>;
+}
+interface AppearanceConfig {
+    defaultThreshold: {
+        mobile: number;
+        tablet: number;
+        desktop: number;
+    };
+    clearProbableDimensionsEnabled?: boolean;
+    isDarkModeEnabled?: boolean;
+    mainColumnWidth?: number;
+    subsectionTheme?: string;
+}
+interface PageSectionsSelectors {
+    top?: string;
+    left?: string;
+    right?: string;
+    main?: string;
+    mainFirstColumn?: string;
+    mainSecondColumn?: string;
+}
+interface KeywordsConfig {
+    includeCountingKeywordInTags?: boolean;
+    sponsors?: string;
+}
+interface QueryConfig {
+    queryByDataDevice?: boolean;
+    lazyLoadingV3?: {
+        enabled: boolean;
+        rootMargin: string;
+    };
+    placementBatches?: PlacementBatchesConfig;
+}
+interface PositionConfig {
+    adPositionIndex: number;
+    sizes?: Array<Array<number>>;
+    keywords?: AstKeywords;
+}
+type FinnBlinkTheme = 'light' | 'dark';
+interface FinnBlinkConfig {
+    enabled?: boolean;
+    channel?: string;
+    userId?: string;
+    uuid?: string;
+    identifierUrl?: string;
+    theme?: FinnBlinkTheme;
+    replacementConfig?: {
+        adsToReplace?: Array<Array<string>>;
+        sizes?: {
+            width: number;
+            height: number;
+        };
+    };
+}
+interface FinnBlinkPlacementConfig {
+    enabled: boolean;
+    renderOnlyWithAdBlock?: boolean;
+    position: string;
+    distributionTypes?: Array<DistributionTypes>;
+    height?: number;
+    limit?: number;
+    offset?: number;
+    requireImage?: boolean;
+    rec?: boolean;
+    theme?: FinnBlinkTheme;
+    advertoryTheme?: string;
+}
+interface PrebidConfig {
+    enabled: boolean;
+    url: string;
+    id: string;
+    externalUidInAuctionEnabled: boolean;
+    relevantCbTimeout?: number;
+    forwardGlimrTags?: boolean;
+}
+interface TCFConfig {
+    enabled: boolean;
+    timeout?: number;
+}
+interface GlimrConfig {
+    enabled: boolean;
+    clientId: string;
+}
+interface WallpaperConfig {
+    enabled: boolean;
+    options?: WallpaperConfigOptions;
+}
+interface WallpaperConfigOptions {
+    appMainContainerSelector?: string;
+    wallpaperAnchorSelector?: string;
+}
+interface BrandmetricsConfig {
+    enabled: boolean;
+    url: string;
+}
+interface GdprConfig {
+    url?: string;
+    allowHidingAds?: boolean;
+}
+interface FullscreenScrollConfig {
+    fadingHeaderEnabled: boolean;
+    headerSelectors: Array<string>;
+    skyscraperSelectors?: Array<string>;
+    headerZIndex: number;
+    overlayStyles?: OverlayStyles;
+    moveCogwheelToTheLeft?: boolean;
+}
+interface OverlayStyles {
+    backgroundColor?: string;
+    foregroundColor?: string;
+    articlesContainerWidth?: number;
+    margin?: string;
+    beforeContentValue?: string;
+}
+interface RefreshConfig {
+    delayTime?: number;
+    scrollRefreshEnabled?: boolean;
+    visibilityStateRefreshEnabled?: boolean;
+    backForwardNavigationRefreshEnabled?: boolean;
+}
+interface WelcomePageConfig {
+    showArrowIcon?: boolean;
+    headerElementSelector?: string;
+    buttonLabel?: string;
+    showCloseButton?: boolean;
+}
+interface BrandboardConfig {
+    enabled: boolean;
+    sidebarContainerSelector: string;
+    sidebarItemsContainerSelector: string;
+}
+interface SplashConfig {
+    themeColors?: ThemeColors;
+    buttonLabel: string;
+    logotype: Logotype;
+    showArrowIcon?: boolean;
+    showAnnonsLabel?: boolean;
+}
+interface TakeoverConfig {
+    enabled?: boolean;
+    splash?: SplashConfig;
+    welcomePage?: WelcomePageConfig;
+    topscroller?: WelcomePageConfig;
+    cookieCapName?: string | null;
+    cookieCapTime?: number;
+    setCookieCapForNotShownAd?: boolean;
+}
+interface Logotype {
+    url: string;
+    alt: string;
+}
+interface ThemeColors {
+    backgroundColor: string;
+    color: string;
+}
+interface NorstatConfig {
+    enabled: true;
+}
+interface SponsorstripeConfig {
+    toogleEnabled: boolean;
+    headerSelector?: string;
+    containersSelectors?: Array<string>;
+}
+interface PrivacyBrokerConfig {
+    enabled: boolean;
+    clientId: string;
+    storageKeyPrefix: string;
+}
+interface DrEditionConfig {
+    enabled: boolean;
+    containerSelector: string;
+    wrapperSelector: string;
+    fallbackGlobalEditionName?: string;
+    videoScriptUrl?: string;
+    addPreviewVideo?: (videoElement: HTMLElement) => void;
+}
+interface DrEditionPlacementConfig {
+    editionName: string;
+}
+interface DevicePlacementBatches {
+    [key: string]: Array<string>;
+}
+type PlacementBatchesConfig = {
+    [device in DeviceType]: DevicePlacementBatches;
+};
+
+type IsConsentedToAll = (callback: ConsentedToAllCallback) => void;
+type ConsentedToAllCallback = (value: boolean) => void;
+type GetConsentToAllSync = () => boolean | null;
+interface ConsentManager {
+    getConsentedToAllSync: GetConsentToAllSync;
+    isConsentedToAll: IsConsentedToAll;
+}
+
+interface AlertoryTag {
+    invCode: string;
+    sizes: Array<Array<number>>;
+    adTypes?: Array<AstAdType>;
+    keywords?: AstKeywords;
+}
+interface XandrConfig {
+    member?: number;
+    keywords: AstKeywords;
+    tags: Array<Array<AlertoryTag>>;
+}
+interface AlertoryConfig {
+    xandr: XandrConfig;
+    advertory: Partial<SiteConfig>;
+}
+
+declare const ES_MODULE_KEYS: {
+    readonly Blink: "Blink";
+};
+type ESModuleKey = (typeof ES_MODULE_KEYS)[keyof typeof ES_MODULE_KEYS];
+type ESMModules = {
+    [K in ESModuleKey]?: BlinkConstructor;
+};
+
+declare global {
+    interface Window extends ESMModules {
+        apntag: AstApnTag;
+        relevantDigital: any;
+        Identity: Identity;
+        SvD: any;
+        gdpr: {
+            allowHidingAds: boolean;
+            setupButton: (targetId: string) => void;
+        };
+        _scc_: any;
+        _tcf_?: ConsentManager;
+        __tcfapi: any;
+        _brandmetrics: any;
+        SVP?: any;
+        advertory_idfv?: string;
+        advertory_anId?: string;
+        advertory: {
+            initialized: boolean;
+            siteConfig: SiteConfig;
+            renderedDrEditionAds?: Array<string>;
+            alertoryConfig?: AlertoryConfig;
+        };
+        advertoryFluepapir: boolean;
+        autoplayQueue: Array<(autoplay: {
+            parse: () => void;
+        }) => void>;
+    }
+    interface Document {
+        prerendering: boolean;
+    }
+    interface Navigator {
+        globalPrivacyControl?: boolean;
+    }
+}
+
+declare module 'glimr-sdk' {
+    function setTagCacheTimeInSeconds(time: number): void;
+    function getTags(clientId: string, fn: (tags: Array<string>, tagsMapping: any) => void): void;
+    export { setTagCacheTimeInSeconds, getTags };
+}
+
+declare module '*.png' {
+    const pngValue: string;
+    export { pngValue };
+}
+
+interface UpdateAdvertoryConfig {
+    clearAds?: boolean;
+    reloadExistingAds?: boolean;
+    renderFinnBlinkPlacements?: boolean;
+    contextSelector?: string;
+}
+
+declare const updateAdvertory: (configPropertiesToUpdate?: Partial<SiteConfig>, updateAdvertoryConfig?: UpdateAdvertoryConfig) => Promise<Array<Placement>>;
+
+declare const getVideoPPIDs: (country: Country) => Promise<string>;
+
+declare const initAdvertoryPackage: (config: SiteConfig) => Promise<void>;
+
+export { getVideoPPIDs, initAdvertoryPackage, updateAdvertory };