@guardian/commercial-core 0.0.0-beta-20250716121613

package/dist/esm/send-commercial-metrics.d.ts

@@ -0,0 +1,58 @@
+import type { ConnectionType } from './types';
+type Metric = {
+    name: string;
+    value: number;
+};
+type Property = {
+    name: string;
+    value: string;
+};
+type TimedEvent = {
+    name: string;
+    ts: number;
+};
+type DurationEvent = {
+    name: string;
+    duration: number;
+};
+type EventProperties = {
+    type?: ConnectionType;
+    downlink?: number;
+    effectiveType?: string;
+};
+declare enum Endpoints {
+    CODE = "//performance-events.code.dev-guardianapis.com/commercial-metrics",
+    PROD = "//performance-events.guardianapis.com/commercial-metrics"
+}
+declare const checkConsent: () => Promise<boolean>;
+/**
+ * A method to asynchronously send metrics after initialization.
+ */
+declare function bypassCommercialMetricsSampling(): Promise<void>;
+interface InitCommercialMetricsArgs {
+    pageViewId: string;
+    browserId: string | undefined;
+    isDev: boolean;
+    adBlockerInUse?: boolean;
+    sampling?: number;
+}
+/**
+ * A method to initialise metrics.
+ * Note: this is initialised in the frontend/DCR bundles, not the commercial bundle.
+ * @param init.pageViewId - identifies the page view. Usually available on `guardian.config.ophan.pageViewId`. Defaults to `null`
+ * @param init.browserId - identifies the browser. Usually available via `getCookie({ name: 'bwid' })`. Defaults to `null`
+ * @param init.isDev - used to determine whether to use CODE or PROD endpoints.
+ * @param init.adBlockerInUse - indicates whether or not an adblocker is being used.
+ * @param init.sampling - rate at which to sample commercial metrics - the default is to send for 1% of pageviews
+ */
+declare function initCommercialMetrics({ pageViewId, browserId, isDev, adBlockerInUse, sampling, }: InitCommercialMetricsArgs): Promise<boolean>;
+export declare const _: {
+    Endpoints: typeof Endpoints;
+    setEndpoint: (isDev: boolean) => Endpoints;
+    mapEventTimerPropertiesToString: (properties: Array<[string, string | number]>) => Property[];
+    roundTimeStamp: (events: TimedEvent[], measures: DurationEvent[]) => Metric[];
+    transformToObjectEntries: (eventTimerProperties: EventProperties) => Array<[string, string | number | undefined]>;
+    reset: () => void;
+};
+export type { Property, TimedEvent, Metric };
+export { bypassCommercialMetricsSampling, initCommercialMetrics, checkConsent };

package/dist/esm/send-commercial-metrics.js

