@yenio-pld/blocks 0.0.0-stage → 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,859 @@
+import * as React from 'react';
+import { FormEvent, KeyboardEvent, RefObject, CSSProperties, ReactNode, ComponentProps, ImgHTMLAttributes, SyntheticEvent } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+export { AvatarColors, avatarFallbackStyle, getAvatarColors, getInitials } from './avatar.js';
+import { CookieConsentValue } from './consent.js';
+export { COOKIE_CONSENT_MAX_AGE, COOKIE_CONSENT_NAME, COOKIE_CONSENT_VALUES, WriteCookieConsentOptions, cookieConsentAllowsReplay, cookieDomainFromHostname, isCookieConsentValue, isEmbeddedWindow, parseCookieConsent, readCookieConsent, serializeCookieConsent, writeCookieConsent } from './consent.js';
+export { THEME_INIT_SCRIPT, THEME_INIT_SCRIPT_ID, THEME_STORAGE_KEY } from './theme-init.js';
+
+/**
+ * Blocks Context Interfaces
+ *
+ * These interfaces define the contract that consuming apps must implement
+ * to provide context to blocks components. Components will automatically
+ * consume these contexts when available, falling back to props otherwise.
+ */
+/**
+ * Language definition for the language switcher.
+ */
+interface BlocksLanguage {
+    code: string;
+    name: string;
+    flag?: string;
+}
+/**
+ * Language context value interface.
+ * Consuming apps implement this interface to provide language state
+ * and actions to blocks components.
+ */
+interface LanguageContextValue {
+    /** Current language code (e.g., "en", "es") */
+    language: string;
+    /** Function to change the language */
+    setLanguage: (lang: string) => void;
+    /** Available languages (optional, components have defaults) */
+    languages?: BlocksLanguage[];
+}
+/**
+ * React context for language.
+ * Blocks components will consume this context when available.
+ */
+declare const LanguageContext: React.Context<LanguageContextValue | null>;
+/**
+ * Hook to consume the language context.
+ * Returns null if no provider is present (components should fall back to props).
+ */
+declare function useLanguageContext(): LanguageContextValue | null;
+
+declare function LoadingState({ label, className, }: {
+    label?: string;
+    className?: string;
+}): React.JSX.Element;
+declare function ErrorState({ title, description, action, className, }: {
+    title?: string;
+    description?: string;
+    action?: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;
+/** Accept any icon component with a className prop — avoids LucideIcon
+ * version skew between blocks peers and consuming apps. */
+type EmptyStateIcon = React.ComponentType<{
+    className?: string;
+    "aria-hidden"?: boolean | "true" | "false";
+}>;
+type EmptyStateProps = {
+    title: string;
+    description?: string;
+    action?: React.ReactNode;
+    icon?: EmptyStateIcon;
+    variant?: "default" | "compact";
+    className?: string;
+};
+declare function EmptyState({ title, description, action, icon: Icon, variant, className, }: EmptyStateProps): React.JSX.Element;
+
+declare function Empty({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function EmptyHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function EmptyMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>): React.JSX.Element;
+declare function EmptyTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function EmptyDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+declare function EmptyContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+type ConfirmDestructiveDialogProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    onConfirm: () => void;
+};
+/**
+ * Shared confirm step for destructive actions (delete, mute, etc.).
+ * Prefer this over window.confirm so focus stays in the app and copy is clear.
+ */
+declare function ConfirmDestructiveDialog({ open, onOpenChange, title, description, confirmLabel, cancelLabel, onConfirm, }: ConfirmDestructiveDialogProps): React.JSX.Element;
+
+type NotificationBellItem = {
+    id: string;
+    title: string;
+    message: string;
+    read: boolean;
+    createdAt: string;
+    href?: string | null;
+};
+type NotificationBellLabels = {
+    title: string;
+    empty: string;
+    viewAll: string;
+};
+declare const DEFAULT_NOTIFICATION_BELL_LABELS: NotificationBellLabels;
+type NotificationBellProps = {
+    items: NotificationBellItem[];
+    unreadCount: number;
+    isLoading?: boolean;
+    labels?: Partial<NotificationBellLabels>;
+    viewAllHref: string;
+    formatTime?: (iso: string) => string;
+    onOpenChange?: (open: boolean) => void;
+    align?: "start" | "end";
+    className?: string;
+};
+declare function NotificationBell({ items, unreadCount, isLoading, labels: labelOverrides, viewAllHref, formatTime, onOpenChange, align, className, }: NotificationBellProps): React.JSX.Element;
+
+type EditableSectionMode = "reading" | "editing" | "saving";
+type EditableSectionLabels = {
+    /** Visible Edit button label. Default: "Edit" */
+    edit?: string;
+    /** Visible Save button label. Default: "Save" */
+    save?: string;
+    /** Visible Save button label while pending. Default: "Saving…" */
+    saving?: string;
+    /** Visible Cancel button label. Default: "Cancel" */
+    cancel?: string;
+    /** Polite live-region message after a successful save. Default: "Saved" */
+    saved?: string;
+    /** ConfirmDestructiveDialog title when discarding dirty edits. */
+    discardTitle?: string;
+    /** ConfirmDestructiveDialog description when discarding dirty edits. */
+    discardDescription?: string;
+    /** ConfirmDestructiveDialog confirm label. Default: "Discard" */
+    discardConfirm?: string;
+    /** ConfirmDestructiveDialog cancel label. Default: "Keep editing" */
+    discardCancel?: string;
+};
+declare const DEFAULT_EDITABLE_SECTION_LABELS: {
+    readonly edit: "Edit";
+    readonly save: "Save";
+    readonly saving: "Saving…";
+    readonly cancel: "Cancel";
+    readonly saved: "Saved";
+    readonly discardTitle: "Discard changes?";
+    readonly discardDescription: "If you leave now, unsaved changes will be lost.";
+    readonly discardConfirm: "Discard";
+    readonly discardCancel: "Keep editing";
+};
+
+type UseEditableSectionOptions = {
+    onSave: () => Promise<void> | void;
+    /** Called when edit mode exits without saving (Cancel / Escape / discard confirm). */
+    onDiscard?: () => void;
+    /** Whether the in-progress edit has unsaved changes. Defaults to false. */
+    isDirty?: boolean;
+    /** Id of an existing heading that names this section (preferred). */
+    labelledBy?: string;
+    /** Fallback accessible name when there is no visible heading. */
+    title?: string;
+    labels?: EditableSectionLabels;
+    /**
+     * After the first edit entry, keep `min-height` at the tallest measured
+     * content height so later toggles do not shift. First toggle may still shift.
+     */
+    stableHeight?: boolean;
+};
+type UseEditableSectionResult = {
+    mode: EditableSectionMode;
+    isEditing: boolean;
+    isSaving: boolean;
+    startEdit: () => void;
+    requestCancel: () => void;
+    formProps: {
+        onSubmit: (event: FormEvent<HTMLFormElement>) => void;
+        onKeyDown: (event: KeyboardEvent<HTMLFormElement>) => void;
+        noValidate: true;
+    };
+    contentRef: RefObject<HTMLElement | null>;
+    editButtonRef: RefObject<HTMLButtonElement | null>;
+    /** Form id for associating external submit buttons via the HTML `form` attribute. */
+    contentFormId: string;
+    editButtonProps: {
+        type: "button";
+        id: string;
+        onClick: () => void;
+        ref: RefObject<HTMLButtonElement | null>;
+        "aria-labelledby"?: string;
+        "aria-label"?: string;
+    };
+    saveButtonProps: {
+        type: "submit";
+        disabled: boolean;
+    };
+    cancelButtonProps: {
+        type: "button";
+        onClick: () => void;
+        disabled: boolean;
+    };
+    status: string | null;
+    statusProps: {
+        role: "status";
+        "aria-live": "polite";
+        className: string;
+    };
+    confirmDiscard: {
+        open: boolean;
+        onOpenChange: (open: boolean) => void;
+        title: string;
+        description: string;
+        confirmLabel: string;
+        cancelLabel: string;
+        onConfirm: () => void;
+    };
+    resolvedLabels: Required<EditableSectionLabels>;
+    contentStyle: CSSProperties | undefined;
+    actionsClassName: string;
+};
+declare function useEditableSection({ onSave, onDiscard, isDirty, labelledBy, title, labels, stableHeight, }: UseEditableSectionOptions): UseEditableSectionResult;
+
+type EditableSectionSlots = {
+    actions: ReactNode;
+    content: ReactNode;
+    status: ReactNode;
+    mode: UseEditableSectionResult["mode"];
+    isSaving: boolean;
+    isEditing: boolean;
+};
+type EditableSectionProps = UseEditableSectionOptions & {
+    readView: () => ReactNode;
+    editView: () => ReactNode;
+    className?: string;
+    /**
+     * Compose chrome yourself (Card, dialog, page header, …). Receives the
+     * stable actions node, the read/edit content, and the live status region.
+     * When omitted, actions render above content with no surrounding chrome.
+     */
+    children?: (slots: EditableSectionSlots) => ReactNode;
+};
+/**
+ * Chrome-free read-first section: semantic text by default, real `<form>` on
+ * Edit, pending Save until `onSave` resolves, and ConfirmDestructiveDialog
+ * when Cancel/Escape would discard dirty edits.
+ *
+ * Does not render a Card — place `actions` wherever your layout needs them.
+ */
+declare function EditableSection({ readView, editView, children, className, ...options }: EditableSectionProps): React.JSX.Element;
+
+/**
+ * Read-mode description list. Column grid and label placement match the
+ * typical edit-form field stack (`flex flex-col gap-1.5` + `text-sm` label)
+ * so labels and values keep the same x-position across modes.
+ */
+type DataListProps = ComponentProps<"dl">;
+declare function DataList({ className, ...props }: DataListProps): React.JSX.Element;
+type DataListItemProps = {
+    label: ReactNode;
+    children?: ReactNode;
+    /** Shown when `children` is nullish or an empty string. Default: "—" */
+    empty?: ReactNode;
+    className?: string;
+    labelClassName?: string;
+    valueClassName?: string;
+};
+declare function DataListItem({ label, children, empty, className, labelClassName, valueClassName, }: DataListItemProps): React.JSX.Element;
+
+type FieldMessageProps = Omit<ComponentProps<"p">, "children"> & {
+    children?: ReactNode;
+    /**
+     * Id referenced by the field's `aria-describedby`. Required when the
+     * message is shown so assistive tech can associate it with the control.
+     */
+    id?: string;
+};
+/**
+ * Reserved slot for field-level validation copy. Always occupies `min-h-5`
+ * so async errors do not shift fields under the pointer (CLS outside the
+ * 500ms input exclusion window).
+ */
+declare function FieldMessage({ id, children, className, ...props }: FieldMessageProps): React.JSX.Element;
+
+type SafeImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, "src" | "onError"> & {
+    src?: string | null;
+    /** Rendered when `src` is missing/empty or the image fails to load. */
+    fallback: ReactNode;
+    onError?: (event: SyntheticEvent<HTMLImageElement>) => void;
+};
+/**
+ * `<img>` that swaps to `fallback` when the source is missing or fails to load,
+ * so the browser never shows its default broken-image glyph.
+ */
+declare function SafeImage({ src, fallback, alt, onError, ...imgProps }: SafeImageProps): React.JSX.Element;
+
+type ThemeSwitcherLabels = {
+    /** Accessible name for the theme trigger */
+    theme?: string;
+    /** Label for "System" option */
+    system?: string;
+    /** Label for "Light" option */
+    light?: string;
+    /** Label for "Dark" option */
+    dark?: string;
+};
+type ThemeSwitcherProps = {
+    className?: string;
+    /** Size of the trigger */
+    size?: "sm" | "md" | "lg";
+    /** Shape of the trigger */
+    shape?: "rounded" | "pill";
+    /**
+     * Kept for existing callers. Both variants render the stored theme's icon
+     * (sun, moon, or monitor) and open the system / light / dark menu.
+     */
+    variant?: "default" | "mini";
+    /** Dropdown alignment */
+    align?: "start" | "center" | "end";
+    /** Dropdown side */
+    side?: "top" | "bottom" | "left" | "right";
+    /** @deprecated No longer used; the trigger no longer renders a tooltip. */
+    tooltipSide?: "top" | "right" | "bottom" | "left";
+    /** @deprecated No longer used; the trigger no longer renders a tooltip. */
+    tooltipAlign?: "start" | "center" | "end";
+    /** @deprecated No longer used; the trigger no longer renders a tooltip. */
+    tooltipSideOffset?: number;
+    /** Translation labels - consumers can pass their own t() values */
+    labels?: ThemeSwitcherLabels;
+};
+declare function ThemeSwitcher({ className, size, shape, align, side, labels: userLabels, }: ThemeSwitcherProps): React.JSX.Element;
+
+type Language = {
+    /** Language key/code (e.g., "en", "es") */
+    key: string;
+    /** Short label kept for callers that still pass segmented copy */
+    label: string;
+    /** Full native name for the menu (e.g., "English", "Español") */
+    nativeName: string;
+};
+type LanguageSwitcherLabels = {
+    /** Accessible name for the language trigger */
+    language?: string;
+};
+/**
+ * Default languages when none are provided via props or context.
+ */
+declare const defaultLanguages: Language[];
+type LanguageSwitcherProps = {
+    /**
+     * Available languages. Optional if using LanguageContext.
+     * When context is available, context.languages is used; props override context.
+     * Falls back to defaultLanguages if neither provided.
+     */
+    languages?: Language[];
+    /**
+     * Current selected language key. Optional if using LanguageContext.
+     * When context is available, context.language is used; props override context.
+     */
+    currentLanguage?: string;
+    /**
+     * Callback when language changes. Optional if using LanguageContext.
+     * When context is available, context.setLanguage is used; props override context.
+     */
+    onLanguageChange?: (languageKey: string) => void;
+    /** Accessible name for the trigger */
+    labels?: LanguageSwitcherLabels;
+    className?: string;
+    /** Size of the trigger */
+    size?: "sm" | "md" | "lg";
+    /** Shape of the trigger */
+    shape?: "rounded" | "squared" | "pill";
+    /**
+     * Kept for existing callers. Both variants render the languages glyph
+     * and open the locale menu.
+     */
+    variant?: "default" | "mini";
+    /** @deprecated The trigger is always the languages glyph. */
+    showIcon?: boolean;
+    /** Dropdown alignment */
+    align?: "start" | "center" | "end";
+    /** Dropdown side */
+    side?: "top" | "bottom" | "left" | "right";
+    /** @deprecated No longer used; the trigger no longer renders a tooltip. */
+    tooltipSide?: "top" | "right" | "bottom" | "left";
+    /** @deprecated No longer used; the trigger no longer renders a tooltip. */
+    tooltipAlign?: "start" | "center" | "end";
+    /** @deprecated No longer used; the trigger no longer renders a tooltip. */
+    tooltipSideOffset?: number;
+};
+declare function LanguageSwitcher({ languages: propLanguages, currentLanguage: propCurrentLanguage, onLanguageChange: propOnLanguageChange, labels, className, size, shape, align, side, }: LanguageSwitcherProps): React.JSX.Element;
+
+type AvatarEditorLabels = {
+    uploadAria?: string;
+    uploadHint?: string;
+    uploadFormats?: string;
+    dragging?: string;
+    zoomOut?: string;
+    zoomIn?: string;
+    zoomLevel?: string;
+    rotateLeft?: string;
+    rotateRight?: string;
+    toggleGrid?: string;
+    reset?: string;
+    replace?: string;
+    discard?: string;
+};
+interface AvatarEditorProps {
+    /** Current cropped image as data URL (controlled) */
+    value?: string | null;
+    /** Callback when the cropped image changes */
+    onChange?: (dataUrl: string | null) => void;
+    /** Size of the editor container in pixels */
+    size?: number;
+    /** Whether to show grid overlay by default */
+    showGrid?: boolean;
+    /** Square output image size in pixels (width === height) */
+    outputSize?: number;
+    /** Output format */
+    outputFormat?: "png" | "jpeg" | "webp";
+    /** Output quality for jpeg/webp (0-1) */
+    outputQuality?: number;
+    /** Additional class names */
+    className?: string;
+    /** Control size variant - 'default' for desktop, 'large' for mobile/touch devices */
+    controlSize?: "default" | "large";
+    /** Override English chrome strings */
+    labels?: AvatarEditorLabels;
+}
+declare function AvatarEditor({ value: _value, onChange, size, showGrid: initialShowGrid, outputSize, outputFormat, outputQuality, className, controlSize, labels, }: AvatarEditorProps): React.JSX.Element;
+
+interface AvatarEditorDialogProps {
+    /** Current avatar URL or data URL */
+    value?: string | null;
+    /** Callback when avatar changes (after accepting) */
+    onChange?: (dataUrl: string | null) => void;
+    /** Async callback for saving/uploading - return true for success, false for failure */
+    onSave?: (dataUrl: string) => Promise<boolean> | boolean;
+    /** Size of the displayed avatar in pixels */
+    displaySize?: number;
+    /** Size of the editor in the dialog */
+    editorSize?: number;
+    /** Output image size */
+    outputSize?: number;
+    /** Placeholder text when no avatar */
+    placeholder?: string;
+    /** Edit button label for accessibility */
+    editLabel?: string;
+    /** Dialog title */
+    dialogTitle?: string;
+    /** Accept button text */
+    acceptText?: string;
+    /** Cancel button text */
+    cancelText?: string;
+    /** Saving button text while upload is in progress */
+    savingText?: string;
+    /** Saved button text after a successful save */
+    savedText?: string;
+    /** Success message */
+    successMessage?: string;
+    /** Error message */
+    errorMessage?: string;
+    /** Additional class names */
+    className?: string;
+    /** Override AvatarEditor chrome strings */
+    editorLabels?: AvatarEditorLabels;
+}
+declare function AvatarEditorDialog({ value, onChange, onSave, displaySize, editorSize, outputSize, placeholder, editLabel, dialogTitle, acceptText, cancelText, savingText, savedText, successMessage, errorMessage, className, editorLabels, }: AvatarEditorDialogProps): React.JSX.Element;
+
+type MultipartUploadPart = {
+    partNumber: number;
+    etag: string;
+};
+type MultipartUploadAdapter = {
+    requestPartUrl: (partNumber: number) => Promise<string>;
+    complete: (parts: MultipartUploadPart[]) => Promise<void>;
+    abort?: () => Promise<void>;
+};
+type UploadProgress = {
+    loaded: number;
+    total: number;
+    percent: number;
+};
+type UploadControllerStatus = "idle" | "uploading" | "paused" | "completing" | "completed" | "cancelled" | "error";
+type UploadJobStatus = Exclude<UploadControllerStatus, "idle">;
+type UploadJob = {
+    id: string;
+    name: string;
+    status: UploadJobStatus;
+    loaded: number;
+    total: number;
+    percent: number;
+    error?: string;
+};
+type FileDropzoneLabels = {
+    idle: string;
+    hint: string;
+    browse: string;
+    rejectType: string;
+    rejectSize: string;
+};
+type FileUploadTrayLabels = {
+    title: string;
+    pause: string;
+    resume: string;
+    cancel: string;
+    uploading: string;
+    paused: string;
+    completing: string;
+    completed: string;
+    cancelled: string;
+    error: string;
+};
+declare const DEFAULT_FILE_DROPZONE_LABELS: FileDropzoneLabels;
+declare const DEFAULT_FILE_UPLOAD_TRAY_LABELS: FileUploadTrayLabels;
+declare const DEFAULT_FILE_UPLOAD_LABELS: {
+    dropzone: FileDropzoneLabels;
+    tray: FileUploadTrayLabels;
+};
+
+type FileDropzoneProps = {
+    accept?: string;
+    maxSize?: number;
+    disabled?: boolean;
+    labels?: Partial<FileDropzoneLabels>;
+    onFile: (file: File) => void;
+    onReject?: (reason: "type" | "size") => void;
+    className?: string;
+};
+declare function FileDropzone({ accept, maxSize, disabled, labels: labelOverrides, onFile, onReject, className, }: FileDropzoneProps): React.JSX.Element;
+
+type FileUploadTrayProps = {
+    jobs: UploadJob[];
+    labels?: Partial<FileUploadTrayLabels>;
+    onPause: (id: string) => void;
+    onResume: (id: string) => void;
+    onCancel: (id: string) => void;
+    className?: string;
+};
+declare function FileUploadTray({ jobs, labels: labelOverrides, onPause, onResume, onCancel, className, }: FileUploadTrayProps): React.JSX.Element | null;
+
+type FileUploadMenuProps = {
+    jobs: UploadJob[];
+    labels?: Partial<FileUploadTrayLabels>;
+    onPause: (id: string) => void;
+    onResume: (id: string) => void;
+    onCancel: (id: string) => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    align?: "start" | "end";
+    className?: string;
+};
+declare function FileUploadMenu({ jobs, labels: labelOverrides, onPause, onResume, onCancel, open, onOpenChange, align, className, }: FileUploadMenuProps): React.JSX.Element | null;
+
+type CreateMultipartUploadControllerOptions = {
+    file: Blob;
+    partSize: number;
+    adapter: MultipartUploadAdapter;
+    onProgress?: (progress: UploadProgress) => void;
+    xhrFactory?: () => XMLHttpRequest;
+    sleep?: (ms: number) => Promise<void>;
+    completedParts?: MultipartUploadPart[];
+};
+type MultipartUploadController = {
+    start: () => Promise<void>;
+    pause: () => void;
+    resume: () => Promise<void>;
+    cancel: () => Promise<void>;
+    getStatus: () => UploadControllerStatus;
+};
+declare function createMultipartUploadController(options: CreateMultipartUploadControllerOptions): MultipartUploadController;
+
+type PartRange = {
+    partNumber: number;
+    start: number;
+    end: number;
+};
+declare function partRanges(fileSize: number, partSize: number): PartRange[];
+declare function progressFromBytes(loaded: number, total: number): {
+    loaded: number;
+    total: number;
+    percent: number;
+};
+declare function fileMatchesAccept(file: File, accept?: string): boolean;
+
+declare function useMediaQuery(query: string): boolean;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+type StatHighlightCardProps = {
+    label: string;
+    value: React.ReactNode;
+    hint?: string;
+    delta?: string;
+    deltaTone?: "up" | "down" | "neutral";
+    className?: string;
+};
+declare function StatHighlightCard({ label, value, hint, delta, deltaTone, className, }: StatHighlightCardProps): React.JSX.Element;
+
+type MetricChartCardProps = {
+    title: string;
+    description?: string;
+    action?: React.ReactNode;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function MetricChartCard({ title, description, action, children, className, }: MetricChartCardProps): React.JSX.Element;
+
+type SparklineStatProps = {
+    label: string;
+    value: React.ReactNode;
+    points: number[];
+    className?: string;
+};
+declare function SparklineStat({ label, value, points, className, }: SparklineStatProps): React.JSX.Element;
+
+declare const TIME_RANGE_OPTIONS: readonly ["day", "week", "month", "year"];
+type TimeRange = (typeof TIME_RANGE_OPTIONS)[number];
+type TimeRangePickerLabels = Partial<Record<TimeRange, string>>;
+type TimeRangePickerProps = {
+    value: TimeRange;
+    onChange: (value: TimeRange) => void;
+    labels?: TimeRangePickerLabels;
+    className?: string;
+};
+declare function TimeRangePicker({ value, onChange, labels, className, }: TimeRangePickerProps): React.JSX.Element;
+
+type DimensionBreakdownRow = {
+    id: string;
+    label: string;
+    value: React.ReactNode;
+    share?: string;
+};
+type DimensionBreakdownTableProps = {
+    title?: string;
+    rows: DimensionBreakdownRow[];
+    empty?: React.ReactNode;
+    className?: string;
+};
+declare function DimensionBreakdownTable({ title, rows, empty, className, }: DimensionBreakdownTableProps): React.JSX.Element;
+
+type CostBreakdownItem = {
+    id: string;
+    label: string;
+    amount: React.ReactNode;
+    basis?: string;
+};
+type CostBreakdownCardProps = {
+    title: string;
+    total?: React.ReactNode;
+    items: CostBreakdownItem[];
+    className?: string;
+};
+declare function CostBreakdownCard({ title, total, items, className, }: CostBreakdownCardProps): React.JSX.Element;
+
+type MetricEmptyStateProps = {
+    title: string;
+    description?: string;
+    action?: React.ReactNode;
+    icon?: EmptyStateIcon;
+    className?: string;
+};
+declare function MetricEmptyState({ title, description, action, icon, className, }: MetricEmptyStateProps): React.JSX.Element;
+
+type MetricSkeletonProps = {
+    className?: string;
+    bars?: number;
+};
+declare function MetricSkeleton({ className, bars }: MetricSkeletonProps): React.JSX.Element;
+
+type CookieConsentBannerLabels = {
+    message: string;
+    acceptAll: string;
+    necessaryOnly: string;
+    policy: string;
+};
+declare const DEFAULT_COOKIE_CONSENT_BANNER_LABELS: CookieConsentBannerLabels;
+type CookieConsentBannerProps = {
+    domain?: string;
+    policyHref?: string;
+    labels?: Partial<CookieConsentBannerLabels>;
+    onChoice?: (value: CookieConsentValue) => void;
+    variant?: "default" | "embed";
+    className?: string;
+};
+declare function CookieConsentBanner({ domain, policyHref, labels, onChoice, variant, className, }: CookieConsentBannerProps): React.JSX.Element | null;
+
+type LegalAcceptDialogLabels = {
+    title: string;
+    description: string;
+    accept: string;
+    terms: string;
+    privacy: string;
+};
+declare const DEFAULT_LEGAL_ACCEPT_DIALOG_LABELS: LegalAcceptDialogLabels;
+type LegalAcceptDialogProps = {
+    open: boolean;
+    termsHref: string;
+    privacyHref: string;
+    summary?: string;
+    accepting?: boolean;
+    labels?: Partial<LegalAcceptDialogLabels>;
+    onAccept: () => void;
+};
+declare function LegalAcceptDialog({ open, termsHref, privacyHref, summary, accepting, labels, onAccept, }: LegalAcceptDialogProps): React.JSX.Element;
+
+type LegalAcceptCheckboxLabels = {
+    label: string;
+    terms: string;
+    privacy: string;
+};
+declare const DEFAULT_LEGAL_ACCEPT_CHECKBOX_LABELS: LegalAcceptCheckboxLabels;
+type LegalAcceptCheckboxProps = {
+    id?: string;
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    termsHref: string;
+    privacyHref: string;
+    labels?: Partial<LegalAcceptCheckboxLabels>;
+    disabled?: boolean;
+    className?: string;
+};
+declare function LegalAcceptCheckbox({ id, checked, onCheckedChange, termsHref, privacyHref, labels, disabled, className, }: LegalAcceptCheckboxProps): React.JSX.Element;
+
+type LegalMarkdownProps = {
+    markdown: string;
+    className?: string;
+};
+declare function LegalMarkdown({ markdown, className }: LegalMarkdownProps): React.JSX.Element;
+
+type AuditActor = {
+    kind: string;
+    id: string;
+    organizationRole?: string | null;
+};
+type AuditSubject = {
+    type: string;
+    id: string;
+};
+type AuditTimelineItem = {
+    id: string;
+    type: string;
+    occurredAt: number;
+    actor: AuditActor;
+    subject: AuditSubject;
+    summary: string;
+};
+type AuditTimelineLabels = {
+    emptyTitle: string;
+    emptyDescription: string;
+    actor: string;
+    subject: string;
+};
+declare const DEFAULT_AUDIT_TIMELINE_LABELS: AuditTimelineLabels;
+type AuditTimelineProps = {
+    items: AuditTimelineItem[];
+    labels?: Partial<AuditTimelineLabels>;
+    /** Single primary action shown only when the timeline is empty. */
+    emptyAction?: ReactNode;
+    className?: string;
+    formatOccurredAt?: (occurredAt: number) => string;
+};
+declare function AuditTimeline({ items, labels, emptyAction, className, formatOccurredAt: format, }: AuditTimelineProps): React.JSX.Element;
+
+type RiskSeverity = "low" | "medium" | "high";
+type RiskBadgeLabels = {
+    low: string;
+    medium: string;
+    high: string;
+    unverifiedRule: string;
+};
+declare const DEFAULT_RISK_BADGE_LABELS: RiskBadgeLabels;
+type RiskBadgeProps = {
+    severity: RiskSeverity;
+    /** When false, the badge also shows the unverified-rule label. */
+    smeVerified?: boolean;
+    labels?: Partial<RiskBadgeLabels>;
+    className?: string;
+};
+declare function RiskBadge({ severity, smeVerified, labels, className, }: RiskBadgeProps): React.JSX.Element;
+
+type EntityGraphNode = {
+    id: string;
+    label: string;
+    kind: string;
+};
+type ControlKind = "ownership" | "other_means" | "senior_manager";
+type EntityGraphEdge = {
+    from: string;
+    to: string;
+    controlKind: ControlKind;
+    ownershipBps?: number;
+};
+type EntityGraphLabels = {
+    emptyTitle: string;
+    emptyDescription: string;
+    ownership: string;
+    otherMeans: string;
+    seniorManager: string;
+};
+declare const DEFAULT_ENTITY_GRAPH_LABELS: EntityGraphLabels;
+type EntityGraphProps = {
+    nodes: EntityGraphNode[];
+    edges: EntityGraphEdge[];
+    labels?: Partial<EntityGraphLabels>;
+    emptyAction?: ReactNode;
+    className?: string;
+};
+declare function EntityGraph({ nodes, edges, labels, emptyAction, className, }: EntityGraphProps): React.JSX.Element;
+
+type MatchReviewSource = {
+    url: string;
+    title: string;
+};
+type MatchReviewStatus = "pending" | "confirmed" | "dismissed";
+type MatchReviewHit = {
+    source: string;
+    score?: number;
+    matchedFields: string[];
+    status: MatchReviewStatus;
+    unverified?: boolean;
+    sources?: MatchReviewSource[];
+};
+type MatchReviewLabels = {
+    emptyTitle: string;
+    emptyDescription: string;
+    source: string;
+    score: string;
+    matchedFields: string;
+    noMatchedFields: string;
+    status: string;
+    unverified: string;
+    reason: string;
+    reasonPlaceholder: string;
+    confirm: string;
+    dismiss: string;
+};
+declare const DEFAULT_MATCH_REVIEW_LABELS: MatchReviewLabels;
+type MatchReviewProps = {
+    hit: MatchReviewHit | null;
+    onResolve: (status: "confirmed" | "dismissed", reason: string) => void;
+    labels?: Partial<MatchReviewLabels>;
+    /** Optional map from source identifiers such as `sat69b` to display copy. */
+    sourceLabels?: Record<string, string>;
+    emptyAction?: ReactNode;
+    className?: string;
+};
+declare function sourceUrlIsHttps(url: string): boolean;
+declare function matchClaimIsUnverified(hit: MatchReviewHit): boolean;
+declare function MatchReview({ hit, onResolve, labels, sourceLabels, emptyAction, className, }: MatchReviewProps): React.JSX.Element;
+
+export { type AuditActor, type AuditSubject, AuditTimeline, type AuditTimelineItem, type AuditTimelineLabels, type AuditTimelineProps, AvatarEditor, AvatarEditorDialog, type AvatarEditorDialogProps, type AvatarEditorLabels, type AvatarEditorProps, type BlocksLanguage, ConfirmDestructiveDialog, type ConfirmDestructiveDialogProps, type ControlKind, CookieConsentBanner, type CookieConsentBannerLabels, type CookieConsentBannerProps, CookieConsentValue, CostBreakdownCard, type CostBreakdownCardProps, type CostBreakdownItem, type CreateMultipartUploadControllerOptions, DEFAULT_AUDIT_TIMELINE_LABELS, DEFAULT_COOKIE_CONSENT_BANNER_LABELS, DEFAULT_EDITABLE_SECTION_LABELS, DEFAULT_ENTITY_GRAPH_LABELS, DEFAULT_FILE_DROPZONE_LABELS, DEFAULT_FILE_UPLOAD_LABELS, DEFAULT_FILE_UPLOAD_TRAY_LABELS, DEFAULT_LEGAL_ACCEPT_CHECKBOX_LABELS, DEFAULT_LEGAL_ACCEPT_DIALOG_LABELS, DEFAULT_MATCH_REVIEW_LABELS, DEFAULT_NOTIFICATION_BELL_LABELS, DEFAULT_RISK_BADGE_LABELS, DataList, DataListItem, type DataListItemProps, type DataListProps, type DimensionBreakdownRow, DimensionBreakdownTable, type DimensionBreakdownTableProps, EditableSection, type EditableSectionLabels, type EditableSectionMode, type EditableSectionProps, type EditableSectionSlots, Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyState, type EmptyStateProps, EmptyTitle, EntityGraph, type EntityGraphEdge, type EntityGraphLabels, type EntityGraphNode, type EntityGraphProps, ErrorState, FieldMessage, type FieldMessageProps, FileDropzone, type FileDropzoneLabels, type FileDropzoneProps, FileUploadMenu, type FileUploadMenuProps, FileUploadTray, type FileUploadTrayLabels, type FileUploadTrayProps, type Language, LanguageContext, type LanguageContextValue, LanguageSwitcher, type LanguageSwitcherLabels, type LanguageSwitcherProps, LegalAcceptCheckbox, type LegalAcceptCheckboxLabels, type LegalAcceptCheckboxProps, LegalAcceptDialog, type LegalAcceptDialogLabels, type LegalAcceptDialogProps, LegalMarkdown, type LegalMarkdownProps, LoadingState, MatchReview, type MatchReviewHit, type MatchReviewLabels, type MatchReviewProps, type MatchReviewSource, type MatchReviewStatus, MetricChartCard, type MetricChartCardProps, MetricEmptyState, type MetricEmptyStateProps, MetricSkeleton, type MetricSkeletonProps, type MultipartUploadAdapter, type MultipartUploadController, type MultipartUploadPart, NotificationBell, type NotificationBellItem, type NotificationBellLabels, type NotificationBellProps, type PartRange, RiskBadge, type RiskBadgeLabels, type RiskBadgeProps, type RiskSeverity, SafeImage, type SafeImageProps, SparklineStat, type SparklineStatProps, StatHighlightCard, type StatHighlightCardProps, TIME_RANGE_OPTIONS, ThemeSwitcher, type ThemeSwitcherLabels, type ThemeSwitcherProps, type TimeRange, TimeRangePicker, type TimeRangePickerLabels, type TimeRangePickerProps, type UploadControllerStatus, type UploadJob, type UploadJobStatus, type UploadProgress, type UseEditableSectionOptions, type UseEditableSectionResult, cn, createMultipartUploadController, defaultLanguages, fileMatchesAccept, matchClaimIsUnverified, partRanges, progressFromBytes, sourceUrlIsHttps, useEditableSection, useLanguageContext, useMediaQuery };