@c15t/react 2.2.0 → 3.0.0-alpha.0

package/dist-types/context.d.ts

@@ -0,0 +1,17 @@
+import type { AllConsentNames, ConsentKernel, ConsentPresentation } from '@c15t/core';
+/**
+ * React context carrying the kernel instance.
+ *
+ * v3 Provider puts a kernel here; hooks pull it out and subscribe via
+ * useSyncExternalStore. No state snapshot lives in context — only the
+ * kernel reference. Consumers subscribe to the kernel directly at their
+ * render site, so each hook isolates re-renders to exactly its slice.
+ */
+export declare const KernelContext: import("react").Context<ConsentKernel | null>;
+/** Provider-owned services used by optional integrations. */
+export interface ProviderServices {
+    clearRecords: () => void;
+    getPresentation: () => ConsentPresentation | undefined;
+    getConsentCategories: () => readonly AllConsentNames[];
+}
+export declare const ProviderServicesContext: import("react").Context<ProviderServices | null>;

package/dist-types/devtools.d.ts

@@ -0,0 +1,54 @@
+import type { DevToolsInstance, DevToolsOptions, DevToolsPosition, DevToolsTab } from '@c15t/dev-tools';
+import type { HTMLAttributes, ReactElement } from 'react';
+/** Props for the kernel-bound React DevTools adapter. */
+export interface ConsentDevToolsProps extends Omit<DevToolsOptions, 'container' | 'kernel'> {
+    /** Prevents the DevTools engine from mounting. @default false */
+    disabled?: boolean;
+}
+/** Backward-compatible props name for {@link ConsentDevTools}. */
+export type C15TDevToolsProps = ConsentDevToolsProps;
+/** Compatible props name for the {@link DevTools} alias. */
+export type DevToolsProps = ConsentDevToolsProps;
+/**
+ * Mounts the c15t DevTools engine for the nearest v3 consent provider.
+ *
+ * @param props - Presentation options passed to the DevTools engine.
+ * @returns `null`; the engine mounts its interface into `document.body`.
+ */
+export declare const ConsentDevTools: ({ disabled, clearRecords, getPresentation, defaultOpen, defaultTab, getConsentCategories, maxEvents, position, }: ConsentDevToolsProps) => null;
+/** Compatible short name for {@link ConsentDevTools}. */
+export declare const DevTools: typeof ConsentDevTools;
+/** Backward-compatible name for {@link ConsentDevTools}. */
+export declare const C15TDevTools: typeof ConsentDevTools;
+/** Props for the embedded c15t panel used by TanStack Devtools. */
+export interface C15tTanStackDevtoolsPanelProps extends HTMLAttributes<HTMLDivElement>, Pick<DevToolsOptions, 'defaultTab' | 'maxEvents' | 'getConsentCategories' | 'getPresentation' | 'clearRecords'> {
+    /** Prevents the embedded DevTools engine from mounting. @default false */
+    disabled?: boolean;
+}
+/** Plugin configuration accepted by React TanStack Devtools. */
+export interface TanStackDevtoolsPlugin {
+    id?: string;
+    name: string;
+    defaultOpen?: boolean;
+    render: ReactElement;
+}
+/** Options for {@link c15tDevtools}. */
+export interface C15tDevtoolsPluginOptions extends C15tTanStackDevtoolsPanelProps {
+    /** Stable plugin identifier. @default 'c15t' */
+    id?: string;
+    /** Display name shown by TanStack Devtools. @default 'c15t' */
+    name?: string;
+    /** Whether TanStack Devtools opens this plugin initially. @default false */
+    defaultOpen?: boolean;
+}
+/** Embeds c15t DevTools inside a TanStack Devtools plugin panel. */
+export declare const C15tTanStackDevtoolsPanel: import("react").ForwardRefExoticComponent<C15tTanStackDevtoolsPanelProps & import("react").RefAttributes<HTMLDivElement>>;
+/**
+ * Create a c15t plugin configuration for React TanStack Devtools.
+ * @param options - Plugin identity, initial state, and embedded panel options.
+ * @returns Plugin configuration whose panel binds to the nearest provider.
+ */
+export declare const c15tDevtools: (options?: C15tDevtoolsPluginOptions) => TanStackDevtoolsPlugin;
+/** Backward-compatible alias for {@link c15tDevtools}. */
+export declare const c15tDevtoolsPlugin: typeof c15tDevtools;
+export type { DevToolsInstance, DevToolsOptions, DevToolsPosition, DevToolsTab, };

package/dist-types/draft.d.ts

