cloudflare-next-intl 0.6.2 → 0.6.4

package/dist/src/error_handling/create_server_error_action.d.ts

@@ -0,0 +1,32 @@
+import type { ErrorHandlingParams } from '../types/types';
+import { type ReportErrorConfig } from './report_error';
+/**
+ * Builds a function that reports a client-originated error via
+ * `reportError`, meant to be re-exported directly from your OWN
+ * `"use server"` file so `config` (and anything it closes over — secrets,
+ * `Secrets.telegramBotToken`-style env reads inside your `onError`) never
+ * has to be imported into client-side code:
+ *
+ * ```ts
+ * // report_client_error.ts
+ * "use server";
+ * import createServerErrorAction from "cloudflare-next-intl/createServerErrorAction";
+ * import intlConfig from "./intl_config";
+ * export const reportClientError = createServerErrorAction(intlConfig);
+ * ```
+ *
+ * This function itself must NOT be called from a file marked `"use server"`
+ * — Next.js requires every top-level export of such a file to be an async
+ * function directly; a factory that returns one doesn't qualify. Put
+ * `"use server"` in your OWN file (as above), not in a file that calls
+ * `createServerErrorAction` and re-exports its result under a different
+ * name than a plain `const`.
+ *
+ * The error is stringified before crossing the client→server action
+ * boundary (Next.js server actions serialize arguments; an `Error` instance
+ * doesn't survive that intact) and `isClient: true` is set automatically.
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ */
+export default function createServerErrorAction(config: ReportErrorConfig | undefined): (error: unknown, classOrMethodName: string, params?: ErrorHandlingParams["params"]) => Promise<void>;

package/dist/src/error_handling/create_server_error_action.js

@@ -0,0 +1,41 @@
+import reportError from './report_error';
+import stringifyUnknown from './stringify_unknown';
+/**
+ * Builds a function that reports a client-originated error via
+ * `reportError`, meant to be re-exported directly from your OWN
+ * `"use server"` file so `config` (and anything it closes over — secrets,
+ * `Secrets.telegramBotToken`-style env reads inside your `onError`) never
+ * has to be imported into client-side code:
+ *
+ * ```ts
+ * // report_client_error.ts
+ * "use server";
+ * import createServerErrorAction from "cloudflare-next-intl/createServerErrorAction";
+ * import intlConfig from "./intl_config";
+ * export const reportClientError = createServerErrorAction(intlConfig);
+ * ```
+ *
+ * This function itself must NOT be called from a file marked `"use server"`
+ * — Next.js requires every top-level export of such a file to be an async
+ * function directly; a factory that returns one doesn't qualify. Put
+ * `"use server"` in your OWN file (as above), not in a file that calls
+ * `createServerErrorAction` and re-exports its result under a different
+ * name than a plain `const`.
+ *
+ * The error is stringified before crossing the client→server action
+ * boundary (Next.js server actions serialize arguments; an `Error` instance
+ * doesn't survive that intact) and `isClient: true` is set automatically.
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ */
+export default function createServerErrorAction(config) {
+    return async function reportClientError(error, classOrMethodName, params) {
+        await reportError(config, {
+            error: stringifyUnknown(error, true),
+            classOrMethodName,
+            params,
+            isClient: true,
+        });
+    };
+}

package/dist/types/client/components/client_helper_script.d.ts

@@ -0,0 +1 @@
+export default function ClientHelperScript(): null;

package/dist/types/client/components/client_provider.d.ts

