impact-nova 1.3.0 → 1.5.2

package/dist/components/ui/chart/chart.js

@@ -1,14 +1,14 @@
-import { jsx as s, jsxs as v } from "react/jsx-runtime";
+import { jsx as s, jsxs as b } from "react/jsx-runtime";
 import * as n from "react";
 import * as l from "highcharts";
 import H from "highcharts-react-official";
 import { cn as g } from "../../../lib/utils.js";
-import { Skeleton as k } from "../skeleton.js";
-import { Minimize2 as A, Maximize2 as T } from "lucide-react";
-import { Button as j } from "../button.js";
+import { Skeleton as L } from "../skeleton.js";
+import { Minimize2 as A, Maximize2 as j } from "lucide-react";
+import { Button as I } from "../button.js";
 import B from "highcharts/highcharts-more";
 import M from "highcharts/highcharts-3d";
-import I from "highcharts/modules/heatmap";
+import T from "highcharts/modules/heatmap";
 import P from "highcharts/modules/treemap";
 import D from "highcharts/modules/venn";
 import V from "highcharts/modules/stock";
@@ -18,35 +18,36 @@ import J from "highcharts/modules/dumbbell";
 import K from "highcharts/modules/lollipop";
 import Q from "highcharts-border-radius";
 import { getBaseChartOptions as U } from "./chart.utils.js";
+import { useImpactNovaI18n as W } from "../../../i18n/ImpactNovaI18nContext.js";
 const c = (e, r) => {
   typeof e == "function" ? e(r) : typeof e == "object" && e.default && typeof e.default == "function" && e.default(r);
 };
