@c15t/svelte 3.0.0-alpha.0

package/dist/context.svelte.js

@@ -0,0 +1,354 @@
+import { allConsentNames, consentTypes as defaultConsentTypes, defaultTranslationConfig, has as evaluateHas, resolveConsentPresentation, } from '@c15t/core';
+import { getContext, setContext } from 'svelte';
+const CONSENT_CONTEXT_KEY = Symbol('c15t-v3-consent');
+const THEME_CONTEXT_KEY = Symbol('c15t-v3-theme');
+const toTranslationConfig = function toTranslationConfig(snapshot) {
+    const resolved = snapshot.translations;
+    if (!resolved) {
+        return defaultTranslationConfig;
+    }
+    return {
+        ...defaultTranslationConfig,
+        defaultLanguage: resolved.language,
+        translations: {
+            ...defaultTranslationConfig.translations,
+            [resolved.language]: resolved.translations,
+        },
+    };
+};
+const toActiveUI = function toActiveUI(ui) {
+    return (ui ?? 'none');
+};
+const displayedConsentTypes = function displayedConsentTypes(categories) {
+    const allowed = categories.length > 0
+        ? new Set(categories)
+        : new Set(allConsentNames);
+    return defaultConsentTypes
+        .filter((type) => allowed.has(type.name))
+        .map((type) => ({ ...type, display: true }));
+};
+const createConsentState = function createConsentState(kernel, options) {
+    const getSnapshotLocal = options.getSnapshot;
+    let actionSequence = 0;
+    // oxlint-disable-next-line sort-keys -- Preserve declaration order, interface shape, and public compatibility.
+    const controller = {
+        get activeUI() {
+            return toActiveUI(getSnapshotLocal().activeUI);
+        },
+        get branding() {
+            return getSnapshotLocal().branding ?? 'c15t';
+        },
+        get consentCategories() {
+            const configured = options.getConsentCategories();
+            const { scope } = getSnapshotLocal().policyRule;
+            return [
+                ...new Set([
+                    'necessary',
+                    ...(configured.length === 0
+                        ? scope
+                        : configured.filter((name) => scope.some((category) => category === name))),
+                ]),
+            ];
+        },
+        get draft() {
+            return options.getDraft();
+        },
+        get presentation() {
+            return options.getPresentation();
+        },
+        // -- Controller-owned state (computed from snapshot + provider options) --
+        get consentTypes() {
+            return displayedConsentTypes(controller.consentCategories);
+        },
+        // -- Methods --------------------------------------------------------------
+        getDisplayedConsents() {
+            return displayedConsentTypes(controller.consentCategories);
+        },
+        has(condition) {
+            const snapshot = getSnapshotLocal();
+            return evaluateHas(condition, snapshot.effectivePermissions);
+        },
+        dismissNotice() {
+            return kernel.commands.dismissNotice();
+        },
+        get iab() {
+            return options.getIAB();
+        },
+        get legalLinks() {
+            return options.getLegalLinks();
+        },
+        get location() {
+            return getSnapshotLocal().location;
+        },
+        get manager() {
+            return null;
+        },
+        get model() {
+            return getSnapshotLocal().iab?.enabled
+                ? 'iab'
+                : getSnapshotLocal().policyRule.model;
+        },
+        get hasPolicy() {
+            return getSnapshotLocal().resolution.status === 'matched';
+        },
+        get hasConsentUi() {
+            const snapshot = getSnapshotLocal();
+            return (snapshot.resolution.status === 'matched' &&
+                (snapshot.policyRule.prompt !== 'none' ||
+                    snapshot.policyRule.rights.length > 0));
+        },
+        // -- Snapshot passthrough (was previously served by a Proxy) -------------
+        get explicitChoice() {
+            return getSnapshotLocal().explicitChoice;
+        },
+        get effectivePermissions() {
+            return getSnapshotLocal().effectivePermissions;
+        },
+        get promptRequirement() {
+            return getSnapshotLocal().promptRequirement;
+        },
+        get noticeDismissal() {
+            return getSnapshotLocal().noticeDismissal;
+        },
+        get privacySignals() {
+            return getSnapshotLocal().privacySignals;
+        },
+        get optOutDirectives() {
+            return getSnapshotLocal().optOutDirectives;
+        },
+        get resolution() {
+            return getSnapshotLocal().resolution;
+        },
+        get policyRule() {
+            return getSnapshotLocal().policyRule;
+        },
+        get restrictions() {
+            return getSnapshotLocal().restrictions;
+        },
+        get nextDeadline() {
+            return getSnapshotLocal().nextDeadline;
+        },
+        get subject() {
+            return getSnapshotLocal().subject;
+        },
+        get evaluatedAt() {
+            return getSnapshotLocal().evaluatedAt;
+        },
+        get evaluationPolicy() {
+            return getSnapshotLocal().evaluationPolicy;
+        },
+        get overrides() {
+            return getSnapshotLocal().overrides;
+        },
+        get policyPending() {
+            return getSnapshotLocal().policyPending;
+        },
+        get revision() {
+            return getSnapshotLocal().revision;
+        },
+        async saveConsents(type) {
+            actionSequence += 1;
+            const sequence = actionSequence;
+            const preserveDialog = kernel.getSnapshot().activeUI === 'dialog';
+            const save = async () => {
+                if (type === 'custom') {
+                    await options.getDraft().save(controller.consentCategories);
+                    return;
+                }
+                const result = await kernel.commands.save(type === 'all' ? 'all' : 'none', {
+                    categories: controller.consentCategories,
+                });
+                if (!result.ok) {
+                    throw new Error('Unable to save preferences.');
+                }
+                if (sequence === actionSequence) {
+                    options.getDraft().reset();
+                }
+            };
+            // The local receipt commits synchronously, before the transport settles.
+            // Restore the open dialog now so loading and failure never hide its draft.
+            const pending = save();
+            if (preserveDialog && sequence === actionSequence) {
+                kernel.set.activeUI('dialog');
+            }
+            const unsubscribe = kernel.subscribe((next) => {
+                if (preserveDialog &&
+                    next.activeUI !== 'dialog' &&
+                    sequence === actionSequence) {
+                    actionSequence += 1;
+                }
+            });
+            try {
+                await pending;
+                if (sequence !== actionSequence || !preserveDialog) {
+                    return;
+                }
+                const current = kernel.getSnapshot();
+                kernel.set.activeUI(current.policyPending ||
+                    current.resolution.status === 'failed' ||
+                    current.promptRequirement.kind === 'none'
+                    ? 'none'
+                    : 'banner');
+            }
+            finally {
+                unsubscribe();
+            }
+        },
+        get selectedConsents() {
+            return options.getDraft().values;
+        },
+        get selectedConsentTypes() {
+            return options.getDraft().values;
+        },
+        setActiveUI(ui) {
+            actionSequence += 1;
+            kernel.set.activeUI(ui);
+        },
+        setConsent(name, value) {
+            options.getDraft().set(name, value);
+        },
+        setLanguage(code) {
+            kernel.set.language(code);
+            void kernel.commands.init();
+        },
+        setSelectedConsent(name, value) {
+            options.getDraft().set(name, value);
+        },
+        subscribeToConsentChanges(listener) {
+            return kernel.subscribe((snapshot) => listener(snapshot.effectivePermissions));
+        },
+        get translationConfig() {
+            return toTranslationConfig(getSnapshotLocal());
+        },
+        get translations() {
+            return getSnapshotLocal().translations;
+        },
+        get user() {
+            return getSnapshotLocal().user;
+        },
+    };
+    return controller;
+};
+export const setConsentContext = function setConsentContext(kernel, options) {
+    const consentState = createConsentState(kernel, options);
+    setContext(CONSENT_CONTEXT_KEY, {
+        clearRecords: () => {
+            if (options.clearRecords) {
+                options.clearRecords();
+            }
+            else {
+                kernel.hydrate({
+                    choice: null,
+                    noticeDismissal: null,
+                    optOutDirectives: [],
+                    subject: null,
+                });
+                kernel.events.emit({ type: 'records:cleared' });
+            }
+        },
+        kernel,
+        get manager() {
+            return kernel;
+        },
+        get snapshot() {
+            return options.getSnapshot();
+        },
+        get state() {
+            return consentState;
+        },
+    });
+};
+export const getConsentContext = function getConsentContext() {
+    const context = getContext(CONSENT_CONTEXT_KEY);
+    if (!context) {
+        throw new Error('c15t: no v3 consent context. Wrap your app with <ConsentManagerProvider options={...}> from @c15t/svelte.');
+    }
+    return context;
+};
+export const getConsentKernel = function getConsentKernel() {
+    return getConsentContext().kernel;
+};
+export const getSnapshot = function getSnapshot() {
+    return getConsentContext().snapshot;
+};
+/**
+ * Returns the reactive consent manager controller for the current component.
+ *
+ * Exposes both readable state (`consents`, `activeUI`, `model`, …) and
+ * mutators (`setConsent`, `saveConsents`, `setActiveUI`, `setLanguage`, …).
+ * This is the primary API for reading and writing consent from inside your
+ * own components — equivalent to React's `useConsentManager()`.
+ *
+ * Must be called inside a component tree wrapped in `<ConsentManagerProvider>`.
+ */
+export const getConsentManager = function getConsentManager() {
+    return getConsentContext().state;
+};
+const resolveHeadlessSurface = (consent, surface) => ({
+    ...resolveConsentPresentation({
+        policy: consent.policyRule,
+        presentation: consent.presentation,
+        surface: surface === 'banner' ? 'prompt' : 'preferences',
+    }),
+    isVisible: consent.activeUI === surface,
+});
+export const getHeadlessConsent = function getHeadlessConsent() {
+    const consent = getConsentManager();
+    return {
+        get activeUI() {
+            return consent.activeUI;
+        },
+        get banner() {
+            return resolveHeadlessSurface(consent, 'banner');
+        },
+        closeUI() {
+            consent.setActiveUI('none');
+        },
+        get dialog() {
+            return resolveHeadlessSurface(consent, 'dialog');
+        },
+        openBanner() {
+            consent.setActiveUI('banner');
+        },
+        openDialog() {
+            consent.setActiveUI('dialog');
+        },
+        async performAction(action) {
+            if (action === 'dismiss') {
+                await consent.dismissNotice();
+                return;
+            }
+            if (action === 'save') {
+                await consent.saveConsents('custom');
+                return;
+            }
+            if (action === 'accept') {
+                await consent.saveConsents('all');
+                return;
+            }
+            if (action === 'reject') {
+                await consent.saveConsents('necessary');
+                return;
+            }
+            consent.setActiveUI('dialog');
+        },
+        async saveCustomPreferences() {
+            await consent.saveConsents('custom');
+        },
+    };
+};
+export const getIAB = function getIAB() {
+    return getConsentContext().state.iab;
+};
+export const setThemeContext = function setThemeContext(value) {
+    setContext(THEME_CONTEXT_KEY, value);
+};
+export const getThemeContext = function getThemeContext() {
+    return (getContext(THEME_CONTEXT_KEY) ?? {
+        colorScheme: 'system',
+        disableAnimation: false,
+        noStyle: false,
+        scrollLock: undefined,
+        trapFocus: undefined,
+    });
+};