@@ -0,0 +1,34 @@
+import type { TranslationObject } from "../../types/types";
+import type { SerializedAuthUser } from "../../firebase_auth/types";
+import type { CookieConsentAnalyticsConfig } from "../../types/types";
+import type { CookieConsentDialogProps } from "../../cookie_consent/client/components/cookie_consent_dialog";
+import type { PrivacyPolicyUpdateDialogProps } from "../../cookie_consent/client/components/privacy_policy_update_dialog";
+interface LocaleContextType {
+    language: string;
+    messages: TranslationObject;
+}
+export declare const LocaleContext: import("react").Context<LocaleContextType | undefined>;
+export default function LocationzationClientProvider({ language, messages, initialAuthUser, skipAuthProvider, analyticsConfig, requiresConsent, autoWireDialogs, dialogProps, updateDialogProps, children }: {
+    language: string;
+    messages: TranslationObject;
+    initialAuthUser?: SerializedAuthUser | null;
+    /** Set when `firebaseAuth.autoWireClientProvider` is `false` — skips wrapping `children` in the client `AuthUserProvider` entirely. */
+    skipAuthProvider?: boolean;
+    /** Resolved server-side from `cookieConsent.analytics`/`getAnalytics` when `autoWireAnalytics` isn't `false`. */
+    analyticsConfig?: CookieConsentAnalyticsConfig;
+    /**
+     * Resolved server-side from `cookieConsent.getCountryCode`/`gdprCountries`.
+     * `false` means the visitor's country doesn't require the consent
+     * banner — `CookieConsentProvider` seeds consent as implicitly granted
+     * for a first-time visitor instead of `null`.
+     */
+    requiresConsent?: boolean;
+    /** From `cookieConsent.autoWireDialogs` — renders `CookieConsentDialog`/`PrivacyPolicyUpdateDialog` automatically when `true` (default). */
+    autoWireDialogs?: boolean;
+    /** From `cookieConsent.dialogProps` — forwarded as-is to the auto-wired `CookieConsentDialog`. */
+    dialogProps?: CookieConsentDialogProps;
+    /** From `cookieConsent.updateDialogProps` — forwarded as-is to the auto-wired `PrivacyPolicyUpdateDialog`. */
+    updateDialogProps?: PrivacyPolicyUpdateDialogProps;
+    children: React.ReactNode;
+}): Component;
+export {};

package/dist/types/client/components/locale_link.d.ts

@@ -0,0 +1,30 @@
+import { type LinkProps } from 'next/link';
+import { type ComponentProps } from 'react';
+type NextLinkProps = Omit<ComponentProps<'a'>, keyof LinkProps> & Omit<LinkProps, 'locale' | 'href' | 'prefetch' | 'onNavigate' | 'hrefLang' | 'replace' | 'scroll'>;
+export type LocaleLinkProps = NextLinkProps & {
+    locale: string;
+};
+/**
+ * Client-only link component for linking to a SPECIFIC locale — e.g. a
+ * language switcher. Import from `cloudflare-next-intl/LocaleLink`.
+ *
+ * For normal in-app navigation that should stay on the current locale, use
+ * the server-side `Link` (`cloudflare-next-intl/Link`) instead — it infers
+ * the locale automatically and doesn't require `"use client"`.
+ *
+ * Renders inside a `Suspense` boundary; falls back to a disabled `<a>`
+ * (`pointer-events-none`) while resolving.
+ *
+ * @param locale Required. The locale to link to (e.g. `"de"`), prepended to
+ *   `href` regardless of the current locale.
+ *
+ * @example
+ * ```tsx
+ * "use client";
+ * import LocaleLink from "cloudflare-next-intl/LocaleLink";
+ *
+ * <LocaleLink href="/about" locale="de">Über uns</LocaleLink> // -> "/de/about"
+ * ```
+ */
+declare const LocaleLink: import("react").ForwardRefExoticComponent<Omit<LocaleLinkProps, "ref"> & import("react").RefAttributes<HTMLAnchorElement>>;
+export default LocaleLink;

package/dist/types/client/components/locale_link_client.d.ts

@@ -0,0 +1,3 @@
+import type { LocaleLinkProps } from './locale_link';
+declare const LocaleLinkClient: import("react").ForwardRefExoticComponent<Omit<LocaleLinkProps, "ref"> & import("react").RefAttributes<HTMLAnchorElement>>;
+export default LocaleLinkClient;

package/dist/types/client/functions/get_cookie.bench.d.ts

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

package/dist/types/client/functions/get_cookie.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Client-only: reads a `document.cookie` value by name. Pairs with
+ * {@link setCookie} for your OWN client-side cookies — this package's
+ * locale/theme cookies are managed internally, you don't need this for those.
+ *
+ * @param name Cookie name to look up.
+ * @returns The decoded cookie value, or `null` if not found (or on error,
+ *   logged instead of thrown).
+ */
+export default function getCookie(name: string): string | null;

package/dist/types/client/functions/get_cookie.test.d.ts

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

