@schibsted/advertory 2.44.0-test-art-4

package/types/core/interface/config.d.ts

@@ -0,0 +1,292 @@
+import { AstAdType, AstDefineTagParams, AstPageOptions, Events, SafeFrameConfig, AstAdObj, AstKeywords } from './ast';
+import { DeviceType } from './device';
+import { Country } from './countries';
+import { PageType } from './page-types';
+import { Pulse, Tracker } from 'features/interface/tracker';
+import { MarginPriority, PrioPreloadMarginMap } from './margins';
+import { DistributionTypes, FinnBlinkFallback } from 'features/interface/finn-blink';
+import { InitNativeAd } from 'features/interface/ad-native';
+import { Newsroom } from './newsrooms';
+export 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;
+    };
+}
+export interface NativeTrackingConfig {
+    nativeTrackingEnabled?: boolean;
+    fireImpressionsBasedOnAppearanceThreshold?: boolean;
+}
+export interface SiteSpecificConfig {
+    publisherClassName?: Newsroom;
+    fullWidthFormatClassName?: 'netboard' | 'panorama';
+    classesToRemoveOnRefresh?: Array<string>;
+}
+export interface SiteHandlers {
+    prepareTag: (tag: AstDefineTagParams) => AstDefineTagParams;
+    siteEvents: Events;
+    preparePageOptions: (pageOptions: AstPageOptions) => Promise<AstPageOptions>;
+    initNativeAd: InitNativeAd;
+    wallpaperHandlers: {
+        initWallpaperAd: (showWallpaperTag: () => void, wallpaperOptions?: WallpaperConfig) => void;
+        adjustAdToHorseshoe: (targetId: string) => void;
+    };
+    loadFinnBlinkAd: (targetId: string, props: LoadFinnBlinkAdProps, fallbackToXandr: FinnBlinkFallback | null, callbackAfterFinnBlinkRender?: () => void) => Promise<void>;
+    replaceAdsWithFinnBlink: (finnBlink?: FinnBlinkConfig) => Promise<void>;
+    initSponsorstripeAd?: (adObj: AstAdObj) => void;
+}
+export 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;
+}
+export interface Placements {
+    desktop: Array<Placement>;
+    tablet: Array<Placement>;
+    mobile: Array<Placement>;
+}
+export 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';
+export interface FinnBlinkConfig {
+    enabled?: boolean;
+    channel?: string;
+    userId?: string;
+    uuid?: string;
+    identifierUrl?: string;
+    theme?: FinnBlinkTheme;
+    replacementConfig?: {
+        adsToReplace?: Array<Array<string>>;
+        sizes?: {
+            width: number;
+            height: number;
+        };
+    };
+}
+export interface LoadFinnBlinkAdProps {
+    publisher: string;
+    country: string;
+    finnBlink?: FinnBlinkConfig;
+}
+export 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;
+}
+export interface PrebidConfig {
+    enabled: boolean;
+    url: string;
+    id: string;
+    externalUidInAuctionEnabled: boolean;
+    relevantCbTimeout?: number;
+    forwardGlimrTags?: boolean;
+}
+export interface TCFConfig {
+    enabled: boolean;
+    timeout?: number;
+}
+export interface GlimrConfig {
+    enabled: boolean;
+    clientId: string;
+}
+export interface WallpaperConfig {
+    enabled: boolean;
+    options?: WallpaperConfigOptions;
+}
+interface WallpaperConfigOptions {
+    appMainContainerSelector?: string;
+    wallpaperAnchorSelector?: string;
+}
+interface BrandmetricsConfig {
+    enabled: boolean;
+    url: string;
+}
+interface GdprConfig {
+    url?: string;
+    allowHidingAds?: boolean;
+}
+export interface FullscreenScrollConfig {
+    fadingHeaderEnabled: boolean;
+    headerSelectors: Array<string>;
+    skyscraperSelectors?: Array<string>;
+    headerZIndex: number;
+    overlayStyles?: OverlayStyles;
+    moveCogwheelToTheLeft?: boolean;
+}
+export interface OverlayStyles {
+    backgroundColor?: string;
+    foregroundColor?: string;
+    articlesContainerWidth?: number;
+    margin?: string;
+    beforeContentValue?: string;
+}
+export interface RefreshConfig {
+    delayTime?: number;
+    scrollRefreshEnabled?: boolean;
+    visibilityStateRefreshEnabled?: boolean;
+    backForwardNavigationRefreshEnabled?: boolean;
+}
+export interface WelcomePageConfig {
+    showArrowIcon?: boolean;
+    headerElementSelector?: string;
+    buttonLabel?: string;
+    showCloseButton?: boolean;
+}
+export interface BrandboardConfig {
+    enabled: boolean;
+    sidebarContainerSelector: string;
+    sidebarItemsContainerSelector: string;
+}
+export interface SplashConfig {
+    themeColors?: ThemeColors;
+    buttonLabel: string;
+    logotype: Logotype;
+    showArrowIcon?: boolean;
+    showAnnonsLabel?: boolean;
+}
+export interface TakeoverConfig {
+    enabled?: boolean;
+    splash?: SplashConfig;
+    welcomePage?: WelcomePageConfig;
+    topscroller?: WelcomePageConfig;
+    cookieCapName?: string | null;
+    cookieCapTime?: number;
+    setCookieCapForNotShownAd?: boolean;
+}
+export interface Logotype {
+    url: string;
+    alt: string;
+}
+export interface ThemeColors {
+    backgroundColor: string;
+    color: string;
+}
+export interface NorstatConfig {
+    enabled: true;
+}
+export interface SponsorstripeConfig {
+    toogleEnabled: boolean;
+    headerSelector?: string;
+    containersSelectors?: Array<string>;
+}
+export interface PrivacyBrokerConfig {
+    enabled: boolean;
+    clientId: string;
+    storageKeyPrefix: string;
+}
+export interface DrEditionConfig {
+    enabled: boolean;
+    containerSelector: string;
+    wrapperSelector: string;
+    fallbackGlobalEditionName?: string;
+    videoScriptUrl?: string;
+    addPreviewVideo?: (videoElement: HTMLElement) => void;
+}
+export interface DrEditionPlacementConfig {
+    editionName: string;
+}
+export interface DevicePlacementBatches {
+    [key: string]: Array<string>;
+}
+export type PlacementBatchesConfig = {
+    [device in DeviceType]: DevicePlacementBatches;
+};
+export type PlacementsGroup = Record<string, Array<Placement>>;
+export declare const UpdatableConfigProperties: readonly ["deviceType", "pageType", "placements", "takeover", "refreshConfig", "editableConfiguration"];
+export type UpdatableConfigProperty = (typeof UpdatableConfigProperties)[number];
+export {};