@@ -0,0 +1,204 @@
+import { getMeasures, isNonNullable, log, onConsent } from '@guardian/libs';
+import { EventTimer } from './event-timer';
+var Endpoints;
+(function (Endpoints) {
+    Endpoints["CODE"] = "//performance-events.code.dev-guardianapis.com/commercial-metrics";
+    Endpoints["PROD"] = "//performance-events.guardianapis.com/commercial-metrics";
+})(Endpoints || (Endpoints = {}));
+let commercialMetricsPayload = {
+    page_view_id: undefined,
+    browser_id: undefined,
+    platform: 'NEXT_GEN',
+    metrics: [],
+    properties: [],
+};
+let devProperties = [];
+let adBlockerProperties = [];
+let endpoint;
+const setEndpoint = (isDev) => (endpoint = isDev ? Endpoints.CODE : Endpoints.PROD);
+const setDevProperties = (isDev) => (devProperties = isDev
+    ? [{ name: 'isDev', value: window.location.hostname }]
+    : []);
+const setAdBlockerProperties = (adBlockerInUse) => {
+    adBlockerProperties =
+        adBlockerInUse !== undefined
+            ? [
+                {
+                    name: 'adBlockerInUse',
+                    value: adBlockerInUse.toString(),
+                },
+            ]
+            : [];
+};
+const transformToObjectEntries = (eventTimerProperties) => {
+    // Transforms object {key: value} pairs into an array of [key, value] arrays
+    return Object.entries(eventTimerProperties);
+};
+const mapEventTimerPropertiesToString = (properties) => {
+    return properties.map(([name, value]) => ({
+        name: String(name),
+        value: String(value),
+    }));
+};
+const roundTimeStamp = (events, measures) => {
+    const roundedEvents = events.map(({ name, ts }) => ({
+        name,
+        value: Math.ceil(ts),
+    }));
+    const roundedMeasures = measures.map(({ name, duration }) => ({
+        name,
+        value: Math.ceil(duration),
+    }));
+    return [...roundedEvents, ...roundedMeasures];
+};
+function sendMetrics() {
+    log('commercial', 'About to send commercial metrics', commercialMetricsPayload);
+    void fetch(endpoint, {
+        method: 'POST',
+        body: JSON.stringify(commercialMetricsPayload),
+        keepalive: true,
+        cache: 'no-store',
+        mode: 'no-cors',
+    });
+}
+/**
+ * Gather how many times the user has experienced the “offline” event
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/offline_event
+ *
+ * This value should be fetched as late as possible in the page lifecycle,
+ * to get an accurate value.
+ *
+ * Relevant for an @guardian/open-journalism investigation.
+ */
+const getOfflineCount = () => typeof window.guardian.offlineCount === 'number'
+    ? [
+        {
+            name: 'offlineCount',
+            value: window.guardian.offlineCount,
+        },
+    ]
+    : [];
+/**
+ * Measures added with @guardian/libs’s `startPerformanceMeasure`
+ *
+ * Allows for more granular monitoring of web page performance.
+ */
+const getPerformanceMeasures = (...teams) => getMeasures(teams).map(({ detail: { subscription, name, action }, duration }) => ({
+    name: [subscription, name, action].filter(isNonNullable).join('_'),
+    value: duration,
+}));
+function gatherMetricsOnPageUnload() {
+    // Assemble commercial properties and metrics
+    const eventTimer = EventTimer.get();
+    const transformedEntries = transformToObjectEntries(eventTimer.properties);
+    const filteredEventTimerProperties = transformedEntries.filter((item) => typeof item[1] !== 'undefined');
+    const mappedEventTimerProperties = mapEventTimerPropertiesToString(filteredEventTimerProperties);
+    const properties = mappedEventTimerProperties
+        .concat(devProperties)
+        .concat(adBlockerProperties);
+    commercialMetricsPayload.properties = properties;
+    const metrics = roundTimeStamp(eventTimer.marks, eventTimer.measures)
+        .concat(getOfflineCount())
+        .concat(getPerformanceMeasures('dotcom'));
+    commercialMetricsPayload.metrics = metrics;
+    sendMetrics();
+}
+const listener = (e) => {
+    if (window.guardian.config.shouldSendCommercialMetrics) {
+        switch (e.type) {
+            case 'visibilitychange':
+                if (document.visibilityState === 'hidden') {
+                    gatherMetricsOnPageUnload();
+                }
+                return;
+            case 'pagehide':
+                gatherMetricsOnPageUnload();
+                return;
+        }
+    }
+};
+const addVisibilityListeners = () => {
+    // Report all available metrics when the page is unloaded or in background.
+    window.addEventListener('visibilitychange', listener, { once: true });
+    // Safari does not reliably fire the `visibilitychange` on page unload.
+    window.addEventListener('pagehide', listener, { once: true });
+};
+const checkConsent = async () => {
+    const consentState = await onConsent();
+    if (consentState.tcfv2) {
+        // TCFv2 mode - check for consent
+        const consents = consentState.tcfv2.consents;
+        const REQUIRED_CONSENTS = [7, 8];
+        return REQUIRED_CONSENTS.every((consent) => consents[consent]);
+    }
+    // non-TCFv2 mode - don't check for consent
+    return true;
+};
+/**
+ * A method to asynchronously send metrics after initialization.
+ */
+async function bypassCommercialMetricsSampling() {
+    if (!window.guardian.config.commercialMetricsInitialised) {
+        console.warn('initCommercialMetrics not yet initialised');
+        return;
+    }
+    const consented = await checkConsent();
+    if (consented) {
+        window.guardian.config.shouldSendCommercialMetrics = true;
+    }
+    else {
+        log('commercial', "Metrics won't be sent because consent wasn't given");
+    }
+}
+/**
+ * A method to initialise metrics.
+ * Note: this is initialised in the frontend/DCR bundles, not the commercial bundle.
+ * @param init.pageViewId - identifies the page view. Usually available on `guardian.config.ophan.pageViewId`. Defaults to `null`
+ * @param init.browserId - identifies the browser. Usually available via `getCookie({ name: 'bwid' })`. Defaults to `null`
+ * @param init.isDev - used to determine whether to use CODE or PROD endpoints.
+ * @param init.adBlockerInUse - indicates whether or not an adblocker is being used.
+ * @param init.sampling - rate at which to sample commercial metrics - the default is to send for 1% of pageviews
+ */
+async function initCommercialMetrics({ pageViewId, browserId, isDev, adBlockerInUse, sampling = 1 / 100, }) {
+    commercialMetricsPayload.page_view_id = pageViewId;
+    commercialMetricsPayload.browser_id = browserId;
+    setEndpoint(isDev);
+    setDevProperties(isDev);
+    setAdBlockerProperties(adBlockerInUse);
+    addVisibilityListeners();
+    if (window.guardian.config.commercialMetricsInitialised) {
+        return false;
+    }
+    window.guardian.config.commercialMetricsInitialised = true;
+    const userIsInSamplingGroup = Math.random() <= sampling;
+    if (isDev || userIsInSamplingGroup) {
+        const consented = await checkConsent();
+        if (consented) {
+            window.guardian.config.shouldSendCommercialMetrics = true;
+            return true;
+        }
+        log('commercial', "Metrics won't be sent because consent wasn't given");
+    }
+    return false;
+}
+export const _ = {
+    Endpoints,
+    setEndpoint,
+    mapEventTimerPropertiesToString,
+    roundTimeStamp,
+    transformToObjectEntries,
+    reset: () => {
+        window.guardian.config.commercialMetricsInitialised = false;
+        window.guardian.config.shouldSendCommercialMetrics = false;
+        commercialMetricsPayload = {
+            page_view_id: undefined,
+            browser_id: undefined,
+            platform: 'NEXT_GEN',
+            metrics: [],
+            properties: [],
+        };
+        removeEventListener('visibilitychange', listener);
+        removeEventListener('pagehide', listener);
+    },
+};
+export { bypassCommercialMetricsSampling, initCommercialMetrics, checkConsent };