package/dist/types/client/functions/set_cookie.bench.d.ts

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

package/dist/types/client/functions/set_cookie.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Client-only: sets a `document.cookie` value directly. Not used by this
+ * package's own locale handling (that goes through `intlMiddleware` server-side)
+ * — this is a small utility for your OWN client-side cookies (e.g. a
+ * "dismissed banner" flag).
+ *
+ * @param name   Cookie name.
+ * @param value  Cookie value; stringified via template literal (no encoding
+ *   applied — avoid values containing `;`). Must be a primitive
+ *   (`string`/`number`/`boolean`) — objects would silently serialize to
+ *   `"[object Object]"`.
+ * @param maxAge Seconds until expiry. Defaults to 1 year.
+ *
+ * Always `path=/; SameSite=Lax`. Swallows errors (e.g. in restrictive
+ * environments) and logs them instead of throwing.
+ */
+export default function setCookie({ name, value, maxAge }: {
+    name: string;
+    value: string | number | boolean;
+    maxAge?: number;
+}): void;

package/dist/types/client/functions/set_cookie.test.d.ts

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

package/dist/types/client/hooks/client_hooks.bench.d.ts

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

package/dist/types/client/hooks/client_hooks.d.ts

@@ -0,0 +1,28 @@
+import type { TranslatorReturnType } from "../../types/types";
+/**
+ * Client Component `useLocale` — reached via the default condition of the
+ * `cloudflare-next-intl/use` subpath (Server Components get the
+ * `use_functions.ts` variant automatically instead; always import from
+ * `"cloudflare-next-intl/use"`, never this file directly).
+ *
+ * Reads the locale from React context set up by `IntlProvider`.
+ *
+ * @returns The current locale (e.g. `"en"`).
+ * @throws If rendered outside `IntlProvider`.
+ * @example
+ * const locale = useLocale(); // "en"
+ */
+export declare function useLocale(): string;
+/**
+ * Client Component `useTranslations` — see {@link useLocale} for the
+ * subpath-resolution note.
+ *
+ * @param namespace Dot-separated key prefix into your messages file.
+ * @returns A `(key: string) => string` translation function, memoized on
+ *   `[language, messages, namespace]`.
+ * @throws If rendered outside `IntlProvider`.
+ * @example
+ * const t = useTranslations("Index");
+ * return <h1>{t("title")}</h1>;
+ */
+export declare function useTranslations(namespace: string): TranslatorReturnType;

package/dist/types/client/hooks/use_path_name.bench.d.ts

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

package/dist/types/client/hooks/use_path_name.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Client hook: like `next/navigation`'s `usePathname`, but with the locale
+ * segment stripped — so `/de/about` returns `/about`, matching the
+ * locale-agnostic paths used elsewhere in this package (e.g. `Link` href).
+ * Must be used inside `IntlProvider`/`LocaleContext` (via {@link useLocale}).
+ *
+ * @returns The current pathname without its locale prefix (e.g. `/about`, or
+ *   `/` for the root).
+ */
+export default function usePathname(): string;

package/dist/types/client/index.d.ts

@@ -0,0 +1,4 @@
+export { default as LocaleLink } from './components/locale_link';
+export { default as usePathname } from './hooks/use_path_name';
+export { default as setCookieClient } from './functions/set_cookie';
+export { default as getCookieClient } from './functions/get_cookie';

package/dist/types/config/cookie_key.bench.d.ts

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

package/dist/types/config/cookie_key.d.ts

@@ -0,0 +1,5 @@
+export declare const localeCookieName = "__user_locale_key__";
+export declare const isBotCookieKey = "__is_bot_key__";
+export declare const isDarkCookieKey = "__is_dark_key__";
+export declare const cookieConsentCookieKey = "__cookie_consent_key__";
+export declare const privacyPolicyDateCookieKey = "__privacy_policy_date_key__";

package/dist/types/config/cookie_key.test.d.ts

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

package/dist/types/config/index.d.ts

@@ -0,0 +1,4 @@
+export { isBotCookieKey, localeCookieName, isDarkCookieKey, cookieConsentCookieKey, privacyPolicyDateCookieKey } from './cookie_key';
+export { default as intlMiddleware } from './middleware';
+export { setIntlConfig } from './init_config';
+export { default as generateIntlSitemap } from './intl_sitemap';