package/dist/devtools-options.d.ts

@@ -0,0 +1,7 @@
+import type { DevToolsOptions } from '@c15t/dev-tools';
+/** Props for the kernel-bound Svelte DevTools adapter. */
+export type ConsentDevToolsProps = Omit<DevToolsOptions, 'container' | 'kernel'>;
+/** Backward-compatible props name for the ConsentDevTools component. */
+export type C15TDevToolsProps = ConsentDevToolsProps;
+/** Compatible props name for the DevTools component alias. */
+export type DevToolsProps = ConsentDevToolsProps;

package/dist/devtools-options.js

@@ -0,0 +1 @@
+export {};

package/dist/devtools.d.ts

@@ -0,0 +1,9 @@
+import ConsentDevTools from './components/consent-dev-tools.svelte';
+/** Compatible short name for {@link ConsentDevTools}. */
+declare const DevTools: import("svelte").Component<import("./devtools-options").ConsentDevToolsProps, {}, "">;
+/** Backward-compatible name for {@link ConsentDevTools}. */
+declare const C15TDevTools: import("svelte").Component<import("./devtools-options").ConsentDevToolsProps, {}, "">;
+export { C15TDevTools, ConsentDevTools, DevTools };
+export default ConsentDevTools;
+export type { DevToolsInstance, DevToolsOptions, DevToolsPosition, DevToolsTab, } from '@c15t/dev-tools';
+export type { C15TDevToolsProps, ConsentDevToolsProps, DevToolsProps, } from './devtools-options';