package/dist/esm/targeting/build-page-targeting.d.ts

@@ -0,0 +1,47 @@
+import type { Participations } from '@guardian/ab-core';
+import type { ConsentState, CountryCode } from '@guardian/libs';
+import type { AdManagerGroup, Frequency } from './personalised';
+import type { SharedTargeting } from './shared';
+import type { TrueOrFalse } from './types';
+type PartialWithNulls<T> = {
+    [P in keyof T]?: T[P] | null;
+};
+type PageTargeting = PartialWithNulls<{
+    ab: string[];
+    af: 't';
+    amtgrp: AdManagerGroup;
+    at: string;
+    bp: 'mobile' | 'tablet' | 'desktop';
+    cc: CountryCode;
+    cmp_interaction: string;
+    consent_tcfv2: string;
+    dcre: TrueOrFalse;
+    fr: Frequency;
+    inskin: TrueOrFalse;
+    pa: TrueOrFalse;
+    permutive: string[];
+    pv: string;
+    rc: string;
+    rdp: string;
+    ref: string;
+    rp: 'dotcom-rendering' | 'dotcom-platform';
+    s: string;
+    sens: TrueOrFalse;
+    si: TrueOrFalse;
+    skinsize: 'l' | 's';
+    urlkw: string[];
+    vl: string;
+    allkw: string[];
+    [_: string]: string | string[];
+} & SharedTargeting>;
+declare const filterValues: (pageTargets: Record<string, unknown>) => Record<string, string | string[]>;
+type BuildPageTargetingParams = {
+    adFree: boolean;
+    clientSideParticipations: Participations;
+    consentState: ConsentState;
+    isSignedIn?: boolean;
+    youtube?: boolean;
+};
+declare const buildPageTargeting: ({ adFree, clientSideParticipations, consentState, isSignedIn, youtube, }: BuildPageTargetingParams) => Record<string, string | string[]>;
+export { buildPageTargeting, filterValues };
+export type { PageTargeting };