package/types/core/interface/countries.d.ts

@@ -0,0 +1,6 @@
+export declare const Countries: {
+    readonly NO: "no";
+    readonly SE: "se";
+};
+export type Country = (typeof Countries)[keyof typeof Countries];
+export type CountryPrefix = 'no-sno' | 'se-generic';

package/types/core/interface/device.d.ts

@@ -0,0 +1,13 @@
+export declare const DeviceTypes: {
+    readonly MOBILE: "mobile";
+    readonly TABLET: "tablet";
+    readonly DESKTOP: "desktop";
+};
+export type DeviceType = (typeof DeviceTypes)[keyof typeof DeviceTypes];
+export type PrepareOptionsDeviceType = 'phone' | 'tablet' | 'desktop';
+export interface DeviceParams {
+    OS: string;
+    mobileOS: string;
+    isHybridApp: boolean;
+    appMode: string;
+}

package/types/core/interface/dictionary.d.ts

@@ -0,0 +1,10 @@
+export interface DictionaryWords {
+    adText: string;
+    adFrom: string;
+    adContent: string;
+    adContentFrom: string;
+}
+export interface Dictionary {
+    no: DictionaryWords;
+    se: DictionaryWords;
+}

package/types/core/interface/fallback.d.ts

@@ -0,0 +1,5 @@
+export interface FallbackReturn {
+    withXandrAd: (targetId: string) => void;
+    withFinnBlinkAd: (targetId: string) => Promise<void>;
+    withFullAdsChain: (targetId: string) => Promise<void>;
+}

package/types/core/interface/formats.d.ts

