@ai-matrx/agents 0.7.1 → 0.9.0

package/dist/catalog/native/index.d.cts

@@ -0,0 +1,655 @@
+import * as react from 'react';
+import { ComponentType, ReactNode } from 'react';
+import { t as AgentCatalogNavigate, v as AgentCatalogOpenPeek, n as AgentCatalog, A as AgentSummary, z as AgentCatalogState, f as AgentTab, i as AgentSortOption, E as AgentFavFilter, m as AgentArchFilter, k as AgentAccessFilter, h as AgentConsumerState, J as DefaultRowState } from '../../orchestra-BWJM2MWP.cjs';
+export { O as OrchestraBadge, W as orchestraDelegatesLine, X as orchestraDepthLine, Y as orchestraLabel, Z as orchestraModeLabel } from '../../orchestra-BWJM2MWP.cjs';
+
+/**
+ * The anchor a row renders for cmd/ctrl-click. DEFAULT (web): a plain `<a>` —
+ * which is a REAL, working link in every framework. A Next.js host passes
+ * `next/link`; a TanStack host passes its own `Link`. On React Native the
+ * default is a pressable `Text` that routes through `navigate`.
+ */
+/**
+ * What a row's link handler receives. A DOM `React.MouseEvent` satisfies this
+ * structurally, and the native default link supplies the two methods itself —
+ * so a shared component can call `preventDefault()` on either platform
+ * without a platform check.
+ */
+interface AgentCatalogLinkClickEvent {
+    metaKey?: boolean;
+    ctrlKey?: boolean;
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+type AgentCatalogLinkComponent = ComponentType<{
+    href: string;
+    className?: string;
+    target?: string;
+    rel?: string;
+    title?: string;
+    "aria-label"?: string;
+    onClick?: (e: AgentCatalogLinkClickEvent) => void;
+    children: ReactNode;
+}>;
+/** Render a model id as whatever door the host has. DEFAULT: plain text. */
+type AgentCatalogRenderModelRef = (args: {
+    modelId: string;
+    className?: string;
+}) => ReactNode;
+interface AgentCatalogUiPorts {
+    /** DEFAULT (web): `window.location.assign`. DEFAULT (native): a reporting no-op. */
+    navigate?: AgentCatalogNavigate;
+    /** DEFAULT: a plain `<a>` (web) / a pressable `Text` (native). */
+    LinkComponent?: AgentCatalogLinkComponent;
+    /** DEFAULT: the model id as plain text. */
+    renderModelRef?: AgentCatalogRenderModelRef;
+    /** ABSENT: the sneak-peek affordance is HIDDEN — never a dead button. */
+    openPeek?: AgentCatalogOpenPeek;
+    /**
+     * Portal container for the desktop popover, when the picker is mounted
+     * inside a dialog. DEFAULT: the document body (Radix's own default).
+     * Web only — the native entry ignores it.
+     */
+    popoverContainer?: HTMLElement | null;
+}
+/**
+ * The three defaults a PLATFORM supplies. Never a host concern: a host
+ * overrides an individual port through `AgentCatalogUiPorts`, and whatever it
+ * leaves unset falls back to the platform's own working answer.
+ */
+interface AgentCatalogPlatformDefaults {
+    navigate: AgentCatalogNavigate;
+    LinkComponent: AgentCatalogLinkComponent;
+    renderModelRef: AgentCatalogRenderModelRef;
+}
+/** The headless catalog this tree is bound to. Throws with no provider. */
+declare function useAgentCatalog(): AgentCatalog;
+/** The UI ports this tree is bound to, with every default already applied. */
+declare function useAgentCatalogUiPorts(): Required<Pick<AgentCatalogUiPorts, "navigate" | "LinkComponent" | "renderModelRef">> & {
+    openPeek: AgentCatalogOpenPeek | undefined;
+    popoverContainer: HTMLElement | null | undefined;
+};
+/**
+ * Subscribe to a slice of catalog state. `useSyncExternalStore` because the
+ * catalog is an external store and React 18/19 concurrency must not tear it.
+ * `select` MUST return a stable reference for unchanged state — every
+ * selector in `../selectors` does.
+ */
+declare function useAgentCatalogState<T>(select: (state: AgentCatalogState) => T): T;
+/** Every row currently in the catalogue, as one stable array. */
+declare function useAgentCatalogRows(): AgentSummary[];
+
+/**
+ * catalog/native/theme.ts — @ai-matrx/agents/catalog/native
+ *
+ * 🚨 C26 ON A PLATFORM WITH NO CSS. The web picker consumes colour ONLY
+ * through named semantic tokens (`--matrx-agent-*` plus the design system's
+ * `--primary`, `--muted-foreground`, …), and `catalog/styles.css` ships their
+ * DEFAULT VALUES so the picker renders correctly unthemed in a fresh app.
+ * React Native has no custom properties and no cascade, so the identical
+ * contract is expressed as a plain object: the package ships every default
+ * value, and a host re-brands by passing `theme` to `AgentCatalogProvider`.
+ *
+ * Every name below is the native twin of a token the web sheet defines, so a
+ * colour changed in one place is findable in the other. NOTHING in the native
+ * components hardcodes a colour — they read this object and nothing else.
+ */
+/** The colour half of the contract. Every value is host-overridable. */
+interface AgentCatalogNativeColors {
+    /** Sheet / list background. Web twin: `--background`. */
+    background: string;
+    /** Cards, inputs and chips sitting on the background. Web twin: `--muted`. */
+    surface: string;
+    /** A pressed/hovered row. Web twin: `bg-muted/50`. */
+    surfacePressed: string;
+    /** Primary text. Web twin: `--foreground`. */
+    text: string;
+    /** Secondary text. Web twin: `--muted-foreground`. */
+    textMuted: string;
+    /** Tertiary text (timestamps, hints). Web twin: `--muted-foreground/70`. */
+    textFaint: string;
+    /** Hairlines. Web twin: `--border`. */
+    border: string;
+    /** The accent. Web twin: `--primary`. */
+    primary: string;
+    /** Text ON the accent. Web twin: `--primary-foreground`. */
+    primaryForeground: string;
+    /** A tinted accent surface (active tab, badges). Web twin: `bg-primary/10`. */
+    primarySoft: string;
+    /** The favourite star. Web twin: `--matrx-agent-favorite`. */
+    favorite: string;
+    /** The drift banner. Web twins: `--matrx-agent-drift-{bg,fg,border}`. */
+    driftBackground: string;
+    driftForeground: string;
+    driftBorder: string;
+}
+interface AgentCatalogNativeTheme {
+    colors: AgentCatalogNativeColors;
+    /** Corner radii, in points. */
+    radius: {
+        sm: number;
+        md: number;
+        lg: number;
+    };
+    /** The one spacing scale the picker uses, in points. */
+    spacing: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+    };
+    /** Font sizes, in points. The web picker's 10/11/12/13px ladder. */
+    fontSize: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+    };
+}
+/**
+ * The DEFAULT theme, mirroring `catalog/styles.css` plus the dark palette the
+ * web picker inherits from the design system. Dark by default is deliberate:
+ * it is what every Matrx mobile surface renders, and a light host overrides
+ * `theme` rather than fighting a half-applied palette.
+ */
+declare const DEFAULT_AGENT_CATALOG_NATIVE_THEME: AgentCatalogNativeTheme;
+/**
+ * The light default, offered so a light host is one prop away rather than a
+ * fifteen-value object away. Values mirror `catalog/styles.css`'s `:root`.
+ */
+declare const LIGHT_AGENT_CATALOG_NATIVE_THEME: AgentCatalogNativeTheme;
+/** A host may override any subset; everything it omits keeps its default. */
+type AgentCatalogNativeThemeOverride = {
+    colors?: Partial<AgentCatalogNativeColors>;
+    radius?: Partial<AgentCatalogNativeTheme["radius"]>;
+    spacing?: Partial<AgentCatalogNativeTheme["spacing"]>;
+    fontSize?: Partial<AgentCatalogNativeTheme["fontSize"]>;
+};
+/** Merge a host override onto a base theme. Pure; never mutates either. */
+declare function resolveAgentCatalogNativeTheme(override?: AgentCatalogNativeThemeOverride, base?: AgentCatalogNativeTheme): AgentCatalogNativeTheme;
+
+/** The resolved theme for this tree. Never throws — there is always a default. */
+declare function useAgentCatalogNativeTheme(): AgentCatalogNativeTheme;
+interface AgentCatalogNativeProviderProps extends AgentCatalogUiPorts {
+    catalog: AgentCatalog;
+    /**
+     * Brand overrides for the picker's token values (C26). Anything omitted
+     * keeps the shipped default, so an unthemed app still renders correctly.
+     */
+    theme?: AgentCatalogNativeThemeOverride;
+    children: ReactNode;
+}
+declare function AgentCatalogProvider({ catalog, theme, children, ...ports }: AgentCatalogNativeProviderProps): react.JSX.Element;
+
+interface AgentPickerProps {
+    /** Unique consumer id for filter/tab state (see `useAgentConsumer`). */
+    consumerId: string;
+    /** THE ONLY CONTRACT BACK TO THE HOST (ruling D1). */
+    onSelect: (agentId: string) => void;
+    activeAgentId?: string | null;
+    /** Focus the search field on mount. Default false on native — a keyboard
+     *  that opens with the sheet covers the list it was meant to filter. */
+    autoFocusSearch?: boolean;
+    /** Tab to open on. Admin surfaces that manage system agents pass `"system"`. */
+    initialTab?: AgentTab;
+    /** ADMIN variant: blend system agents into the "All" tab. */
+    includeSystemInAll?: boolean;
+    /** Restrict which ownership tabs this call site may reach. Enforced, not decorated. */
+    visibleTabs?: readonly AgentTab[];
+    /** Label override for the builtin-agent tab. Admin surfaces use "System". */
+    systemTabLabel?: string;
+    /** Show the host's active agent above the filtered list. Default true. */
+    showPinnedAgent?: boolean;
+    /** Hide records that are invalid for this call site. */
+    excludeAgentIds?: readonly string[];
+    /** Offer the mandate's live-resolved default agent at the top of the list. */
+    defaultMandateKey?: string;
+    /** Compact spacing for a short sheet. */
+    compact?: boolean;
+    /** Called after a selection, so a sheet shell can close itself. */
+    onAfterSelect?: () => void;
+}
+declare function AgentPickerBody({ consumerId, onSelect, activeAgentId, autoFocusSearch, initialTab, includeSystemInAll, visibleTabs, systemTabLabel, showPinnedAgent, excludeAgentIds, defaultMandateKey, compact, onAfterSelect, }: AgentPickerProps): react.JSX.Element;
+
+interface AgentListSheetProps extends AgentPickerProps {
+    /**
+     * Heading above the picker. Omit it when the host's sheet chrome already
+     * prints one — two titles is worse than none.
+     */
+    title?: string;
+}
+declare function AgentListSheet({ title, ...props }: AgentListSheetProps): react.JSX.Element;
+
+type AgentListInlinePickerProps = AgentPickerProps;
+declare function AgentListInlinePicker(props: AgentListInlinePickerProps): react.JSX.Element;
+
+/**
+ * catalog/shared/useAgentConsumer.ts — VERBATIM port of matrx-frontend
+ * `features/agents/hooks/useAgentConsumer.ts`.
+ *
+ * Wraps a single consumer slot identified by `consumerId`. Registers the slot
+ * on mount, optionally unregisters on unmount, and returns every filter/sort/
+ * pagination value plus stable write helpers.
+ *
+ * Two seams inverted, nothing else:
+ *   - `useAppSelector`/`useAppDispatch` → `useAgentCatalog()` + the store's
+ *     own methods.
+ *   - `useServerAgentSearch` (a separate frontend hook) is folded IN, because
+ *     it was already wired here and nowhere else: EVERY agent surface that
+ *     uses a consumer searches the full server-side set. A local-only search
+ *     over a paginated list reports "no results" for agents that were merely
+ *     never fetched — a wrong answer, not a missing feature.
+ */
+
+interface UseAgentConsumerReturn {
+    tab: AgentTab;
+    sortBy: AgentSortOption;
+    searchTerm: string;
+    includedCats: string[];
+    includedTags: string[];
+    favFilter: AgentFavFilter;
+    archFilter: AgentArchFilter;
+    accessFilter: AgentAccessFilter;
+    favoritesFirst: boolean;
+    listPage: number;
+    sharedPage: number;
+    /** The whole slot, for the selectors that take a consumer state. */
+    state: AgentConsumerState;
+    /** True if any filter differs from its default value. */
+    hasActiveFilters: boolean;
+    /** Tier 2 search — also match against agent prompt content. */
+    deepSearch: boolean;
+    /** True while a server-side search is in flight. */
+    isServerSearching: boolean;
+    setSearchTerm: (value: string) => void;
+    setDeepSearch: (value: boolean) => void;
+    setSortBy: (value: AgentSortOption) => void;
+    setTab: (value: AgentTab) => void;
+    setFavFilter: (value: AgentFavFilter) => void;
+    setArchFilter: (value: AgentArchFilter) => void;
+    setAccessFilter: (value: AgentAccessFilter) => void;
+    /** Add category to inclusion set; if already present, remove (toggle). */
+    toggleCategory: (cat: string) => void;
+    /** Add tag to inclusion set; if already present, remove (toggle). */
+    toggleTag: (tag: string) => void;
+    /**
+     * Replace the WHOLE category inclusion set in one write.
+     *
+     * Prefer this over looping `toggleCategory` whenever more than one value
+     * changes. Each `toggleCategory` call computes its next array from the
+     * `includedCats` captured in the CURRENT render, so two toggles fired in the
+     * same tick both start from the same snapshot and the second one's patch
+     * overwrites the first — a "Clear filter" click with three categories active
+     * removes only one. One write of the final set cannot drift that way.
+     */
+    setIncludedCats: (next: string[]) => void;
+    /** Replace the WHOLE tag inclusion set in one write. See setIncludedCats. */
+    setIncludedTags: (next: string[]) => void;
+    toggleFavoritesFirst: () => void;
+    loadMoreList: () => void;
+    loadMoreShared: () => void;
+    resetFilters: () => void;
+}
+declare function useAgentConsumer(consumerId: string, options?: {
+    /** Delete the slot on unmount. Default false — persistent consumers keep state. */
+    unregisterOnUnmount?: boolean;
+    /** Applied only when the consumer is first registered (idempotent). */
+    initialTab?: AgentTab;
+}): UseAgentConsumerReturn;
+
+/**
+ * The four ownership counts a tab strip prints. Declared HERE, beside the code
+ * that computes them, so both the web tab strip and the native one name the
+ * same shape (0.9.0 — it used to live in the web-only `AgentListTabs`).
+ */
+interface AgentListTabCounts {
+    mine: number;
+    shared: number;
+    all: number;
+    system: number;
+}
+interface AgentListCoreOptions {
+    consumerId: string;
+    onSelect?: (agentId: string) => void;
+    navigateTo?: string;
+    /** Route-scoped agent id (chat/builder headers). `undefined` = nothing pinned. */
+    activeAgentIdOverride?: string | null;
+    /**
+     * Tab this surface opens on, applied once on first mount. Admin surfaces
+     * that manage system agents pass `"system"`. When omitted the normal
+     * user heuristic applies (a user with no agents of their own lands on the
+     * public/system catalogue).
+     */
+    initialTab?: AgentTab;
+    /**
+     * ADMIN reading of the "All" tab: blend system agents into it instead of
+     * keeping them to their own tab. See `makeSelectFilteredAgents`.
+     */
+    includeSystemInAll?: boolean;
+    /**
+     * 🚨 THE OWNERSHIP TABS THIS CALL SITE MAY REACH — a HARD restriction, not a
+     * default.
+     *
+     * `AgentListTabs` already hides the buttons this list omits, but hiding a
+     * button never emptied the list behind it: the active tab lives in the
+     * consumer's REMEMBERED state, and `initialTab` is applied exactly once per
+     * mount (`defaultTabAppliedRef`). So a person who had been on "Mine" and
+     * then moved a control that narrows the picker got the personal catalogue
+     * with the tab bar removed — the forbidden list, and no way to see that it
+     * was forbidden. That is the defect Arman named on the mandate binding
+     * screen's global rung (VISION-RECONCILIATION D2, 2026-08-31: the picker
+     * opened on "Mine · 40").
+     *
+     * Given here, the tab is COERCED into the allowed set on every change of it,
+     * not just at mount — so a restriction that arrives later is enforced later.
+     */
+    visibleTabs?: readonly AgentTab[];
+    /** Hide records that are invalid for this call site. */
+    excludeAgentIds?: readonly string[];
+    /**
+     * Show the platform DEFAULT agent for this mandate key at the top of the
+     * list, resolved live through the server (never a hardcoded name). Requires
+     * the catalog to have been built with a `transport`.
+     */
+    defaultMandateKey?: string;
+}
+/**
+ * How long the hover-preview detail panel stays open after the cursor leaves
+ * an agent row (or the panel itself) before it closes. Generous on purpose:
+ * the panel renders to the side of the list, so the user needs ample time to
+ * travel the cursor across the gap to reach it without it vanishing. Paired
+ * with a reserved, non-resizing popover width so the target never moves.
+ */
+declare const HOVER_GRACE_MS = 900;
+/**
+ * THE RULE, ALONE AND TESTABLE: which tab a restricted picker must land on.
+ *
+ * Returns `null` when the current tab is already allowed (nothing to do), and
+ * otherwise the tab to switch to — `initialTab` when that is itself allowed,
+ * else the first allowed tab.
+ */
+declare function coerceVisibleTab(current: AgentTab, allowed: readonly AgentTab[], initialTab?: AgentTab): AgentTab | null;
+declare function useAgentListCore({ consumerId, onSelect, navigateTo, activeAgentIdOverride, initialTab, includeSystemInAll, visibleTabs, excludeAgentIds, defaultMandateKey, }: AgentListCoreOptions): {
+    agents: AgentSummary[];
+    isLoading: boolean;
+    activeAgentId: string | null;
+    pinnedAgent: AgentSummary | null;
+    defaultRow: DefaultRowState | null;
+    allCategories: string[];
+    allTags: string[];
+    consumer: UseAgentConsumerReturn;
+    tabCounts: AgentListTabCounts;
+    activeFilterCount: number;
+    hoveredAgent: AgentSummary | null;
+    setHoveredAgent: react.Dispatch<react.SetStateAction<AgentSummary | null>>;
+    ensureLoaded: () => void;
+    handleSelectAgent: (agent: AgentSummary) => void;
+    handleAgentHover: (agent: AgentSummary, panelOpen: boolean) => void;
+    handleAgentHoverEnd: (agent: AgentSummary, onClear: () => void) => void;
+    handleDetailPanelMouseEnter: () => void;
+    handleDetailPanelMouseLeave: (onClear: () => void) => void;
+};
+
+interface AgentListContentProps {
+    agents: AgentSummary[];
+    isLoading: boolean;
+    consumer: UseAgentConsumerReturn;
+    activeAgentId: string | null;
+    allCategories: string[];
+    allTags: string[];
+    onSelectAgent: (agent: AgentSummary) => void;
+    onDetailPress: (agent: AgentSummary) => void;
+    onFilterChipPress: (panel: "sort" | "categories" | "tags") => void;
+    onReset: () => void;
+    activeFilterCount: number;
+    tabCounts: AgentListTabCounts;
+    visibleTabs?: readonly AgentTab[] | undefined;
+    systemTabLabel?: string | undefined;
+    pinnedAgent?: AgentSummary | null | undefined;
+    defaultRow?: DefaultRowState | null | undefined;
+    autoFocusSearch?: boolean;
+}
+declare function AgentListContent({ agents, isLoading, consumer, activeAgentId, allCategories, allTags, onSelectAgent, onDetailPress, onFilterChipPress, onReset, activeFilterCount, tabCounts, visibleTabs, systemTabLabel, pinnedAgent, defaultRow, autoFocusSearch, }: AgentListContentProps): react.JSX.Element;
+
+interface AgentListTabsProps {
+    consumer: UseAgentConsumerReturn;
+    tabCounts: AgentListTabCounts;
+    visibleTabs?: readonly AgentTab[] | undefined;
+    /** Label for the builtin tab. Users see "Public"; admin surfaces "System". */
+    systemTabLabel?: string | undefined;
+}
+declare function AgentListTabs({ consumer, tabCounts, visibleTabs, systemTabLabel, }: AgentListTabsProps): react.JSX.Element;
+
+interface AgentFilterBarProps {
+    consumer: UseAgentConsumerReturn;
+    allCategories: string[];
+    allTags: string[];
+    activeFilterCount: number;
+    onFilterChipPress: (panel: "sort" | "categories" | "tags") => void;
+    onReset: () => void;
+}
+declare function AgentFilterBar({ consumer, allCategories, allTags, activeFilterCount, onFilterChipPress, onReset, }: AgentFilterBarProps): react.JSX.Element;
+
+interface AgentRowProps {
+    agent: AgentSummary;
+    isActive: boolean;
+    onPress: () => void;
+    onDetailPress: () => void;
+}
+declare function AgentRow({ agent, isActive, onPress, onDetailPress, }: AgentRowProps): react.JSX.Element;
+
+interface AgentDetailCardProps {
+    agent: AgentSummary;
+    onSelect: () => void;
+}
+declare function AgentDetailCard({ agent, onSelect }: AgentDetailCardProps): react.JSX.Element;
+
+type AgentSubViewName = "sort" | "categories" | "tags";
+interface AgentSubViewProps {
+    view: AgentSubViewName;
+    consumer: UseAgentConsumerReturn;
+    allCategories: string[];
+    allTags: string[];
+    search: string;
+    setSearch: (value: string) => void;
+    onBack: () => void;
+}
+declare function AgentSubView({ view, consumer, allCategories, allTags, search, setSearch, onBack, }: AgentSubViewProps): react.JSX.Element;
+
+/**
+ * catalog/native/FavoriteAgentButton.tsx — the native twin of
+ * `catalog/react/FavoriteAgentButton.tsx`. Same one write
+ * (`catalog.setFavorite`, optimistic and rolled back by the store), same
+ * ownership rule: a row you do not own cannot be favourited, and the control
+ * says so instead of silently doing nothing.
+ */
+interface FavoriteAgentButtonProps {
+    id: string;
+    size?: number;
+    disabled?: boolean;
+}
+declare function FavoriteAgentButton({ id, size, disabled, }: FavoriteAgentButtonProps): react.JSX.Element;
+
+declare const SHAPES: {
+    star: {
+        paths: string[];
+        fillable: true;
+    };
+    chevronRight: {
+        paths: string[];
+    };
+    chevronDown: {
+        paths: string[];
+    };
+    search: {
+        paths: string[];
+        circles: {
+            cx: number;
+            cy: number;
+            r: number;
+        }[];
+    };
+    x: {
+        paths: string[];
+    };
+    check: {
+        paths: string[];
+    };
+    arrowUpDown: {
+        paths: string[];
+    };
+    folder: {
+        paths: string[];
+    };
+    tag: {
+        paths: string[];
+        circles: {
+            cx: number;
+            cy: number;
+            r: number;
+            filled: true;
+        }[];
+    };
+    rotateCcw: {
+        paths: string[];
+    };
+    loader: {
+        paths: string[];
+    };
+    alertTriangle: {
+        paths: string[];
+    };
+    /**
+     * The Orchestra marker (Lucide `music-4`): the glyph the Workflow Studio's
+     * picker used for a conductor, kept identical so the same agent wears the
+     * same mark in every client.
+     */
+    music4: {
+        paths: string[];
+        circles: {
+            cx: number;
+            cy: number;
+            r: number;
+        }[];
+    };
+    clock: {
+        paths: string[];
+        circles: {
+            cx: number;
+            cy: number;
+            r: number;
+        }[];
+    };
+    globe: {
+        paths: string[];
+        circles: {
+            cx: number;
+            cy: number;
+            r: number;
+        }[];
+    };
+    users: {
+        paths: string[];
+        circles: {
+            cx: number;
+            cy: number;
+            r: number;
+        }[];
+    };
+    externalLink: {
+        paths: string[];
+    };
+    messageCircle: {
+        paths: string[];
+    };
+    rocket: {
+        paths: string[];
+    };
+    circleCheck: {
+        paths: string[];
+        circles: {
+            cx: number;
+            cy: number;
+            r: number;
+        }[];
+    };
+};
+type AgentCatalogIconName = keyof typeof SHAPES;
+
+/** The `react-native-svg` surface this package uses, structurally. */
+interface SvgModuleLike {
+    default: unknown;
+    Svg?: unknown;
+    Path: unknown;
+    Circle: unknown;
+}
+/** Test seam: forget the probe so a test can exercise both paths. */
+declare function _resetNativeIconState(svg?: SvgModuleLike | null): void;
+/**
+ * Resolve `react-native-svg` once. Kept inside a function (not at module
+ * scope) so importing this file never throws in an environment that has no
+ * such module — an import-time throw would take the whole picker down instead
+ * of degrading it.
+ */
+declare function resolveSvgModule(): SvgModuleLike | null;
+/**
+ * The degradation announcement. Fires ONCE per process, with the remedy.
+ * `report` is the catalog's own `errorSink` — the picker passes it down so
+ * this file never reaches for a console of its own.
+ */
+declare function announceMissingSvgOnce(report: (event: {
+    code: string;
+    message: string;
+    context?: object;
+}) => void): void;
+interface AgentIconProps {
+    name: AgentCatalogIconName;
+    /** Points. Default 14 — the web picker's `w-3.5`. */
+    size?: number;
+    color: string;
+    /** Paint the shape (the favourite star's "on" state). */
+    filled?: boolean;
+    /**
+     * Where the degradation is reported. REQUIRED so nothing here can fail
+     * silently; every call site already holds the catalog's `errorSink`.
+     */
+    report: (event: {
+        code: string;
+        message: string;
+        context?: object;
+    }) => void;
+}
+/**
+ * ONE icon component. `name` picks the shape from the shared path table, so
+ * the native picker can never wear a glyph the web picker does not have.
+ */
+declare function AgentIcon({ name, size, color, filled, report, }: AgentIconProps): react.JSX.Element;
+
+declare function SearchInput({ value, onChange, placeholder, autoFocus, }: {
+    value: string;
+    onChange: (v: string) => void;
+    placeholder: string;
+    autoFocus?: boolean;
+}): react.JSX.Element;
+declare function FilterChip({ icon, label, active, onPress, }: {
+    icon: AgentCatalogIconName;
+    label: string;
+    active: boolean;
+    onPress: () => void;
+}): react.JSX.Element;
+declare function OptionRow({ label, selected, onPress, }: {
+    label: string;
+    selected: boolean;
+    onPress: () => void;
+}): react.JSX.Element;
+declare function CheckRow({ label, checked, onPress, }: {
+    label: string;
+    checked: boolean;
+    onPress: () => void;
+}): react.JSX.Element;
+declare function SidePanelHeader({ title, onClose, }: {
+    title: string;
+    onClose: () => void;
+}): react.JSX.Element;
+
+export { type AgentCatalogIconName, type AgentCatalogLinkComponent, type AgentCatalogNativeColors, type AgentCatalogNativeProviderProps, type AgentCatalogNativeTheme, type AgentCatalogNativeThemeOverride, type AgentCatalogPlatformDefaults, AgentCatalogProvider, type AgentCatalogRenderModelRef, type AgentCatalogUiPorts, AgentDetailCard, type AgentDetailCardProps, AgentFilterBar, type AgentFilterBarProps, AgentIcon, type AgentIconProps, AgentListContent, type AgentListContentProps, type AgentListCoreOptions, AgentListInlinePicker, type AgentListInlinePickerProps, AgentListSheet, type AgentListSheetProps, type AgentListTabCounts, AgentListTabs, type AgentListTabsProps, AgentPickerBody, type AgentPickerProps, AgentRow, type AgentRowProps, AgentSubView, type AgentSubViewName, type AgentSubViewProps, CheckRow, DEFAULT_AGENT_CATALOG_NATIVE_THEME, FavoriteAgentButton, type FavoriteAgentButtonProps, FilterChip, HOVER_GRACE_MS, LIGHT_AGENT_CATALOG_NATIVE_THEME, OptionRow, SearchInput, SidePanelHeader, type UseAgentConsumerReturn, _resetNativeIconState, announceMissingSvgOnce, coerceVisibleTab, resolveAgentCatalogNativeTheme, resolveSvgModule, useAgentCatalog, useAgentCatalogNativeTheme, useAgentCatalogRows, useAgentCatalogState, useAgentCatalogUiPorts, useAgentConsumer, useAgentListCore };