@@ -0,0 +1,31 @@
+import type { AllConsentNames, ConsentState, SaveResult, SaveInput } from '@c15t/core';
+import type { ReactNode } from 'react';
+/** A local, unmasked selection, committed only by an explicit save. */
+export interface ConsentDraftHandle {
+    values: Readonly<ConsentState>;
+    displayedCategories: readonly AllConsentNames[];
+    isDirty: boolean;
+    /** A material policy change requires reset and review before saving. */
+    isStale: boolean;
+    set: (category: AllConsentNames, value: boolean) => void;
+    update: (patch: Partial<ConsentState>) => void;
+    acceptAll: () => void;
+    rejectAll: () => void;
+    save: () => Promise<SaveResult>;
+    reset: () => void;
+}
+export interface ConsentDraftProviderProps {
+    children: ReactNode;
+    /** Defaults apply only to categories without an explicit receipt. */
+    initial?: Partial<ConsentState>;
+}
+export declare const ConsentDraftProvider: ({ children, initial, }: ConsentDraftProviderProps) => import("react").JSX.Element;
+/** Internal UI save path shared by stock controls and headless actions. */
+export declare const useConsentSaveAction: () => (input?: SaveInput) => Promise<SaveResult>;
+/** Keep the compatibility manager selection and its save on the same draft. */
+export declare const useConsentManagerDraft: () => {
+    draft: ConsentDraftHandle;
+    save: (input?: SaveInput) => Promise<SaveResult>;
+};
+/** Read and edit displayed choices without replacing masked effective permissions. */
+export declare const useConsentDraft: () => ConsentDraftHandle;

package/dist-types/external-iab-context.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The IAB bridge for an externally owned runtime.
+ *
+ * When a host creates the runtime itself — an Astro page, a SvelteKit
+ * layout — that runtime already mounted the CMP and owns its lifecycle.
+ * This provider republishes `runtime.iab` into React context instead of
+ * calling `createIAB()` a second time, which would install a second
+ * `__tcfapi` on the page.
+ *
+ * It deliberately imports nothing from `@c15t/iab`: the module is a peer of
+ * the runtime, not of the component tree, and a preference-centre chunk
+ * that pulled in the TCF encoder would cost every visitor bytes only an IAB
+ * site needs.
+ */
+import type { ConsentRuntime } from '@c15t/core/runtime';
+import type { ReactNode } from 'react';
+/** Props for {@link ExternalIABProvider}. */
+export interface ExternalIABProviderProps {
+    /** The runtime that owns the CMP. */
+    runtime: ConsentRuntime;
+    children: ReactNode;
+}
+/**
+ * Publish an externally owned runtime's CMP into React context.
+ *
+ * @param props - The owning runtime and the tree to render.
+ * @returns The children, wrapped in the IAB context.
+ */
+export declare const ExternalIABProvider: ({ runtime, children, }: ExternalIABProviderProps) => import("react").JSX.Element;

package/dist-types/frame.d.ts

@@ -0,0 +1 @@
+export * from './components/frame';

package/dist-types/headless.d.ts

@@ -1,10 +1,14 @@
-export { type ConsentManagerInterface, configureConsentManager, defaultTranslationConfig, detectBrowserLanguage, type EuropePolicyMode, mergeTranslationConfigs, type PolicyPackPresets, policyPackPresets, prepareTranslationConfig, } from 'c15t';
+/**
+ * `@c15t/react/headless` — hooks for building your own consent UI on the
+ * kernel, without the prebuilt components or their CSS.
+ *
+ * Pair with `ConsentProvider` from `@c15t/react` (or `@c15t/react/provider`).
+ */
+export { defaultTranslationConfig, detectBrowserLanguage, mergeTranslationConfigs, prepareTranslationConfig, } from '@c15t/core';
+export { type ConsentDialogTriggerVisibility, type UseConsentDialogTriggerOptions, type UseConsentDialogTriggerResult, useConsentDialogTrigger, } from './component-hooks/use-panel-trigger';
+export { useConsentManager } from './component-hooks/use-manager';
+export { type HeadlessConsentBannerAction, type HeadlessConsentBannerState, type HeadlessConsentDialogAction, type HeadlessConsentDialogState, type HeadlessConsentSurface, type HeadlessConsentSurfaceAction, type HeadlessConsentSurfaceState, type HeadlessConsentWriteAction, useHeadlessConsentUI, } from './component-hooks/use-headless-consent-ui';
+export { useTranslations } from './component-hooks/use-translations';
 export { useColorScheme } from './hooks/use-color-scheme';
-export { type ConsentDialogTriggerVisibility, type UseConsentDialogTriggerOptions, type UseConsentDialogTriggerResult, useConsentDialogTrigger, } from './hooks/use-consent-dialog-trigger';
-export { useConsentManager } from './hooks/use-consent-manager';
-export { ConsentScriptConflictError, type ConsentScriptReadyControls, type ConsentScriptStatus, type ConsentScriptUnmountBehavior, type UseConsentScriptOptions, type UseConsentScriptResult, useConsentScript, } from './hooks/use-consent-script';
 export { useFocusTrap } from './hooks/use-focus-trap';