@@ -0,0 +1,59 @@
+export declare const SpecialFormats: {
+    readonly ABSOLUTE_FULLSCREEN: "ABSOLUTE_FULLSCREEN";
+    readonly FIXED_FULLSCREEN: "FIXED_FULLSCREEN";
+    readonly ANY_FULLSCREEN: "ANY_FULLSCREEN";
+    readonly VERTICAL_FULLWIDTH: "VERTICAL_FULLWIDTH";
+    readonly FULLWIDTH: "FULLWIDTH";
+    readonly NATIVE_AD: "NATIVE_AD";
+    readonly TAKEOVER: "TAKEOVER";
+    readonly WALLPAPER: "WALLPAPER";
+    readonly COLLAPSE: "COLLAPSE";
+};
+export type SpecialFormat = (typeof SpecialFormats)[keyof typeof SpecialFormats];
+export declare const SpecialFormatSizes: {
+    ANY_FULLSCREEN: {
+        width: number;
+        height: number;
+    }[];
+    ABSOLUTE_FULLSCREEN: {
+        width: number;
+        height: number;
+    }[];
+    VERTICAL_FULLWIDTH: {
+        width: number;
+        height: number;
+    }[];
+    FIXED_FULLSCREEN: {
+        width: number;
+        height: number;
+    }[];
+    FULLWIDTH: ({
+        width: number;
+        height?: undefined;
+    } | {
+        width: number;
+        height: number;
+    })[];
+    NATIVE_AD: {
+        width: number;
+        height: number;
+    }[];
+    TAKEOVER: {
+        width: number;
+        height: number;
+    }[];
+    WALLPAPER: {
+        width: number;
+        height: number;
+    }[];
+    COLLAPSE: {
+        width: number;
+        height: number;
+    }[];
+};
+declare const DYNAMIC_SIZE_WIDTH_MAPPER: {
+    wallpaper: number;
+    'l-format': number;
+};
+export type DynamicSizeFormat = keyof typeof DYNAMIC_SIZE_WIDTH_MAPPER;
+export { DYNAMIC_SIZE_WIDTH_MAPPER };

package/types/core/interface/http-client.d.ts

@@ -0,0 +1,4 @@
+export interface HttpClient {
+    get: <T>(url: string, options: RequestInit) => Promise<T>;
+    post: <T>(url: string, headers: Headers, data: T) => Promise<T>;
+}

package/types/core/interface/keywords.d.ts

@@ -0,0 +1,87 @@
+import { EmptyObject } from './common';
+import { CMPChoice } from './cmp';
+import { PageType } from './page-types';
+import { Country } from './countries';
+import { GlimrPublisher } from './publishers';
+export interface ExternalIdSrcKeywords {
+    'aa-sch-externalid_src': number;
+}
+export interface SeExternalIdSrcKeywords {
+    'se-generic-externalid_src': number;
+}
+export interface ScreenKeywords {
+    'se-generic-viewportheight': number;
+    'se-generic-viewportwidth': number;
+    'se-generic-screenheight': number;
+    'se-generic-screenwidth': number;
+}
+interface SeDeviceKeywords {
+    'se-generic-sitemode': string;
+}
+interface NoDeviceKeywords {
+    'no-sno-device': string;
+}
+export type DeviceKeywords = SeDeviceKeywords | NoDeviceKeywords | EmptyObject;
+interface SeApptypeKeywords {
+    'se-generic-appmode': string;
+    'se-generic-mobileos': string;
+}
+interface NoApptypeKeywords {
+    'no-sno-apptype': string;
+}
+export type AppTypeKeywords = SeApptypeKeywords | NoApptypeKeywords | EmptyObject;
+export interface SupplyTypeKeywords {
+    'aa-sch-supply_type': string;
+}
+export interface SDKVersionKeywords {
+    'se-generic-sdk-version': string;
+}
+export interface PublisherKeywords {
+    'aa-sch-publisher': string;
+}
+export interface SeGlimrKeywords {
+    'se-generic-geo': Array<string>;
+    'se-generic--weather': Array<string>;
+    'se-generic-geofence': Array<string>;
+}
+export interface NoGlimrKeywords {
+    'no-sno-geo': Array<string | GlimrPublisher>;
+    'no-sno-weather': Array<string>;
+    'no-sno-geofence': Array<string>;
+}
+export interface AdvertisingConsentKeywords {
+    'aa-sch-cmp_advertising': CMPChoice;
+}
+export interface AnalyticsConsentKeywords {
+    'aa-sch-cmp_analytics': CMPChoice;
+}
+export interface PageTypeKeywords {
+    'aa-sch-page_type': PageType;
+}
+export interface PublisherGroupKeywords {
+    'se-generic-publishergroup': 'schibsted';
+}
+export interface CountryCodeKeywords {
+    'aa-sch-country_code': Country;
+}
+export interface InventoryTypeKeywords {
+    'aa-sch-inventory_type': 'editorial';
+}
+export interface ObituariesKeywords {
+    'no-sno-news-section': string;
+}
+export interface SponsorsKeywords {
+    'no-sno-news-sponsors': Array<string>;
+}
+export interface ContextExistKeywords {
+    'aa-sch-has_context_keyword': number;
+}
+export interface TcfConsentKeywords {
+    gdpr: number;
+    gdpr_consent: string;
+}
+export interface PlusExistKeyword {
+    'se-generic-has_plus': 'yes' | 'no';
+}
+export type AbMembershipLevels = 'regular' | 'loggedin' | 'plus';
+export {};