-typeof l == "object" && (c(B, l), c(M, l), c(I, l), c(P, l), c(D, l), c(O, l), c(G, l), c(J, l), c(K, l), c(V, l), c(Q, l));
-const b = n.createContext(null), L = () => {
-  const e = n.useContext(b);
+typeof l == "object" && (c(B, l), c(M, l), c(T, l), c(P, l), c(D, l), c(O, l), c(G, l), c(J, l), c(K, l), c(V, l), c(Q, l));
+const F = n.createContext(null), k = () => {
+  const e = n.useContext(F);
   if (!e)
     throw new Error("Chart components must be used within a ChartContainer");
   return e;
 }, z = n.forwardRef(
-  ({ className: e, children: r, isLoading: i = !1, ...o }, m) => {
-    const a = n.useRef(null), h = n.useRef(null), [u, f] = n.useState(!1), [x, p] = n.useState(!1);
-    n.useImperativeHandle(m, () => a.current);
+  ({ className: e, children: r, isLoading: i = !1, ...o }, f) => {
+    const a = n.useRef(null), u = n.useRef(null), [m, h] = n.useState(!1), [x, p] = n.useState(!1);
+    n.useImperativeHandle(f, () => a.current);
     const w = () => {
       const t = a.current;
       t && (p(!0), t.classList.add("fullscreen-animating"), setTimeout(() => {
-        t.requestFullscreen ? t.requestFullscreen() : t.webkitRequestFullscreen ? t.webkitRequestFullscreen() : t.msRequestFullscreen && t.msRequestFullscreen(), f(!0), t.classList.remove("fullscreen-animating");
+        t.requestFullscreen ? t.requestFullscreen() : t.webkitRequestFullscreen ? t.webkitRequestFullscreen() : t.msRequestFullscreen && t.msRequestFullscreen(), h(!0), t.classList.remove("fullscreen-animating");
       }, 200));
     }, C = () => {
       const t = a.current;
       t && (p(!0), t.classList.add("fullscreen-animating-out"), setTimeout(() => {
-        document.exitFullscreen ? document.exitFullscreen() : document.webkitExitFullscreen ? document.webkitExitFullscreen() : document.msExitFullscreen && document.msExitFullscreen(), f(!1), t.classList.remove("fullscreen-animating-out");
+        document.exitFullscreen ? document.exitFullscreen() : document.webkitExitFullscreen ? document.webkitExitFullscreen() : document.msExitFullscreen && document.msExitFullscreen(), h(!1), t.classList.remove("fullscreen-animating-out");
       }, 200));
     }, q = () => {
-      u ? C() : w();
+      m ? C() : w();
     };
     return n.useEffect(() => {
       const t = () => {
-        document.fullscreenElement || document.webkitFullscreenElement || document.msFullscreenElement || f(!1);
+        document.fullscreenElement || document.webkitFullscreenElement || document.msFullscreenElement || h(!1);
       };
       return document.addEventListener("fullscreenchange", t), document.addEventListener("webkitfullscreenchange", t), () => {
         document.removeEventListener("fullscreenchange", t), document.removeEventListener(
@@ -55,14 +56,14 @@ const b = n.createContext(null), L = () => {
         );
       };
     }, []), n.useEffect(() => {
-      if (!h?.current?.chart) return;
-      const t = h.current.chart;
+      if (!u?.current?.chart) return;
+      const t = u.current.chart;
       let d = null;
       const E = () => {
-        u && a.current ? (d && cancelAnimationFrame(d), d = requestAnimationFrame(() => {
-          const F = a.current;
-          if (!F) return;
-          const R = F.getBoundingClientRect(), N = F.querySelector('[class*="ChartContent"]');
+        m && a.current ? (d && cancelAnimationFrame(d), d = requestAnimationFrame(() => {
+          const v = a.current;
+          if (!v) return;
+          const R = v.getBoundingClientRect(), N = v.querySelector('[class*="ChartContent"]');
           if (N) {
             const y = N.getBoundingClientRect();
             t.setSize(y.width, y.height, !1);
@@ -74,15 +75,15 @@ const b = n.createContext(null), L = () => {
       return window.addEventListener("resize", E), () => {
         d && cancelAnimationFrame(d), window.removeEventListener("resize", E);
       };
-    }, [u]), /* @__PURE__ */ s(
-      b.Provider,
+    }, [m]), /* @__PURE__ */ s(
+      F.Provider,
       {
         value: {
-          isExpanded: u,
+          isExpanded: m,
           toggleFullscreen: q,
           isLoading: i,
           containerRef: a,
-          chartComponentRef: h
+          chartComponentRef: u
         },
         children: /* @__PURE__ */ s(
           "div",
@@ -91,7 +92,7 @@ const b = n.createContext(null), L = () => {
             className: g(
               e,
               "w-full relative bg-card transition-all duration-200 ease-in-out",
-              u && "fixed inset-0 z-50 h-screen w-screen p-4 bg-background flex flex-col",
+              m && "fixed inset-0 z-50 h-screen w-screen p-4 bg-background flex flex-col",
               x && "overflow-hidden"
             ),
             ...o,
@@ -103,66 +104,66 @@ const b = n.createContext(null), L = () => {
   }
 );
 z.displayName = "ChartContainer";
-const W = n.forwardRef(
+const X = n.forwardRef(
   ({ className: e, children: r, ...i }, o) => /* @__PURE__ */ s("div", { ref: o, className: g("flex items-center justify-between mb-4", e), ...i, children: r })
 );
-W.displayName = "ChartHeader";
-const X = n.forwardRef(
+X.displayName = "ChartHeader";
+const Y = n.forwardRef(
   ({ className: e, ...r }, i) => /* @__PURE__ */ s("h3", { ref: i, className: g("text-lg font-semibold leading-none tracking-tight", e), ...r })
 );
-X.displayName = "ChartTitle";
-const Y = n.forwardRef(
+Y.displayName = "ChartTitle";
+const Z = n.forwardRef(
   ({ className: e, ...r }, i) => /* @__PURE__ */ s("div", { ref: i, className: g("flex items-center gap-2", e), ...r })
 );
-Y.displayName = "ChartActions";
-const Z = n.forwardRef(
+Z.displayName = "ChartActions";
+const _ = n.forwardRef(
   ({ className: e, ...r }, i) => {
-    const { toggleFullscreen: o, isExpanded: m } = L();
-    return /* @__PURE__ */ v(
-      j,
+    const { t: o } = W(), { toggleFullscreen: f, isExpanded: a } = k(), u = o("aria.toggleFullscreen");
+    return /* @__PURE__ */ b(
+      I,
       {
         variant: "ghost",
         size: "icon",
-        onClick: o,
+        onClick: f,
         ref: i,
         className: g("h-8 w-8", e),
-        "aria-label": "Toggle Fullscreen",
+        "aria-label": u,
         ...r,
         children: [
-          m ? /* @__PURE__ */ s(A, { className: "h-4 w-4" }) : /* @__PURE__ */ s(T, { className: "h-4 w-4" }),
-          /* @__PURE__ */ s("span", { className: "sr-only", children: "Toggle Fullscreen" })
+          a ? /* @__PURE__ */ s(A, { className: "h-4 w-4" }) : /* @__PURE__ */ s(j, { className: "h-4 w-4" }),
+          /* @__PURE__ */ s("span", { className: "sr-only", children: u })
         ]
       }
     );
   }
 );
-Z.displayName = "ChartFullScreen";
+_.displayName = "ChartFullScreen";
 const S = n.forwardRef(
-  ({ className: e, children: r, loader: i, ...o }, m) => {
-    const { isLoading: a, chartComponentRef: h, isExpanded: u } = L();
-    return a && i ? /* @__PURE__ */ s("div", { ref: m, className: g(e, "w-full relative flex items-center justify-center flex-1 min-h-[300px]", u && "min-h-0"), ...o, children: i }) : /* @__PURE__ */ v("div", { ref: m, className: g(e, "w-full relative flex-1 min-h-[300px]", u && "min-h-0"), ...o, children: [
-      a && /* @__PURE__ */ v("div", { className: "absolute inset-0 z-10 bg-background/50 flex flex-col gap-2 p-4", children: [
-        /* @__PURE__ */ s(k, { className: "h-8 w-1/3" }),
-        /* @__PURE__ */ s(k, { className: "flex-1 w-full" })
+  ({ className: e, children: r, loader: i, ...o }, f) => {
+    const { isLoading: a, chartComponentRef: u, isExpanded: m } = k();
+    return a && i ? /* @__PURE__ */ s("div", { ref: f, className: g(e, "w-full relative flex items-center justify-center flex-1 min-h-[300px]", m && "min-h-0"), ...o, children: i }) : /* @__PURE__ */ b("div", { ref: f, className: g(e, "w-full relative flex-1 min-h-[300px]", m && "min-h-0"), ...o, children: [
+      a && /* @__PURE__ */ b("div", { className: "absolute inset-0 z-10 bg-background/50 flex flex-col gap-2 p-4", children: [
+        /* @__PURE__ */ s(L, { className: "h-8 w-1/3" }),
+        /* @__PURE__ */ s(L, { className: "flex-1 w-full" })
       ] }),
-      n.Children.map(r, (f) => n.isValidElement(f) ? n.cloneElement(f, { ref: h }) : f)
+      n.Children.map(r, (h) => n.isValidElement(h) ? n.cloneElement(h, { ref: u }) : h)
     ] });
   }
 );
 S.displayName = "ChartContent";
-const _ = n.forwardRef(
+const $ = n.forwardRef(
   (e, r) => {
     const {
       height: i,
       width: o,
-      className: m,
+      className: f,
       isLoading: a,
-      loader: h,
-      title: u,
-      children: f,
+      loader: u,
+      title: m,
+      children: h,
       ...x
-    } = e, p = n.useContext(b), w = n.useMemo(() => {
-      const C = U({ title: u, ...x });
+    } = e, p = n.useContext(F), w = n.useMemo(() => {
+      const C = U({ title: m, ...x });
       return {
         ...C,
         chart: {
@@ -180,7 +181,7 @@ const _ = n.forwardRef(
         ref: r,
         containerProps: { style: { height: "100%", width: "100%" } }
       }
-    ) : /* @__PURE__ */ s(z, { className: m, isLoading: a, children: /* @__PURE__ */ s(S, { loader: h, children: /* @__PURE__ */ s(
+    ) : /* @__PURE__ */ s(z, { className: f, isLoading: a, children: /* @__PURE__ */ s(S, { loader: u, children: /* @__PURE__ */ s(
       H,
       {
         highcharts: l,
@@ -191,13 +192,13 @@ const _ = n.forwardRef(
     ) }) });
   }
 );
-_.displayName = "Chart";
+$.displayName = "Chart";
 export {
-  _ as Chart,
-  Y as ChartActions,
+  $ as Chart,
+  Z as ChartActions,
   z as ChartContainer,
   S as ChartContent,
-  Z as ChartFullScreen,
-  W as ChartHeader,
-  X as ChartTitle
+  _ as ChartFullScreen,
+  X as ChartHeader,
+  Y as ChartTitle
 };

package/dist/components/ui/chips.js

@@ -1,10 +1,11 @@
 import { jsxs as l, jsx as t } from "react/jsx-runtime";
-import * as m from "react";
-import { Slot as f } from "@radix-ui/react-slot";
-import { cva as g } from "class-variance-authority";
-import { Cross as x } from "../../icons/index.js";
-import { cn as b } from "../../lib/utils.js";
-const v = g(
+import * as f from "react";
+import { Slot as g } from "@radix-ui/react-slot";
+import { cva as x } from "class-variance-authority";
+import { Cross as b } from "../../icons/index.js";
+import { cn as v } from "../../lib/utils.js";
+import { useImpactNovaI18n as h } from "../../i18n/ImpactNovaI18nContext.js";
+const y = x(
   "inline-flex items-center gap-1.5 px-2.5 py-0.5 text-xs font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
   {
     variants: {
@@ -31,38 +32,41 @@ const v = g(
       shape: "pill"
     }
   }
-), h = m.forwardRef(
-  ({ className: n, variant: r, size: e, shape: o, onRemove: a, removable: i, asChild: d = !1, children: s, ...p }, c) => /* @__PURE__ */ l(
-    d ? f : "div",
-    {
-      ref: c,
-      className: b(v({ variant: r, size: e, shape: o }), n),
-      "data-component": "chip",
-      "data-variant": r ?? "default",
-      "data-size": e ?? "md",
-      "data-shape": o ?? "pill",
-      ...p,
-      children: [
-        s,
-        i && /* @__PURE__ */ t(
-          "button",
-          {
-            type: "button",
-            onClick: (u) => {
-              u.stopPropagation(), a?.();
-            },
-            className: "ml-1 p-1 rounded-full hover:bg-black/20 focus:outline-none focus:ring-2 focus:ring-ring",
-            "aria-label": "Remove",
-            "data-component": "chip-remove",
-            children: /* @__PURE__ */ t(x, { size: 8 })
-          }
-        )
-      ]
-    }
-  )
+), C = f.forwardRef(
+  ({ className: a, variant: r, size: o, shape: e, onRemove: n, removable: i, asChild: s = !1, children: d, ...p }, c) => {
+    const { t: u } = h();
+    return /* @__PURE__ */ l(
+      s ? g : "div",
+      {
+        ref: c,
+        className: v(y({ variant: r, size: o, shape: e }), a),
+        "data-component": "chip",
+        "data-variant": r ?? "default",
+        "data-size": o ?? "md",
+        "data-shape": e ?? "pill",
+        ...p,
+        children: [
+          d,
+          i && /* @__PURE__ */ t(
+            "button",
+            {
+              type: "button",
+              onClick: (m) => {
+                m.stopPropagation(), n?.();
+              },
+              className: "ml-1 p-1 rounded-full hover:bg-black/20 focus:outline-none focus:ring-2 focus:ring-ring",
+              "aria-label": u("aria.remove"),
+              "data-component": "chip-remove",
+              children: /* @__PURE__ */ t(b, { size: 8 })
+            }
+          )
+        ]
+      }
+    );
+  }
 );
-h.displayName = "Chip";
+C.displayName = "Chip";
 export {
-  h as Chip,
-  v as chipVariants
+  C as Chip,
+  y as chipVariants
 };

package/dist/components/ui/command-palette/command-palette-context.d.ts

@@ -0,0 +1,52 @@
+import { ShortcutRegistry, ConflictInfo } from './shortcut-registry';
+import { CommandDefinition, KeyBinding, ShortcutScope } from './utils';
+/**
+ * CommandPaletteProvider — React context that wraps ShortcutRegistry,
+ * manages ⌘K open/close, and provides the API to all descendants.
+ */
+import * as React from 'react';
+export interface CommandPaletteContextValue {
+    /** The underlying registry instance */
+    registry: ShortcutRegistry;
+    /** Whether the command palette dialog is open */
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    /** Register a command (auto-applies saved overrides) */
+    registerCommand: (command: CommandDefinition) => void;
+    /** Unregister a command by ID */
+    unregisterCommand: (commandId: string) => void;
+    /** Update a command's keybinding (returns conflict info if any) */
+    updateKeybinding: (commandId: string, keybinding: KeyBinding) => {
+        success: boolean;
+        conflict?: ConflictInfo;
+        reserved?: boolean;
+    };
+    /** Reset a command's keybinding to default */
+    resetKeybinding: (commandId: string) => void;
+    /** Get all commands for the palette */
+    getPaletteCommands: () => CommandDefinition[];
+    /** Get all commands for settings */
+    getSettingsCommands: () => CommandDefinition[];
+    /** Get effective keybinding for a command */
+    getEffectiveKeybinding: (commandId: string) => KeyBinding | undefined;
+    /** Get recent command IDs (most recent first) */
+    getRecentCommandIds: () => string[];
+    /** Push/pop scope */
+    pushScope: (scope: ShortcutScope) => void;
+    popScope: (scope: ShortcutScope) => void;
+    /** Set/get the currently focused instance (for multi-table dispatch) */
+    setActiveInstance: (instance: string | null) => void;
+    getActiveInstance: () => string | null;
+    /** Force a re-render of consumers (incremented on registry change) */
+    version: number;
+}
+export interface CommandPaletteProviderProps {
+    children: React.ReactNode;
+    /** Custom keybinding to open the palette (defaults to ⌘K / Ctrl+K) */
+    openKeybinding?: KeyBinding;
+}
+export declare function CommandPaletteProvider({ children, openKeybinding, }: CommandPaletteProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace CommandPaletteProvider {
+    var displayName: string;
+}
+export declare function useCommandPalette(): CommandPaletteContextValue;

package/dist/components/ui/command-palette/command-palette-context.js

@@ -0,0 +1,110 @@
+import { jsx as R } from "react/jsx-runtime";
+import * as e from "react";
+import { ShortcutRegistry as A } from "./shortcut-registry.js";
+import { matchesKeybinding as N } from "./utils.js";
+const h = e.createContext(null);
+function T({
+  children: o,
+  openKeybinding: u = { key: "k", meta: !0 }
+}) {
+  const n = e.useRef(null);
+  n.current || (n.current = new A());
+  const s = n.current, [c, i] = e.useState(!1), [l, K] = e.useState(0);
+  e.useEffect(() => s.subscribe(() => {
+    K((r) => r + 1);
+  }), [s]), e.useEffect(() => {
+    const t = (r) => {
+      const a = r.target, I = a.closest?.("[data-command-palette]"), x = a.tagName === "INPUT" || a.tagName === "TEXTAREA" || a.tagName === "SELECT" || a.isContentEditable;
+      if (N(r, u)) {
+        r.preventDefault(), r.stopPropagation(), i((w) => !w);
+        return;
+      }
+      c || x && !I && !(r.metaKey || r.ctrlKey) || s.handleKeyEvent(r);
+    };
+    return window.addEventListener("keydown", t, !0), () => window.removeEventListener("keydown", t, !0);
+  }, [s, c, u]);
+  const m = e.useCallback(
+    (t) => n.current.register(t),
+    []
+  ), d = e.useCallback(
+    (t) => n.current.unregister(t),
+    []
+  ), C = e.useCallback(
+    (t, r) => n.current.updateKeybinding(t, r),
+    []
+  ), g = e.useCallback(
+    (t) => n.current.resetKeybinding(t),
+    []
+  ), p = e.useCallback(
+    () => n.current.getPaletteCommands(),
+    []
+  ), b = e.useCallback(
+    () => n.current.getSettingsCommands(),
+    []
+  ), f = e.useCallback(
+    (t) => n.current.getEffectiveKeybinding(t),
+    []
+  ), y = e.useCallback(
+    () => n.current.getRecentCommandIds(),
+    []
+  ), P = e.useCallback(
+    (t) => n.current.pushScope(t),
+    []
+  ), k = e.useCallback(
+    (t) => n.current.popScope(t),
+    []
+  ), E = e.useCallback(
+    (t) => n.current.setActiveInstance(t),
+    []
+  ), v = e.useCallback(
+    () => n.current.getActiveInstance(),
+    []
+  ), S = e.useMemo(() => ({
+    registry: s,
+    open: c,
+    setOpen: i,
+    registerCommand: m,
+    unregisterCommand: d,
+    updateKeybinding: C,
+    resetKeybinding: g,
+    getPaletteCommands: p,
+    getSettingsCommands: b,
+    getEffectiveKeybinding: f,
+    getRecentCommandIds: y,
+    pushScope: P,
+    popScope: k,
+    setActiveInstance: E,
+    getActiveInstance: v,
+    version: l
+  }), [
+    s,
+    c,
+    l,
+    m,
+    d,
+    C,
+    g,
+    p,
+    b,
+    f,
+    y,
+    P,
+    k,
+    E,
+    v
+  ]);
+  return /* @__PURE__ */ R(h.Provider, { value: S, children: o });
+}
+T.displayName = "CommandPaletteProvider";
+function V() {
+  const o = e.useContext(h);
+  if (!o)
+    throw new Error(
+      "useCommandPalette must be used within a <CommandPaletteProvider>. Wrap your application root with <CommandPaletteProvider>."
+    );
+  return o;
+}
+export {
+  T as CommandPaletteProvider,
+  V as useCommandPalette
+};

package/dist/components/ui/command-palette/command-palette.d.ts

@@ -0,0 +1,67 @@
+import { CommandDefinition, KeyBinding } from './utils';
+/**
+ * CommandPalette — The ⌘K overlay with search, grouped results, and keyboard navigation.
+ *
+ * Built from scratch using existing impact-nova Dialog, Input, and Separator components.
+ * Implements fuzzy search, keyboard navigation (↑↓ Enter Esc), recently-used sorting,
+ * and displays shortcut badges via the Kbd component.
+ *
+ * Sub-components exported:
+ *   CommandPalette, CommandPaletteInput, CommandPaletteList,
+ *   CommandPaletteGroup, CommandPaletteItem, CommandPaletteShortcut,
+ *   CommandPaletteEmpty, CommandPaletteSeparator, CommandPaletteFooter
+ */
+import * as React from 'react';
+export interface CommandPaletteProps {
+    className?: string;
+    children?: React.ReactNode;
+    /** Custom list of commands (overrides automatic registry commands) */
+    commands?: CommandDefinition[];
+    /** Placeholder text for the search input */
+    placeholder?: string;
+    /** Called when a command is executed */
+    onCommandExecute?: (command: CommandDefinition) => void;
+    /** Called when the palette opens/closes */
+    onOpenChange?: (open: boolean) => void;
+}
+declare function CommandPalette({ className, children, commands: externalCommands, placeholder, onCommandExecute, onOpenChange, }: CommandPaletteProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CommandPalette {
+    var displayName: string;
+}
+export interface CommandPaletteInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    onValueChange?: (value: string) => void;
+}
+declare const CommandPaletteInput: React.ForwardRefExoticComponent<CommandPaletteInputProps & React.RefAttributes<HTMLInputElement>>;
+declare const CommandPaletteList: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export interface CommandPaletteGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    heading?: string;
+}
+declare const CommandPaletteGroup: React.ForwardRefExoticComponent<CommandPaletteGroupProps & React.RefAttributes<HTMLDivElement>>;
+export interface CommandPaletteItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    command: CommandDefinition;
+    isSelected?: boolean;
+    onSelect?: () => void;
+    keybinding?: KeyBinding;
+}
+declare const CommandPaletteItem: React.ForwardRefExoticComponent<CommandPaletteItemProps & React.RefAttributes<HTMLDivElement>>;
+export interface CommandPaletteShortcutProps extends React.HTMLAttributes<HTMLSpanElement> {
+    keybinding: KeyBinding;
+    isSelected?: boolean;
+}
+declare function CommandPaletteShortcut({ keybinding, isSelected, className, ...props }: CommandPaletteShortcutProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CommandPaletteShortcut {
+    var displayName: string;
+}
+declare function CommandPaletteEmpty({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare namespace CommandPaletteEmpty {
+    var displayName: string;
+}
+declare function CommandPaletteSeparator({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare namespace CommandPaletteSeparator {
+    var displayName: string;
+}
+declare function CommandPaletteFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+declare namespace CommandPaletteFooter {
+    var displayName: string;
+}
+export { CommandPalette, CommandPaletteInput, CommandPaletteList, CommandPaletteGroup, CommandPaletteItem, CommandPaletteShortcut, CommandPaletteEmpty, CommandPaletteSeparator, CommandPaletteFooter, };