package/dist/esm/targeting/build-page-targeting.js

@@ -0,0 +1,108 @@
+import { cmp, getConsentFor, getCookie, isString } from '@guardian/libs';
+import { supportsPerformanceAPI } from '../event-timer';
+import { getLocale } from '../geo/get-locale';
+import { getContentTargeting } from './content';
+import { getPersonalisedTargeting } from './personalised';
+import { getSessionTargeting } from './session';
+import { getSharedTargeting } from './shared';
+import { getViewportTargeting } from './viewport';
+const filterValues = (pageTargets) => {
+    const filtered = {};
+    for (const key in pageTargets) {
+        const value = pageTargets[key];
+        if (isString(value)) {
+            filtered[key] = value;
+        }
+        else if (Array.isArray(value) &&
+            value.length > 0 &&
+            value.every(isString)) {
+            filtered[key] = value;
+        }
+    }
+    return filtered;
+};
+const lastPerformanceEntryIsNavigationType = () => {
+    if (!supportsPerformanceAPI()) {
+        return false;
+    }
+    const navigationEvents = performance.getEntriesByType('navigation');
+    const lastNavigationEvent = navigationEvents[navigationEvents.length - 1];
+    // https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/entryType#navigation
+    return lastNavigationEvent?.entryType === 'navigation';
+};
+const referrerMatchesHost = (referrer) => {
+    if (!referrer) {
+        return false;
+    }
+    const referrerUrl = new URL(referrer);
+    return referrerUrl.hostname === window.location.hostname;
+};
+// A consentless friendly way of determining if this is the users first visit to the page
+const isFirstVisit = (referrer) => {
+    if (supportsPerformanceAPI() && !lastPerformanceEntryIsNavigationType()) {
+        return false;
+    }
+    return !referrerMatchesHost(referrer);
+};
+const buildPageTargeting = ({ adFree, clientSideParticipations, consentState, isSignedIn = false, youtube = false, }) => {
+    const { page, isDotcomRendering } = window.guardian.config;
+    const adFreeTargeting = adFree ? { af: 't' } : {};
+    const sharedAdTargeting = page.sharedAdTargeting
+        ? getSharedTargeting(page.sharedAdTargeting)
+        : {};
+    const contentTargeting = getContentTargeting({
+        webPublicationDate: page.webPublicationDate,
+        eligibleForDCR: page.dcrCouldRender,
+        path: `/${page.pageId}`,
+        renderingPlatform: isDotcomRendering
+            ? 'dotcom-rendering'
+            : 'dotcom-platform',
+        section: page.section,
+        sensitive: page.isSensitive,
+        videoLength: page.videoDuration,
+        keywords: sharedAdTargeting.k ?? [],
+    });
+    const referrer = document.referrer || '';
+    const sessionTargeting = getSessionTargeting({
+        adTest: getCookie({ name: 'adtest', shouldMemoize: true }),
+        countryCode: getLocale(),
+        isSignedIn,
+        pageViewId: window.guardian.config.ophan.pageViewId,
+        participations: {
+            clientSideParticipations,
+            serverSideParticipations: window.guardian.config.tests ?? {},
+        },
+        referrer,
+    });
+    const getViewport = () => {
+        return {
+            width: window.innerWidth || document.body.clientWidth || 0,
+            height: window.innerHeight || document.body.clientHeight || 0,
+        };
+    };
+    const viewportTargeting = getViewportTargeting({
+        viewPortWidth: getViewport().width,
+        cmpBannerWillShow: !cmp.hasInitialised() || cmp.willShowPrivacyMessageSync(),
+    });
+    const personalisedTargeting = getPersonalisedTargeting({
+        state: consentState,
+        youtube,
+    });
+    const consentlessTargeting = {};
+    if (!getConsentFor('googletag', consentState)) {
+        consentlessTargeting.firstvisit = isFirstVisit(referrer) ? 't' : 'f';
+    }
+    const pageTargets = {
+        ...personalisedTargeting,
+        ...sharedAdTargeting,
+        ...adFreeTargeting,
+        ...contentTargeting,
+        ...sessionTargeting,
+        ...viewportTargeting,
+        ...consentlessTargeting,
+    };
+    // filter !(string | string[]) and empty values
+    const pageTargeting = filterValues(pageTargets);
+    return pageTargeting;
+};
+export { buildPageTargeting, filterValues };