package/dist/types/config/init_config.bench.d.ts

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

package/dist/types/config/init_config.d.ts

@@ -0,0 +1,18 @@
+import type { LocalePrefixMode, Locales, RoutingConfig } from '../types/types';
+/**
+ * Defines and type-checks your app's i18n routing config.
+ *
+ * Identity function at runtime — it exists purely so TypeScript infers
+ * `AppLocales`/`AppLocalePrefixMode` from the literal config object you pass
+ * in, giving you autocomplete/type errors on `locale` params elsewhere.
+ *
+ * Export the result from the file referenced by `@intl-config` (see your
+ * `next.config`), e.g.:
+ * ```ts
+ * export default setIntlConfig({
+ *   locales: ["en", "fr"] as const,
+ *   defaultLocale: "en",
+ * });
+ * ```
+ */
+export declare function setIntlConfig<const AppLocales extends Locales, const AppLocalePrefixMode extends LocalePrefixMode = 'as-needed'>(config: RoutingConfig<AppLocales, AppLocalePrefixMode>): RoutingConfig<AppLocales, AppLocalePrefixMode>;

package/dist/types/config/init_config.test.d.ts

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

package/dist/types/config/intl_config.d.ts

@@ -0,0 +1,3 @@
+import type { LocalePrefixMode, Locales, RoutingConfig } from '../types/types';
+declare const config: RoutingConfig<Locales, LocalePrefixMode>;
+export default config;

package/dist/types/config/intl_config.test.d.ts

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

package/dist/types/config/intl_sitemap.bench.d.ts

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

package/dist/types/config/intl_sitemap.d.ts

@@ -0,0 +1,8 @@
+import type { MetadataRoute } from 'next';
+import type { IntlSitemap } from '../types/types';
+declare function generateIntlSitemapIml({ intlSitemap, url }: {
+    intlSitemap: IntlSitemap[];
+    url: string;
+}): MetadataRoute.Sitemap;
+declare const generateIntlSitemap: typeof generateIntlSitemapIml;
+export default generateIntlSitemap;

package/dist/types/config/intl_sitemap.test.d.ts

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

package/dist/types/config/middleware.bench.d.ts

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

package/dist/types/config/middleware.d.ts

@@ -0,0 +1,21 @@
+import type { NextRequest } from 'next/server';
+import { NextResponse } from 'next/server';
+import type { MiddlewareCustomHandler } from '../types/types';
+export declare const localesSet: Set<string>;
+/**
+ * This middleware function runs for every incoming request. Handles locale
+ * detection/routing, then optionally defers to your own custom logic.
+ *
+ * @param request The incoming request (pass through from your `middleware.ts`).
+ * @param options.middlewareHandler  Your own logic (auth, feature flags, etc.),
+ *   run alongside locale routing — see {@link MiddlewareCustomHandler} for the
+ *   full contract (`rewriteUrl` / `redirectUrl` and what to return).
+ * @param options.runHandlerOnRedirect  By default, `middlewareHandler` does
+ *   NOT run for the locale-redirect case (so it never receives a
+ *   `redirectUrl`). Set to `true` to also run it on redirects.
+ *   Defaults to `false`.
+ */
+export default function intlMiddleware(request: NextRequest, options?: {
+    middlewareHandler?: MiddlewareCustomHandler;
+    runHandlerOnRedirect?: boolean;
+}): Promise<NextResponse<unknown>>;

package/dist/types/config/middleware.test.d.ts

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

package/dist/types/cookie_consent/client/components/clarity_script.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Loads and initializes Microsoft Clarity. Split into its own module and
+ * loaded via `next/dynamic` from `cookie_consent_analytics.tsx` so it's
+ * only fetched as a separate chunk once actually rendered (consent granted
+ * and `analytics.clarityProjectId` set) — `@microsoft/clarity` is a real
+ * dependency of this package, so it's always installed regardless.
+ */
+export default function ClarityScript({ projectId }: {
+    projectId: string;
+}): null;

package/dist/types/cookie_consent/client/components/cookie_consent_analytics.bench.d.ts

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

package/dist/types/cookie_consent/client/components/cookie_consent_analytics.d.ts

