@sesionario/blocks 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,700 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { LucideIcon } from 'lucide-react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { HlsConfig, RetryConfig, LoaderResponse } from 'hls.js';
+import * as RPNInput from 'react-phone-number-input';
+import { ClassValue } from 'clsx';
+
+/**
+ * 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;
+type EmptyStateProps = {
+    title: string;
+    description?: string;
+    action?: React.ReactNode;
+    icon?: LucideIcon;
+    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 ThemeSwitcherLabels = {
+    /** Tooltip label for the theme switcher */
+    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 switcher */
+    size?: "sm" | "md" | "lg";
+    /** Shape of the button */
+    shape?: "rounded" | "pill";
+    /** Mini variant shows only current theme icon as dropdown */
+    variant?: "default" | "mini";
+    /** Dropdown alignment (for mini variant) */
+    align?: "start" | "center" | "end";
+    /** Dropdown side (for mini variant) */
+    side?: "top" | "bottom" | "left" | "right";
+    /** @deprecated No longer used; mini variant no longer renders a tooltip. */
+    tooltipSide?: "top" | "right" | "bottom" | "left";
+    /** @deprecated No longer used; mini variant no longer renders a tooltip. */
+    tooltipAlign?: "start" | "center" | "end";
+    /** @deprecated No longer used; mini variant no longer renders a tooltip. */
+    tooltipSideOffset?: number;
+    /** Translation labels - consumers can pass their own t() values */
+    labels?: ThemeSwitcherLabels;
+};
+declare function ThemeSwitcher({ className, size, shape, variant, align, side, labels: userLabels, }: ThemeSwitcherProps): React.JSX.Element;
+
+type OrgSwitcherTenant = {
+    id: string;
+    name: string;
+    logo?: string | null;
+    role?: string;
+    statusBadge?: ReactNode;
+};
+type OrgSwitcherLabels = {
+    /** Dropdown section heading */
+    heading?: string;
+    /** Create action label */
+    create?: string;
+    /** Empty state when no active tenant */
+    empty?: string;
+};
+type OrgSwitcherProps = {
+    activeTenant: OrgSwitcherTenant | null;
+    tenants: OrgSwitcherTenant[];
+    onSelectTenant: (id: string) => void;
+    createUrl?: string;
+    isLoading?: boolean;
+    collapsed?: boolean;
+    isMobile?: boolean;
+    activeSubtitle?: string;
+    labels?: OrgSwitcherLabels;
+    className?: string;
+    triggerClassName?: string;
+};
+declare function OrgSwitcher({ activeTenant, tenants, onSelectTenant, createUrl, isLoading, collapsed, isMobile, activeSubtitle, labels: userLabels, className, triggerClassName: triggerClassNameProp, }: OrgSwitcherProps): React.JSX.Element;
+
+type Language = {
+    /** Language key/code (e.g., "en", "es") */
+    key: string;
+    /** Short label for segmented control (e.g., "EN", "ES") */
+    label: string;
+    /** Full native name for dropdown (e.g., "English", "Español") */
+    nativeName: string;
+};
+type LanguageSwitcherLabels = {
+    /** Tooltip label for the language switcher */
+    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;
+    /** Labels for accessibility/tooltips */
+    labels?: LanguageSwitcherLabels;
+    className?: string;
+    /** Size of the switcher */
+    size?: "sm" | "md" | "lg";
+    /** Shape of the button */
+    shape?: "rounded" | "squared" | "pill";
+    /** Mini variant shows only an icon */
+    variant?: "default" | "mini";
+    /** Show language icon in default variant */
+    showIcon?: boolean;
+    /** Dropdown alignment */
+    align?: "start" | "center" | "end";
+    /** Dropdown side */
+    side?: "top" | "bottom" | "left" | "right";
+    /** @deprecated No longer used; mini variant no longer renders a tooltip. */
+    tooltipSide?: "top" | "right" | "bottom" | "left";
+    /** @deprecated No longer used; mini variant no longer renders a tooltip. */
+    tooltipAlign?: "start" | "center" | "end";
+    /** @deprecated No longer used; mini variant no longer renders a tooltip. */
+    tooltipSideOffset?: number;
+};
+declare function LanguageSwitcher({ languages: propLanguages, currentLanguage: propCurrentLanguage, onLanguageChange: propOnLanguageChange, labels, className, size, shape, variant, showIcon, align, side, }: LanguageSwitcherProps): React.JSX.Element;
+
+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;
+    /** Output image size in pixels */
+    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";
+}
+declare function AvatarEditor({ value: _value, onChange, size, showGrid: initialShowGrid, outputSize, outputFormat, outputQuality, className, controlSize, }: 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;
+    /** Success message */
+    successMessage?: string;
+    /** Error message */
+    errorMessage?: string;
+    /** Additional class names */
+    className?: string;
+}
+declare function AvatarEditorDialog({ value, onChange, onSave, displaySize, editorSize, outputSize, placeholder, editLabel, dialogTitle, acceptText, cancelText, successMessage, errorMessage, className, }: AvatarEditorDialogProps): React.JSX.Element;
+
+/** Category keys, in display order. */
+type EmojiCategoryKey = "smileys" | "people" | "nature" | "food" | "travel" | "activities" | "objects" | "symbols" | "flags";
+interface EmojiDatum {
+    /** The emoji glyph to insert. */
+    e: string;
+    /** English label, for aria-label / tooltip. */
+    n: string;
+    /** Normalized bilingual (en+es) search haystack; space-joined tokens. */
+    k: string;
+    /** Uniform skin-tone variants, tone 1..5. Present only when applicable. */
+    t?: string[];
+}
+interface EmojiCategoryData {
+    key: EmojiCategoryKey;
+    emojis: EmojiDatum[];
+}
+
+/** 0 = default (no modifier / yellow); 1..5 = Fitzpatrick light..dark. */
+type EmojiSkinTone = 0 | 1 | 2 | 3 | 4 | 5;
+type EmojiPickerLocale = "en" | "es";
+interface EmojiPickerLabels {
+    searchPlaceholder?: string;
+    searchAriaLabel?: string;
+    noResults?: string;
+    recentTitle?: string;
+    skinToneAriaLabel?: string;
+    /** Overrides the built-in category section titles (keyed by category, plus
+     * `recent`). When omitted, titles come from `locale`. */
+    categoryTitles?: Partial<Record<EmojiCategoryKey | "recent", string>>;
+}
+interface EmojiPickerProps {
+    /** Called with the (skin-tone-applied) emoji glyph when one is chosen. */
+    onSelect: (emoji: string) => void;
+    /** Drives the default section titles + skin-tone labels. Search is always
+     * bilingual regardless. Default `"en"`. */
+    locale?: EmojiPickerLocale;
+    labels?: EmojiPickerLabels;
+    className?: string;
+    /** How many recently-used emoji to remember. Default 24. */
+    recentLimit?: number;
+    /** localStorage namespace for recents + skin-tone preference. Default
+     * `"blocks-emoji"`. Set to `null` to disable persistence entirely. */
+    storageKey?: string | null;
+}
+/**
+ * Normalizes a search query the same way keyword haystacks are normalized at
+ * generation time (see `scripts/generate-emoji-data.mjs`): lowercased, accents
+ * stripped, punctuation collapsed to spaces. Keeping the two in lockstep is
+ * what lets "corazón", "corazon" and "heart" all match the same emoji.
+ */
+declare function normalizeEmojiQuery(input: string): string;
+/**
+ * Zero-dependency emoji picker with bilingual (English + Spanish) search,
+ * category navigation, a persisted "frequently used" section, a global skin
+ * tone preference, and keyboard navigation (desktop-first). Usable standalone
+ * or inside {@link EmojiPickerPopover}.
+ */
+declare function EmojiPicker({ onSelect, locale, labels, className, recentLimit, storageKey, }: EmojiPickerProps): React.JSX.Element;
+
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): React.JSX.Element;
+
+interface EmojiPickerPopoverProps extends EmojiPickerProps {
+    /** aria-label for the trigger button. Defaults by `locale`. */
+    triggerLabel?: string;
+    /** Extra classes for the trigger button. */
+    triggerClassName?: string;
+    /** Popover side. Default `"top"`. */
+    side?: React.ComponentProps<typeof PopoverContent>["side"];
+    /** Popover alignment. Default `"end"`. */
+    align?: React.ComponentProps<typeof PopoverContent>["align"];
+    /** Controlled open state (optional). */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Keep the popover open after choosing an emoji (e.g. to add several).
+     * Default `false`. */
+    keepOpenOnSelect?: boolean;
+}
+/**
+ * Convenience wrapper: a `Smile` icon button that opens {@link EmojiPicker} in
+ * a popover. Drop it next to a textarea/input; wire `onSelect` to insert at the
+ * caret. Uncontrolled by default; pass `open`/`onOpenChange` to control it.
+ */
+declare function EmojiPickerPopover({ onSelect, triggerLabel, triggerClassName, side, align, open, onOpenChange, keepOpenOnSelect, locale, ...pickerProps }: EmojiPickerPopoverProps): React.JSX.Element;
+
+/**
+ * Playback error description, ported from the app's HLS player but stripped of
+ * Sentry. `@sesionario/blocks` must stay reporting-agnostic: the player surfaces
+ * a {@link DescribedPlaybackError} through an optional `onError` prop so each
+ * app can wire its own reporting (Sentry, Datadog, console, …).
+ *
+ * User-facing messages are intentionally NOT baked in here — they come from the
+ * player's `labels` prop so they stay translatable. This module only classifies
+ * the error and produces a machine-readable summary + detail for logging.
+ */
+type HlsPlayerMode = "live" | "vod";
+/** Coarse category the player uses to pick the right localized message. */
+type PlaybackErrorKind = "unavailable" | "network" | "media" | "unsupported" | "generic";
+type PlaybackErrorContext = {
+    mode: HlsPlayerMode;
+    src: string;
+    manifestParsed: boolean;
+    retryCount?: number;
+    source: "hls" | "native" | "unsupported";
+};
+type PlaybackErrorDetail = {
+    source: PlaybackErrorContext["source"];
+    kind: PlaybackErrorKind;
+    type?: string;
+    details?: string;
+    fatal?: boolean;
+    httpStatus?: number;
+    url?: string;
+    reason?: string;
+    errorMessage?: string;
+    mediaErrorCode?: number;
+    mediaErrorName?: string;
+    context: PlaybackErrorContext;
+};
+type DescribePlaybackErrorInput = {
+    source: "hls";
+    type?: string;
+    details?: string;
+    fatal: boolean;
+    url?: string;
+    response?: {
+        code?: number;
+        text?: string;
+    };
+    reason?: string;
+    error?: unknown;
+    context: PlaybackErrorContext;
+} | {
+    source: "native";
+    mediaError?: MediaError | null;
+    context: PlaybackErrorContext;
+} | {
+    source: "unsupported";
+    context: PlaybackErrorContext;
+};
+type DescribedPlaybackError = {
+    /** Machine-readable one-line summary for logs. */
+    summary: string;
+    /** Coarse category for choosing a localized message. */
+    kind: PlaybackErrorKind;
+    detail: PlaybackErrorDetail;
+};
+declare function describePlaybackError(input: DescribePlaybackErrorInput): DescribedPlaybackError;
+
+interface PlaybackStats {
+    /** Concurrent live viewers (meaningful in live mode). */
+    viewers?: number;
+    /** Cumulative VOD reproductions. */
+    views?: number;
+}
+interface UsePlaybackStatsOptions {
+    /** Poll interval in ms. Default 15000. */
+    intervalMs?: number;
+    /** When false, polling is paused. Default true. */
+    enabled?: boolean;
+}
+/**
+ * Polls a playback-stats endpoint (media-svc `GET /playback/:mediaId/stats`)
+ * and returns `{ viewers, views }`. Plain `fetch`, zero dependencies, so wiring
+ * it into an app is a one-liner. Fails silently (stats are non-critical); the
+ * last successful value is retained across transient errors.
+ */
+declare function usePlaybackStats(statsUrl: string | null | undefined, { intervalMs, enabled }?: UsePlaybackStatsOptions): PlaybackStats;
+
+interface VideoPlayerLabels {
+    play?: string;
+    pause?: string;
+    mute?: string;
+    unmute?: string;
+    enterFullscreen?: string;
+    exitFullscreen?: string;
+    pictureInPicture?: string;
+    settings?: string;
+    quality?: string;
+    auto?: string;
+    speed?: string;
+    live?: string;
+    goLive?: string;
+    tapToUnmute?: string;
+    loading?: string;
+    waiting?: string;
+    retry?: string;
+    /** Messages by error kind; a generic fallback covers the rest. */
+    errorUnavailable?: string;
+    errorNetwork?: string;
+    errorMedia?: string;
+    errorUnsupported?: string;
+    errorGeneric?: string;
+    /** `(n) => "N watching"`. */
+    formatViewers?: (n: number) => string;
+    /** `(n) => "N views"`. */
+    formatViews?: (n: number) => string;
+}
+interface VideoPlayerProps {
+    src: string;
+    mode: "live" | "vod";
+    /** Cover image; renders a click-to-play state before attaching HLS. */
+    poster?: string;
+    autoPlay?: boolean;
+    muted?: boolean;
+    /** Presentational stats (see `usePlaybackStats`). */
+    stats?: PlaybackStats;
+    labels?: VideoPlayerLabels;
+    /** Show the resolution picker when multiple levels exist. Default true. */
+    showQualitySelector?: boolean;
+    onPlayingChange?: (playing: boolean) => void;
+    /** Fires once, the first time playback actually starts — wire your view
+     * beacon here. */
+    onFirstPlay?: () => void;
+    onError?: (error: DescribedPlaybackError) => void;
+    className?: string;
+}
+/**
+ * Standardized HLS video player with a fully custom control bar (no native
+ * `controls`): click-to-play poster, play/pause, mute + volume, resolution
+ * picker, playback speed (VOD), Picture-in-Picture, fullscreen, a VOD seekbar
+ * with buffered ranges, and a live badge (no seekbar) with a "go live"
+ * affordance. `stats` renders live viewer / VOD reproduction counts.
+ *
+ * hls.js is a peer dependency loaded on demand; see {@link useHlsPlayback}.
+ */
+declare function VideoPlayer({ src, mode, poster, autoPlay, muted, stats, labels, showQualitySelector, onPlayingChange, onFirstPlay, onError, className, }: VideoPlayerProps): React.JSX.Element;
+
+type PlaybackState = "idle" | "loading" | "ready" | "waiting" | "error";
+/** Autoplay overlay state once the manifest is parsed. */
+type AutoplayState = "none" | "playing" | "muted" | "blocked";
+interface QualityLevel {
+    /** hls.js level index. */
+    index: number;
+    /** Vertical resolution, e.g. 720. */
+    height: number;
+}
+interface UseHlsPlaybackOptions {
+    src: string;
+    mode: HlsPlayerMode;
+    /** When false, nothing is attached/loaded (poster gating). */
+    active: boolean;
+    /** Attempt autoplay once the manifest is ready. Live always autoplays. */
+    autoPlay?: boolean;
+    /** Start muted (independent of the autoplay cascade). */
+    muted?: boolean;
+    onError?: (error: DescribedPlaybackError) => void;
+    onPlayingChange?: (playing: boolean) => void;
+}
+interface UseHlsPlaybackResult {
+    videoRef: React.RefObject<HTMLVideoElement | null>;
+    state: PlaybackState;
+    /** Available quality levels (empty for native HLS / single-level). */
+    qualities: QualityLevel[];
+    /** Selected level index, or -1 for automatic. */
+    activeLevel: number;
+    setLevel: (index: number) => void;
+    autoplayState: AutoplayState;
+    /** The classified error, when `state === "error"`. */
+    error: DescribedPlaybackError | null;
+    retry: () => void;
+}
+/**
+ * Attaches hls.js (loaded on demand via dynamic import) or native HLS to a
+ * `<video>` element and exposes the state a custom control bar needs. Ported
+ * from the app's production `HlsPlayer` effect, minus the built-in UI and
+ * Sentry: errors are classified and handed to `onError`.
+ */
+declare function useHlsPlayback({ src, mode, active, autoPlay, muted, onError, onPlayingChange, }: UseHlsPlaybackOptions): UseHlsPlaybackResult;
+
+/** Retry transient live-edge 404s; hls.js skips all 4xx by default. */
+declare function shouldRetryLiveEdge404(retryConfig: RetryConfig | null | undefined, retryCount: number, _isTimeout: boolean, loaderResponse: LoaderResponse | undefined, defaultRetry: boolean): boolean;
+/**
+ * HLS.js options tuned for live playback through a Cloudflare R2 custom domain.
+ * Ported from the app's production player: stays 4 segments (~8s) behind the
+ * live edge so transient upload lag never reaches the playhead, and retries the
+ * 404s that appear while a new segment is still being written.
+ */
+declare function createLiveHlsConfig(): Partial<HlsConfig>;
+/**
+ * HLS.js options for on-demand (VOD) playback. No live-edge cushion; enables
+ * the worker and lets hls.js manage the buffer with its defaults, which are
+ * well suited to seekable recordings.
+ */
+declare function createVodHlsConfig(): Partial<HlsConfig>;
+
+/**
+ * Debounces a value — useful for ZIP lookups and autocomplete queries.
+ */
+declare function useDebouncedValue<T>(value: T, delayMs: number): T;
+/**
+ * Like {@link useDebouncedValue} but the returned value is `undefined` until
+ * the first `delayMs` has elapsed for the current `value`, and resets to
+ * `undefined` whenever `value` changes. Use for “only act after user pauses”
+ * (e.g. auto-submit / auto-validate) without firing on the initial tick.
+ */
+declare function useDebouncedValueStrict<T>(value: T, delayMs: number): T | undefined;
+
+interface UseSearchHotkeyOptions {
+    /** Initial open state. Defaults to `false`. */
+    defaultOpen?: boolean;
+    /** Disables the keyboard listener without unmounting the palette. */
+    disabled?: boolean;
+}
+interface UseSearchHotkeyResult {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    toggle: () => void;
+}
+/**
+ * Manages open state for a global command palette and wires up the
+ * Ctrl/Cmd+K shortcut to toggle it. Ctrl+F is deliberately left alone —
+ * overriding the browser's native find is bad UX.
+ */
+declare function useSearchHotkey(options?: UseSearchHotkeyOptions): UseSearchHotkeyResult;
+
+/**
+ * A search result returned by search-svc's `GET /search` after ACL
+ * hydration. Mirrors `search-svc/src/domain/search/types.ts` `SearchHit` —
+ * kept duplicated (not imported) since blocks has no dependency on any
+ * backend service.
+ */
+interface SearchHit {
+    id: string;
+    type: string;
+    service: string;
+    entityId: string;
+    orgId: string | null;
+    userId: string | null;
+    visibility: string;
+    title: string;
+    snippet: string;
+    url: string;
+    payload: Record<string, unknown>;
+    score: number;
+}
+/** A static, per-app navigable feature/functionality (not user content). */
+interface FeatureEntry {
+    id: string;
+    label: string;
+    href: string;
+    icon?: ReactNode;
+    /** Extra terms matched against the query (aliases, section name, etc). */
+    keywords?: string[];
+    /** Optional sub-group label, e.g. "Configuración" vs "Navegación". */
+    group?: string;
+}
+/** What the caller's `onSelect` receives — a feature or a hydrated search hit. */
+type SearchCommandSelection = {
+    kind: "feature";
+    feature: FeatureEntry;
+} | {
+    kind: "hit";
+    hit: SearchHit;
+};
+interface SearchCommandLabels {
+    /** Input placeholder. */
+    placeholder?: string;
+    /** Dialog title (visually hidden, read by screen readers). */
+    dialogTitle?: string;
+    /** Dialog description (visually hidden, read by screen readers). */
+    dialogDescription?: string;
+    /** Shown while `fetchResults` is in flight. */
+    loading?: string;
+    /** Shown when there are no features and no hits for the current query. */
+    empty?: string;
+    /** Shown when `fetchResults` rejects. */
+    error?: string;
+    /** Heading for the static features group. */
+    featuresGroup?: string;
+    /** Fallback heading for a hit type with no entry in `typeLabels`. */
+    defaultResultsGroup?: string;
+}
+
+interface SearchCommandProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Transport-agnostic fetcher — each app supplies its own (proxy route, RPC, etc). */
+    fetchResults: (query: string) => Promise<SearchHit[]>;
+    onSelect: (selection: SearchCommandSelection) => void;
+    /** Static per-app registry of navigable features, filtered client-side. */
+    features?: FeatureEntry[];
+    /** Maps a `SearchHit.type` to a display group heading, e.g. `{ event: "Eventos" }`. */
+    typeLabels?: Record<string, string>;
+    labels?: SearchCommandLabels;
+    /** Query must reach this length before `fetchResults` is called. Default 2. */
+    minQueryLength?: number;
+    /** Debounce delay before calling `fetchResults`. Default 200ms. */
+    debounceMs?: number;
+    className?: string;
+}
+declare function SearchCommand({ open, onOpenChange, fetchResults, onSelect, features, typeLabels, labels: userLabels, minQueryLength, debounceMs, className, }: SearchCommandProps): React.JSX.Element;
+
+/**
+ * Minimal, accent-insensitive fuzzy match for the static feature registry.
+ * Not used for server-returned search hits — those come back already
+ * relevance-ranked (vector + keyword RRF) and must never be hidden by a
+ * literal-substring filter, since semantic matches often don't share
+ * substrings with the query.
+ */
+/**
+ * True if `query` is a substring of `target`, or a subsequence of it (i.e.
+ * every query character appears in `target`, in order, possibly with gaps).
+ * Both comparisons are case- and accent-insensitive.
+ */
+declare function fuzzyMatch(query: string, target: string): boolean;
+
+/**
+ * International phone input with country picker (default: Mexico).
+ * Consuming apps must import `react-phone-number-input/style.css` in their root layout.
+ */
+
+type PhoneInputProps = Omit<React.ComponentProps<"input">, "onChange" | "value" | "ref"> & Omit<RPNInput.Props<typeof RPNInput.default>, "onChange" | "defaultCountry"> & {
+    defaultCountry?: RPNInput.Country;
+    onChange?: (value: RPNInput.Value) => void;
+};
+declare const PhoneInput: React.ForwardRefExoticComponent<PhoneInputProps>;
+
+type MexicoStateId = "MXAGU" | "MXBCN" | "MXBCS" | "MXCAM" | "MXCHP" | "MXCHH" | "MXCMX" | "MXCOA" | "MXCOL" | "MXDUR" | "MXGUA" | "MXGRO" | "MXHID" | "MXJAL" | "MXMEX" | "MXMIC" | "MXMOR" | "MXNAY" | "MXNLE" | "MXOAX" | "MXPUE" | "MXQUE" | "MXROO" | "MXSLP" | "MXSIN" | "MXSON" | "MXTAB" | "MXTAM" | "MXTLA" | "MXVER" | "MXYUC" | "MXZAC";
+interface MexicoState {
+    id: MexicoStateId;
+    name: string;
+}
+declare const MEXICO_STATES: MexicoState[];
+
+interface MexicoMapProps {
+    selected: MexicoStateId[];
+    /** Omit to render a read-only display (no interaction, no keyboard handlers). */
+    onToggle?: (id: MexicoStateId) => void;
+    className?: string;
+}
+declare function MexicoMap({ selected, onToggle, className }: MexicoMapProps): React.JSX.Element;
+
+type ProfessionalVerificationStatus = "unverified" | "pending_review" | "verified";
+interface VerifiedProfessionalBadgeProps {
+    status: ProfessionalVerificationStatus;
+    size?: "sm" | "md";
+    /** Icon-only with title/aria-label when false (default). */
+    showLabel?: boolean;
+    className?: string;
+}
+declare function VerifiedProfessionalBadge({ status, size, showLabel, className, }: VerifiedProfessionalBadgeProps): React.JSX.Element | null;
+
+declare const MEXICO_STATE_PATHS: Record<MexicoStateId, string>;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { type AutoplayState, AvatarEditor, AvatarEditorDialog, type AvatarEditorDialogProps, type AvatarEditorProps, type BlocksLanguage, type DescribedPlaybackError, type EmojiCategoryData, type EmojiCategoryKey, type EmojiDatum, EmojiPicker, type EmojiPickerLabels, type EmojiPickerLocale, EmojiPickerPopover, type EmojiPickerPopoverProps, type EmojiPickerProps, type EmojiSkinTone, Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyState, type EmptyStateProps, EmptyTitle, ErrorState, type FeatureEntry, type HlsPlayerMode, type Language, LanguageContext, type LanguageContextValue, LanguageSwitcher, type LanguageSwitcherLabels, type LanguageSwitcherProps, LoadingState, MEXICO_STATES, MEXICO_STATE_PATHS, MexicoMap, type MexicoMapProps, type MexicoState, type MexicoStateId, OrgSwitcher, type OrgSwitcherLabels, type OrgSwitcherProps, type OrgSwitcherTenant, PhoneInput, type PhoneInputProps, type PlaybackErrorContext, type PlaybackErrorDetail, type PlaybackErrorKind, type PlaybackState, type PlaybackStats, type ProfessionalVerificationStatus, type QualityLevel, SearchCommand, type SearchCommandLabels, type SearchCommandProps, type SearchCommandSelection, type SearchHit, ThemeSwitcher, type ThemeSwitcherLabels, type ThemeSwitcherProps, type UseHlsPlaybackOptions, type UseHlsPlaybackResult, type UsePlaybackStatsOptions, type UseSearchHotkeyOptions, type UseSearchHotkeyResult, VerifiedProfessionalBadge, type VerifiedProfessionalBadgeProps, VideoPlayer, type VideoPlayerLabels, type VideoPlayerProps, cn, createLiveHlsConfig, createVodHlsConfig, defaultLanguages, describePlaybackError, fuzzyMatch, normalizeEmojiQuery, shouldRetryLiveEdge404, useDebouncedValue, useDebouncedValueStrict, useHlsPlayback, useLanguageContext, usePlaybackStats, useSearchHotkey };