package/dist/devtools.js

@@ -0,0 +1,7 @@
+import ConsentDevTools from './components/consent-dev-tools.svelte';
+/** Compatible short name for {@link ConsentDevTools}. */
+const DevTools = ConsentDevTools;
+/** Backward-compatible name for {@link ConsentDevTools}. */
+const C15TDevTools = ConsentDevTools;
+export { C15TDevTools, ConsentDevTools, DevTools };
+export default ConsentDevTools;

package/dist/headless.d.ts

@@ -0,0 +1,10 @@
+export type { AllConsentNames } from '@c15t/core';
+export type { ConsentState, KernelActiveUI, KernelConfig } from '@c15t/core';
+export { focusTrap } from './actions/focus-trap';
+export { portal } from './actions/portal';
+export { scrollLock } from './actions/scroll-lock';
+export { default as InlineLegalLinks } from './components/inline-legal-links.svelte';
+export { getConsentKernel, getConsentManager, getHeadlessConsent, getIAB, getSnapshot, type HeadlessConsentSurfaceState, type SvelteIABState, } from './context.svelte';
+export { getIABTranslations, type IABTranslations } from './iab-translations';
+export { getIABBannerDisplayItems, type ProcessedFeature, type ProcessedGVLData, type ProcessedPurpose, type ProcessedSpecialFeature, type ProcessedStack, type ProcessedVendor, processGVLData, type VendorId, } from './iab-types';
+export type { ConsentManagerOptions } from './types';