-export { type HeadlessConsentBannerAction, type HeadlessConsentBannerState, type HeadlessConsentDialogAction, type HeadlessConsentDialogState, type HeadlessConsentSurface, type HeadlessConsentSurfaceAction, type HeadlessConsentSurfaceState, type HeadlessConsentWriteAction, type UseHeadlessConsentUIResult, useHeadlessConsentUI, } from './hooks/use-headless-consent-ui';
-export { useTranslations } from './hooks/use-translations';
-export { ConsentManagerProvider } from './providers/consent-manager-provider';
-export type { ConsentManagerOptions, ConsentManagerProviderProps, } from './types/consent-manager';
+export type { ReactUIOptions } from './types/manager';

package/dist-types/hooks/use-color-scheme.d.ts

@@ -3,4 +3,4 @@ export type ColorScheme = 'light' | 'dark' | 'system' | null;
  * Manage color scheme preferences for components.
  * React wrapper for `@c15t/ui` setupColorScheme.
  */
-export declare function useColorScheme(colorScheme?: ColorScheme): void;
+export declare const useColorScheme: (colorScheme?: ColorScheme) => void;

package/dist-types/hooks/use-component-config.d.ts

@@ -20,7 +20,7 @@ export type ResolvedComponentConfig = Required<ComponentConfig>;
  *
  * @remarks
  * Provides a consistent way to handle configuration props that can be set
- * globally via the ConsentManagerProvider or overridden locally on individual
+ * globally via the ConsentProvider or overridden locally on individual
  * components. Local values take precedence over global values.
  *
  * The configuration props are defined in UIOptions from @c15t/ui/theme,
@@ -51,4 +51,4 @@ export type ResolvedComponentConfig = Required<ComponentConfig>;
  *
  * @public
  */
-export declare function useComponentConfig(localOverrides?: ComponentConfig): ResolvedComponentConfig;
+export declare const useComponentConfig: (localOverrides?: ComponentConfig) => ResolvedComponentConfig;

package/dist-types/hooks/use-focus-trap.d.ts

@@ -1,4 +1,4 @@
-import { type RefObject } from 'react';
+import type { RefObject } from 'react';
 /**
  * Hook that manages focus trapping within a container.
  *
@@ -11,4 +11,4 @@ import { type RefObject } from 'react';
  *
  * @public
  */
-export declare function useFocusTrap(shouldTrap: boolean, containerRef: RefObject<HTMLElement | null> | null): void;
+export declare const useFocusTrap: (shouldTrap: boolean, containerRef: RefObject<HTMLElement | null> | null) => void;

package/dist-types/hooks/use-headless-iab-consent-ui.d.ts