@@ -0,0 +1,19 @@
+import type { CookieConsentAnalyticsConfig } from '../../../types/types';
+/**
+ * Renders whichever analytics/ads scripts have a resolved secret, gated on
+ * consent: Google Consent Mode bootstrap always loads (defaults to
+ * `denied`, only sends `update` once `consent` is decided); Cloudflare Web
+ * Analytics beacon and Microsoft Clarity only load once `consent === true`.
+ * Rendered automatically by `IntlProvider` when `cookieConsent.analytics`/
+ * `getAnalytics` resolves at least one field and `autoWireAnalytics` isn't
+ * `false` — render manually instead if you set `autoWireAnalytics: false`.
+ */
+export default function CookieConsentAnalytics({ config }: {
+    config: CookieConsentAnalyticsConfig;
+}): React.ReactElement | null;
+/**
+ * Denies storage by default and loads the configured Google tags; the
+ * effect above sends the `update` once consent is known. Only IDs present
+ * in `config` are included.
+ */
+export declare function googleConsentModeBootstrapScript(config: CookieConsentAnalyticsConfig): string;

package/dist/types/cookie_consent/client/components/cookie_consent_dialog.d.ts

@@ -0,0 +1,35 @@
+import type { ConsentValue, CookieDialogClassNames, CookieDialogStyles } from '../../types';
+export interface CookieConsentDialogProps {
+    /** Banner message text. */
+    message?: React.ReactNode;
+    /**
+     * Link element rendered right after `message`. Defaults to a link to
+     * `cookieConsent.privacyPolicyPath` (`'/privacy-policy'` unless
+     * configured otherwise) with `privacyPolicyLinkText` as its label. Pass
+     * `null` to render no link, or your own element to override it.
+     */
+    link?: React.ReactNode;
+    /** Label for the default privacy-policy link. Ignored when `link` is set. */
+    privacyPolicyLinkText?: string;
+    acceptText?: string;
+    declineText?: string;
+    /** Hides the decline ("necessary only") button, leaving only accept. */
+    hideDecline?: boolean;
+    id?: string;
+    classNames?: CookieDialogClassNames;
+    styles?: CookieDialogStyles;
+    /**
+     * Full custom render — receives the resolved consent state/actions and
+     * bypasses the default markup entirely. Use for a fully bespoke dialog.
+     */
+    render?: (props: {
+        setConsent: (value: ConsentValue) => void;
+    }) => React.ReactNode;
+}
+/**
+ * Cookie-consent banner. Renders `null` once `consent` is already decided.
+ * Every visual aspect is overridable via `classNames`/`styles` (per-slot) or
+ * `render` (full custom markup) — none of it is hardcoded to Tailwind or any
+ * particular design system.
+ */
+export default function CookieConsentDialog({ message, link, privacyPolicyLinkText, acceptText, declineText, hideDecline, id, classNames, styles, render, }: CookieConsentDialogProps): React.ReactElement | null;

package/dist/types/cookie_consent/client/components/default_dialog_styles.d.ts

@@ -0,0 +1,2 @@
+import type { CookieDialogClassNames } from '../../types';
+export declare const defaultCookieDialogClassNames: CookieDialogClassNames;

package/dist/types/cookie_consent/client/components/default_dialog_text.d.ts

@@ -0,0 +1,13 @@
+export interface CookieConsentDefaultText {
+    message: string;
+    privacyPolicyLinkText: string;
+    acceptText: string;
+    declineText: string;
+}
+export interface PrivacyPolicyUpdateDefaultText {
+    message: string;
+    privacyPolicyLinkText: string;
+    closeText: string;
+}
+export declare const defaultCookieConsentText: Record<string, CookieConsentDefaultText>;
+export declare const defaultPrivacyPolicyUpdateText: Record<string, PrivacyPolicyUpdateDefaultText>;