package/dist/headless.js

@@ -0,0 +1,7 @@
+export { focusTrap } from './actions/focus-trap';
+export { portal } from './actions/portal';
+export { scrollLock } from './actions/scroll-lock';
+export { default as InlineLegalLinks } from './components/inline-legal-links.svelte';
+export { getConsentKernel, getConsentManager, getHeadlessConsent, getIAB, getSnapshot, } from './context.svelte';
+export { getIABTranslations } from './iab-translations';
+export { getIABBannerDisplayItems, processGVLData, } from './iab-types';

package/dist/iab/styles.css

@@ -0,0 +1,11 @@
+/**
+ * @c15t/svelte — IAB TCF component styles.
+ *
+ * Import this stylesheet in addition to `@c15t/svelte/styles.css`
+ * when using the prebuilt IAB consent UI.
+ *
+ * Usage (src/app.css):
+ *   @import "@c15t/svelte/styles.css";
+ *   @import "@c15t/svelte/iab/styles.css";
+ */
+@import '@c15t/ui/iab/styles.css';

package/dist/iab-loader.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The package's lazy IAB factory.
+ *
+ * `<ConsentManagerProvider>` is imported by every app, IAB or not, so it
+ * cannot import `@c15t/iab` statically — that put the CMP API and the
+ * `__tcfapi` bridge in the layout chunk of apps that never turn IAB on
+ * (3.3 KB gzipped on the SvelteKit bench, with the TC-string encoder
+ * behind its own dynamic import inside `@c15t/iab`). The runtime calls
+ * `createIAB` synchronously, so the deferral happens here:
+ * {@link lazyCreateIAB} hands back a handle immediately and forwards to
+ * the real one once the dynamic import resolves.
+ *
+ * Surfaces that render against the handle wait for {@link whenIABReady}
+ * first, so they never read methods that have not arrived.
+ */
+import type { ProviderIABOptions } from './types';
+/** The `createIAB` the provider hands the runtime. */
+export declare const lazyCreateIAB: import("@c15t/core/runtime").ConsentRuntimeIABFactory;
+/** Resolves once every pending `@c15t/iab` load has settled. */
+export declare const whenIABReady: () => Promise<void>;
+/**
+ * Whether IAB is configured for this provider.
+ *
+ * Mirrors the runtime's own check, so the provider only wires the loader
+ * for apps that will actually mount a CMP.
+ *
+ * @param iab - The provider's `iab` option.
+ * @returns `true` when the runtime would mount the TCF addon.
+ */
+export declare const isIABConfigured: (iab: ProviderIABOptions | undefined) => boolean;

package/dist/iab-loader.js

