@schibsted/advertory 3.7.11 → 3.8.0

package/omni/es/index.d.ts

@@ -0,0 +1,889 @@
+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;
+    customBody1?: string;
+    customBody2?: string;
+    customBody3?: string;
+    customBody4?: string;
+    customBody5?: string;
+    description?: string;
+    customIcon1?: AstNativeIcon;
+    customIcon2: AstNativeIcon;
+    customDisplayUrl1?: string;
+}
+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 Events {
+    adRequested: () => void;
+    adAvailable: (adObj: AstAdObj) => void;
+    adLoaded: (adObj: AstAdObj) => void;
+    adNoBid: (adObj: AstAdObj) => void;
+    adError: (adError: AstAdError, adObj: AstAdObj) => void;
+    adCollapse: () => void;
+    adRequestFailure: (adError: AstAdError) => void;
+    adBadRequest: (adError: AstAdError) => void;
+    adLoadedMediated: (adObj: AstAdObj) => void;
+    adNoBidMediated: (adObj: AstAdObj) => void;
+}
+interface AstNativeItem {
+    required: boolean;
+}
+type AstKeywordValue = Array<string> | string | number | Array<number> | undefined;
+type Keywords = Record<string, AstKeywordValue>;
+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;
+    customTitle5?: AstNativeItem;
+    title: AstNativeItem;
+    body: AstNativeItem;
+    image: AstNativeItem;
+    icon: AstNativeItem;
+    sponsoredBy: AstNativeItem;
+    cta: AstNativeItem;
+    clickUrl: AstNativeItem;
+    clickTrackers?: AstNativeItem;
+    clickFallbackUrl?: AstNativeItem;
+    desc2: AstNativeItem;
+    rating?: AstNativeItem;
+    displayUrl: AstNativeItem;
+    likes?: AstNativeItem;
+    downloads?: AstNativeItem;
+    price?: AstNativeItem;
+    saleprice?: AstNativeItem;
+    phone?: AstNativeItem;
+    address?: AstNativeItem;
+    description: AstNativeItem;
+    video?: AstNativeItem;
+    custom?: AstNativeItem;
+    customBody1?: AstNativeItem;
+    customBody2?: AstNativeItem;
+    customBody3?: AstNativeItem;
+    customBody4?: AstNativeItem;
+    customBody5?: AstNativeItem;
+    customCta1?: AstNativeItem;
+    customCta2?: AstNativeItem;
+    customCta3?: AstNativeItem;
+    customCta4?: AstNativeItem;
+    customCta5?: AstNativeItem;
+    customDisplayUrl1?: AstNativeItem;
+    customDisplayUrl2?: AstNativeItem;
+    customDisplayUrl3?: AstNativeItem;
+    customDisplayUrl4?: AstNativeItem;
+    customDisplayUrl5?: AstNativeItem;
+    customIcon1?: AstNativeItem;
+    customIcon2?: AstNativeItem;
+    customIcon3?: AstNativeItem;
+    customIcon4?: AstNativeItem;
+    customIcon5?: AstNativeItem;
+    customImage1?: AstNativeItem;
+    customImage2?: AstNativeItem;
+    customImage3?: AstNativeItem;
+    customImage4?: AstNativeItem;
+    customImage5?: AstNativeItem;
+    customSocialIcon1?: AstNativeItem;
+    customSocialIcon2?: AstNativeItem;
+    customSocialIcon3?: AstNativeItem;
+    customSocialIcon4?: AstNativeItem;
+    customSocialIcon5?: AstNativeItem;
+    customSocialUrl1?: AstNativeItem;
+    customSocialUrl2?: AstNativeItem;
+    customSocialUrl3?: AstNativeItem;
+    customSocialUrl4?: AstNativeItem;
+    customSocialUrl5?: AstNativeItem;
+    fullText?: AstNativeItem;
+    impressionTrackers?: AstNativeItem;
+    javascriptTrackers?: AstNativeItem;
+    omidTrackers?: AstNativeItem;
+    privacyLink?: AstNativeItem;
+    sdkKV?: AstNativeItem;
+    type?: AstNativeItem;
+}
+interface AstDefineTagParams {
+    invCode: string;
+    targetId: string;
+    sizes: Array<Array<number>>;
+    keywords?: AstKeywords;
+    rendererOptions?: AstRendererOptions;
+    native?: AstNativeParams;
+    allowedFormats?: Array<AstAdType>;
+    enableSafeFrame?: boolean;
+    externalImpId?: string;
+    safeframeConfig?: SafeFrameConfig;
+    dynamicSizeWidthCheck?: boolean;
+    allowSmallerSizes?: boolean;
+    globalPlacementId?: string;
+}
+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 AstUserSync {
+    disabled: boolean;
+}
+interface AstRenderingManagement {
+    sandboxAdIframe: boolean;
+    sandboxAttributes: Array<string>;
+}
+interface AstPageOptions {
+    keywords: Keywords;
+    enableSafeFrame?: boolean;
+    disablePsa?: boolean;
+    user?: AstUser;
+    member?: number;
+    publisherId: number;
+    trackingManagement?: AstTrackingManagement;
+    renderingManagement?: AstRenderingManagement;
+    userSync?: AstUserSync;
+}
+interface AstNativeIcon {
+    url: string;
+    height?: number;
+    width?: number;
+    prevent_crop?: boolean;
+}
+
+declare const siteEvents: {
+    adRequested: () => void;
+    adAvailable: (adObj: AstAdObj) => void;
+    adLoaded: (adObj: AstAdObj) => void;
+    adNoBid: (adObj: AstAdObj) => void;
+    adError: (adError: AstAdError, adObj: AstAdObj) => void;
+    adCollapse: () => void;
+    adRequestFailure: (adError: AstAdError) => void;
+    adBadRequest: (adError: AstAdError) => void;
+    adLoadedMediated: (adObj: AstAdObj) => void;
+    adNoBidMediated: (adObj: AstAdObj) => void;
+};
+
+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];
+
+/**
+ * SDK-agnostic shape of the pulse tracker instance advertory actually calls.
+ * getActor is typed Promise<unknown> — nothing in this codebase reads its
+ * resolved value, so it isn't tied to any SDK's ActorInput type.
+ */
+interface PulseInstance {
+    getAdvertisingIdentifiers: () => Promise<AdvertisingIdentifiers>;
+    getUserId: () => Promise<string | number | undefined>;
+    getEnvironmentId: () => Promise<string | undefined>;
+    getActor: () => Promise<unknown>;
+    state?: {
+        pageViewId?: string;
+    };
+}
+
+interface AdvertisingIdentifiers {
+    xandr?: {
+        ppId1?: string;
+        ppId2?: string;
+    };
+}
+interface PulseLegacyExtras {
+    trackElementView?: (eventInput: unknown) => Promise<void>;
+    trackElementClick?: (eventInput: unknown) => Promise<void>;
+    trackClickUIElement?: (eventInput: unknown) => Promise<void>;
+    trackViewUIElement?: (eventInput: unknown) => Promise<void>;
+    trackLegacyViewUIElement?: (eventInput: unknown, trackOptions?: unknown) => Promise<unknown>;
+    trackLegacyClickUIElement?: (eventInput: unknown, trackOptions?: unknown) => Promise<unknown>;
+}
+interface PulseConfig {
+    clientId: string;
+    instance: PulseInstance & PulseLegacyExtras;
+    hasherUrl?: string;
+}
+
+declare const Newsrooms: {
+    readonly SVD: "svd";
+    readonly VG: "vg";
+    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 TVNU: "tvnu";
+    readonly POLARIS: "polaris";
+    readonly KOKET: "koket";
+    readonly TV4: "tv4";
+    readonly FOTBOLLSKANALEN: "fotbollskanalen";
+    readonly OMNI: "omni";
+};
+type Newsroom = (typeof Newsrooms)[keyof typeof Newsrooms];
+
+interface AdNativeData {
+    containerId: string;
+    img: string;
+    imgAltText: string;
+    imgWidth?: number;
+    imgHeight?: number;
+    logo: string;
+    sponsoredBy: string;
+    title: string;
+    url: string;
+    cta: string;
+    description: string;
+    adText: string;
+    adFrom: string;
+    adContent: string;
+    adContentFrom: string;
+    desc2: string;
+    video?: {
+        content: string;
+    };
+    customTitle1?: string;
+    customTitle2?: string;
+    customTitle3?: string;
+    customTitle4?: string;
+    customBody1?: string;
+    customBody2?: string;
+    customBody3?: string;
+    customBody4?: string;
+    customBody5?: string;
+    logo2?: string;
+    previewVideoSrc?: string;
+}
+interface Options {
+    publisher?: Newsroom;
+    video?: {};
+    language?: Country;
+    pageType?: PageType;
+    deviceType?: DeviceType;
+    appearanceConfig?: AppearanceConfig;
+    nativeTrackingConfig?: NativeTrackingConfig;
+    adPlacementFormat?: string;
+    productTag?: string;
+    pageSectionsSelectors?: PageSectionsSelectors;
+    clickLinkSelector?: string;
+    containerId?: string;
+}
+interface AdNativeTemplates {
+    [templatesName: string]: (nativeData: AdNativeData, options: Options) => string | null;
+}
+interface AdNativeTemplatesGrouped {
+    videoTemplates: AdNativeTemplates;
+    displayTemplates: AdNativeTemplates;
+}
+type InitNativeAd = (adObj: AstAdObj, options?: Partial<SiteConfig>) => void;
+interface CreateInitNativeAdConfig {
+    templates: AdNativeTemplatesGrouped;
+    getOptions: (siteConfig: Partial<SiteConfig>) => Options;
+    postProcess?: (adObj: AstAdObj, adContainer: HTMLElement) => void;
+}
+
+declare const CogwheelPositions: {
+    readonly LEFT: "left";
+    readonly RIGHT: "right";
+};
+type CogwheelPosition = (typeof CogwheelPositions)[keyof typeof CogwheelPositions];
+
+interface SiteConfig {
+    pageContext: PageContext;
+    pageSetup?: PageSetup;
+    developerOptions?: DeveloperOptions;
+    pageOptions: AstPageOptions;
+    placements: Placements;
+    appearanceConfig: AppearanceConfig;
+    queryConfig?: QueryConfig;
+    refreshConfig?: RefreshConfig;
+    nativeTrackingConfig?: NativeTrackingConfig;
+    pageSectionsSelectors?: PageSectionsSelectors;
+    siteSpecificConfig?: SiteSpecificConfig;
+    customHandlers?: CustomHandlers;
+    glimr?: GlimrConfig;
+    tcf?: TCFConfig;
+    prebid?: PrebidConfig;
+    pulse?: PulseConfig;
+    finnBlink?: FinnBlinkConfig;
+    wallpaper?: WallpaperConfig;
+    fullscreenScroll?: FullscreenScrollConfig;
+    takeover?: TakeoverConfig;
+    brandmetrics?: BrandmetricsConfig;
+    gdpr?: GdprConfig;
+    norstat?: NorstatConfig;
+    sponsorstripe?: SponsorstripeConfig;
+    drEdition?: DrEditionConfig;
+    kilkaya?: KilkayaConfig;
+    rightColumnSplit?: RightColumnSplitConfig;
+    editory?: EditoryConfig;
+    adScaleConfig?: AdScaleConfig;
+    widescreenSwitching?: WidescreenSwitchingConfig;
+    fullWidth?: FullWidthConfig;
+}
+interface PageContext {
+    publisher: string;
+    countryCode: Country;
+    pageType: PageType;
+    deviceType: DeviceType;
+    isMobileApp?: boolean;
+}
+interface PageSetup {
+    pageOptions?: PageSetupPageOptions;
+    tag?: PageSetupTag;
+}
+interface PageSetupKeywords {
+    appType?: boolean;
+    device?: boolean;
+    externalIdSrc?: boolean;
+    hasContext?: boolean;
+    screen?: boolean;
+    analyticsConsent?: boolean;
+    sectionPageType?: boolean;
+    obituaries?: boolean;
+    sdkVersion?: boolean;
+    hasPlusMembership?: boolean;
+}
+interface PageSetupAstOptions {
+    addPublisherToGeo?: boolean;
+    includeExternalUid?: boolean;
+    sandboxAdIframeEnabled?: boolean;
+}
+interface PageSetupPageOptions {
+    keywords?: PageSetupKeywords;
+    options?: PageSetupAstOptions;
+}
+interface PageSetupTag {
+    reloadKeywords?: boolean;
+    includeCountingKeywordInTags?: boolean;
+    forwardExternalImpId?: boolean;
+    useAppTabletInvCode?: boolean;
+}
+interface DeveloperOptions {
+    astUrl?: string;
+    gptUrl?: string;
+    testMember?: number;
+}
+interface PlacementRefreshConfig {
+    scroll?: boolean;
+    bfCache?: boolean;
+}
+interface Placement {
+    targetId: string;
+    sizes: Array<Array<number>>;
+    allowedFormats: Array<AstAdType>;
+    invCode: string;
+    keywords: Keywords;
+    refresh?: PlacementRefreshConfig;
+    ssaNativeAdEnabled?: boolean;
+    requestThreshold?: number;
+    finnBlink?: FinnBlinkPlacementConfig;
+    nativeCustomProperties?: Array<string>;
+    minViewWidth?: number;
+    dynamicSizeWidthCheck?: boolean;
+    safeframeConfig?: SafeFrameConfig;
+    drEdition?: DrEditionPlacementConfig;
+    isBackfill?: boolean;
+    takeoverCookieCapForSharedPlacement?: boolean;
+    serverSidePlacement?: boolean;
+    xandrPlacementId?: number;
+    supportsNonRTB?: boolean;
+    globalPlacementId?: string;
+}
+interface Placements {
+    desktop: Array<Placement>;
+    tablet: Array<Placement>;
+    mobile: Array<Placement>;
+}
+type Theme = 'light' | 'dark';
+interface AppearanceConfig {
+    defaultThreshold: {
+        mobile: number;
+        tablet: number;
+        desktop: number;
+    };
+    clearProbableDimensionsEnabled?: boolean;
+    theme?: Theme;
+    mainColumnWidth?: number;
+}
+interface LazyLoadingConfig {
+    enabled: boolean;
+    rootMargin: string;
+}
+interface QueryConfig {
+    queryByDataDeviceAttribute?: boolean;
+    lazyLoadingV3?: LazyLoadingConfig;
+    placementBatches?: PlacementBatchesConfig;
+    batchSize?: number;
+}
+interface RefreshConfig {
+    delayTimeToNextRefresh?: number;
+    scrollRefreshEnabled?: boolean;
+    visibilityStateRefreshEnabled?: boolean;
+    backForwardNavigationRefreshEnabled?: boolean;
+}
+interface NativeTrackingConfig {
+    enabled?: boolean;
+    fireImpressionsBasedOnAppearanceThreshold?: boolean;
+}
+interface PageSectionsSelectors {
+    top?: string;
+    left?: string;
+    right?: string;
+    main?: string;
+    header?: string;
+    mainFirstColumn?: string;
+    mainSecondColumn?: string;
+}
+interface SiteSpecificConfig {
+    publisherClassName?: Newsroom;
+    fullWidthFormatClassName?: 'netboard' | 'panorama';
+    classesToRemoveOnRefresh?: Array<string>;
+    dynamicOutstreamFormats?: Array<string>;
+}
+interface CustomHandlers {
+    initNativeAd?: InitNativeAd;
+}
+interface GlimrConfig {
+    enabled: boolean;
+    clientId: string;
+}
+interface TCFConfig {
+    enabled: boolean;
+    advertisingCMPSignalEnabled?: boolean;
+    schibstedConsentToPayEnabled?: boolean;
+    schibstedAdChoicesOverrideValue?: string;
+    timeout?: number;
+    nonRtb?: NonRTBConfig;
+}
+interface PrebidConfig {
+    enabled: boolean;
+    prebidUrl: string;
+    configId: string;
+    externalUidInAuctionEnabled: boolean;
+    relevantCallbackTimeout?: number;
+    forwardGlimrTags?: boolean;
+}
+interface NonRTBConfig {
+    invCodeSuffix?: string;
+}
+interface FinnBlinkSDKPayload {
+    channel?: string;
+}
+interface FinnBlinkSizes {
+    width: number;
+    height: number;
+}
+interface FinnBlinkReplacementConfig {
+    adsToReplace?: Partial<Record<DeviceType, Array<Array<string>>>>;
+    sizes?: Partial<Record<DeviceType, FinnBlinkSizes>>;
+}
+interface FinnBlinkConfig {
+    enabled?: boolean;
+    sdkPayload?: FinnBlinkSDKPayload;
+    replacementConfig?: FinnBlinkReplacementConfig;
+}
+interface FinnBlinkPlacementSDKPayload {
+    position?: string;
+    height?: number;
+    offset?: number;
+    requireImage?: boolean;
+}
+interface FinnBlinkPlacementConfig {
+    enabled: boolean;
+    sdkPayload?: FinnBlinkPlacementSDKPayload;
+    renderOnlyWithAdBlock?: boolean;
+    advertoryTheme?: string;
+    loadOnlyFinnBlink?: boolean;
+}
+interface WallpaperConfigOptions {
+    wallpaperAnchorSelector?: string;
+}
+interface WallpaperConfig {
+    enabled: boolean;
+    options?: WallpaperConfigOptions;
+}
+interface OverlayStyles {
+    backgroundColor?: string;
+    foregroundColor?: string;
+    articlesContainerWidth?: number;
+    margin?: Partial<Record<DeviceType, string>>;
+    beforeContentValue?: string;
+}
+interface FullscreenScrollOptions {
+    fadingHeaderEnabled?: boolean;
+    headerSelectors?: Array<string>;
+    skyscraperSelectors?: Array<string>;
+    headerZIndex?: number;
+    overlayStyles?: OverlayStyles;
+    cogwheelPosition?: CogwheelPosition;
+    iosSafeAreaTopFix?: string;
+}
+interface FullscreenScrollConfig {
+    enabled: boolean;
+    options?: FullscreenScrollOptions;
+}
+interface WelcomePageConfig {
+    showArrowIcon?: boolean;
+    buttonLabel?: string;
+    showCloseButton?: boolean;
+}
+interface Logotype {
+    url: string;
+    alt: string;
+}
+interface ThemeColors {
+    backgroundColor: string;
+    color: string;
+}
+interface SplashConfig {
+    themeColors?: ThemeColors;
+    buttonLabel: string;
+    logotype: Logotype;
+    showArrowIcon?: boolean;
+    showAnnonsLabel?: boolean;
+}
+interface TakeoverOptions {
+    secondVisitEnabled?: boolean;
+    cookieCapName?: string | null;
+    cookieCapTime?: number;
+    setCookieCapForNotShownAd?: boolean;
+}
+interface TakeoverConfig {
+    enabled?: boolean;
+    splash?: SplashConfig;
+    welcomePage?: WelcomePageConfig;
+    topscroller?: WelcomePageConfig;
+    options?: TakeoverOptions;
+}
+interface BrandmetricsConfig {
+    enabled: boolean;
+    brandmetricsUrl: string;
+}
+interface GdprConfig {
+    gdprUrl?: string;
+    allowHidingAds?: boolean;
+}
+interface NorstatConfig {
+    enabled: true;
+}
+interface SponsorStripeOptions {
+    containersSelectors?: Array<string>;
+    staticElementsSelectors?: Array<string>;
+    dynamicElementsSelectors?: Array<string>;
+    hideOnScroll?: boolean;
+    stickBelowHeader?: boolean;
+}
+interface SponsorstripeConfig {
+    enabled: boolean;
+    options?: SponsorStripeOptions;
+}
+interface DrEditionOptions {
+    containerSelector: string;
+    wrapperSelector: string;
+    fallbackGlobalEditionName?: string;
+    videoScriptUrl?: string;
+    addPreviewVideo?: (videoElement: HTMLElement) => void;
+}
+interface DrEditionConfig {
+    enabled: boolean;
+    options: DrEditionOptions;
+}
+interface DrEditionPlacementConfig {
+    editionName: string;
+}
+interface KilkayaOptions {
+    kilkayaUrl: string;
+}
+interface KilkayaConfig {
+    enabled: boolean;
+    options: KilkayaOptions;
+}
+interface RightColumnSplitConfig {
+    enabled: boolean;
+    splitPointIDs: Array<string>;
+    adSelector: string;
+    trackSelector?: string;
+}
+interface EditableConfigurationConfig {
+    enabled?: boolean;
+    pageTypeToFetch?: string;
+}
+interface AdNativeBuilderConfig {
+    enabled?: boolean;
+}
+interface EditoryConfig {
+    editoryUrl?: string;
+    editableConfiguration?: EditableConfigurationConfig;
+    adNativeBuilder?: AdNativeBuilderConfig;
+}
+interface AdScaleConfig {
+    enabled: boolean;
+    adsToBeScaled: Partial<Record<DeviceType, Array<string>>>;
+    offset?: Record<string, number>;
+}
+interface WidescreenSwitchingOptions {
+    rotationInterval?: number;
+    widescreenIdPrefix?: string;
+}
+interface WidescreenSwitchingConfig {
+    enabled: boolean;
+    options?: WidescreenSwitchingOptions;
+}
+interface FullWidthBreakoutStyles {
+    left?: string;
+    marginLeft?: string;
+}
+interface FullWidthStyles {
+    adContainer?: FullWidthBreakoutStyles;
+    adContainerWrapper?: FullWidthBreakoutStyles;
+}
+interface FullWidthOptions {
+    styles?: Partial<Record<DeviceType, FullWidthStyles>>;
+}
+interface FullWidthConfig {
+    enabled: boolean;
+    options?: FullWidthOptions;
+}
+interface SiteHandlers {
+    prepareTag: (tag: AstDefineTagParams) => AstDefineTagParams;
+    siteEvents: Events;
+    preparePageOptions: (pageOptions: AstPageOptions) => Promise<AstPageOptions>;
+    initNativeAd?: InitNativeAd;
+}
+interface DevicePlacementBatches {
+    [key: string]: Array<string>;
+}
+type PlacementBatchesConfig = {
+    [device in DeviceType]: DevicePlacementBatches;
+};
+
+declare const siteSpecificConfig: SiteSpecificConfig;
+
+interface UpdateAdvertoryConfig {
+    clearAds?: boolean;
+    reloadExistingAds?: boolean;
+    renderFinnBlinkPlacements?: boolean;
+    contextSelector?: string;
+}
+
+interface BaseTag {
+    slug?: string;
+    enabled?: boolean;
+    id: string;
+    title: string;
+    metadata?: [{
+        url: string;
+        type: string;
+    }];
+}
+interface Tag extends BaseTag {
+    type?: 'descriptor' | 'organization' | 'person' | 'place' | 'location' | 'event';
+}
+interface VideoSection {
+    title: string;
+    id: string;
+    shortPath: string;
+    metadata: {
+        podcast_author?: string;
+        podcast_categoryTree?: string;
+        actingEditor?: string;
+        afp?: 'true';
+        sponsored?: 'true';
+        [property: string]: unknown;
+    };
+    parent: VideoSection;
+}
+interface VideoAdsConfigParams {
+    aspectRatio?: string;
+    tags: Array<Tag>;
+    assetSection: VideoSection;
+    publisher: string;
+    isApp: boolean;
+    pageAdsKeywords?: Keywords;
+    startMode: 'manual' | 'auto' | 'silent';
+    isUserLoggedIn: boolean;
+    isUsedInOverlayVideoPlayer?: boolean;
+    isLiveStudio: boolean;
+    assetId: string;
+    isAndroidApp: boolean;
+    deviceType: DeviceType;
+}
+interface VideoStream {
+    attributes?: {
+        id?: number;
+    };
+}
+
+interface Advertory {
+    init: (config: SiteConfig) => Promise<void>;
+    update: (configToUpdate?: Partial<SiteConfig>, options?: UpdateAdvertoryConfig) => Promise<Array<Placement>>;
+    getVideoPPIDs: (country: Country) => Promise<string>;
+    createInitNativeAd: (config: CreateInitNativeAdConfig) => InitNativeAd;
+    getVideoAdsConfig: (params: VideoAdsConfigParams) => (stream: VideoStream) => Promise<Record<string, unknown>>;
+}
+
+declare const createAdvertory: (handlers: SiteHandlers, siteSpecificConfig?: SiteSpecificConfig) => Advertory;
+
+declare const prepareTag: (tag: AstDefineTagParams) => AstDefineTagParams;
+
+declare const preparePageOptions: (pageOptions: AstPageOptions) => Promise<AstPageOptions>;
+
+interface AdComponentProps {
+    targetId: string;
+    adTheme?: string;
+    probableHeight?: string;
+    probableWidth?: string;
+    classNames?: AdStylesConfig;
+    irisClassNames?: Array<string>;
+    device?: 'mobile' | 'desktop' | 'all';
+    disabled?: boolean;
+}
+interface AdStylesConfig {
+    wrapper: string;
+    container: string;
+    theme?: string;
+}
+
+declare const Takeover: (props: AdComponentProps) => JSX.Element;
+
+const HANDLERS = {
+  prepareTag,
+  preparePageOptions,
+  siteEvents,
+};
+
+const advertory = createAdvertory(HANDLERS, siteSpecificConfig);
+
+export { Takeover, advertory as default };