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;
    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;
}
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];

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 extends TrackerInstance {
    pulseTracker?: TrackerInstance;
    trackElementView?: (eventInput: unknown) => Promise<void>;
    trackElementClick?: (eventInput: unknown) => Promise<void>;
    trackClickUIElement?: (eventInput: unknown) => Promise<void>;
    trackViewUIElement?: (eventInput: unknown) => Promise<void>;
    trackLegacyClickUIElement?: (eventInput: unknown) => Promise<void>;
    trackLegacyViewUIElement?: (eventInput: unknown) => Promise<void>;
}
interface Tracker {
    clientId: string;
    instance: TrackerInstance;
    hasherUrl?: string;
}
interface Pulse {
    clientId: string;
    instance: PulseInstance;
}

type DistributionTypes = 'REALESTATE' | 'REALESTATE_RETARGET' | 'REALESTATE_LEISURE' | 'REALESTATE_LEISURE_RETARGET' | 'REALESTATE_PROJECT' | 'REALESTATE_PROJECT_RETARGET' | 'CAR' | 'JOB';

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 TVNU: "tvnu";
    readonly POLARIS: "polaris";
    readonly KOKET: "koket";
    readonly TV4: "tv4";
    readonly FOTBOLLSKANALEN: "fotbollskanalen";
};
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;
    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;
}
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;
    tracker?: Tracker;
    pulse?: Pulse;
    finnBlink?: FinnBlinkConfig;
    wallpaper?: WallpaperConfig;
    fullscreenScroll?: FullscreenScrollConfig;
    takeover?: TakeoverConfig;
    brandmetrics?: BrandmetricsConfig;
    gdpr?: GdprConfig;
    norstat?: NorstatConfig;
    sponsorstripe?: SponsorstripeConfig;
    drEdition?: DrEditionConfig;
    kilkaya?: KilkayaConfig;
    rightColumnSplit?: RightColumnSplitConfig;
    editableConfiguration?: EditableConfigurationConfig;
    adScaleConfig?: AdScaleConfig;
    widescreenSwitching?: WidescreenSwitchingConfig;
}
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;
    supportsNonRTB?: boolean;
}
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;
}
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;
}
interface PrebidConfig {
    enabled: boolean;
    prebidUrl: string;
    configId: string;
    externalUidInAuctionEnabled: boolean;
    relevantCallbackTimeout?: number;
    forwardGlimrTags?: boolean;
}
interface FinnBlinkSDKPayload {
    channel?: string;
    userId?: string;
    theme?: Theme;
    uuid?: string;
}
interface FinnBlinkConfig {
    enabled?: boolean;
    identifierUrl?: string;
    sdkPayload?: FinnBlinkSDKPayload;
    replacementConfig?: {
        adsToReplace?: Array<Array<string>>;
        sizes?: {
            width: number;
            height: number;
        };
    };
}
interface FinnBlinkPlacementSDKPayload {
    position?: string;
    height?: number;
    limit?: number;
    offset?: number;
    requireImage?: boolean;
    rec?: boolean;
    distributionTypes?: Array<DistributionTypes>;
    theme?: Theme;
}
interface FinnBlinkPlacementConfig {
    enabled: boolean;
    sdkPayload?: FinnBlinkPlacementSDKPayload;
    renderOnlyWithAdBlock?: boolean;
    advertoryTheme?: string;
    loadOnlyFinnBlink?: boolean;
    useNewConstructor?: boolean;
}
interface WallpaperConfigOptions {
    wallpaperAnchorSelector?: string;
}
interface WallpaperConfig {
    enabled: boolean;
    options?: WallpaperConfigOptions;
}
interface OverlayStyles {
    backgroundColor?: string;
    foregroundColor?: string;
    articlesContainerWidth?: number;
    margin?: 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 {
    useS3Config?: boolean;
    pageTypeToFetch?: string;
}
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 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>;

declare const initAdsOnVg: (adObj: AstAdObj, options?: Partial<SiteConfig>) => void;

interface AdComponentProps {
    placementId: 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 Topboard: ({ placementId, adTheme }: AdComponentProps) => JSX.Element;

declare const Netboard: ({ placementId, adTheme }: AdComponentProps) => JSX.Element;

declare const Skyscraper: ({ placementId, adTheme }: AdComponentProps) => JSX.Element;

declare const Wallpaper: ({ placementId, adTheme }: AdComponentProps) => JSX.Element;

declare const Sponsorstripe: ({ placementId, device }: AdComponentProps) => JSX.Element;

const HANDLERS = {
  prepareTag,
  preparePageOptions,
  siteEvents,
  initNativeAd: initAdsOnVg,
};

const advertory = createAdvertory(HANDLERS, siteSpecificConfig);

export { Netboard, Skyscraper, Sponsorstripe, Topboard, Wallpaper, advertory as default };