@@ -0,0 +1,33 @@
+/**
+ * The package's lazy IAB factory.
+ *
+ * `<ConsentManagerProvider>` is imported by every app, IAB or not, so it
+ * cannot import `@c15t/iab` statically — that put the CMP API and the
+ * `__tcfapi` bridge in the layout chunk of apps that never turn IAB on
+ * (3.3 KB gzipped on the SvelteKit bench, with the TC-string encoder
+ * behind its own dynamic import inside `@c15t/iab`). The runtime calls
+ * `createIAB` synchronously, so the deferral happens here:
+ * {@link lazyCreateIAB} hands back a handle immediately and forwards to
+ * the real one once the dynamic import resolves.
+ *
+ * Surfaces that render against the handle wait for {@link whenIABReady}
+ * first, so they never read methods that have not arrived.
+ */
+import { createLazyIABFactory } from '@c15t/core/runtime';
+const factory = createLazyIABFactory(() => import('@c15t/iab'));
+/** The `createIAB` the provider hands the runtime. */
+export const lazyCreateIAB = factory.create;
+/** Resolves once every pending `@c15t/iab` load has settled. */
+export const whenIABReady = factory.whenReady;
+/**
+ * Whether IAB is configured for this provider.
+ *
+ * Mirrors the runtime's own check, so the provider only wires the loader
+ * for apps that will actually mount a CMP.
+ *
+ * @param iab - The provider's `iab` option.
+ * @returns `true` when the runtime would mount the TCF addon.
+ */
+export const isIABConfigured = function isIABConfigured(iab) {
+    return Boolean(iab) && iab.enabled !== false;
+};

package/dist/iab-translations.d.ts

@@ -0,0 +1,84 @@
+import type { TranslationConfig } from '@c15t/core';
+/**
+ * IAB translations interface.
+ * Matches the structure in @c15t/translations.
+ */
+export interface IABTranslations {
+    banner: {
+        title: string;
+        description: string;
+        partnersLink: string;
+        andMore: string;
+        legitimateInterestNotice: string;
+        scopeServiceSpecific: string;
+        scopeGroup: string;
+    };
+    common: {
+        acceptAll: string;
+        rejectAll: string;
+        customize: string;
+        saveSettings: string;
+        loading: string;
+        showingSelectedVendor: string;
+        clearSelection: string;
+        customPartner: string;
+    };
+    preferenceCenter: {
+        title: string;
+        description: string;
+        tabs: {
+            purposes: string;
+            vendors: string;
+        };
+        purposeItem: {
+            partners: string;
+            vendorsUseLegitimateInterest: string;
+            examples: string;
+            partnersUsingPurpose: string;
+            withYourPermission: string;
+            legitimateInterest: string;
+            objectButton: string;
+            objected: string;
+            rightToObject: string;
+        };
+        specialPurposes: {
+            title: string;
+            tooltip: string;
+        };
+        vendorList: {
+            search: string;
+            showingCount: string;
+            iabVendorsHeading: string;
+            iabVendorsNotice: string;
+            customVendorsHeading: string;
+            customVendorsNotice: string;
+            purposes: string;
+            specialPurposes: string;
+            specialFeatures: string;
+            features: string;
+            dataCategories: string;
+            usesCookies: string;
+            nonCookieAccess: string;
+            maxAge: string;
+            maxAgeRefreshes: string;
+            retention: string;
+            retainedDays: string;
+            legitimateInterest: string;
+            privacyPolicy: string;
+            storageDisclosure: string;
+            requiredNotice: string;
+            noVendorsFound: string;
+            partnerCount: string;
+            partnerSingular: string;
+            partnerPlural: string;
+        };
+        footer: {
+            consentStorage: string;
+        };
+    };
+}
+/**
+ * Get IAB translations with fallback to defaults.
+ * Svelte equivalent of the React `useIABTranslations` hook.
+ */
+export declare const getIABTranslations: (translationConfig?: TranslationConfig) => IABTranslations;

package/dist/iab-translations.js

@@ -0,0 +1,45 @@
+import { defaultTranslationConfig } from '@c15t/core';
+import { resolveTranslations } from '@c15t/ui/utils';
+// oxlint-disable-next-line typescript/no-non-null-assertion -- enTranslations is guaranteed to exist in defaultTranslationConfig
+const DEFAULT_IAB_TRANSLATIONS = defaultTranslationConfig.translations.en
+    .iab;
+/**
+ * Deep merge helper for IAB translations.
+ */
+const deepMerge = function deepMerge(defaults, overrides) {
+    if (!overrides) {
+        return defaults;
+    }
+    const result = { ...defaults };
+    for (const key of Object.keys(defaults)) {
+        const defaultValue = defaults[key];
+        const overrideValue = overrides[key];
+        if (overrideValue !== undefined &&
+            typeof defaultValue === 'object' &&
+            defaultValue !== null &&
+            typeof overrideValue === 'object' &&
+            overrideValue !== null &&
+            !Array.isArray(defaultValue)) {
+            result[key] = deepMerge(defaultValue, overrideValue);
+        }
+        else if (overrideValue !== undefined) {
+            result[key] = overrideValue;
+        }
+    }
+    return result;
+};
+/**
+ * Get IAB translations with fallback to defaults.
+ * Svelte equivalent of the React `useIABTranslations` hook.
+ */
+export const getIABTranslations = function getIABTranslations(translationConfig) {
+    const translations = resolveTranslations(translationConfig ?? {}, defaultTranslationConfig);
+    if (!translations.iab) {
+        return DEFAULT_IAB_TRANSLATIONS;
+    }
+    return {
+        banner: deepMerge(DEFAULT_IAB_TRANSLATIONS.banner, translations.iab.banner),
+        common: deepMerge(DEFAULT_IAB_TRANSLATIONS.common, translations.iab.common),
+        preferenceCenter: deepMerge(DEFAULT_IAB_TRANSLATIONS.preferenceCenter, translations.iab.preferenceCenter),
+    };
+};