package/dist/types/cookie_consent/client/components/default_privacy_policy_link.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Renders the default privacy-policy link used by `CookieConsentDialog`/
+ * `PrivacyPolicyUpdateDialog` when their `link` prop is omitted. Returns
+ * `null` when `privacyPolicyPath` is `false` (disabled via
+ * `cookieConsent.privacyPolicyPath`). Locale-prefixes `privacyPolicyPath`
+ * the same way the server `Link` component does — reads the locale set by
+ * `LocationzationClientProvider` on the current render.
+ */
+export default function DefaultPrivacyPolicyLink({ privacyPolicyPath, text, className, style }: {
+    privacyPolicyPath: string | false;
+    text: string;
+    className?: string;
+    style?: React.CSSProperties;
+}): React.ReactElement | null;

package/dist/types/cookie_consent/client/components/dialog_portal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Renders `children` into `document.body` via a portal, so the default
+ * dialogs always stack on top of the host app regardless of its own
+ * stacking contexts (a `z-index` alone can't escape an ancestor with
+ * `transform`/`filter`/`opacity`/`isolation`, all common in app shells).
+ * Only called client-side (both dialogs already gate on `isMounted`), so
+ * `document` is always defined here.
+ */
+export default function DialogPortal({ children }: {
+    children: React.ReactNode;
+}): React.ReactPortal;

package/dist/types/cookie_consent/client/components/privacy_policy_update_dialog.d.ts

@@ -0,0 +1,31 @@
+import type { CookieDialogClassNames, CookieDialogStyles } from '../../types';
+export interface PrivacyPolicyUpdateDialogProps {
+    message?: React.ReactNode;
+    /**
+     * Link element rendered right after `message`. Defaults to a link to
+     * `cookieConsent.privacyPolicyPath` (`'/privacy-policy'` unless
+     * configured otherwise) with `privacyPolicyLinkText` as its label. Pass
+     * `null` to render no link, or your own element to override it.
+     */
+    link?: React.ReactNode;
+    /** Label for the default privacy-policy link. Ignored when `link` is set. */
+    privacyPolicyLinkText?: string;
+    closeText?: string;
+    id?: string;
+    classNames?: CookieDialogClassNames;
+    styles?: CookieDialogStyles;
+    /**
+     * Full custom render — receives the acknowledge action and bypasses the
+     * default markup entirely.
+     */
+    render?: (props: {
+        acknowledge: () => void;
+    }) => React.ReactNode;
+}
+/**
+ * "Privacy policy updated" banner. Auto-enabled only when
+ * `cookieConsent.privacyPolicyDate` is set on the `RoutingConfig` — renders
+ * `null` otherwise, or once acknowledged. Every visual aspect is overridable
+ * via `classNames`/`styles` (per-slot) or `render` (full custom markup).
+ */
+export default function PrivacyPolicyUpdateDialog({ message, link, privacyPolicyLinkText, closeText, id, classNames, styles, render, }: PrivacyPolicyUpdateDialogProps): React.ReactElement | null;

package/dist/types/cookie_consent/client/cookie_consent_provider.bench.d.ts

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

package/dist/types/cookie_consent/client/cookie_consent_provider.d.ts

@@ -0,0 +1,39 @@
+import type { CookieConsentContextType } from '../types';
+export declare const CookieConsentContext: import("react").Context<CookieConsentContextType | null>;
+/**
+ * Provides cookie-consent + privacy-policy-update state to
+ * `useCookieConsent()` and the default `CookieConsentDialog`/
+ * `PrivacyPolicyUpdateDialog` components. Requires `cookieConsent` to be set
+ * on the `RoutingConfig` passed to `setIntlConfig` — throws a descriptive
+ * error otherwise.
+ *
+ * The privacy-policy-update banner turns on automatically, and only when
+ * `cookieConsent.privacyPolicyDate` is configured: once a visitor has
+ * consented, if their stored consent date predates `privacyPolicyDate`,
+ * `privacyPolicyUpdated` becomes `true` until they call
+ * `acknowledgePrivacyPolicyUpdate()` — or until they navigate to
+ * `cookieConsent.privacyPolicyPath`, which auto-acknowledges it (visiting
+ * the page counts as having seen the update; skipped entirely when
+ * `privacyPolicyPath` is `false`).
+ *
+ * @param requiresConsent Resolved server-side from
+ *   `cookieConsent.getCountryCode`/`gdprCountries` — `false` means the
+ *   visitor's country doesn't require the banner at all, so a first-time
+ *   visitor (no stored cookie) gets `consent` seeded to `true` instead of
+ *   `null`, skipping the dialog and unlocking analytics immediately.
+ *   Defaults to `true` (always show the banner) when omitted, e.g. when
+ *   `cookieConsent.getCountryCode` isn't configured.
+ *
+ * @example
+ * ```tsx
+ * <CookieConsentProvider>
+ *   {children}
+ *   <CookieConsentDialog />
+ *   <PrivacyPolicyUpdateDialog />
+ * </CookieConsentProvider>
+ * ```
+ */
+export default function CookieConsentProvider({ requiresConsent, children }: {
+    requiresConsent?: boolean;
+    children: React.ReactNode;
+}): React.ReactElement;