@@ -1,7 +1,6 @@
-import { useConsentManager } from './use-consent-manager';
-export type HeadlessIABPreferenceTab = 'purposes' | 'vendors';
-export type HeadlessIABBannerAction = 'accept' | 'reject' | 'customize';
-export type HeadlessIABDialogAction = 'accept' | 'reject' | 'customize';
+import type { HeadlessIABBannerAction, HeadlessIABDialogAction, HeadlessIABPreferenceTab } from '@c15t/iab/headless';
+import { useIABConsentManager } from './use-iab-manager';
+export type { HeadlessIABBannerAction, HeadlessIABDialogAction, HeadlessIABPreferenceTab, };
 export interface HeadlessIABBannerState {
     isVisible: boolean;
     isReady: boolean;
@@ -17,9 +16,9 @@ export interface HeadlessIABDialogState {
     scrollLock?: boolean;
 }
 export interface UseHeadlessIABConsentUIResult {
-    activeUI: ReturnType<typeof useConsentManager>['activeUI'];
-    model: ReturnType<typeof useConsentManager>['model'];
-    iab: ReturnType<typeof useConsentManager>['iab'];
+    activeUI: ReturnType<typeof useIABConsentManager>['activeUI'];
+    model: ReturnType<typeof useIABConsentManager>['model'];
+    iab: ReturnType<typeof useIABConsentManager>['iab'];
     isIABEnabled: boolean;
     banner: HeadlessIABBannerState;
     dialog: HeadlessIABDialogState;
@@ -38,4 +37,4 @@ export interface UseHeadlessIABConsentUIResult {
     performBannerAction: (action: HeadlessIABBannerAction) => Promise<void> | void;
     performDialogAction: (action: HeadlessIABDialogAction) => Promise<void> | void;
 }
-export declare function useHeadlessIABConsentUI(): UseHeadlessIABConsentUIResult;
+export declare const useHeadlessIABConsentUI: () => UseHeadlessIABConsentUIResult;

package/dist-types/hooks/use-iab-manager.d.ts

@@ -0,0 +1,52 @@
+import type { ActiveUI, ConsentPresentation, TranslationConfig } from '@c15t/core';
+export declare const useIABConsentManager: (overrides?: ConsentPresentation) => {
+    activeUI: ActiveUI;
+    iab: import("../iab-context").ReactIABState | null;
+    model: import("@c15t/core").KernelModel | null;
+    policyBanner: {
+        allowedActions: import("@c15t/core").PresentationAction[];
+        requiredActions: import("@c15t/core").PresentationAction[];
+        equivalentActions: import("@c15t/core").PresentationAction[][];
+        orderedActions: import("@c15t/core").PresentationAction[];
+        actionGroups: import("@c15t/core").PresentationAction[][];
+        primaryActions: import("@c15t/core").PresentationAction[];
+        diagnostics: import("@c15t/core").PresentationDiagnostic[];
+        rights: readonly import("@c15t/schema/types").PolicyRight[];
+        preferenceControls: Exclude<import("@c15t/schema/types").PolicyRight, 'disclosure'>[];
+        direction: 'row' | 'column';
+        uiProfile: 'balanced' | 'compact' | 'strict';
+        scrollLock: boolean;
+        trapFocus: boolean;
+        shouldFillActions: boolean;
+        variant: import("@c15t/core").PromptVariant;
+        position: import("@c15t/core").PromptPosition;
+        positionSource: 'host' | 'default';
+        blocking: boolean;
+        isVisible: boolean;
+    };
+    policyDialog: {
+        allowedActions: import("@c15t/core").PresentationAction[];
+        requiredActions: import("@c15t/core").PresentationAction[];
+        equivalentActions: import("@c15t/core").PresentationAction[][];
+        orderedActions: import("@c15t/core").PresentationAction[];
+        actionGroups: import("@c15t/core").PresentationAction[][];
+        primaryActions: import("@c15t/core").PresentationAction[];
+        diagnostics: import("@c15t/core").PresentationDiagnostic[];
+        rights: readonly import("@c15t/schema/types").PolicyRight[];
+        preferenceControls: Exclude<import("@c15t/schema/types").PolicyRight, 'disclosure'>[];
+        direction: 'row' | 'column';
+        uiProfile: 'balanced' | 'compact' | 'strict';
+        scrollLock: boolean;
+        trapFocus: boolean;
+        shouldFillActions: boolean;
+        variant: import("@c15t/core").PromptVariant;
+        position: import("@c15t/core").PromptPosition;
+        positionSource: 'host' | 'default';
+        blocking: boolean;
+        isVisible: boolean;
+    };
+    setActiveUI: (ui: ActiveUI, _options?: {
+        force?: boolean;
+    }) => void;
+    translationConfig: TranslationConfig;
+};

package/dist-types/hooks/use-is-hydrated.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns true after the component has hydrated on the client.
+ *
+ * @returns Whether the current render is client-hydrated.
+ *
+ * @internal
+ */
+export declare const useIsHydrated: () => boolean;

package/dist-types/hooks/use-reduced-motion.d.ts

@@ -27,4 +27,4 @@
  *
  * @public
  */
-export declare function useReducedMotion(): boolean;
+export declare const useReducedMotion: () => boolean;

package/dist-types/hooks/use-scroll-lock.d.ts

@@ -2,4 +2,4 @@
  * Hook to manage document scroll locking.
  * React wrapper for `@c15t/ui` setupScrollLock.
  */
-export declare function useScrollLock(shouldLock: boolean): void;
+export declare const useScrollLock: (shouldLock: boolean) => void;

package/dist-types/hooks/use-text-direction.d.ts

@@ -2,4 +2,4 @@
  * Manage text direction based on the language.
  * React wrapper for `@c15t/ui` text direction utilities.
  */
-export declare function useTextDirection(language?: string): "ltr" | "rtl";
+export declare const useTextDirection: (language?: string) => "ltr" | "rtl";

package/dist-types/hooks/use-theme.d.ts

@@ -1 +1,2 @@
-export declare const useTheme: () => import("../context/theme-context").ThemeContextValue;
+import type { ThemeContextValue } from '../context/theme-context';
+export declare const useTheme: () => ThemeContextValue;

package/dist-types/hooks.d.ts

@@ -0,0 +1,148 @@
+/**
+ * v3 React hooks.
+ *
+ * Every selector hook uses `useSyncExternalStore` to subscribe to the
+ * kernel. Hydration reads the immutable server snapshot. After hydration,
+ * consumers read live state, including browser-only privacy signals.
+ *
+ * The selectors follow the "useSyncExternalStore with selector" pattern:
+ * subscribe to all kernel changes, but narrow the returned value to the
+ * slice we care about. React only schedules a re-render if the slice
+ * `Object.is`-differs. A child reading `useConsent('marketing')` does
+ * not re-render when `useConsent('measurement')` flips elsewhere.
+ *
+ * Action hooks return stable references (the kernel's own methods).
+ * Consumers do not need `useCallback`. Under React Compiler this is
+ * safe because actions don't produce values — they cause state changes
+ * observed through the selector hooks, whose subscription model handles
+ * invalidation correctly.
+ */
+import type { AllConsentNames, ConsentKernel, PromptPresentation, PreferencesPresentation, ConsentSnapshot, ConsentState, KernelActiveUI, KernelBranding, KernelIABState, KernelModel, KernelOverrides, KernelTranslations, KernelUser, LocationResponse, PolicyScopeMode } from '@c15t/core';
+/**
+ * Full snapshot accessor. Escape hatch for consumers that genuinely need
+ * multiple slices. Prefer narrow hooks for re-render isolation.
+ */
+export declare const useSnapshot: () => ConsentSnapshot;
+/**
+ * Effective permission for one category. This can be true under an opt-out
+ * policy without an explicit grant. Re-renders only when that permission changes.
+ */
+export declare const useConsent: (category: AllConsentNames) => boolean;
+/**
+ * Effective permissions for all categories. Use `useExplicitChoice` for recorded
+ * choices. Re-renders when permissions change.
+ */
+export declare const useConsents: () => Readonly<ConsentState>;
+/**
+ * Current overrides (country, region, language, GPC).
+ */
+export declare const useOverrides: () => Readonly<KernelOverrides>;
+/**
+ * Identified user or null.
+ */
+export declare const useUser: () => Readonly<KernelUser> | null;
+/** Geographic context reported by the backend. */
+export declare const useLocation: () => Readonly<LocationResponse> | null;
+/** Active translation bundle. */
+export declare const useTranslations: () => Readonly<KernelTranslations> | null;
+/** Active branding identifier. */
+export declare const useBranding: () => KernelBranding | null;
+/**
+ * Whether the kernel holds a resolved policy rule.
+ *
+ * `false` while resolution is unconfigured, failed, or matched nothing, and
+ * while a pending init has not answered yet. Without a policy there is
+ * nothing to consent to, so every prebuilt consent surface renders nothing;
+ * headless hosts should do the same.
+ */
+export declare const useHasConsentPolicy: () => boolean;
+/**
+ * Whether any prebuilt consent surface has something to show: a policy rule
+ * is resolved and it either owes a first-layer prompt or keeps a right
+ * reachable. A `none` rule without rights owes nothing, so every surface
+ * renders nothing; give it `rights: ['preferences']` to keep a settings
+ * route. Every other model always carries rights, so for them this equals
+ * {@link useHasConsentPolicy}.
+ */
+export declare const useHasConsentUI: () => boolean;
+/**
+ * Derived consent model (opt-in / opt-out / iab), or `null` while no policy
+ * rule is resolved. The kernel keeps a safe fallback rule internally; this
+ * hook hides it so hosts can key "no consent UI" on `null`.
+ */
+export declare const useModel: () => KernelModel | null;
+/** Which UI surface to render (none / banner / dialog). */
+export declare const useActiveUI: () => KernelActiveUI;
+/** Category allowlist from `policy.consent.categories`. */
+export declare const usePolicyCategories: () => readonly AllConsentNames[];
+/** `strict` or `permissive` — from `policy.consent.scopeMode`. */
+export declare const usePolicyScopeMode: () => PolicyScopeMode;
+/** Full IAB state slice (null when IAB is not enabled). */
+export declare const useIABSnapshot: () => Readonly<KernelIABState> | null;
+/** Is IAB active? */
+export declare const useIABEnabled: () => boolean;
+/** Consent for a specific IAB vendor. Accepts numeric or string IDs; IAB
+ * vendors are numeric but the kernel stores them as strings for
+ * uniformity with custom vendors. */
+export declare const useVendorConsent: (vendorId: string | number) => boolean;
+/** Consent for a specific IAB purpose (1–11). */
+export declare const usePurposeConsent: (purposeId: number) => boolean;
+/** Opt-in for a special feature (1 = geolocation, 2 = device ID). */
+export declare const useSpecialFeatureOptIn: (featureId: number) => boolean;
+/** Latest TCF string. `null` until the IAB module encodes one. */
+export declare const useTCString: () => string | null;
+/**
+ * Sync mutation: apply overrides (country, region, language, GPC).
+ */
+export declare const useSetOverrides: () => (input: KernelOverrides) => void;
+/**
+ * Sync mutation: switch active language.
+ */
+export declare const useSetLanguage: () => (code: string) => void;
+/**
+ * Sync mutation: set the active UI surface (banner/dialog/none).
+ */
+export declare const useSetActiveUI: () => (ui: KernelActiveUI) => void;
+/**
+ * Async command: persist current or given consents. Returns the kernel's
+ * own save() method so identity is stable across renders.
+ */
+export declare const useSaveConsents: () => ConsentKernel['commands']['save'];
+/**
+ * Subscribe to consent changes. The callback receives the full consent record
+ * whenever the kernel emits a snapshot.
+ */
+export declare const useSubscribeToConsentChanges: () => (listener: (state: ConsentState) => void) => () => void;
+/**
+ * Async command: identify a user.
+ */
+export declare const useIdentify: () => ConsentKernel['commands']['identify'];
+/**
+ * Async command: run the init transport (currently a no-op in the kernel;
+ * boot modules wire in SSR hydration, prefetch, banner fetch).
+ */
+export declare const useInit: () => ConsentKernel['commands']['init'];
+/** Read explicitChoice from the kernel without a competing projection. */
+export declare const useExplicitChoice: () => ConsentSnapshot['explicitChoice'];
+/** Read effectivePermissions from the kernel without a competing projection. */
+export declare const useEffectivePermissions: () => ConsentSnapshot['effectivePermissions'];
+/** Read promptRequirement from the kernel without a competing projection. */
+export declare const usePromptRequirement: () => ConsentSnapshot['promptRequirement'];
+/** Read noticeDismissal from the kernel without a competing projection. */
+export declare const useNoticeDismissal: () => ConsentSnapshot['noticeDismissal'];
+/** Read privacySignals from the kernel without a competing projection. */
+export declare const usePrivacySignals: () => ConsentSnapshot['privacySignals'];
+/** Read optOutDirectives from the kernel without a competing projection. */
+export declare const useOptOutDirectives: () => ConsentSnapshot['optOutDirectives'];
+/** Read resolution from the kernel without a competing projection. */
+export declare const usePolicyResolution: () => ConsentSnapshot['resolution'];
+/** Read policyRule from the kernel without a competing projection. */
+export declare const usePolicyRule: () => ConsentSnapshot['policyRule'];
+/** Read restrictions from the kernel without a competing projection. */
+export declare const useRestrictions: () => ConsentSnapshot['restrictions'];
+/** Dismiss the current local notice without recording a category choice. */
+export declare const useDismissNotice: () => ConsentKernel['commands']['dismissNotice'];
+/** Host first-layer presentation. */
+export declare const usePromptPresentation: () => PromptPresentation;
+/** Host persistent preferences presentation. */
+export declare const usePreferencesPresentation: () => PreferencesPresentation;

package/dist-types/iab-context.d.ts

@@ -0,0 +1,28 @@
+import type { GlobalVendorList, KernelIABState, NonIABVendor } from '@c15t/core';
+import type { CreateIABOptions, IABHandle } from '@c15t/iab';
+import type { ReactNode } from 'react';
+export interface ReactIABState extends KernelIABState {
+    config: {
+        enabled: boolean;
+        cmpId: number | null;
+    };
+    isLoadingGVL: boolean;
+    nonIABVendors: NonIABVendor[];
+    preferenceCenterTab: 'purposes' | 'vendors';
+    setPreferenceCenterTab: (tab: 'purposes' | 'vendors') => void;
+    setVendorConsent: (vendorId: string | number, value: boolean) => void;
+    setVendorLegitimateInterest: (vendorId: string | number, value: boolean) => void;
+    setPurposeConsent: (purposeId: number, value: boolean) => void;
+    setPurposeLegitimateInterest: (purposeId: number, value: boolean) => void;
+    setSpecialFeatureOptIn: (featureId: number, value: boolean) => void;
+    acceptAll: () => void;
+    rejectAll: () => void;
+    save: () => Promise<void>;
+}
+export interface IABProviderProps extends Omit<CreateIABOptions, 'kernel' | 'gvl'> {
+    children: ReactNode;
+    gvl?: GlobalVendorList | null;
+}
+export declare const IABProvider: ({ children, ...options }: IABProviderProps) => import("react").JSX.Element;
+export declare const useIAB: () => ReactIABState | null;
+export type { CreateIABOptions, IABHandle };

package/dist-types/iab.d.ts

@@ -8,17 +8,23 @@
  *
  * @example
  * ```tsx
- * import { iab } from '@c15t/iab';
- * import { IABConsentBanner, IABConsentDialog } from '@c15t/react/iab';
+ * import { ConsentProvider, hosted } from '@c15t/react';
+ * import { IABProvider, IABConsentBanner, IABConsentDialog } from '@c15t/react/iab';
  *
- * <ConsentManagerProvider options={{ mode: 'hosted', iab: iab({ cmpId: 28 }) }}>
- *   <IABConsentBanner />
- *   <IABConsentDialog />
- * </ConsentManagerProvider>
+ * <ConsentProvider
+ *   options={{ mode: hosted({ url: '/api/c15t' }) }}
+ * >
+ *   <IABProvider cmpId={28}>
+ *     <IABConsentBanner />
+ *     <IABConsentDialog />
+ *   </IABProvider>
+ * </ConsentProvider>
  * ```
  *
  * @packageDocumentation
  */
-export { IABConsentBanner, type IABConsentBannerProps, } from './components/iab-consent-banner';
-export { IABConsentDialog, type IABConsentDialogProps, } from './components/iab-consent-dialog';
+export { IABConsentBanner, type IABConsentBannerProps, } from './components/iab-prompt';
+export { IABConsentDialog, type IABConsentDialogProps, } from './components/iab-panel';
 export { type HeadlessIABBannerAction, type HeadlessIABBannerState, type HeadlessIABDialogAction, type HeadlessIABDialogState, type HeadlessIABPreferenceTab, type UseHeadlessIABConsentUIResult, useHeadlessIABConsentUI, } from './hooks/use-headless-iab-consent-ui';
+export { IABProvider } from './iab-context';
+export type { IABProviderProps } from './iab-context';

package/dist-types/index.d.ts

@@ -1,22 +1,61 @@
-export type { AllConsentNames, ConsentManagerInterface, ConsentStoreState, ConsentType, EuropePolicyMode, Overrides, PolicyPackPresets, Translations, } from 'c15t';
-export { configureConsentManager, defaultTranslationConfig, detectBrowserLanguage, mergeTranslationConfigs, policyPackPresets, prepareTranslationConfig, } from 'c15t';
-export { ConsentBanner, type ConsentBannerProps, } from './components/consent-banner';
-export * from './components/consent-banner/components';
-export { ConsentDialog, type ConsentDialogProps, } from './components/consent-dialog';
-export { ConsentDialogLink, type ConsentDialogLinkProps, } from './components/consent-dialog-link';
-export { ConsentDialogTrigger, type ConsentDialogTriggerCompound, type ConsentDialogTriggerProps, ConsentDialogTriggerToolbar, type ConsentDialogTriggerToolbarAction, type ConsentDialogTriggerToolbarPreferences, type ConsentDialogTriggerToolbarProps, TriggerButton, type TriggerButtonProps, TriggerIcon, type TriggerIconProps, type TriggerIconType, type TriggerOrientation, TriggerRoot, type TriggerRootProps, type TriggerSize, TriggerText, type TriggerTextProps, type TriggerVisibility, type UseDraggableOptions, type UseDraggableReturn, useDraggable, useTriggerContext, } from './components/consent-dialog-trigger';
-export { ConsentWidget, type ConsentWidgetProps, } from './components/consent-widget';
-export { Frame, type FrameProps } from './components/frame';
-export { GoogleMap, type GoogleMapCoordinates, type GoogleMapInstance, type GoogleMapOptions, type GoogleMapProps, type GoogleMapsApi, type GoogleMapsLibrary, YouTubeEmbed, type YouTubeEmbedParams, type YouTubeEmbedProps, type YouTubeSrcSource, type YouTubeVideoIdSource, } from './components/integrations';
-export { ConsentButton } from './components/shared/primitives/button';
-export { useColorScheme } from './hooks/use-color-scheme';
-export { type ConsentDialogTriggerVisibility, type UseConsentDialogTriggerOptions, type UseConsentDialogTriggerResult, useConsentDialogTrigger, } from './hooks/use-consent-dialog-trigger';
-export { useConsentManager } from './hooks/use-consent-manager';
-export { ConsentScriptConflictError, type ConsentScriptReadyControls, type ConsentScriptStatus, type ConsentScriptUnmountBehavior, type UseConsentScriptOptions, type UseConsentScriptResult, useConsentScript, } from './hooks/use-consent-script';
-export { useFocusTrap } from './hooks/use-focus-trap';
-export { type HeadlessConsentBannerAction, type HeadlessConsentBannerState, type HeadlessConsentDialogAction, type HeadlessConsentDialogState, type HeadlessConsentSurface, type HeadlessConsentSurfaceAction, type HeadlessConsentSurfaceState, type HeadlessConsentWriteAction, type UseHeadlessConsentUIResult, useHeadlessConsentUI, } from './hooks/use-headless-consent-ui';
-export { useSSRStatus } from './hooks/use-ssr-status';
-export { useTranslations } from './hooks/use-translations';
-export { ConsentManagerProvider } from './providers/consent-manager-provider';
-export type { ConsentManagerOptions, ConsentManagerProviderProps, } from './types/consent-manager';
-export type { ColorTokens, ComponentSlots, MotionTokens, RadiusTokens, ShadowTokens, SlotStyle, SpacingTokens, Theme, TypographyTokens, } from './types/theme';
+/**
+ * `@c15t/react` — React adapter for the c15t consent kernel.
+ *
+ * Pattern:
+ *   import {
+ *     ConsentProvider,
+ *     hosted,
+ *     useConsent,
+ *     useSaveConsents,
+ *   } from '@c15t/react';
+ *
+ *   function App({ children }) {
+ *     return (
+ *       <ConsentProvider options={{ mode: hosted({ url: '/api/c15t' }) }}>
+ *         {children}
+ *       </ConsentProvider>
+ *     );
+ *   }
+ *
+ *   function MarketingScripts() {
+ *     const allowed = useConsent('marketing');
+ *     return allowed ? <GoogleTagManager /> : null;
+ *   }
+ *
+ * Design notes:
+ * - Selector hooks subscribe via `useSyncExternalStore` so re-renders
+ *   stay scoped to the exact slice each hook reads.
+ * - Action hooks return stable kernel methods — no `useCallback` dance
+ *   required at the consumer site.
+ * - No provider-level useEffect syncing state into React state. No
+ *   cache patching. No method rewriting. Provider boot work is explicit
+ *   module wiring around a single per-mount kernel.
+ */
+export type { ConsentKernel, ConsentSnapshot, ConsentState, HostedTransportOptions, InitContext, InitResponse, InitResult, KernelConfig, KernelEvent, KernelOverrides, KernelTransport, KernelUser, Listener, HostedModeOptions, ProviderTransportContext, ProviderTransportFactory, ProviderTransportKind, SavePayload, SaveResult, Unsubscribe, } from '@c15t/core';
+export { createConsentKernel, custom, hosted } from '@c15t/core';
+export type { OfflineModeOptions } from './transports/offline';
+export { offline } from './transports/offline';
+export { ConsentDialog, ConsentWidget } from './aggregate-components';
+export type { ConsentBannerButton, ConsentBannerLayout, ConsentBannerProps, ConsentBannerRight, ConsentBannerRightLinkProps, ConsentBannerRightsProps, ConsentBannerSurface, } from './components/prompt';
+export { ConsentBanner, type ConsentBannerCompoundComponent, useConsentBannerSurface, } from './components/prompt';
+export type { ConsentDialogCompoundComponent, ConsentDialogProps, } from './components/panel';
+export type { ConsentDialogLinkProps } from './components/panel-link';
+export { ConsentDialogLink } from './components/panel-link';
+export type { ConsentDialogTriggerProps, ConsentDialogTriggerToolbarAction, ConsentDialogTriggerToolbarPreferences, ConsentDialogTriggerToolbarProps, TriggerOrientation, } from './components/panel-trigger';
+export { ConsentDialogTrigger, ConsentDialogTriggerToolbar, } from './components/panel-trigger';
+export type { ConsentWidgetCompoundComponent, ConsentWidgetProps, } from './components/preferences';
+export type { FrameProps } from './components/frame';
+export { Frame } from './components/frame';
+export type { ConsentDraftHandle, ConsentDraftProviderProps } from './draft';
+export { ConsentDraftProvider, useConsentDraft } from './draft';
+export { useConsentManager } from './component-hooks/use-manager';
+export { useTranslations } from './component-hooks/use-translations';
+export { useActiveUI, useBranding, useConsent, useConsents, useHasConsentPolicy, useHasConsentUI, useIABEnabled, useIABSnapshot, useIdentify, useInit, useLocation, useModel, useOverrides, usePromptPresentation, usePolicyCategories, usePreferencesPresentation, usePolicyScopeMode, usePurposeConsent, useSaveConsents, useSetActiveUI, useSetLanguage, useSetOverrides, useSnapshot, useSpecialFeatureOptIn, useTCString, useUser, useVendorConsent, } from './hooks';
+export type { UseIframeBlockerOptions, UseNetworkBlockerOptions, UsePersistenceOptions, UseScriptLoaderOptions, } from './module-hooks';
+export { useIframeBlocker, useNetworkBlocker, usePersistence, useScriptLoader, } from './module-hooks';
+export type { ConsentProviderOptions, ConsentProviderCallbacks, ConsentProviderPrefetch, ConsentProviderProps, ExternalRuntimeProviderOptions, ExternalRuntimeProviderProps, OwnedRuntimeProviderProps, } from './provider';
+export { ConsentProvider } from './provider';
+export type { ReactUIOptions } from './types/manager';
+export { defineTheme, type Theme } from './types/theme';
+export { useExplicitChoice, useEffectivePermissions, usePromptRequirement, useNoticeDismissal, usePrivacySignals, useOptOutDirectives, usePolicyResolution, usePolicyRule, useRestrictions, useDismissNotice, } from './hooks';
+export type { ConsentPresentation, PromptPresentation, PreferencesPresentation, PresentationAction, PromptPosition, PromptVariant, ResolvedConsentPresentation, } from '@c15t/core';

package/dist-types/module-hooks/iframe-blocker.d.ts

@@ -0,0 +1,6 @@
+import type { IframeBlockerHandle } from '@c15t/core/modules/iframe-blocker';
+export interface UseIframeBlockerOptions {
+    disableAutomaticBlocking?: boolean;
+}
+export declare const useIframeBlocker: (options?: UseIframeBlockerOptions) => IframeBlockerHandle;
+export type { IframeBlockerHandle };