package/dist/esm/targeting/content.d.ts

@@ -0,0 +1,87 @@
+import type { SharedTargeting } from './shared';
+import type { False, True } from './types';
+declare const videoLengths: readonly ["25", "30", "60", "90", "120", "150", "180", "210", "240", "270", "300"];
+/**
+ * Content Targeting comes from the server
+ *
+ * For a specific URL, it will only change on
+ * - a Composer/CAPI update
+ * - a rendering platform capability update
+ * - a main media update
+ * - a series tag update
+ * - a surge in page views per minute
+ *
+ */
+type ContentTargeting = {
+    /**
+     * **D**ot**c**om-**r**endering **E**ligible - [see on Ad Manager][gam]
+     *
+     * Type: _Predefined_
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=11958028
+     */
+    dcre: True | False;
+    /**
+     * **R**ecently Published **C**ontent - [see on Ad Manager][gam]
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=13845194
+     */
+    rc: string;
+    /**
+     * Rendering Platform - [see on Ad Manager][gam]
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=11881005
+     */
+    rp: 'dotcom-rendering' | 'dotcom-platform';
+    /**
+     * Site **S**ection - [see on Ad Manager][gam]
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=173967
+     */
+    s: string;
+    /**
+     * **Sens**itive - [see on Ad Manager][gam]
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=11654206
+     */
+    sens: True | False;
+    /**
+     * URL Keywords - [see on Ad Manager][gam]
+     *
+     * Type: _Dynamic_
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=12058265
+     */
+    urlkw: string[];
+    /**
+     * **V**ideo **L**ength - [see on Ad Manager][gam]
+     *
+     * Video.JS only (?)
+     *
+     * Type: _Predefined_
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=195087
+     */
+    vl: null | (typeof videoLengths)[number];
+    /**
+     * **All** **K**ey**w**ords - [see on Ad Manager][gam]
+     * This is a list of all keywords on the page, including the section and the URL keywords
+     * Type: _Dynamic_
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=13995840
+     */
+    allkw: string[];
+};
+type Content = {
+    eligibleForDCR: boolean;
+    path: SharedTargeting['url'];
+    renderingPlatform: ContentTargeting['rp'];
+    section: ContentTargeting['s'];
+    sensitive: boolean;
+    videoLength?: number;
+    webPublicationDate: number;
+    keywords: string[];
+};
+declare const getContentTargeting: ({ eligibleForDCR, path, renderingPlatform, section, sensitive, videoLength, webPublicationDate, keywords, }: Content) => ContentTargeting;
+export { getContentTargeting };
+export type { ContentTargeting };

package/dist/esm/targeting/content.js