package/dist/types/cookie_consent/client/use_cookie_consent.d.ts

@@ -0,0 +1,6 @@
+import type { CookieConsentContextType } from '../types';
+/**
+ * Reads cookie-consent + privacy-policy-update state. Must be called within
+ * a `CookieConsentProvider`.
+ */
+export default function useCookieConsent(): CookieConsentContextType;

package/dist/types/cookie_consent/gdpr_countries.bench.d.ts

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

package/dist/types/cookie_consent/gdpr_countries.d.ts

@@ -0,0 +1,18 @@
+import type { CookieConsentGetCloudflareContext, ErrorHandlingRoutingConfig } from '../types/types';
+/**
+ * Default `cookieConsent.gdprCountries` — EU/EEA member states (GDPR),
+ * Iceland/Liechtenstein/Norway (EEA), the UK (UK-GDPR), and Switzerland
+ * (nFADP). ISO 3166-1 alpha-2.
+ */
+export declare const defaultGdprCountries: readonly string[];
+/**
+ * Resolves whether the cookie-consent banner is required for a visitor.
+ *
+ * - Neither getter set: fail-safe — consent is required by default since
+ *   the visitor's country can't be determined at all.
+ * - Either getter set: fail-safe — a country that couldn't be resolved
+ *   still requires consent; only a resolved country OUTSIDE
+ *   `gdprCountries` skips the banner. `getCountryCode` takes precedence
+ *   over `getCloudflareContext` when both are set.
+ */
+export default function resolveRequiresConsent(getCountryCode: (() => string | undefined | Promise<string | undefined>) | undefined, getCloudflareContext: CookieConsentGetCloudflareContext | undefined, gdprCountries: readonly string[] | undefined, errorHandlingConfig?: ErrorHandlingRoutingConfig): Promise<boolean>;

package/dist/types/cookie_consent/gdpr_countries.perf.test.d.ts

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

package/dist/types/cookie_consent/gdpr_countries.test.d.ts

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

package/dist/types/cookie_consent/index.d.ts

@@ -0,0 +1,10 @@
+export { default as CookieConsentProvider } from './client/cookie_consent_provider';
+export { default as useCookieConsent } from './client/use_cookie_consent';
+export { default as CookieConsentDialog } from './client/components/cookie_consent_dialog';
+export { default as PrivacyPolicyUpdateDialog } from './client/components/privacy_policy_update_dialog';
+export { default as CookieConsentAnalytics } from './client/components/cookie_consent_analytics';
+export { defaultGdprCountries } from './gdpr_countries';
+export type { CookieConsentContextType, ConsentValue, CookieDialogClassNames, CookieDialogStyles } from './types';
+export type { CookieConsentDialogProps } from './client/components/cookie_consent_dialog';
+export type { PrivacyPolicyUpdateDialogProps } from './client/components/privacy_policy_update_dialog';
+export type { CookieConsentRoutingConfig, CookieConsentAnalyticsConfig, CookieConsentCloudflareContext, CookieConsentGetCloudflareContext, } from '../types/types';

package/dist/types/cookie_consent/require_config.d.ts

@@ -0,0 +1,7 @@
+import type { CookieConsentRoutingConfig } from '../types/types';
+/**
+ * Throws a descriptive error instead of silently no-op'ing when the
+ * `cookie_consent` submodule is used without `cookieConsent` set on the
+ * `RoutingConfig` passed to `setIntlConfig`.
+ */
+export default function requireCookieConsentConfig(value: CookieConsentRoutingConfig | undefined): CookieConsentRoutingConfig;

package/dist/types/cookie_consent/require_config.test.d.ts

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