package/dist/iab-types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The Svelte adapter's view of the shared IAB display model.
+ *
+ * The derivation itself — which purposes a stack absorbs, which rows a
+ * preference centre lists, what each row's test-id is — lives in
+ * `@c15t/iab/headless` so React, Svelte, Vue and the Astro server render
+ * cannot drift apart. This module is the thin naming layer that was left
+ * behind: the local type aliases the components already import, and two
+ * wrappers keeping the argument shapes they already call with.
+ *
+ * `@c15t/iab/headless` is pure derivation with no TCF encoder behind it,
+ * so importing it here does not pull the CMP API into an app that never
+ * mounts an IAB surface — the components that import this module are
+ * themselves only reachable from `<IABConsentBanner>`/`<IABConsentDialog>`.
+ */
+import type { GlobalVendorList } from '@c15t/core';
+import type { HeadlessIABDialogData, HeadlessIABProcessedFeature, HeadlessIABProcessedPurpose, HeadlessIABProcessedSpecialFeature, HeadlessIABProcessedStack, HeadlessIABProcessedVendor, HeadlessIABVendorId } from '@c15t/iab/headless';
+export type VendorId = HeadlessIABVendorId;
+export type ProcessedVendor = HeadlessIABProcessedVendor;
+export type ProcessedPurpose = HeadlessIABProcessedPurpose;
+export type ProcessedSpecialFeature = HeadlessIABProcessedSpecialFeature;
+export type ProcessedFeature = HeadlessIABProcessedFeature;
+export type ProcessedStack = HeadlessIABProcessedStack;
+export type { HeadlessIABDialogDisplayModel as IABDisplayModel, HeadlessIABDisplayConsentRow as IABDisplayConsentRow, HeadlessIABDisplayRow as IABDisplayRow, HeadlessIABDisplayStackRow as IABDisplayStackRow, } from '@c15t/iab/headless';
+export { resolveIABDialogDisplayModel } from '@c15t/iab/headless';
+/** Custom vendor not registered with IAB. */
+export interface NonIABVendor {
+    id: string | number;
+    name: string;
+    privacyPolicyUrl: string;
+    purposes: number[];
+    legIntPurposes?: number[];
+    specialFeatures?: number[];
+    features?: number[];
+    dataCategories?: number[];
+    usesCookies?: boolean;
+    usesNonCookieAccess?: boolean;
+    cookieMaxAgeSeconds?: number;
+}
+/** Result of processing GVL data into UI-friendly format. */
+export type ProcessedGVLData = HeadlessIABDialogData;
+/**
+ * Process raw GVL data into UI-friendly format.
+ *
+ * @param gvl - The Global Vendor List.
+ * @param customVendors - Publisher-declared non-IAB vendors.
+ * @returns The processed purposes, stacks, features and vendors.
+ */
+export declare const processGVLData: (gvl: GlobalVendorList, customVendors?: NonIABVendor[]) => ProcessedGVLData;
+/**
+ * Compute display items for the IAB consent banner.
+ *
+ * @param gvl - The Global Vendor List.
+ * @param maxItems - How many items to list before collapsing the rest.
+ * Defaults to the cap the shared model applies, so the four banners list
+ * the same number of items unless a caller asks otherwise.
+ * @returns The item names to list, and how many were left out.
+ */
+export declare const getIABBannerDisplayItems: (gvl: GlobalVendorList, maxItems?: number) => {
+    displayed: string[];
+    remainingCount: number;
+};