@@ -0,0 +1,73 @@
+import { isString } from '@guardian/libs';
+/* -- Types -- */
+const videoLengths = [
+    '25', // TODO: confirm this is a real value
+    '30',
+    '60',
+    '90',
+    '120',
+    '150',
+    '180',
+    '210',
+    '240',
+    '270',
+    '300',
+];
+/* -- Methods -- */
+const getVideoLength = (videoLength) => {
+    const index = Math.min(Math.ceil(videoLength / 30), 10);
+    return videoLengths[index] ?? null;
+};
+const getUrlKeywords = (url) => {
+    const lastSegment = url
+        .split('/')
+        .filter(Boolean) // This handles a trailing slash
+        .slice(-1)[0];
+    return isString(lastSegment) ? lastSegment.split('-').filter(Boolean) : [];
+};
+const concatUnique = (a, b) => [
+    ...new Set([...a, ...b]),
+];
+// "0" means content < 2 hours old
+// "1" means content between 2 hours and 24 hours old.
+// "2" means content between 24 hours and 3 days old
+// "3" means content between 3 and 7 days old
+// "4" means content between 7 days and 1 month old
+// "5" means content between 1 and 10 months old
+// "6" means content between 10 and 14 months old
+// "7" means content more than 14 months old
+const calculateRecentlyPublishedBucket = (webPublicationDate) => {
+    const now = Date.now();
+    const hoursSincePublication = (now - webPublicationDate) / 1000 / 60 / 60;
+    const daysSincePublication = hoursSincePublication / 24;
+    const monthsSincePublication = daysSincePublication / 30; // near enough for our purposes
+    if (hoursSincePublication < 2)
+        return '0';
+    if (hoursSincePublication < 24)
+        return '1';
+    if (daysSincePublication < 3)
+        return '2';
+    if (daysSincePublication < 7)
+        return '3';
+    if (daysSincePublication < 30)
+        return '4';
+    if (monthsSincePublication < 10)
+        return '5';
+    if (monthsSincePublication < 14)
+        return '6';
+    return '7';
+};
+const getContentTargeting = ({ eligibleForDCR, path, renderingPlatform, section, sensitive, videoLength, webPublicationDate, keywords, }) => {
+    const urlkw = getUrlKeywords(path);
+    return {
+        dcre: eligibleForDCR ? 't' : 'f',
+        rc: calculateRecentlyPublishedBucket(webPublicationDate),
+        rp: renderingPlatform,
+        s: section,
+        sens: sensitive ? 't' : 'f',
+        urlkw,
+        vl: videoLength ? getVideoLength(videoLength) : null,
+        allkw: concatUnique(urlkw, keywords),
+    };
+};
+export { getContentTargeting };

package/dist/esm/targeting/personalised.d.ts

@@ -0,0 +1,83 @@
+import type { ConsentState, TCEventStatusCode } from '@guardian/libs';
+import type { False, NotApplicable, True } from './types';
+declare const frequency: readonly ["0", "1", "2", "3", "4", "5", "6-9", "10-15", "16-19", "20-29", "30plus"];
+type Frequency = (typeof frequency)[number];
+declare const adManagerGroups: readonly ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];
+type AdManagerGroup = (typeof adManagerGroups)[number];
+/**
+ * Personalised Targeting requires user consent
+ *
+ * It allows or prevents personalised advertising, restrict data processing
+ * and handles access to cookies and local storage
+ */
+type PersonalisedTargeting = {
+    /**
+     * **A**d **M**anager **T**argeting **Gr**ou**p** – [see on Ad Manager][gam]
+     *
+     * Type: _Predefined_
+     *
+     * Sample values:
+     * -
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=12318099
+     * */
+    amtgrp: AdManagerGroup | null;
+    /**
+     * Interaction with TCFv2 banner – [see on Ad Manager][gam]
+     *
+     * Type: _Predefined_
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=12083384
+     */
+    cmp_interaction?: TCEventStatusCode | NotApplicable;
+    /**
+     * **TCFv2 Consent** to [all purposes] – [see on Ad Manager][gam]
+     *
+     * Type: _Predefined_
+     *
+     * [all purposes]: https://vendor-list.consensu.org/v2/vendor-list.json
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=12080297
+     * */
+    consent_tcfv2: True | False | NotApplicable;
+    /**
+     * **Fr**equency – [see on Ad Manager][gam]
+     *
+     * Type: _Predefined_
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=214647
+     */
+    fr: Frequency;
+    /**
+     * **P**ersonalised **A**ds Consent – [see on Ad Manager][gam]
+     *
+     * Type: _Predefined_
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=11701767
+     */
+    pa: True | False;
+    /**
+     * **Permutive** user segments – [see on Ad Manager][gam]
+     *
+     * Type: _Predefined_
+     *
+     * Values: 900+ number IDs
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=11958727
+     */
+    permutive: string[];
+    /**
+     * **R**estrict **D**ata **P**rocessing Flag – [see on Ad Manager][gam]
+     *
+     * Type: _Predefined_
+     *
+     * [gam]: https://admanager.google.com/59666047#inventory/custom_targeting/detail/custom_key_id=11701767
+     */
+    rdp: True | False | NotApplicable;
+};
+type Personalised = {
+    state: ConsentState;
+    youtube: boolean;
+};
+declare const getPersonalisedTargeting: ({ state, youtube, }: Personalised) => PersonalisedTargeting;
+export { getPersonalisedTargeting };
+export type { PersonalisedTargeting, AdManagerGroup, Frequency };