package/types/core/interface/library.d.ts

@@ -0,0 +1,5 @@
+interface LoadLibraryOptions {
+    timeout?: number;
+}
+export type LoadLibrary = (source: string, options?: LoadLibraryOptions) => Promise<void>;
+export {};

package/types/core/interface/local-storage-client.d.ts

@@ -0,0 +1,6 @@
+export interface LocalStorageClient {
+    get: <T>(key: string) => T | null;
+    set: <T>(key: string, value: T | null) => void;
+    setWithTimestamp: <T>(key: string, value: T | null, timestamp?: number) => void;
+    getByTimestamp: <T>(key: string, expirationTime?: number) => T | null;
+}

package/types/core/interface/margins.d.ts

@@ -0,0 +1,11 @@
+export type MarginPriority = 'high' | 'normal' | 'low';
+export type MarginsConfig = Record<MarginPriority, PrioEntry>;
+export interface PrioEntry {
+    renderMargin: number;
+    refreshMargin: number;
+}
+export interface PrioPreloadMarginMap {
+    high?: Partial<PrioEntry>;
+    normal?: Partial<PrioEntry>;
+    low?: Partial<PrioEntry>;
+}

package/types/core/interface/module.d.ts

@@ -0,0 +1,13 @@
+import { BlinkConstructor } from 'features/interface/finn-blink';
+export declare const ES_MODULE_KEYS: {
+    readonly Blink: "Blink";
+};
+type ESModuleKey = (typeof ES_MODULE_KEYS)[keyof typeof ES_MODULE_KEYS];
+export type ESMModules = {
+    [K in ESModuleKey]?: BlinkConstructor;
+};
+interface LoadModuleOptions {
+    timeout?: number;
+}
+export type LoadModule = (source: string, options?: LoadModuleOptions) => Promise<void>;
+export {};

package/types/core/interface/newsrooms.d.ts

@@ -0,0 +1,17 @@
+export 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";
+};
+export type Newsroom = (typeof Newsrooms)[keyof typeof Newsrooms];

package/types/core/interface/observer.d.ts

@@ -0,0 +1,7 @@
+import { AstApnTag } from './ast';
+export interface ObserverOptions {
+    rootMargin: string;
+}
+export type RefreshAdType = (apntag: AstApnTag, targetId: string, target: HTMLElement) => void;
+export type onRefreshType = (apntag: AstApnTag, targetId: string, yPosition: number, renderTime: number, delayTime: number, target: HTMLElement) => void;
+export type onChangeType = (apntag: AstApnTag, targetId: string) => void;

package/types/core/interface/os.d.ts

@@ -0,0 +1 @@
+export type OSTypes = 'windows' | 'macos' | 'linux' | 'android' | 'ios' | 'unknown';

package/types/core/interface/page-types.d.ts

@@ -0,0 +1,8 @@
+export declare const PageTypes: {
+    readonly FRONT: "front";
+    readonly ARTICLE: "article";
+    readonly SECTION: "section";
+    readonly COLLECTION: "collection";
+    readonly OTHER: "other";
+};
+export type PageType = (typeof PageTypes)[keyof typeof PageTypes];

package/types/core/interface/placement-groups.d.ts

@@ -0,0 +1,5 @@
+import { Placement } from './config';
+export interface PlacementGroups {
+    [key: string]: Array<Placement>;
+    noGroupedPlacements: Array<Placement>;
+}

package/types/core/interface/post-message.d.ts

@@ -0,0 +1,9 @@
+export interface AdsMessage {
+    name: string;
+    targetId?: string;
+    wallpaperImageUrl?: string;
+    wallpaperColor?: string;
+    imageURL?: string;
+    size?: Array<number>;
+    cmd?: any;
+}

package/types/core/interface/publishers.d.ts

@@ -0,0 +1,15 @@
+export declare const GlimrPublishers: {
+    readonly svd: "svd";
+    readonly vg: "vg";
+    readonly godare: "godare";
+    readonly aftenposten: "no-aftenposten";
+    readonly sa: "no-stavangeraftenblad";
+    readonly bt: "no-bergenstidende";
+    readonly aftonbladet: "aftonbladet";
+    readonly e24: "e24";
+    readonly minmote: "minmote";
+    readonly pent: "pent";
+    readonly godt: "godt";
+    readonly tek: "no-tek";
+};
+export type GlimrPublisher = (typeof GlimrPublishers)[keyof typeof GlimrPublishers];

package/types/core/interface/refresh.d.ts

@@ -0,0 +1,4 @@
+export interface ResetWrapperParams {
+    adWrapper: HTMLElement;
+    placementContainer: HTMLElement;
+}

package/types/core/interface/session-storage-client.d.ts

@@ -0,0 +1,5 @@
+export interface SessionStorageClient {
+    get: <T>(key: string) => T | null;
+    set: <T>(key: string, data: T) => void;
+    remove: (key: string) => void;
+}

package/types/core/interface/storage.d.ts

@@ -0,0 +1,18 @@
+import { AstKeywords } from './ast';
+export interface DefaultStorageData {
+    wallpaper: {
+        isAvailable: boolean;
+    };
+    horseshoe: {
+        isAvailable: boolean;
+    };
+    initialClassNames: {
+        [key: string]: {
+            wrapper?: Array<string>;
+            container?: Array<string>;
+        };
+    };
+    alertoryConfigKeywords: AstKeywords;
+}
+export interface StorageData extends DefaultStorageData {
+}

package/types/core/interface/styles.d.ts

@@ -0,0 +1 @@
+export type PixelValue = `${number}px`;

package/types/core/interface/tcf.d.ts

@@ -0,0 +1,11 @@
+export type IsConsentedToAll = (callback: ConsentedToAllCallback) => void;
+export type ConsentedToAllCallback = (value: boolean) => void;
+export type GetConsentToAllSync = () => boolean | null;
+export interface ConsentManager {
+    getConsentedToAllSync: GetConsentToAllSync;
+    isConsentedToAll: IsConsentedToAll;
+}
+export interface TCFConsentUtilities {
+    initConsentManager: () => Promise<ConsentManager>;
+    getConsentSync: () => boolean | null;
+}

package/types/core/interface/update-advertory.d.ts

@@ -0,0 +1,6 @@
+export interface UpdateAdvertoryConfig {
+    clearAds?: boolean;
+    reloadExistingAds?: boolean;
+    renderFinnBlinkPlacements?: boolean;
+    contextSelector?: string;
+}

package/types/core/languages/dictionary.d.ts

@@ -0,0 +1,3 @@
+import { Dictionary } from 'core/interface/dictionary';
+declare const DICTIONARY: Dictionary;
+export { DICTIONARY };

package/types/core/logger/index.d.ts

@@ -0,0 +1,2 @@
+declare const log: (message: string, params?: any) => void;
+export { log };

package/types/core/prepare-page-options/prepare-page-options-no.d.ts

@@ -0,0 +1,9 @@
+import { PageOptions } from './prepare-page-options';
+import { AppTypeKeywords, DeviceKeywords, ObituariesKeywords } from 'core/interface/keywords';
+import { Newsroom } from 'core/interface/newsrooms';
+import { EmptyObject } from 'core/interface/common';
+export declare class PageOptionsNO extends PageOptions {
+    protected getAppTypeKeywords(): AppTypeKeywords;
+    protected getDeviceKeywords: () => DeviceKeywords;
+    protected getObituariesKeywords(site: Newsroom): ObituariesKeywords | EmptyObject;
+}