@sekiui/elements 0.0.65 → 0.0.70

package/dist/types/components.d.ts

@@ -11,11 +11,17 @@ import { BadgeVariant } from "./components/badge/seki-badge.interface";
 import { CalendarMode, DateRange } from "./components/calendar/seki-calendar";
 import { WeekStartsOn } from "./utils/calendar/date-utils";
 import { CarouselContext } from "./components/carousel/seki-carousel";
+import { ChartData, ChartOptions, ChartType } from "./components/chart/chart-types";
+import { ComboboxChangeEventDetail, ComboboxCustomValueEventDetail, ComboboxEmptyReason, ComboboxItem, ComboboxMultiSelectDisplay, ComboboxSearchEventDetail, ComboboxValue } from "./utils/combobox";
 import { ColumnDef, ColumnReorderDetail, ColumnResizeDetail, ColumnsChangeDetail, FilterChangeDetail, FilterValue, PageChangeDetail, RowClickDetail, RowExpandDetail, SelectionChangeDetail, SortChangeDetail } from "./components/data-table/interfaces";
 import { DatePickerMode, DateRange as DateRange1 } from "./components/date-picker/seki-date-picker";
+import { DrawerDirection } from "./components/drawer/seki-drawer-content";
 import { DropdownMenuAlign, DropdownMenuSide } from "./components/dropdown-menu/seki-dropdown-menu";
 import { DropdownMenuAlign as DropdownMenuAlign1, DropdownMenuSide as DropdownMenuSide1 } from "./components/dropdown-menu/seki-dropdown-menu";
+import { HoverCardAlign, HoverCardSide } from "./components/hover-card/seki-hover-card";
+import { HoverCardAlign as HoverCardAlign1, HoverCardSide as HoverCardSide1 } from "./components/hover-card/seki-hover-card";
 import { Event } from "./stencil-public-runtime";
+import { MenubarContentAlign, MenubarContentSide } from "./components/menubar/types";
 import { NavigationMenuContext } from "./components/navigation-menu/seki-navigation-menu";
 import { PopoverAlign, PopoverSide } from "./components/popover/seki-popover";
 import { PopoverAlign as PopoverAlign1, PopoverSide as PopoverSide1 } from "./components/popover/seki-popover";
@@ -27,6 +33,7 @@ import { SpinnerColor, SpinnerSize } from "./components/spinner/seki-spinner.int
 import { TableCellAlign } from "./components/table/seki-table-cell";
 import { TableHeadAlign } from "./components/table/seki-table-head";
 import { ToastPosition } from "./components/toast/seki-toaster";
+import { ToggleGroupValueChangeEventDetail } from "./utils/toggle-group";
 import { TooltipHideDetail, TooltipPositionedDetail, TooltipShowDetail, TooltipSide } from "./components/tooltip/seki-tooltip";
 export { AlertVariant } from "./components/alert/seki-alert";
 export { AvatarShape, AvatarSize } from "./components/avatar/seki-avatar";
@@ -34,11 +41,17 @@ export { BadgeVariant } from "./components/badge/seki-badge.interface";
 export { CalendarMode, DateRange } from "./components/calendar/seki-calendar";
 export { WeekStartsOn } from "./utils/calendar/date-utils";
 export { CarouselContext } from "./components/carousel/seki-carousel";
+export { ChartData, ChartOptions, ChartType } from "./components/chart/chart-types";
+export { ComboboxChangeEventDetail, ComboboxCustomValueEventDetail, ComboboxEmptyReason, ComboboxItem, ComboboxMultiSelectDisplay, ComboboxSearchEventDetail, ComboboxValue } from "./utils/combobox";
 export { ColumnDef, ColumnReorderDetail, ColumnResizeDetail, ColumnsChangeDetail, FilterChangeDetail, FilterValue, PageChangeDetail, RowClickDetail, RowExpandDetail, SelectionChangeDetail, SortChangeDetail } from "./components/data-table/interfaces";
 export { DatePickerMode, DateRange as DateRange1 } from "./components/date-picker/seki-date-picker";
+export { DrawerDirection } from "./components/drawer/seki-drawer-content";
 export { DropdownMenuAlign, DropdownMenuSide } from "./components/dropdown-menu/seki-dropdown-menu";
 export { DropdownMenuAlign as DropdownMenuAlign1, DropdownMenuSide as DropdownMenuSide1 } from "./components/dropdown-menu/seki-dropdown-menu";
+export { HoverCardAlign, HoverCardSide } from "./components/hover-card/seki-hover-card";
+export { HoverCardAlign as HoverCardAlign1, HoverCardSide as HoverCardSide1 } from "./components/hover-card/seki-hover-card";
 export { Event } from "./stencil-public-runtime";
+export { MenubarContentAlign, MenubarContentSide } from "./components/menubar/types";
 export { NavigationMenuContext } from "./components/navigation-menu/seki-navigation-menu";
 export { PopoverAlign, PopoverSide } from "./components/popover/seki-popover";
 export { PopoverAlign as PopoverAlign1, PopoverSide as PopoverSide1 } from "./components/popover/seki-popover";
@@ -50,6 +63,7 @@ export { SpinnerColor, SpinnerSize } from "./components/spinner/seki-spinner.int
 export { TableCellAlign } from "./components/table/seki-table-cell";
 export { TableHeadAlign } from "./components/table/seki-table-head";
 export { ToastPosition } from "./components/toast/seki-toaster";
+export { ToggleGroupValueChangeEventDetail } from "./utils/toggle-group";
 export { TooltipHideDetail, TooltipPositionedDetail, TooltipShowDetail, TooltipSide } from "./components/tooltip/seki-tooltip";
 export namespace Components {
     /**
@@ -144,6 +158,70 @@ export namespace Components {
          */
         "class"?: string;
     }
+    /**
+     * Alert Dialog root component for confirmation dialogs
+     * A modal dialog that interrupts the user with important content and expects a response.
+     * Wraps seki-dialog internally with Alert Dialog-specific behavior.
+     */
+    interface SekiAlertDialog {
+        /**
+          * Closes the alert dialog
+         */
+        "closeDialog": () => Promise<void>;
+        /**
+          * Default open state (uncontrolled)
+          * @default false
+         */
+        "defaultOpen": boolean;
+        /**
+          * Controlled open state
+          * @default false
+         */
+        "open": boolean;
+        /**
+          * Opens the alert dialog
+         */
+        "openDialog": () => Promise<void>;
+    }
+    /**
+     * Alert Dialog Action Button Component
+     * A button that confirms and closes the alert dialog. Supports default and destructive variants
+     * for different action types. Emits a sekiAction event before closing.
+     */
+    interface SekiAlertDialogAction {
+        /**
+          * The visual variant of the action button - 'default': Primary button style for standard confirmations - 'destructive': Red/danger style for destructive actions
+          * @default 'default'
+         */
+        "variant": 'default' | 'destructive';
+    }
+    /**
+     * Alert Dialog Cancel Button Component
+     * A button that cancels and closes the alert dialog without confirming the action.
+     * Emits a sekiCancel event before closing.
+     */
+    interface SekiAlertDialogCancel {
+    }
+    /**
+     * Alert Dialog Content Component
+     * The content panel for the alert dialog with role="alertdialog".
+     * This is a modal dialog that interrupts the user with important content
+     * and expects a response. Unlike regular dialogs, it does NOT close on
+     * overlay click - users must explicitly confirm or cancel.
+     */
+    interface SekiAlertDialogContent {
+        /**
+          * Whether pressing Escape closes the alert dialog
+          * @default true
+         */
+        "closeOnEscape": boolean;
+    }
+    /**
+     * Alert Dialog Trigger Component
+     * The element that opens the alert dialog when clicked.
+     */
+    interface SekiAlertDialogTrigger {
+    }
     /**
      * Title text within an alert component.
      * Renders as a heading with appropriate typography styles.
@@ -622,6 +700,21 @@ export namespace Components {
      */
     interface SekiCarouselPrevious {
     }
+    interface SekiChart {
+        "colors"?: string[];
+        "data"?: ChartData;
+        "dataJson"?: string;
+        /**
+          * @default '300px'
+         */
+        "height": string;
+        "options"?: ChartOptions;
+        "optionsJson"?: string;
+        /**
+          * @default 'line'
+         */
+        "type": ChartType;
+    }
     /**
      * @component seki-checkbox
      * @description A checkbox control that allows users to toggle between checked, unchecked,
@@ -717,6 +810,270 @@ export namespace Components {
          */
         "asChild": boolean;
     }
+    interface SekiCombobox {
+        /**
+          * Allow values not in the list
+          * @default false
+         */
+        "allowCustomValue": boolean;
+        /**
+          * ID of element that describes this combobox
+         */
+        "ariaDescribedby"?: string;
+        /**
+          * Accessible label for screen readers
+         */
+        "ariaLabel"?: string;
+        /**
+          * ID of element that labels this combobox
+         */
+        "ariaLabelledby"?: string;
+        /**
+          * Clear all selections
+         */
+        "clearSelection": () => Promise<void>;
+        /**
+          * Programmatically close the dropdown
+         */
+        "closeDropdown": () => Promise<void>;
+        /**
+          * Debounce delay for search (ms)
+          * @default 300
+         */
+        "debounce": number;
+        /**
+          * Initial dropdown open state (uncontrolled mode)
+          * @default false
+         */
+        "defaultOpen": boolean;
+        /**
+          * Initial selected value (uncontrolled mode)
+         */
+        "defaultValue"?: ComboboxValue;
+        /**
+          * Disable component
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Static items for client-side filtering
+         */
+        "items"?: ComboboxItem[];
+        /**
+          * Set loading state externally (for async)
+          * @default false
+         */
+        "loading": boolean;
+        /**
+          * Multi-select display mode
+          * @default 'chips'
+         */
+        "multiSelectDisplay": ComboboxMultiSelectDisplay;
+        /**
+          * Enable multi-select mode
+          * @default false
+         */
+        "multiple": boolean;
+        /**
+          * Control dropdown open state (controlled mode)
+         */
+        "open"?: boolean;
+        /**
+          * Programmatically open the dropdown
+         */
+        "openDropdown": () => Promise<void>;
+        /**
+          * Placeholder text
+          * @default 'Search...'
+         */
+        "placeholder": string;
+        /**
+          * Mark as required
+          * @default false
+         */
+        "required": boolean;
+        /**
+          * Set the search query programmatically
+         */
+        "setQuery": (query: string) => Promise<void>;
+        /**
+          * Current selected value (controlled mode)
+         */
+        "value"?: ComboboxValue;
+    }
+    interface SekiComboboxContent {
+        /**
+          * Maximum height of the dropdown
+          * @default '15rem'
+         */
+        "maxHeight": string;
+    }
+    /**
+     * seki-combobox-empty: Display empty/loading/error states for combobox dropdown
+     * @component ComboboxEmpty
+     * @example <seki-combobox-empty reason="no-results">
+     *   No results found.
+     * </seki-combobox-empty>
+     * @example <seki-combobox-empty reason="loading">
+     *   <span slot="loading">Loading...</span>
+     * </seki-combobox-empty>
+     */
+    interface SekiComboboxEmpty {
+        /**
+          * The reason why the combobox is showing an empty state
+          * @default 'no-results'
+         */
+        "reason": ComboboxEmptyReason;
+    }
+    interface SekiComboboxGroup {
+        /**
+          * Group label
+         */
+        "label": string;
+    }
+    interface SekiComboboxInput {
+    }
+    interface SekiComboboxItem {
+        /**
+          * Disable this item
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Item value
+         */
+        "value": string;
+    }
+    /**
+     * Command root component - command palette for navigation
+     */
+    interface SekiCommand {
+        /**
+          * Enable built-in filtering
+          * @default true
+         */
+        "filter": boolean;
+        /**
+          * Controlled search value
+          * @default ''
+         */
+        "value": string;
+    }
+    /**
+     * Command empty state - shown when no results match
+     */
+    interface SekiCommandEmpty {
+    }
+    /**
+     * Command group - groups related items with a heading
+     */
+    interface SekiCommandGroup {
+        /**
+          * Show even when all items are filtered out
+          * @default false
+         */
+        "forceMount": boolean;
+        /**
+          * Group header text
+         */
+        "heading": string;
+    }
+    /**
+     * Command input - search field for filtering items
+     */
+    interface SekiCommandInput {
+        /**
+          * Focus the input
+         */
+        "focusInput": () => Promise<void>;
+        /**
+          * Placeholder text
+          * @default 'Type a command or search...'
+         */
+        "placeholder": string;
+    }
+    /**
+     * Command item - selectable option in the command list
+     */
+    interface SekiCommandItem {
+        /**
+          * Whether the item is disabled
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Additional search terms (space-separated)
+         */
+        "keywords"?: string;
+        /**
+          * Keyboard shortcut hint (e.g., "⌘K")
+         */
+        "shortcut"?: string;
+        /**
+          * Unique value emitted on select
+         */
+        "value": string;
+    }
+    /**
+     * Command list - scrollable container for items and groups
+     */
+    interface SekiCommandList {
+    }
+    /**
+     * Command separator/divider
+     */
+    interface SekiCommandSeparator {
+    }
+    /**
+     * Context Menu component - right-click context menu with items
+     */
+    interface SekiContextMenu {
+        /**
+          * Close the menu
+         */
+        "closeMenu": () => Promise<void>;
+        /**
+          * Controlled open state
+          * @default false
+         */
+        "open": boolean;
+        /**
+          * Open the menu at specified coordinates
+          * @param x - X coordinate (typically from mouse event)
+          * @param y - Y coordinate (typically from mouse event)
+         */
+        "openMenu": (x: number, y: number) => Promise<void>;
+    }
+    /**
+     * Context Menu content panel - displays at cursor position
+     */
+    interface SekiContextMenuContent {
+        /**
+          * Accessible label for the menu
+         */
+        "ariaLabel"?: string;
+    }
+    /**
+     * Context Menu trigger component
+     * Handles right-click (desktop) and long-press (touch) to open context menu
+     */
+    interface SekiContextMenuTrigger {
+        /**
+          * Whether the trigger is disabled
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Duration in milliseconds for long press on touch devices
+          * @default 500
+         */
+        "longPressDuration": number;
+        /**
+          * Movement threshold in pixels before canceling long press
+          * @default 10
+         */
+        "moveThreshold": number;
+    }
     interface SekiDataTable {
         /**
           * Buffer rows above/below viewport
@@ -995,6 +1352,73 @@ export namespace Components {
      */
     interface SekiDialogTrigger {
     }
+    /**
+     * seki-drawer: Mobile-friendly drawer component with swipe gestures
+     * @component Drawer
+     * @example <seki-drawer>
+     *   <seki-sheet-trigger>
+     *     <seki-button>Open Drawer</seki-button>
+     *   </seki-sheet-trigger>
+     *   <seki-drawer-content direction="bottom" snap-points="0.5,1">
+     *     <seki-sheet-header>
+     *       <seki-sheet-title>Title</seki-sheet-title>
+     *     </seki-sheet-header>
+     *     Content here
+     *   </seki-drawer-content>
+     * </seki-drawer>
+     */
+    interface SekiDrawer {
+        /**
+          * Closes the drawer
+         */
+        "close": () => Promise<void>;
+        /**
+          * Opens the drawer
+         */
+        "open": () => Promise<void>;
+        /**
+          * Snaps to a specific point (0-1)
+         */
+        "snapTo": (point: number) => Promise<void>;
+        /**
+          * Toggles the drawer
+         */
+        "toggle": () => Promise<void>;
+    }
+    /**
+     * seki-drawer-content: Container for drawer content with gesture support
+     * @component DrawerContent
+     */
+    interface SekiDrawerContent {
+        /**
+          * Accessible label for the drawer
+         */
+        "ariaLabel"?: string;
+        /**
+          * Distance threshold (0-1) to trigger close when dragging
+          * @default 0.5
+         */
+        "closeThreshold": number;
+        /**
+          * Direction the drawer slides in from
+          * @default 'bottom'
+         */
+        "direction": DrawerDirection;
+        /**
+          * Show the drag handle indicator Default: true for bottom/top, false for left/right
+         */
+        "showHandle"?: boolean;
+        /**
+          * Comma-separated snap points (0-1). E.g., "0.5,1" for half and full open
+          * @default '1'
+         */
+        "snapPoints": string;
+        /**
+          * Velocity threshold (px/s) to trigger close on quick swipe
+          * @default 500
+         */
+        "velocityThreshold": number;
+    }
     /**
      * Dropdown Menu component - context menu with items
      */
@@ -1124,6 +1548,21 @@ export namespace Components {
      */
     interface SekiDropdownMenuShortcut {
     }
+    /**
+     * Dropdown Menu Sub - A submenu component for nested dropdown menus
+     */
+    interface SekiDropdownMenuSub {
+        /**
+          * Delay in milliseconds before closing the submenu on mouse leave
+          * @default 100
+         */
+        "closeDelay": number;
+        /**
+          * Delay in milliseconds before opening the submenu on hover
+          * @default 100
+         */
+        "openDelay": number;
+    }
     /**
      * Dropdown Menu trigger button
      */
@@ -1197,6 +1636,101 @@ export namespace Components {
          */
         "disabled": boolean;
     }
+    /**
+     * Hover Card Container Component
+     * A hover-triggered card component for previewing content (e.g., user profiles, link previews).
+     * Shows a floating card with rich content when hovering over a trigger element.
+     * This container manages state and timing, providing context to child components
+     * (seki-hover-card-trigger and seki-hover-card-content).
+     * @example ```html
+     * <seki-hover-card open-delay="100" close-delay="200">
+     *   <seki-hover-card-trigger>
+     *     <a href="/user/john">@john</a>
+     *   </seki-hover-card-trigger>
+     *   <seki-hover-card-content side="top">
+     *     <div class="user-preview">
+     *       <img src="avatar.jpg" alt="John's avatar" />
+     *       <h4>John Doe</h4>
+     *       <p>Software Engineer at Acme Inc.</p>
+     *     </div>
+     *   </seki-hover-card-content>
+     * </seki-hover-card>
+     * ```
+     */
+    interface SekiHoverCard {
+        /**
+          * Alignment along the side axis
+          * @default 'center'
+         */
+        "align": HoverCardAlign;
+        /**
+          * Milliseconds to delay before closing the hover card
+          * @default 300
+         */
+        "closeDelay": number;
+        /**
+          * Disable hover card interactions
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Milliseconds to delay before opening the hover card
+          * @default 200
+         */
+        "openDelay": number;
+        /**
+          * Preferred side for hover card content placement
+          * @default 'bottom'
+         */
+        "side": HoverCardSide;
+    }
+    /**
+     * Hover Card Content Component
+     * The floating content panel that displays when the hover card is open.
+     * Handles positioning, viewport boundary collision, arrow placement,
+     * and interaction handlers to maintain open state while user interacts with content.
+     * @example ```html
+     * <seki-hover-card-content side="top" align="center">
+     *   <div class="user-preview">
+     *     <img src="avatar.jpg" alt="Avatar" />
+     *     <h4>John Doe</h4>
+     *     <p>Software Engineer</p>
+     *   </div>
+     * </seki-hover-card-content>
+     * ```
+     */
+    interface SekiHoverCardContent {
+        /**
+          * Override the alignment from the parent container
+         */
+        "align"?: HoverCardAlign1;
+        /**
+          * Offset along the alignment axis in pixels
+          * @default 0
+         */
+        "alignOffset": number;
+        /**
+          * Override the side positioning from the parent container
+         */
+        "side"?: HoverCardSide1;
+        /**
+          * Distance from the trigger element in pixels
+          * @default 8
+         */
+        "sideOffset": number;
+    }
+    /**
+     * Hover Card Trigger Component
+     * The trigger element that activates the hover card on hover, focus, or touch.
+     * Handles mouse, keyboard, and touch interactions with appropriate behavior for each.
+     * @example ```html
+     * <seki-hover-card-trigger>
+     *   <a href="/user/john">@john</a>
+     * </seki-hover-card-trigger>
+     * ```
+     */
+    interface SekiHoverCardTrigger {
+    }
     interface SekiInput {
         /**
           * ID of element describing this input
@@ -1278,6 +1812,93 @@ export namespace Components {
          */
         "value"?: string;
     }
+    interface SekiInputAddon {
+        /**
+          * Size variant (usually set by parent input-group)
+          * @default 'md'
+         */
+        "size": 'sm' | 'md' | 'lg';
+    }
+    interface SekiInputGroup {
+        /**
+          * Accessible label for the input group
+         */
+        "ariaLabel"?: string;
+        /**
+          * Whether all children are disabled
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Size applied to all child components (input, addon, button)
+          * @default 'md'
+         */
+        "size": 'sm' | 'md' | 'lg';
+    }
+    interface SekiInputOtp {
+        /**
+          * ID of element describing this input
+         */
+        "ariaDescribedby"?: string;
+        /**
+          * Custom aria-label for the input
+         */
+        "ariaLabel"?: string;
+        /**
+          * Autocomplete hint for mobile keyboards
+          * @default 'one-time-code'
+         */
+        "autocomplete": string;
+        /**
+          * Whether the input is disabled
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Whether the input is in an invalid/error state
+          * @default false
+         */
+        "invalid": boolean;
+        /**
+          * Whether to mask the input (show bullets)
+          * @default false
+         */
+        "masked": boolean;
+        /**
+          * Total number of characters allowed
+          * @default 6
+         */
+        "maxlength": number;
+        /**
+          * Form field name
+         */
+        "name"?: string;
+        /**
+          * Input pattern: 'digits' for numbers only, 'alphanumeric' for letters and numbers
+          * @default 'digits'
+         */
+        "pattern": 'digits' | 'alphanumeric';
+        /**
+          * Whether the input is required
+          * @default false
+         */
+        "required": boolean;
+        /**
+          * Current OTP value
+          * @default ''
+         */
+        "value": string;
+    }
+    interface SekiInputOtpGroup {
+    }
+    interface SekiInputOtpSeparator {
+    }
+    interface SekiInputOtpSlot {
+        /**
+          * The index of this slot (0-based)
+         */
+        "index": number;
+    }
     interface SekiKbd {
         /**
           * Size variant of the kbd element
@@ -1285,6 +1906,179 @@ export namespace Components {
          */
         "size": 'sm' | 'md' | 'lg';
     }
+    /**
+     * Menubar - horizontal menu bar with dropdown menus
+     */
+    interface SekiMenubar {
+        /**
+          * Whether arrow keys wrap around
+          * @default true
+         */
+        "loop": boolean;
+    }
+    /**
+     * Menubar checkbox item - toggleable menu option
+     */
+    interface SekiMenubarCheckbox {
+        /**
+          * Whether the checkbox is checked
+          * @default false
+         */
+        "checked": boolean;
+        /**
+          * Whether the item is disabled
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Keyboard shortcut hint
+         */
+        "shortcut"?: string;
+    }
+    /**
+     * Menubar content - dropdown content container
+     */
+    interface SekiMenubarContent {
+        /**
+          * Alignment along the side
+          * @default 'start'
+         */
+        "align": MenubarContentAlign;
+        /**
+          * Preferred side for placement
+          * @default 'bottom'
+         */
+        "side": MenubarContentSide;
+        /**
+          * Offset from trigger
+          * @default 4
+         */
+        "sideOffset": number;
+    }
+    /**
+     * Menubar group - groups related menu items with optional label
+     */
+    interface SekiMenubarGroup {
+        /**
+          * Optional group label
+         */
+        "label"?: string;
+    }
+    /**
+     * Menubar item - selectable menu option
+     */
+    interface SekiMenubarItem {
+        /**
+          * Whether the item is disabled
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Add left padding for alignment with icons
+          * @default false
+         */
+        "inset": boolean;
+        /**
+          * Keyboard shortcut hint (e.g., "⌘K")
+         */
+        "shortcut"?: string;
+        /**
+          * Value emitted when item is selected
+         */
+        "value"?: string;
+    }
+    /**
+     * Menubar menu - individual menu container
+     */
+    interface SekiMenubarMenu {
+        /**
+          * Unique identifier for this menu
+         */
+        "menuId": string;
+    }
+    /**
+     * Menubar radio item - single-select option
+     */
+    interface SekiMenubarRadio {
+        /**
+          * Whether the item is disabled
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * The value of this radio item
+         */
+        "value": string;
+    }
+    /**
+     * Menubar radio group - container for radio items
+     */
+    interface SekiMenubarRadioGroup {
+        /**
+          * The value of the selected radio item
+         */
+        "value"?: string;
+    }
+    /**
+     * Menubar separator - visual divider between menu items
+     */
+    interface SekiMenubarSeparator {
+    }
+    /**
+     * Menubar shortcut - displays keyboard shortcut hint
+     */
+    interface SekiMenubarShortcut {
+    }
+    /**
+     * Menubar sub - submenu container with hover behavior
+     */
+    interface SekiMenubarSub {
+        /**
+          * Delay before closing on mouse leave (ms)
+          * @default 100
+         */
+        "closeDelay": number;
+        /**
+          * Delay before opening on hover (ms)
+          * @default 100
+         */
+        "openDelay": number;
+    }
+    /**
+     * Menubar sub content - submenu content container
+     */
+    interface SekiMenubarSubContent {
+        /**
+          * Offset from trigger
+          * @default 2
+         */
+        "sideOffset": number;
+    }
+    /**
+     * Menubar sub trigger - opens submenu on hover
+     */
+    interface SekiMenubarSubTrigger {
+        /**
+          * Whether the trigger is disabled
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Add left padding for alignment
+          * @default false
+         */
+        "inset": boolean;
+    }
+    /**
+     * Menubar trigger - button that opens a menu
+     */
+    interface SekiMenubarTrigger {
+        /**
+          * Whether the trigger is disabled
+          * @default false
+         */
+        "disabled": boolean;
+    }
     interface SekiNavigationMenu {
         /**
           * Accessible label for the navigation
@@ -1665,19 +2459,135 @@ export namespace Components {
          */
         "value": string;
     }
-    interface SekiSelect {
+    /**
+     * Resizable handle - draggable divider between panels
+     */
+    interface SekiResizableHandle {
         /**
-          * ID of element that describes this select
+          * Disable this handle
+          * @default false
          */
-        "ariaDescribedby"?: string;
+        "disabled": boolean;
         /**
-          * Accessible label for screen readers
+          * Show visible grip indicator
+          * @default false
          */
-        "ariaLabel"?: string;
+        "withHandle": boolean;
+    }
+    /**
+     * Resizable panel - individual content panel with size constraints
+     */
+    interface SekiResizablePanel {
         /**
-          * ID of element that labels this select
+          * Collapse the panel
          */
-        "ariaLabelledby"?: string;
+        "collapse": () => Promise<void>;
+        /**
+          * Size when collapsed (percentage)
+          * @default 0
+         */
+        "collapsedSize": number;
+        /**
+          * Whether panel can collapse
+          * @default false
+         */
+        "collapsible": boolean;
+        /**
+          * Default size as percentage (0-100)
+         */
+        "defaultSize"?: number;
+        /**
+          * Expand the panel
+         */
+        "expand": () => Promise<void>;
+        /**
+          * Get panel ID (for internal use)
+         */
+        "getPanelId": () => Promise<string>;
+        /**
+          * Get current size
+         */
+        "getSize": () => Promise<number>;
+        /**
+          * Check if collapsed
+         */
+        "isCollapsed": () => Promise<boolean>;
+        /**
+          * Maximum size as percentage
+          * @default 100
+         */
+        "maxSize": number;
+        /**
+          * Minimum size as percentage
+          * @default 0
+         */
+        "minSize": number;
+    }
+    /**
+     * Resizable panel group - container that manages layout direction and coordinates panel sizes
+     */
+    interface SekiResizablePanelGroup {
+        /**
+          * ID for localStorage persistence (enables auto-save when set)
+         */
+        "autoSaveId"?: string;
+        /**
+          * Layout direction
+          * @default 'horizontal'
+         */
+        "direction": 'horizontal' | 'vertical';
+        /**
+          * Disable all resize interactions
+          * @default false
+         */
+        "disabled": boolean;
+    }
+    /**
+     * Scroll Area Component
+     * Augments native scroll functionality with custom, cross-browser styled scrollbars.
+     * Hides native scrollbars and provides custom scrollbar elements that sync with scroll position.
+     * @example <seki-scroll-area style="height: 200px;">
+     *   <div>Scrollable content...</div>
+     *   <seki-scroll-bar slot="scrollbar" orientation="vertical"></seki-scroll-bar>
+     * </seki-scroll-area>
+     */
+    interface SekiScrollArea {
+        /**
+          * Delay in ms before hiding scrollbars (for auto/scroll/hover types)
+          * @default 600
+         */
+        "scrollHideDelay": number;
+        /**
+          * Controls when scrollbars are visible - 'always': Always visible when content overflows - 'auto': Visible on scroll, hide after delay - 'scroll': Same as auto (alias) - 'hover': Visible on hover or scroll
+          * @default 'hover'
+         */
+        "type": 'auto' | 'always' | 'scroll' | 'hover';
+    }
+    /**
+     * Scroll Bar Component
+     * Custom scrollbar that syncs with the parent scroll area's scroll position.
+     * Supports vertical and horizontal orientations.
+     */
+    interface SekiScrollBar {
+        /**
+          * Scrollbar orientation
+          * @default 'vertical'
+         */
+        "orientation": 'vertical' | 'horizontal';
+    }
+    interface SekiSelect {
+        /**
+          * ID of element that describes this select
+         */
+        "ariaDescribedby"?: string;
+        /**
+          * Accessible label for screen readers
+         */
+        "ariaLabel"?: string;
+        /**
+          * ID of element that labels this select
+         */
+        "ariaLabelledby"?: string;
         /**
           * Clear all selections
          */
@@ -2451,12 +3361,55 @@ export namespace Components {
           * @default 'md'
          */
         "size": 'sm' | 'md' | 'lg';
+        /**
+          * Value identifier when used inside a toggle group.
+         */
+        "value"?: string;
         /**
           * Visual style variant of the toggle.
           * @default 'default'
          */
         "variant": 'default' | 'outline';
     }
+    interface SekiToggleGroup {
+        /**
+          * Accessible label
+         */
+        "ariaLabel"?: string;
+        /**
+          * Initial value for uncontrolled mode
+         */
+        "defaultValue"?: string | string[];
+        /**
+          * Disable all toggles
+          * @default false
+         */
+        "disabled": boolean;
+        /**
+          * Layout orientation
+          * @default 'horizontal'
+         */
+        "orientation": 'horizontal' | 'vertical';
+        /**
+          * Size for all toggles
+          * @default 'md'
+         */
+        "size": 'sm' | 'md' | 'lg';
+        /**
+          * Selection mode: single (radio-like) or multiple (checkbox-like)
+          * @default 'single'
+         */
+        "type": 'single' | 'multiple';
+        /**
+          * Controlled value
+         */
+        "value"?: string | string[];
+        /**
+          * Visual style variant for all toggles
+          * @default 'default'
+         */
+        "variant": 'default' | 'outline';
+    }
     /**
      * Tooltip Component
      * A fully accessible tooltip component that displays contextual information
@@ -2513,6 +3466,26 @@ export interface SekiAccordionCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiAccordionElement;
 }
+export interface SekiAlertDialogCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiAlertDialogElement;
+}
+export interface SekiAlertDialogActionCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiAlertDialogActionElement;
+}
+export interface SekiAlertDialogCancelCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiAlertDialogCancelElement;
+}
+export interface SekiAlertDialogContentCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiAlertDialogContentElement;
+}
+export interface SekiAlertDialogTriggerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiAlertDialogTriggerElement;
+}
 export interface SekiAvatarImageCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiAvatarImageElement;
@@ -2533,6 +3506,30 @@ export interface SekiCollapsibleCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiCollapsibleElement;
 }
+export interface SekiComboboxCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiComboboxElement;
+}
+export interface SekiCommandCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiCommandElement;
+}
+export interface SekiCommandInputCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiCommandInputElement;
+}
+export interface SekiCommandItemCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiCommandItemElement;
+}
+export interface SekiContextMenuCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiContextMenuElement;
+}
+export interface SekiContextMenuTriggerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiContextMenuTriggerElement;
+}
 export interface SekiDataTableCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiDataTableElement;
@@ -2561,6 +3558,14 @@ export interface SekiDialogTriggerCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiDialogTriggerElement;
 }
+export interface SekiDrawerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiDrawerElement;
+}
+export interface SekiDrawerContentCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiDrawerContentElement;
+}
 export interface SekiDropdownMenuCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiDropdownMenuElement;
@@ -2585,10 +3590,46 @@ export interface SekiDropdownMenuTriggerCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiDropdownMenuTriggerElement;
 }
+export interface SekiHoverCardCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiHoverCardElement;
+}
+export interface SekiHoverCardContentCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiHoverCardContentElement;
+}
+export interface SekiHoverCardTriggerCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiHoverCardTriggerElement;
+}
 export interface SekiInputCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiInputElement;
 }
+export interface SekiInputOtpCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiInputOtpElement;
+}
+export interface SekiMenubarCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiMenubarElement;
+}
+export interface SekiMenubarCheckboxCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiMenubarCheckboxElement;
+}
+export interface SekiMenubarItemCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiMenubarItemElement;
+}
+export interface SekiMenubarRadioCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiMenubarRadioElement;
+}
+export interface SekiMenubarRadioGroupCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiMenubarRadioGroupElement;
+}
 export interface SekiNavigationMenuCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiNavigationMenuElement;
@@ -2617,6 +3658,18 @@ export interface SekiRadioGroupItemCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiRadioGroupItemElement;
 }
+export interface SekiResizablePanelCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiResizablePanelElement;
+}
+export interface SekiResizablePanelGroupCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiResizablePanelGroupElement;
+}
+export interface SekiScrollAreaCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiScrollAreaElement;
+}
 export interface SekiSelectCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiSelectElement;
@@ -2669,6 +3722,10 @@ export interface SekiToggleCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiToggleElement;
 }
+export interface SekiToggleGroupCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLSekiToggleGroupElement;
+}
 export interface SekiTooltipCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLSekiTooltipElement;
@@ -2756,6 +3813,120 @@ declare global {
         prototype: HTMLSekiAlertDescriptionElement;
         new (): HTMLSekiAlertDescriptionElement;
     };
+    interface HTMLSekiAlertDialogElementEventMap {
+        "sekiOpenChange": boolean;
+    }
+    /**
+     * Alert Dialog root component for confirmation dialogs
+     * A modal dialog that interrupts the user with important content and expects a response.
+     * Wraps seki-dialog internally with Alert Dialog-specific behavior.
+     */
+    interface HTMLSekiAlertDialogElement extends Components.SekiAlertDialog, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiAlertDialogElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogElement, ev: SekiAlertDialogCustomEvent<HTMLSekiAlertDialogElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiAlertDialogElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogElement, ev: SekiAlertDialogCustomEvent<HTMLSekiAlertDialogElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiAlertDialogElement: {
+        prototype: HTMLSekiAlertDialogElement;
+        new (): HTMLSekiAlertDialogElement;
+    };
+    interface HTMLSekiAlertDialogActionElementEventMap {
+        "sekiAction": void;
+        "sekiAlertDialogRequestClose": void;
+    }
+    /**
+     * Alert Dialog Action Button Component
+     * A button that confirms and closes the alert dialog. Supports default and destructive variants
+     * for different action types. Emits a sekiAction event before closing.
+     */
+    interface HTMLSekiAlertDialogActionElement extends Components.SekiAlertDialogAction, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiAlertDialogActionElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogActionElement, ev: SekiAlertDialogActionCustomEvent<HTMLSekiAlertDialogActionElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiAlertDialogActionElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogActionElement, ev: SekiAlertDialogActionCustomEvent<HTMLSekiAlertDialogActionElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiAlertDialogActionElement: {
+        prototype: HTMLSekiAlertDialogActionElement;
+        new (): HTMLSekiAlertDialogActionElement;
+    };
+    interface HTMLSekiAlertDialogCancelElementEventMap {
+        "sekiCancel": void;
+        "sekiAlertDialogRequestClose": void;
+    }
+    /**
+     * Alert Dialog Cancel Button Component
+     * A button that cancels and closes the alert dialog without confirming the action.
+     * Emits a sekiCancel event before closing.
+     */
+    interface HTMLSekiAlertDialogCancelElement extends Components.SekiAlertDialogCancel, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiAlertDialogCancelElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogCancelElement, ev: SekiAlertDialogCancelCustomEvent<HTMLSekiAlertDialogCancelElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiAlertDialogCancelElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogCancelElement, ev: SekiAlertDialogCancelCustomEvent<HTMLSekiAlertDialogCancelElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiAlertDialogCancelElement: {
+        prototype: HTMLSekiAlertDialogCancelElement;
+        new (): HTMLSekiAlertDialogCancelElement;
+    };
+    interface HTMLSekiAlertDialogContentElementEventMap {
+        "sekiAlertDialogRequestClose": void;
+        "sekiCancel": void;
+    }
+    /**
+     * Alert Dialog Content Component
+     * The content panel for the alert dialog with role="alertdialog".
+     * This is a modal dialog that interrupts the user with important content
+     * and expects a response. Unlike regular dialogs, it does NOT close on
+     * overlay click - users must explicitly confirm or cancel.
+     */
+    interface HTMLSekiAlertDialogContentElement extends Components.SekiAlertDialogContent, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiAlertDialogContentElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogContentElement, ev: SekiAlertDialogContentCustomEvent<HTMLSekiAlertDialogContentElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiAlertDialogContentElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogContentElement, ev: SekiAlertDialogContentCustomEvent<HTMLSekiAlertDialogContentElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiAlertDialogContentElement: {
+        prototype: HTMLSekiAlertDialogContentElement;
+        new (): HTMLSekiAlertDialogContentElement;
+    };
+    interface HTMLSekiAlertDialogTriggerElementEventMap {
+        "sekiAlertDialogTriggerClick": void;
+    }
+    /**
+     * Alert Dialog Trigger Component
+     * The element that opens the alert dialog when clicked.
+     */
+    interface HTMLSekiAlertDialogTriggerElement extends Components.SekiAlertDialogTrigger, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiAlertDialogTriggerElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogTriggerElement, ev: SekiAlertDialogTriggerCustomEvent<HTMLSekiAlertDialogTriggerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiAlertDialogTriggerElementEventMap>(type: K, listener: (this: HTMLSekiAlertDialogTriggerElement, ev: SekiAlertDialogTriggerCustomEvent<HTMLSekiAlertDialogTriggerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiAlertDialogTriggerElement: {
+        prototype: HTMLSekiAlertDialogTriggerElement;
+        new (): HTMLSekiAlertDialogTriggerElement;
+    };
     /**
      * Title text within an alert component.
      * Renders as a heading with appropriate typography styles.
@@ -3127,6 +4298,12 @@ declare global {
         prototype: HTMLSekiCarouselPreviousElement;
         new (): HTMLSekiCarouselPreviousElement;
     };
+    interface HTMLSekiChartElement extends Components.SekiChart, HTMLStencilElement {
+    }
+    var HTMLSekiChartElement: {
+        prototype: HTMLSekiChartElement;
+        new (): HTMLSekiChartElement;
+    };
     interface HTMLSekiCheckboxElementEventMap {
         "sekiChange": { checked: boolean; indeterminate: boolean };
     }
@@ -3187,68 +4364,275 @@ declare global {
         prototype: HTMLSekiCollapsibleTriggerElement;
         new (): HTMLSekiCollapsibleTriggerElement;
     };
-    interface HTMLSekiDataTableElementEventMap {
-        "seki-selection-change": SelectionChangeDetail;
-        "seki-row-expand": RowExpandDetail;
-        "seki-row-click": RowClickDetail;
-        "seki-column-resize": ColumnResizeDetail;
-        "seki-column-reorder": ColumnReorderDetail;
-        "seki-columns-change": ColumnsChangeDetail;
-        "seki-sort-change": SortChangeDetail;
-        "seki-filter-change": FilterChangeDetail;
-        "seki-page-change": PageChangeDetail;
+    interface HTMLSekiComboboxElementEventMap {
+        "sekiChange": ComboboxChangeEventDetail;
+        "sekiSearch": ComboboxSearchEventDetail;
+        "sekiCustomValue": ComboboxCustomValueEventDetail;
     }
-    interface HTMLSekiDataTableElement extends Components.SekiDataTable, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLSekiDataTableElementEventMap>(type: K, listener: (this: HTMLSekiDataTableElement, ev: SekiDataTableCustomEvent<HTMLSekiDataTableElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    interface HTMLSekiComboboxElement extends Components.SekiCombobox, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiComboboxElementEventMap>(type: K, listener: (this: HTMLSekiComboboxElement, ev: SekiComboboxCustomEvent<HTMLSekiComboboxElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLSekiDataTableElementEventMap>(type: K, listener: (this: HTMLSekiDataTableElement, ev: SekiDataTableCustomEvent<HTMLSekiDataTableElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiComboboxElementEventMap>(type: K, listener: (this: HTMLSekiComboboxElement, ev: SekiComboboxCustomEvent<HTMLSekiComboboxElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
-    var HTMLSekiDataTableElement: {
-        prototype: HTMLSekiDataTableElement;
-        new (): HTMLSekiDataTableElement;
+    var HTMLSekiComboboxElement: {
+        prototype: HTMLSekiComboboxElement;
+        new (): HTMLSekiComboboxElement;
     };
-    interface HTMLSekiDatePickerElementEventMap {
-        "sekiChange": Date | DateRange1;
-        "sekiOpen": void;
-        "sekiClose": void;
+    interface HTMLSekiComboboxContentElement extends Components.SekiComboboxContent, HTMLStencilElement {
     }
+    var HTMLSekiComboboxContentElement: {
+        prototype: HTMLSekiComboboxContentElement;
+        new (): HTMLSekiComboboxContentElement;
+    };
     /**
-     * seki-date-picker: A date picker component with popover calendar
-     * @component DatePicker
-     * @example <seki-date-picker placeholder="Pick a date"></seki-date-picker>
-     * <seki-date-picker mode="range" placeholder="Pick a date range"></seki-date-picker>
+     * seki-combobox-empty: Display empty/loading/error states for combobox dropdown
+     * @component ComboboxEmpty
+     * @example <seki-combobox-empty reason="no-results">
+     *   No results found.
+     * </seki-combobox-empty>
+     * @example <seki-combobox-empty reason="loading">
+     *   <span slot="loading">Loading...</span>
+     * </seki-combobox-empty>
      */
-    interface HTMLSekiDatePickerElement extends Components.SekiDatePicker, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLSekiDatePickerElementEventMap>(type: K, listener: (this: HTMLSekiDatePickerElement, ev: SekiDatePickerCustomEvent<HTMLSekiDatePickerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
-        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLSekiDatePickerElementEventMap>(type: K, listener: (this: HTMLSekiDatePickerElement, ev: SekiDatePickerCustomEvent<HTMLSekiDatePickerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
-        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    interface HTMLSekiComboboxEmptyElement extends Components.SekiComboboxEmpty, HTMLStencilElement {
     }
-    var HTMLSekiDatePickerElement: {
-        prototype: HTMLSekiDatePickerElement;
-        new (): HTMLSekiDatePickerElement;
+    var HTMLSekiComboboxEmptyElement: {
+        prototype: HTMLSekiComboboxEmptyElement;
+        new (): HTMLSekiComboboxEmptyElement;
     };
-    interface HTMLSekiDialogElementEventMap {
-        "sekiOpenChange": boolean;
+    interface HTMLSekiComboboxGroupElement extends Components.SekiComboboxGroup, HTMLStencilElement {
+    }
+    var HTMLSekiComboboxGroupElement: {
+        prototype: HTMLSekiComboboxGroupElement;
+        new (): HTMLSekiComboboxGroupElement;
+    };
+    interface HTMLSekiComboboxInputElement extends Components.SekiComboboxInput, HTMLStencilElement {
+    }
+    var HTMLSekiComboboxInputElement: {
+        prototype: HTMLSekiComboboxInputElement;
+        new (): HTMLSekiComboboxInputElement;
+    };
+    interface HTMLSekiComboboxItemElement extends Components.SekiComboboxItem, HTMLStencilElement {
+    }
+    var HTMLSekiComboboxItemElement: {
+        prototype: HTMLSekiComboboxItemElement;
+        new (): HTMLSekiComboboxItemElement;
+    };
+    interface HTMLSekiCommandElementEventMap {
+        "sekiValueChange": string;
+        "sekiSelect": string;
     }
     /**
-     * Dialog root component for modal dialogs
+     * Command root component - command palette for navigation
      */
-    interface HTMLSekiDialogElement extends Components.SekiDialog, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLSekiDialogElementEventMap>(type: K, listener: (this: HTMLSekiDialogElement, ev: SekiDialogCustomEvent<HTMLSekiDialogElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    interface HTMLSekiCommandElement extends Components.SekiCommand, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiCommandElementEventMap>(type: K, listener: (this: HTMLSekiCommandElement, ev: SekiCommandCustomEvent<HTMLSekiCommandElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLSekiDialogElementEventMap>(type: K, listener: (this: HTMLSekiDialogElement, ev: SekiDialogCustomEvent<HTMLSekiDialogElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiCommandElementEventMap>(type: K, listener: (this: HTMLSekiCommandElement, ev: SekiCommandCustomEvent<HTMLSekiCommandElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiCommandElement: {
+        prototype: HTMLSekiCommandElement;
+        new (): HTMLSekiCommandElement;
+    };
+    /**
+     * Command empty state - shown when no results match
+     */
+    interface HTMLSekiCommandEmptyElement extends Components.SekiCommandEmpty, HTMLStencilElement {
+    }
+    var HTMLSekiCommandEmptyElement: {
+        prototype: HTMLSekiCommandEmptyElement;
+        new (): HTMLSekiCommandEmptyElement;
+    };
+    /**
+     * Command group - groups related items with a heading
+     */
+    interface HTMLSekiCommandGroupElement extends Components.SekiCommandGroup, HTMLStencilElement {
+    }
+    var HTMLSekiCommandGroupElement: {
+        prototype: HTMLSekiCommandGroupElement;
+        new (): HTMLSekiCommandGroupElement;
+    };
+    interface HTMLSekiCommandInputElementEventMap {
+        "sekiCommandInputChange": string;
+    }
+    /**
+     * Command input - search field for filtering items
+     */
+    interface HTMLSekiCommandInputElement extends Components.SekiCommandInput, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiCommandInputElementEventMap>(type: K, listener: (this: HTMLSekiCommandInputElement, ev: SekiCommandInputCustomEvent<HTMLSekiCommandInputElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiCommandInputElementEventMap>(type: K, listener: (this: HTMLSekiCommandInputElement, ev: SekiCommandInputCustomEvent<HTMLSekiCommandInputElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiCommandInputElement: {
+        prototype: HTMLSekiCommandInputElement;
+        new (): HTMLSekiCommandInputElement;
+    };
+    interface HTMLSekiCommandItemElementEventMap {
+        "sekiCommandSelect": string;
+    }
+    /**
+     * Command item - selectable option in the command list
+     */
+    interface HTMLSekiCommandItemElement extends Components.SekiCommandItem, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiCommandItemElementEventMap>(type: K, listener: (this: HTMLSekiCommandItemElement, ev: SekiCommandItemCustomEvent<HTMLSekiCommandItemElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiCommandItemElementEventMap>(type: K, listener: (this: HTMLSekiCommandItemElement, ev: SekiCommandItemCustomEvent<HTMLSekiCommandItemElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiCommandItemElement: {
+        prototype: HTMLSekiCommandItemElement;
+        new (): HTMLSekiCommandItemElement;
+    };
+    /**
+     * Command list - scrollable container for items and groups
+     */
+    interface HTMLSekiCommandListElement extends Components.SekiCommandList, HTMLStencilElement {
+    }
+    var HTMLSekiCommandListElement: {
+        prototype: HTMLSekiCommandListElement;
+        new (): HTMLSekiCommandListElement;
+    };
+    /**
+     * Command separator/divider
+     */
+    interface HTMLSekiCommandSeparatorElement extends Components.SekiCommandSeparator, HTMLStencilElement {
+    }
+    var HTMLSekiCommandSeparatorElement: {
+        prototype: HTMLSekiCommandSeparatorElement;
+        new (): HTMLSekiCommandSeparatorElement;
+    };
+    interface HTMLSekiContextMenuElementEventMap {
+        "sekiOpenChange": boolean;
+        "sekiSelect": string;
+    }
+    /**
+     * Context Menu component - right-click context menu with items
+     */
+    interface HTMLSekiContextMenuElement extends Components.SekiContextMenu, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiContextMenuElementEventMap>(type: K, listener: (this: HTMLSekiContextMenuElement, ev: SekiContextMenuCustomEvent<HTMLSekiContextMenuElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiContextMenuElementEventMap>(type: K, listener: (this: HTMLSekiContextMenuElement, ev: SekiContextMenuCustomEvent<HTMLSekiContextMenuElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiContextMenuElement: {
+        prototype: HTMLSekiContextMenuElement;
+        new (): HTMLSekiContextMenuElement;
+    };
+    /**
+     * Context Menu content panel - displays at cursor position
+     */
+    interface HTMLSekiContextMenuContentElement extends Components.SekiContextMenuContent, HTMLStencilElement {
+    }
+    var HTMLSekiContextMenuContentElement: {
+        prototype: HTMLSekiContextMenuContentElement;
+        new (): HTMLSekiContextMenuContentElement;
+    };
+    interface HTMLSekiContextMenuTriggerElementEventMap {
+        "sekiContextMenuOpen": { x: number; y: number };
+    }
+    /**
+     * Context Menu trigger component
+     * Handles right-click (desktop) and long-press (touch) to open context menu
+     */
+    interface HTMLSekiContextMenuTriggerElement extends Components.SekiContextMenuTrigger, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiContextMenuTriggerElementEventMap>(type: K, listener: (this: HTMLSekiContextMenuTriggerElement, ev: SekiContextMenuTriggerCustomEvent<HTMLSekiContextMenuTriggerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiContextMenuTriggerElementEventMap>(type: K, listener: (this: HTMLSekiContextMenuTriggerElement, ev: SekiContextMenuTriggerCustomEvent<HTMLSekiContextMenuTriggerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiContextMenuTriggerElement: {
+        prototype: HTMLSekiContextMenuTriggerElement;
+        new (): HTMLSekiContextMenuTriggerElement;
+    };
+    interface HTMLSekiDataTableElementEventMap {
+        "seki-selection-change": SelectionChangeDetail;
+        "seki-row-expand": RowExpandDetail;
+        "seki-row-click": RowClickDetail;
+        "seki-column-resize": ColumnResizeDetail;
+        "seki-column-reorder": ColumnReorderDetail;
+        "seki-columns-change": ColumnsChangeDetail;
+        "seki-sort-change": SortChangeDetail;
+        "seki-filter-change": FilterChangeDetail;
+        "seki-page-change": PageChangeDetail;
+    }
+    interface HTMLSekiDataTableElement extends Components.SekiDataTable, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiDataTableElementEventMap>(type: K, listener: (this: HTMLSekiDataTableElement, ev: SekiDataTableCustomEvent<HTMLSekiDataTableElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiDataTableElementEventMap>(type: K, listener: (this: HTMLSekiDataTableElement, ev: SekiDataTableCustomEvent<HTMLSekiDataTableElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiDataTableElement: {
+        prototype: HTMLSekiDataTableElement;
+        new (): HTMLSekiDataTableElement;
+    };
+    interface HTMLSekiDatePickerElementEventMap {
+        "sekiChange": Date | DateRange1;
+        "sekiOpen": void;
+        "sekiClose": void;
+    }
+    /**
+     * seki-date-picker: A date picker component with popover calendar
+     * @component DatePicker
+     * @example <seki-date-picker placeholder="Pick a date"></seki-date-picker>
+     * <seki-date-picker mode="range" placeholder="Pick a date range"></seki-date-picker>
+     */
+    interface HTMLSekiDatePickerElement extends Components.SekiDatePicker, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiDatePickerElementEventMap>(type: K, listener: (this: HTMLSekiDatePickerElement, ev: SekiDatePickerCustomEvent<HTMLSekiDatePickerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiDatePickerElementEventMap>(type: K, listener: (this: HTMLSekiDatePickerElement, ev: SekiDatePickerCustomEvent<HTMLSekiDatePickerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiDatePickerElement: {
+        prototype: HTMLSekiDatePickerElement;
+        new (): HTMLSekiDatePickerElement;
+    };
+    interface HTMLSekiDialogElementEventMap {
+        "sekiOpenChange": boolean;
+    }
+    /**
+     * Dialog root component for modal dialogs
+     */
+    interface HTMLSekiDialogElement extends Components.SekiDialog, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiDialogElementEventMap>(type: K, listener: (this: HTMLSekiDialogElement, ev: SekiDialogCustomEvent<HTMLSekiDialogElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiDialogElementEventMap>(type: K, listener: (this: HTMLSekiDialogElement, ev: SekiDialogCustomEvent<HTMLSekiDialogElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
@@ -3373,6 +4757,62 @@ declare global {
         prototype: HTMLSekiDialogTriggerElement;
         new (): HTMLSekiDialogTriggerElement;
     };
+    interface HTMLSekiDrawerElementEventMap {
+        "drawerOpen": void;
+        "drawerClose": void;
+        "drawerSnap": { point: number };
+    }
+    /**
+     * seki-drawer: Mobile-friendly drawer component with swipe gestures
+     * @component Drawer
+     * @example <seki-drawer>
+     *   <seki-sheet-trigger>
+     *     <seki-button>Open Drawer</seki-button>
+     *   </seki-sheet-trigger>
+     *   <seki-drawer-content direction="bottom" snap-points="0.5,1">
+     *     <seki-sheet-header>
+     *       <seki-sheet-title>Title</seki-sheet-title>
+     *     </seki-sheet-header>
+     *     Content here
+     *   </seki-drawer-content>
+     * </seki-drawer>
+     */
+    interface HTMLSekiDrawerElement extends Components.SekiDrawer, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiDrawerElementEventMap>(type: K, listener: (this: HTMLSekiDrawerElement, ev: SekiDrawerCustomEvent<HTMLSekiDrawerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiDrawerElementEventMap>(type: K, listener: (this: HTMLSekiDrawerElement, ev: SekiDrawerCustomEvent<HTMLSekiDrawerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiDrawerElement: {
+        prototype: HTMLSekiDrawerElement;
+        new (): HTMLSekiDrawerElement;
+    };
+    interface HTMLSekiDrawerContentElementEventMap {
+        "requestClose": void;
+        "requestSnap": { point: number };
+    }
+    /**
+     * seki-drawer-content: Container for drawer content with gesture support
+     * @component DrawerContent
+     */
+    interface HTMLSekiDrawerContentElement extends Components.SekiDrawerContent, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiDrawerContentElementEventMap>(type: K, listener: (this: HTMLSekiDrawerContentElement, ev: SekiDrawerContentCustomEvent<HTMLSekiDrawerContentElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiDrawerContentElementEventMap>(type: K, listener: (this: HTMLSekiDrawerContentElement, ev: SekiDrawerContentCustomEvent<HTMLSekiDrawerContentElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiDrawerContentElement: {
+        prototype: HTMLSekiDrawerContentElement;
+        new (): HTMLSekiDrawerContentElement;
+    };
     interface HTMLSekiDropdownMenuElementEventMap {
         "sekiOpenChange": boolean;
         "sekiSelect": string;
@@ -3510,6 +4950,15 @@ declare global {
         prototype: HTMLSekiDropdownMenuShortcutElement;
         new (): HTMLSekiDropdownMenuShortcutElement;
     };
+    /**
+     * Dropdown Menu Sub - A submenu component for nested dropdown menus
+     */
+    interface HTMLSekiDropdownMenuSubElement extends Components.SekiDropdownMenuSub, HTMLStencilElement {
+    }
+    var HTMLSekiDropdownMenuSubElement: {
+        prototype: HTMLSekiDropdownMenuSubElement;
+        new (): HTMLSekiDropdownMenuSubElement;
+    };
     interface HTMLSekiDropdownMenuTriggerElementEventMap {
         "sekiDropdownTriggerClick": void;
     }
@@ -3572,6 +5021,106 @@ declare global {
         prototype: HTMLSekiFieldsetElement;
         new (): HTMLSekiFieldsetElement;
     };
+    interface HTMLSekiHoverCardElementEventMap {
+        "sekiOpenChange": { open: boolean };
+    }
+    /**
+     * Hover Card Container Component
+     * A hover-triggered card component for previewing content (e.g., user profiles, link previews).
+     * Shows a floating card with rich content when hovering over a trigger element.
+     * This container manages state and timing, providing context to child components
+     * (seki-hover-card-trigger and seki-hover-card-content).
+     * @example ```html
+     * <seki-hover-card open-delay="100" close-delay="200">
+     *   <seki-hover-card-trigger>
+     *     <a href="/user/john">@john</a>
+     *   </seki-hover-card-trigger>
+     *   <seki-hover-card-content side="top">
+     *     <div class="user-preview">
+     *       <img src="avatar.jpg" alt="John's avatar" />
+     *       <h4>John Doe</h4>
+     *       <p>Software Engineer at Acme Inc.</p>
+     *     </div>
+     *   </seki-hover-card-content>
+     * </seki-hover-card>
+     * ```
+     */
+    interface HTMLSekiHoverCardElement extends Components.SekiHoverCard, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiHoverCardElementEventMap>(type: K, listener: (this: HTMLSekiHoverCardElement, ev: SekiHoverCardCustomEvent<HTMLSekiHoverCardElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiHoverCardElementEventMap>(type: K, listener: (this: HTMLSekiHoverCardElement, ev: SekiHoverCardCustomEvent<HTMLSekiHoverCardElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiHoverCardElement: {
+        prototype: HTMLSekiHoverCardElement;
+        new (): HTMLSekiHoverCardElement;
+    };
+    interface HTMLSekiHoverCardContentElementEventMap {
+        "sekiHoverCardRequestClose": void;
+        "sekiHoverCardCancelClose": void;
+    }
+    /**
+     * Hover Card Content Component
+     * The floating content panel that displays when the hover card is open.
+     * Handles positioning, viewport boundary collision, arrow placement,
+     * and interaction handlers to maintain open state while user interacts with content.
+     * @example ```html
+     * <seki-hover-card-content side="top" align="center">
+     *   <div class="user-preview">
+     *     <img src="avatar.jpg" alt="Avatar" />
+     *     <h4>John Doe</h4>
+     *     <p>Software Engineer</p>
+     *   </div>
+     * </seki-hover-card-content>
+     * ```
+     */
+    interface HTMLSekiHoverCardContentElement extends Components.SekiHoverCardContent, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiHoverCardContentElementEventMap>(type: K, listener: (this: HTMLSekiHoverCardContentElement, ev: SekiHoverCardContentCustomEvent<HTMLSekiHoverCardContentElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiHoverCardContentElementEventMap>(type: K, listener: (this: HTMLSekiHoverCardContentElement, ev: SekiHoverCardContentCustomEvent<HTMLSekiHoverCardContentElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiHoverCardContentElement: {
+        prototype: HTMLSekiHoverCardContentElement;
+        new (): HTMLSekiHoverCardContentElement;
+    };
+    interface HTMLSekiHoverCardTriggerElementEventMap {
+        "sekiHoverCardRequestOpen": void;
+        "sekiHoverCardRequestClose": void;
+        "sekiHoverCardCancelClose": void;
+    }
+    /**
+     * Hover Card Trigger Component
+     * The trigger element that activates the hover card on hover, focus, or touch.
+     * Handles mouse, keyboard, and touch interactions with appropriate behavior for each.
+     * @example ```html
+     * <seki-hover-card-trigger>
+     *   <a href="/user/john">@john</a>
+     * </seki-hover-card-trigger>
+     * ```
+     */
+    interface HTMLSekiHoverCardTriggerElement extends Components.SekiHoverCardTrigger, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiHoverCardTriggerElementEventMap>(type: K, listener: (this: HTMLSekiHoverCardTriggerElement, ev: SekiHoverCardTriggerCustomEvent<HTMLSekiHoverCardTriggerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiHoverCardTriggerElementEventMap>(type: K, listener: (this: HTMLSekiHoverCardTriggerElement, ev: SekiHoverCardTriggerCustomEvent<HTMLSekiHoverCardTriggerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiHoverCardTriggerElement: {
+        prototype: HTMLSekiHoverCardTriggerElement;
+        new (): HTMLSekiHoverCardTriggerElement;
+    };
     interface HTMLSekiInputElementEventMap {
         "sekiInput": { value: string; nativeEvent: Event };
         "sekiChange": { value: string; nativeEvent: Event };
@@ -3592,76 +5141,308 @@ declare global {
         prototype: HTMLSekiInputElement;
         new (): HTMLSekiInputElement;
     };
-    interface HTMLSekiKbdElement extends Components.SekiKbd, HTMLStencilElement {
+    interface HTMLSekiInputAddonElement extends Components.SekiInputAddon, HTMLStencilElement {
     }
-    var HTMLSekiKbdElement: {
-        prototype: HTMLSekiKbdElement;
-        new (): HTMLSekiKbdElement;
+    var HTMLSekiInputAddonElement: {
+        prototype: HTMLSekiInputAddonElement;
+        new (): HTMLSekiInputAddonElement;
     };
-    interface HTMLSekiNavigationMenuElementEventMap {
-        "seki-menu-open": { triggerId: string };
-        "seki-menu-close": { triggerId: string };
-        "seki-mobile-toggle": { open: boolean };
+    interface HTMLSekiInputGroupElement extends Components.SekiInputGroup, HTMLStencilElement {
     }
-    interface HTMLSekiNavigationMenuElement extends Components.SekiNavigationMenu, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLSekiNavigationMenuElementEventMap>(type: K, listener: (this: HTMLSekiNavigationMenuElement, ev: SekiNavigationMenuCustomEvent<HTMLSekiNavigationMenuElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    var HTMLSekiInputGroupElement: {
+        prototype: HTMLSekiInputGroupElement;
+        new (): HTMLSekiInputGroupElement;
+    };
+    interface HTMLSekiInputOtpElementEventMap {
+        "sekiInput": { value: string };
+        "sekiChange": { value: string };
+        "sekiComplete": { value: string };
+        "sekiOtpStateChange": void;
+    }
+    interface HTMLSekiInputOtpElement extends Components.SekiInputOtp, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiInputOtpElementEventMap>(type: K, listener: (this: HTMLSekiInputOtpElement, ev: SekiInputOtpCustomEvent<HTMLSekiInputOtpElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLSekiNavigationMenuElementEventMap>(type: K, listener: (this: HTMLSekiNavigationMenuElement, ev: SekiNavigationMenuCustomEvent<HTMLSekiNavigationMenuElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiInputOtpElementEventMap>(type: K, listener: (this: HTMLSekiInputOtpElement, ev: SekiInputOtpCustomEvent<HTMLSekiInputOtpElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
-    var HTMLSekiNavigationMenuElement: {
-        prototype: HTMLSekiNavigationMenuElement;
-        new (): HTMLSekiNavigationMenuElement;
+    var HTMLSekiInputOtpElement: {
+        prototype: HTMLSekiInputOtpElement;
+        new (): HTMLSekiInputOtpElement;
     };
-    interface HTMLSekiNavigationMenuContentElement extends Components.SekiNavigationMenuContent, HTMLStencilElement {
+    interface HTMLSekiInputOtpGroupElement extends Components.SekiInputOtpGroup, HTMLStencilElement {
     }
-    var HTMLSekiNavigationMenuContentElement: {
-        prototype: HTMLSekiNavigationMenuContentElement;
-        new (): HTMLSekiNavigationMenuContentElement;
+    var HTMLSekiInputOtpGroupElement: {
+        prototype: HTMLSekiInputOtpGroupElement;
+        new (): HTMLSekiInputOtpGroupElement;
     };
-    interface HTMLSekiNavigationMenuItemElement extends Components.SekiNavigationMenuItem, HTMLStencilElement {
+    interface HTMLSekiInputOtpSeparatorElement extends Components.SekiInputOtpSeparator, HTMLStencilElement {
     }
-    var HTMLSekiNavigationMenuItemElement: {
-        prototype: HTMLSekiNavigationMenuItemElement;
-        new (): HTMLSekiNavigationMenuItemElement;
+    var HTMLSekiInputOtpSeparatorElement: {
+        prototype: HTMLSekiInputOtpSeparatorElement;
+        new (): HTMLSekiInputOtpSeparatorElement;
     };
-    interface HTMLSekiNavigationMenuLinkElement extends Components.SekiNavigationMenuLink, HTMLStencilElement {
+    interface HTMLSekiInputOtpSlotElement extends Components.SekiInputOtpSlot, HTMLStencilElement {
     }
-    var HTMLSekiNavigationMenuLinkElement: {
-        prototype: HTMLSekiNavigationMenuLinkElement;
-        new (): HTMLSekiNavigationMenuLinkElement;
+    var HTMLSekiInputOtpSlotElement: {
+        prototype: HTMLSekiInputOtpSlotElement;
+        new (): HTMLSekiInputOtpSlotElement;
     };
-    interface HTMLSekiNavigationMenuListElement extends Components.SekiNavigationMenuList, HTMLStencilElement {
+    interface HTMLSekiKbdElement extends Components.SekiKbd, HTMLStencilElement {
     }
-    var HTMLSekiNavigationMenuListElement: {
-        prototype: HTMLSekiNavigationMenuListElement;
-        new (): HTMLSekiNavigationMenuListElement;
+    var HTMLSekiKbdElement: {
+        prototype: HTMLSekiKbdElement;
+        new (): HTMLSekiKbdElement;
     };
-    interface HTMLSekiNavigationMenuTriggerElementEventMap {
-        "seki-trigger-activate": { itemId: string };
+    interface HTMLSekiMenubarElementEventMap {
+        "sekiSelect": string;
+        "sekiOpenChange": string | null;
     }
-    interface HTMLSekiNavigationMenuTriggerElement extends Components.SekiNavigationMenuTrigger, HTMLStencilElement {
-        addEventListener<K extends keyof HTMLSekiNavigationMenuTriggerElementEventMap>(type: K, listener: (this: HTMLSekiNavigationMenuTriggerElement, ev: SekiNavigationMenuTriggerCustomEvent<HTMLSekiNavigationMenuTriggerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+    /**
+     * Menubar - horizontal menu bar with dropdown menus
+     */
+    interface HTMLSekiMenubarElement extends Components.SekiMenubar, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiMenubarElementEventMap>(type: K, listener: (this: HTMLSekiMenubarElement, ev: SekiMenubarCustomEvent<HTMLSekiMenubarElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
         addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-        removeEventListener<K extends keyof HTMLSekiNavigationMenuTriggerElementEventMap>(type: K, listener: (this: HTMLSekiNavigationMenuTriggerElement, ev: SekiNavigationMenuTriggerCustomEvent<HTMLSekiNavigationMenuTriggerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiMenubarElementEventMap>(type: K, listener: (this: HTMLSekiMenubarElement, ev: SekiMenubarCustomEvent<HTMLSekiMenubarElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
         removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     }
-    var HTMLSekiNavigationMenuTriggerElement: {
-        prototype: HTMLSekiNavigationMenuTriggerElement;
-        new (): HTMLSekiNavigationMenuTriggerElement;
+    var HTMLSekiMenubarElement: {
+        prototype: HTMLSekiMenubarElement;
+        new (): HTMLSekiMenubarElement;
     };
-    interface HTMLSekiNavigationMenuViewportElement extends Components.SekiNavigationMenuViewport, HTMLStencilElement {
+    interface HTMLSekiMenubarCheckboxElementEventMap {
+        "sekiCheckedChange": boolean;
     }
-    var HTMLSekiNavigationMenuViewportElement: {
-        prototype: HTMLSekiNavigationMenuViewportElement;
+    /**
+     * Menubar checkbox item - toggleable menu option
+     */
+    interface HTMLSekiMenubarCheckboxElement extends Components.SekiMenubarCheckbox, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiMenubarCheckboxElementEventMap>(type: K, listener: (this: HTMLSekiMenubarCheckboxElement, ev: SekiMenubarCheckboxCustomEvent<HTMLSekiMenubarCheckboxElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiMenubarCheckboxElementEventMap>(type: K, listener: (this: HTMLSekiMenubarCheckboxElement, ev: SekiMenubarCheckboxCustomEvent<HTMLSekiMenubarCheckboxElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiMenubarCheckboxElement: {
+        prototype: HTMLSekiMenubarCheckboxElement;
+        new (): HTMLSekiMenubarCheckboxElement;
+    };
+    /**
+     * Menubar content - dropdown content container
+     */
+    interface HTMLSekiMenubarContentElement extends Components.SekiMenubarContent, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarContentElement: {
+        prototype: HTMLSekiMenubarContentElement;
+        new (): HTMLSekiMenubarContentElement;
+    };
+    /**
+     * Menubar group - groups related menu items with optional label
+     */
+    interface HTMLSekiMenubarGroupElement extends Components.SekiMenubarGroup, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarGroupElement: {
+        prototype: HTMLSekiMenubarGroupElement;
+        new (): HTMLSekiMenubarGroupElement;
+    };
+    interface HTMLSekiMenubarItemElementEventMap {
+        "sekiMenubarSelect": string;
+    }
+    /**
+     * Menubar item - selectable menu option
+     */
+    interface HTMLSekiMenubarItemElement extends Components.SekiMenubarItem, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiMenubarItemElementEventMap>(type: K, listener: (this: HTMLSekiMenubarItemElement, ev: SekiMenubarItemCustomEvent<HTMLSekiMenubarItemElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiMenubarItemElementEventMap>(type: K, listener: (this: HTMLSekiMenubarItemElement, ev: SekiMenubarItemCustomEvent<HTMLSekiMenubarItemElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiMenubarItemElement: {
+        prototype: HTMLSekiMenubarItemElement;
+        new (): HTMLSekiMenubarItemElement;
+    };
+    /**
+     * Menubar menu - individual menu container
+     */
+    interface HTMLSekiMenubarMenuElement extends Components.SekiMenubarMenu, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarMenuElement: {
+        prototype: HTMLSekiMenubarMenuElement;
+        new (): HTMLSekiMenubarMenuElement;
+    };
+    interface HTMLSekiMenubarRadioElementEventMap {
+        "sekiMenubarRadioSelect": string;
+    }
+    /**
+     * Menubar radio item - single-select option
+     */
+    interface HTMLSekiMenubarRadioElement extends Components.SekiMenubarRadio, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiMenubarRadioElementEventMap>(type: K, listener: (this: HTMLSekiMenubarRadioElement, ev: SekiMenubarRadioCustomEvent<HTMLSekiMenubarRadioElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiMenubarRadioElementEventMap>(type: K, listener: (this: HTMLSekiMenubarRadioElement, ev: SekiMenubarRadioCustomEvent<HTMLSekiMenubarRadioElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiMenubarRadioElement: {
+        prototype: HTMLSekiMenubarRadioElement;
+        new (): HTMLSekiMenubarRadioElement;
+    };
+    interface HTMLSekiMenubarRadioGroupElementEventMap {
+        "sekiValueChange": string;
+    }
+    /**
+     * Menubar radio group - container for radio items
+     */
+    interface HTMLSekiMenubarRadioGroupElement extends Components.SekiMenubarRadioGroup, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiMenubarRadioGroupElementEventMap>(type: K, listener: (this: HTMLSekiMenubarRadioGroupElement, ev: SekiMenubarRadioGroupCustomEvent<HTMLSekiMenubarRadioGroupElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiMenubarRadioGroupElementEventMap>(type: K, listener: (this: HTMLSekiMenubarRadioGroupElement, ev: SekiMenubarRadioGroupCustomEvent<HTMLSekiMenubarRadioGroupElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiMenubarRadioGroupElement: {
+        prototype: HTMLSekiMenubarRadioGroupElement;
+        new (): HTMLSekiMenubarRadioGroupElement;
+    };
+    /**
+     * Menubar separator - visual divider between menu items
+     */
+    interface HTMLSekiMenubarSeparatorElement extends Components.SekiMenubarSeparator, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarSeparatorElement: {
+        prototype: HTMLSekiMenubarSeparatorElement;
+        new (): HTMLSekiMenubarSeparatorElement;
+    };
+    /**
+     * Menubar shortcut - displays keyboard shortcut hint
+     */
+    interface HTMLSekiMenubarShortcutElement extends Components.SekiMenubarShortcut, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarShortcutElement: {
+        prototype: HTMLSekiMenubarShortcutElement;
+        new (): HTMLSekiMenubarShortcutElement;
+    };
+    /**
+     * Menubar sub - submenu container with hover behavior
+     */
+    interface HTMLSekiMenubarSubElement extends Components.SekiMenubarSub, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarSubElement: {
+        prototype: HTMLSekiMenubarSubElement;
+        new (): HTMLSekiMenubarSubElement;
+    };
+    /**
+     * Menubar sub content - submenu content container
+     */
+    interface HTMLSekiMenubarSubContentElement extends Components.SekiMenubarSubContent, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarSubContentElement: {
+        prototype: HTMLSekiMenubarSubContentElement;
+        new (): HTMLSekiMenubarSubContentElement;
+    };
+    /**
+     * Menubar sub trigger - opens submenu on hover
+     */
+    interface HTMLSekiMenubarSubTriggerElement extends Components.SekiMenubarSubTrigger, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarSubTriggerElement: {
+        prototype: HTMLSekiMenubarSubTriggerElement;
+        new (): HTMLSekiMenubarSubTriggerElement;
+    };
+    /**
+     * Menubar trigger - button that opens a menu
+     */
+    interface HTMLSekiMenubarTriggerElement extends Components.SekiMenubarTrigger, HTMLStencilElement {
+    }
+    var HTMLSekiMenubarTriggerElement: {
+        prototype: HTMLSekiMenubarTriggerElement;
+        new (): HTMLSekiMenubarTriggerElement;
+    };
+    interface HTMLSekiNavigationMenuElementEventMap {
+        "seki-menu-open": { triggerId: string };
+        "seki-menu-close": { triggerId: string };
+        "seki-mobile-toggle": { open: boolean };
+    }
+    interface HTMLSekiNavigationMenuElement extends Components.SekiNavigationMenu, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiNavigationMenuElementEventMap>(type: K, listener: (this: HTMLSekiNavigationMenuElement, ev: SekiNavigationMenuCustomEvent<HTMLSekiNavigationMenuElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiNavigationMenuElementEventMap>(type: K, listener: (this: HTMLSekiNavigationMenuElement, ev: SekiNavigationMenuCustomEvent<HTMLSekiNavigationMenuElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiNavigationMenuElement: {
+        prototype: HTMLSekiNavigationMenuElement;
+        new (): HTMLSekiNavigationMenuElement;
+    };
+    interface HTMLSekiNavigationMenuContentElement extends Components.SekiNavigationMenuContent, HTMLStencilElement {
+    }
+    var HTMLSekiNavigationMenuContentElement: {
+        prototype: HTMLSekiNavigationMenuContentElement;
+        new (): HTMLSekiNavigationMenuContentElement;
+    };
+    interface HTMLSekiNavigationMenuItemElement extends Components.SekiNavigationMenuItem, HTMLStencilElement {
+    }
+    var HTMLSekiNavigationMenuItemElement: {
+        prototype: HTMLSekiNavigationMenuItemElement;
+        new (): HTMLSekiNavigationMenuItemElement;
+    };
+    interface HTMLSekiNavigationMenuLinkElement extends Components.SekiNavigationMenuLink, HTMLStencilElement {
+    }
+    var HTMLSekiNavigationMenuLinkElement: {
+        prototype: HTMLSekiNavigationMenuLinkElement;
+        new (): HTMLSekiNavigationMenuLinkElement;
+    };
+    interface HTMLSekiNavigationMenuListElement extends Components.SekiNavigationMenuList, HTMLStencilElement {
+    }
+    var HTMLSekiNavigationMenuListElement: {
+        prototype: HTMLSekiNavigationMenuListElement;
+        new (): HTMLSekiNavigationMenuListElement;
+    };
+    interface HTMLSekiNavigationMenuTriggerElementEventMap {
+        "seki-trigger-activate": { itemId: string };
+    }
+    interface HTMLSekiNavigationMenuTriggerElement extends Components.SekiNavigationMenuTrigger, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiNavigationMenuTriggerElementEventMap>(type: K, listener: (this: HTMLSekiNavigationMenuTriggerElement, ev: SekiNavigationMenuTriggerCustomEvent<HTMLSekiNavigationMenuTriggerElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiNavigationMenuTriggerElementEventMap>(type: K, listener: (this: HTMLSekiNavigationMenuTriggerElement, ev: SekiNavigationMenuTriggerCustomEvent<HTMLSekiNavigationMenuTriggerElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiNavigationMenuTriggerElement: {
+        prototype: HTMLSekiNavigationMenuTriggerElement;
+        new (): HTMLSekiNavigationMenuTriggerElement;
+    };
+    interface HTMLSekiNavigationMenuViewportElement extends Components.SekiNavigationMenuViewport, HTMLStencilElement {
+    }
+    var HTMLSekiNavigationMenuViewportElement: {
+        prototype: HTMLSekiNavigationMenuViewportElement;
         new (): HTMLSekiNavigationMenuViewportElement;
     };
     /**
@@ -3882,6 +5663,95 @@ declare global {
         prototype: HTMLSekiRadioGroupItemElement;
         new (): HTMLSekiRadioGroupItemElement;
     };
+    /**
+     * Resizable handle - draggable divider between panels
+     */
+    interface HTMLSekiResizableHandleElement extends Components.SekiResizableHandle, HTMLStencilElement {
+    }
+    var HTMLSekiResizableHandleElement: {
+        prototype: HTMLSekiResizableHandleElement;
+        new (): HTMLSekiResizableHandleElement;
+    };
+    interface HTMLSekiResizablePanelElementEventMap {
+        "sekiResize": number;
+        "sekiCollapse": void;
+        "sekiExpand": void;
+    }
+    /**
+     * Resizable panel - individual content panel with size constraints
+     */
+    interface HTMLSekiResizablePanelElement extends Components.SekiResizablePanel, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiResizablePanelElementEventMap>(type: K, listener: (this: HTMLSekiResizablePanelElement, ev: SekiResizablePanelCustomEvent<HTMLSekiResizablePanelElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiResizablePanelElementEventMap>(type: K, listener: (this: HTMLSekiResizablePanelElement, ev: SekiResizablePanelCustomEvent<HTMLSekiResizablePanelElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiResizablePanelElement: {
+        prototype: HTMLSekiResizablePanelElement;
+        new (): HTMLSekiResizablePanelElement;
+    };
+    interface HTMLSekiResizablePanelGroupElementEventMap {
+        "sekiLayoutChange": number[];
+        "sekiDirectionChange": 'horizontal' | 'vertical';
+    }
+    /**
+     * Resizable panel group - container that manages layout direction and coordinates panel sizes
+     */
+    interface HTMLSekiResizablePanelGroupElement extends Components.SekiResizablePanelGroup, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiResizablePanelGroupElementEventMap>(type: K, listener: (this: HTMLSekiResizablePanelGroupElement, ev: SekiResizablePanelGroupCustomEvent<HTMLSekiResizablePanelGroupElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiResizablePanelGroupElementEventMap>(type: K, listener: (this: HTMLSekiResizablePanelGroupElement, ev: SekiResizablePanelGroupCustomEvent<HTMLSekiResizablePanelGroupElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiResizablePanelGroupElement: {
+        prototype: HTMLSekiResizablePanelGroupElement;
+        new (): HTMLSekiResizablePanelGroupElement;
+    };
+    interface HTMLSekiScrollAreaElementEventMap {
+        "sekiScroll": { scrollTop: number; scrollLeft: number };
+    }
+    /**
+     * Scroll Area Component
+     * Augments native scroll functionality with custom, cross-browser styled scrollbars.
+     * Hides native scrollbars and provides custom scrollbar elements that sync with scroll position.
+     * @example <seki-scroll-area style="height: 200px;">
+     *   <div>Scrollable content...</div>
+     *   <seki-scroll-bar slot="scrollbar" orientation="vertical"></seki-scroll-bar>
+     * </seki-scroll-area>
+     */
+    interface HTMLSekiScrollAreaElement extends Components.SekiScrollArea, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiScrollAreaElementEventMap>(type: K, listener: (this: HTMLSekiScrollAreaElement, ev: SekiScrollAreaCustomEvent<HTMLSekiScrollAreaElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiScrollAreaElementEventMap>(type: K, listener: (this: HTMLSekiScrollAreaElement, ev: SekiScrollAreaCustomEvent<HTMLSekiScrollAreaElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiScrollAreaElement: {
+        prototype: HTMLSekiScrollAreaElement;
+        new (): HTMLSekiScrollAreaElement;
+    };
+    /**
+     * Scroll Bar Component
+     * Custom scrollbar that syncs with the parent scroll area's scroll position.
+     * Supports vertical and horizontal orientations.
+     */
+    interface HTMLSekiScrollBarElement extends Components.SekiScrollBar, HTMLStencilElement {
+    }
+    var HTMLSekiScrollBarElement: {
+        prototype: HTMLSekiScrollBarElement;
+        new (): HTMLSekiScrollBarElement;
+    };
     interface HTMLSekiSelectElementEventMap {
         "sekiChange": SelectChangeEventDetail;
         "sekiOpenChange": SelectOpenChangeEventDetail;
@@ -4518,6 +6388,23 @@ declare global {
         prototype: HTMLSekiToggleElement;
         new (): HTMLSekiToggleElement;
     };
+    interface HTMLSekiToggleGroupElementEventMap {
+        "sekiValueChange": ToggleGroupValueChangeEventDetail;
+    }
+    interface HTMLSekiToggleGroupElement extends Components.SekiToggleGroup, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLSekiToggleGroupElementEventMap>(type: K, listener: (this: HTMLSekiToggleGroupElement, ev: SekiToggleGroupCustomEvent<HTMLSekiToggleGroupElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLSekiToggleGroupElementEventMap>(type: K, listener: (this: HTMLSekiToggleGroupElement, ev: SekiToggleGroupCustomEvent<HTMLSekiToggleGroupElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLSekiToggleGroupElement: {
+        prototype: HTMLSekiToggleGroupElement;
+        new (): HTMLSekiToggleGroupElement;
+    };
     interface HTMLSekiTooltipElementEventMap {
         "showTooltip": TooltipShowDetail;
         "hideTooltip": TooltipHideDetail;
@@ -4556,6 +6443,11 @@ declare global {
         "seki-accordion-trigger": HTMLSekiAccordionTriggerElement;
         "seki-alert": HTMLSekiAlertElement;
         "seki-alert-description": HTMLSekiAlertDescriptionElement;
+        "seki-alert-dialog": HTMLSekiAlertDialogElement;
+        "seki-alert-dialog-action": HTMLSekiAlertDialogActionElement;
+        "seki-alert-dialog-cancel": HTMLSekiAlertDialogCancelElement;
+        "seki-alert-dialog-content": HTMLSekiAlertDialogContentElement;
+        "seki-alert-dialog-trigger": HTMLSekiAlertDialogTriggerElement;
         "seki-alert-title": HTMLSekiAlertTitleElement;
         "seki-aspect-ratio": HTMLSekiAspectRatioElement;
         "seki-avatar": HTMLSekiAvatarElement;
@@ -4585,10 +6477,27 @@ declare global {
         "seki-carousel-item": HTMLSekiCarouselItemElement;
         "seki-carousel-next": HTMLSekiCarouselNextElement;
         "seki-carousel-previous": HTMLSekiCarouselPreviousElement;
+        "seki-chart": HTMLSekiChartElement;
         "seki-checkbox": HTMLSekiCheckboxElement;
         "seki-collapsible": HTMLSekiCollapsibleElement;
         "seki-collapsible-content": HTMLSekiCollapsibleContentElement;
         "seki-collapsible-trigger": HTMLSekiCollapsibleTriggerElement;
+        "seki-combobox": HTMLSekiComboboxElement;
+        "seki-combobox-content": HTMLSekiComboboxContentElement;
+        "seki-combobox-empty": HTMLSekiComboboxEmptyElement;
+        "seki-combobox-group": HTMLSekiComboboxGroupElement;
+        "seki-combobox-input": HTMLSekiComboboxInputElement;
+        "seki-combobox-item": HTMLSekiComboboxItemElement;
+        "seki-command": HTMLSekiCommandElement;
+        "seki-command-empty": HTMLSekiCommandEmptyElement;
+        "seki-command-group": HTMLSekiCommandGroupElement;
+        "seki-command-input": HTMLSekiCommandInputElement;
+        "seki-command-item": HTMLSekiCommandItemElement;
+        "seki-command-list": HTMLSekiCommandListElement;
+        "seki-command-separator": HTMLSekiCommandSeparatorElement;
+        "seki-context-menu": HTMLSekiContextMenuElement;
+        "seki-context-menu-content": HTMLSekiContextMenuContentElement;
+        "seki-context-menu-trigger": HTMLSekiContextMenuTriggerElement;
         "seki-data-table": HTMLSekiDataTableElement;
         "seki-date-picker": HTMLSekiDatePickerElement;
         "seki-dialog": HTMLSekiDialogElement;
@@ -4600,6 +6509,8 @@ declare global {
         "seki-dialog-overlay": HTMLSekiDialogOverlayElement;
         "seki-dialog-title": HTMLSekiDialogTitleElement;
         "seki-dialog-trigger": HTMLSekiDialogTriggerElement;
+        "seki-drawer": HTMLSekiDrawerElement;
+        "seki-drawer-content": HTMLSekiDrawerContentElement;
         "seki-dropdown-menu": HTMLSekiDropdownMenuElement;
         "seki-dropdown-menu-checkbox": HTMLSekiDropdownMenuCheckboxElement;
         "seki-dropdown-menu-content": HTMLSekiDropdownMenuContentElement;
@@ -4609,6 +6520,7 @@ declare global {
         "seki-dropdown-menu-radio-group": HTMLSekiDropdownMenuRadioGroupElement;
         "seki-dropdown-menu-separator": HTMLSekiDropdownMenuSeparatorElement;
         "seki-dropdown-menu-shortcut": HTMLSekiDropdownMenuShortcutElement;
+        "seki-dropdown-menu-sub": HTMLSekiDropdownMenuSubElement;
         "seki-dropdown-menu-trigger": HTMLSekiDropdownMenuTriggerElement;
         "seki-field": HTMLSekiFieldElement;
         "seki-field-description": HTMLSekiFieldDescriptionElement;
@@ -4617,8 +6529,31 @@ declare global {
         "seki-field-label": HTMLSekiFieldLabelElement;
         "seki-field-legend": HTMLSekiFieldLegendElement;
         "seki-fieldset": HTMLSekiFieldsetElement;
+        "seki-hover-card": HTMLSekiHoverCardElement;
+        "seki-hover-card-content": HTMLSekiHoverCardContentElement;
+        "seki-hover-card-trigger": HTMLSekiHoverCardTriggerElement;
         "seki-input": HTMLSekiInputElement;
+        "seki-input-addon": HTMLSekiInputAddonElement;
+        "seki-input-group": HTMLSekiInputGroupElement;
+        "seki-input-otp": HTMLSekiInputOtpElement;
+        "seki-input-otp-group": HTMLSekiInputOtpGroupElement;
+        "seki-input-otp-separator": HTMLSekiInputOtpSeparatorElement;
+        "seki-input-otp-slot": HTMLSekiInputOtpSlotElement;
         "seki-kbd": HTMLSekiKbdElement;
+        "seki-menubar": HTMLSekiMenubarElement;
+        "seki-menubar-checkbox": HTMLSekiMenubarCheckboxElement;
+        "seki-menubar-content": HTMLSekiMenubarContentElement;
+        "seki-menubar-group": HTMLSekiMenubarGroupElement;
+        "seki-menubar-item": HTMLSekiMenubarItemElement;
+        "seki-menubar-menu": HTMLSekiMenubarMenuElement;
+        "seki-menubar-radio": HTMLSekiMenubarRadioElement;
+        "seki-menubar-radio-group": HTMLSekiMenubarRadioGroupElement;
+        "seki-menubar-separator": HTMLSekiMenubarSeparatorElement;
+        "seki-menubar-shortcut": HTMLSekiMenubarShortcutElement;
+        "seki-menubar-sub": HTMLSekiMenubarSubElement;
+        "seki-menubar-sub-content": HTMLSekiMenubarSubContentElement;
+        "seki-menubar-sub-trigger": HTMLSekiMenubarSubTriggerElement;
+        "seki-menubar-trigger": HTMLSekiMenubarTriggerElement;
         "seki-navigation-menu": HTMLSekiNavigationMenuElement;
         "seki-navigation-menu-content": HTMLSekiNavigationMenuContentElement;
         "seki-navigation-menu-item": HTMLSekiNavigationMenuItemElement;
@@ -4640,6 +6575,11 @@ declare global {
         "seki-progress": HTMLSekiProgressElement;
         "seki-radio-group": HTMLSekiRadioGroupElement;
         "seki-radio-group-item": HTMLSekiRadioGroupItemElement;
+        "seki-resizable-handle": HTMLSekiResizableHandleElement;
+        "seki-resizable-panel": HTMLSekiResizablePanelElement;
+        "seki-resizable-panel-group": HTMLSekiResizablePanelGroupElement;
+        "seki-scroll-area": HTMLSekiScrollAreaElement;
+        "seki-scroll-bar": HTMLSekiScrollBarElement;
         "seki-select": HTMLSekiSelectElement;
         "seki-select-content": HTMLSekiSelectContentElement;
         "seki-select-group": HTMLSekiSelectGroupElement;
@@ -4695,6 +6635,7 @@ declare global {
         "seki-textarea": HTMLSekiTextareaElement;
         "seki-toaster": HTMLSekiToasterElement;
         "seki-toggle": HTMLSekiToggleElement;
+        "seki-toggle-group": HTMLSekiToggleGroupElement;
         "seki-tooltip": HTMLSekiTooltipElement;
     }
 }
@@ -4791,6 +6732,91 @@ declare namespace LocalJSX {
          */
         "class"?: string;
     }
+    /**
+     * Alert Dialog root component for confirmation dialogs
+     * A modal dialog that interrupts the user with important content and expects a response.
+     * Wraps seki-dialog internally with Alert Dialog-specific behavior.
+     */
+    interface SekiAlertDialog {
+        /**
+          * Default open state (uncontrolled)
+          * @default false
+         */
+        "defaultOpen"?: boolean;
+        /**
+          * Emitted when open state changes
+         */
+        "onSekiOpenChange"?: (event: SekiAlertDialogCustomEvent<boolean>) => void;
+        /**
+          * Controlled open state
+          * @default false
+         */
+        "open"?: boolean;
+    }
+    /**
+     * Alert Dialog Action Button Component
+     * A button that confirms and closes the alert dialog. Supports default and destructive variants
+     * for different action types. Emits a sekiAction event before closing.
+     */
+    interface SekiAlertDialogAction {
+        /**
+          * Emitted when the action button is clicked
+         */
+        "onSekiAction"?: (event: SekiAlertDialogActionCustomEvent<void>) => void;
+        /**
+          * Emitted to request closing the alert dialog (fallback when context is unavailable)
+         */
+        "onSekiAlertDialogRequestClose"?: (event: SekiAlertDialogActionCustomEvent<void>) => void;
+        /**
+          * The visual variant of the action button - 'default': Primary button style for standard confirmations - 'destructive': Red/danger style for destructive actions
+          * @default 'default'
+         */
+        "variant"?: 'default' | 'destructive';
+    }
+    /**
+     * Alert Dialog Cancel Button Component
+     * A button that cancels and closes the alert dialog without confirming the action.
+     * Emits a sekiCancel event before closing.
+     */
+    interface SekiAlertDialogCancel {
+        /**
+          * Emitted to request closing the alert dialog (fallback when context is unavailable)
+         */
+        "onSekiAlertDialogRequestClose"?: (event: SekiAlertDialogCancelCustomEvent<void>) => void;
+        /**
+          * Emitted when the cancel button is clicked
+         */
+        "onSekiCancel"?: (event: SekiAlertDialogCancelCustomEvent<void>) => void;
+    }
+    /**
+     * Alert Dialog Content Component
+     * The content panel for the alert dialog with role="alertdialog".
+     * This is a modal dialog that interrupts the user with important content
+     * and expects a response. Unlike regular dialogs, it does NOT close on
+     * overlay click - users must explicitly confirm or cancel.
+     */
+    interface SekiAlertDialogContent {
+        /**
+          * Whether pressing Escape closes the alert dialog
+          * @default true
+         */
+        "closeOnEscape"?: boolean;
+        /**
+          * Emitted when the alert dialog requests to close
+         */
+        "onSekiAlertDialogRequestClose"?: (event: SekiAlertDialogContentCustomEvent<void>) => void;
+        /**
+          * Emitted when the alert dialog is cancelled (Escape key)
+         */
+        "onSekiCancel"?: (event: SekiAlertDialogContentCustomEvent<void>) => void;
+    }
+    /**
+     * Alert Dialog Trigger Component
+     * The element that opens the alert dialog when clicked.
+     */
+    interface SekiAlertDialogTrigger {
+        "onSekiAlertDialogTriggerClick"?: (event: SekiAlertDialogTriggerCustomEvent<void>) => void;
+    }
     /**
      * Title text within an alert component.
      * Renders as a heading with appropriate typography styles.
@@ -5273,6 +7299,21 @@ declare namespace LocalJSX {
      */
     interface SekiCarouselPrevious {
     }
+    interface SekiChart {
+        "colors"?: string[];
+        "data"?: ChartData;
+        "dataJson"?: string;
+        /**
+          * @default '300px'
+         */
+        "height"?: string;
+        "options"?: ChartOptions;
+        "optionsJson"?: string;
+        /**
+          * @default 'line'
+         */
+        "type"?: ChartType;
+    }
     /**
      * @component seki-checkbox
      * @description A checkbox control that allows users to toggle between checked, unchecked,
@@ -5364,22 +7405,296 @@ declare namespace LocalJSX {
          */
         "asChild"?: boolean;
     }
-    interface SekiDataTable {
-        /**
-          * Buffer rows above/below viewport
-          * @default 5
-         */
-        "bufferSize"?: number;
+    interface SekiCombobox {
         /**
-          * Show column visibility picker
+          * Allow values not in the list
           * @default false
          */
-        "columnPicker"?: boolean;
+        "allowCustomValue"?: boolean;
         /**
-          * Column definitions (JSON array)
-          * @default '[]'
+          * ID of element that describes this combobox
          */
-        "columns"?: string | ColumnDef[];
+        "ariaDescribedby"?: string;
+        /**
+          * Accessible label for screen readers
+         */
+        "ariaLabel"?: string;
+        /**
+          * ID of element that labels this combobox
+         */
+        "ariaLabelledby"?: string;
+        /**
+          * Debounce delay for search (ms)
+          * @default 300
+         */
+        "debounce"?: number;
+        /**
+          * Initial dropdown open state (uncontrolled mode)
+          * @default false
+         */
+        "defaultOpen"?: boolean;
+        /**
+          * Initial selected value (uncontrolled mode)
+         */
+        "defaultValue"?: ComboboxValue;
+        /**
+          * Disable component
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Static items for client-side filtering
+         */
+        "items"?: ComboboxItem[];
+        /**
+          * Set loading state externally (for async)
+          * @default false
+         */
+        "loading"?: boolean;
+        /**
+          * Multi-select display mode
+          * @default 'chips'
+         */
+        "multiSelectDisplay"?: ComboboxMultiSelectDisplay;
+        /**
+          * Enable multi-select mode
+          * @default false
+         */
+        "multiple"?: boolean;
+        /**
+          * Emitted when selected value changes
+         */
+        "onSekiChange"?: (event: SekiComboboxCustomEvent<ComboboxChangeEventDetail>) => void;
+        /**
+          * Emitted when a custom value is submitted
+         */
+        "onSekiCustomValue"?: (event: SekiComboboxCustomEvent<ComboboxCustomValueEventDetail>) => void;
+        /**
+          * Emitted when search query changes (after debounce)
+         */
+        "onSekiSearch"?: (event: SekiComboboxCustomEvent<ComboboxSearchEventDetail>) => void;
+        /**
+          * Control dropdown open state (controlled mode)
+         */
+        "open"?: boolean;
+        /**
+          * Placeholder text
+          * @default 'Search...'
+         */
+        "placeholder"?: string;
+        /**
+          * Mark as required
+          * @default false
+         */
+        "required"?: boolean;
+        /**
+          * Current selected value (controlled mode)
+         */
+        "value"?: ComboboxValue;
+    }
+    interface SekiComboboxContent {
+        /**
+          * Maximum height of the dropdown
+          * @default '15rem'
+         */
+        "maxHeight"?: string;
+    }
+    /**
+     * seki-combobox-empty: Display empty/loading/error states for combobox dropdown
+     * @component ComboboxEmpty
+     * @example <seki-combobox-empty reason="no-results">
+     *   No results found.
+     * </seki-combobox-empty>
+     * @example <seki-combobox-empty reason="loading">
+     *   <span slot="loading">Loading...</span>
+     * </seki-combobox-empty>
+     */
+    interface SekiComboboxEmpty {
+        /**
+          * The reason why the combobox is showing an empty state
+          * @default 'no-results'
+         */
+        "reason"?: ComboboxEmptyReason;
+    }
+    interface SekiComboboxGroup {
+        /**
+          * Group label
+         */
+        "label": string;
+    }
+    interface SekiComboboxInput {
+    }
+    interface SekiComboboxItem {
+        /**
+          * Disable this item
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Item value
+         */
+        "value": string;
+    }
+    /**
+     * Command root component - command palette for navigation
+     */
+    interface SekiCommand {
+        /**
+          * Enable built-in filtering
+          * @default true
+         */
+        "filter"?: boolean;
+        /**
+          * Emitted when an item is selected
+         */
+        "onSekiSelect"?: (event: SekiCommandCustomEvent<string>) => void;
+        /**
+          * Emitted when search value changes
+         */
+        "onSekiValueChange"?: (event: SekiCommandCustomEvent<string>) => void;
+        /**
+          * Controlled search value
+          * @default ''
+         */
+        "value"?: string;
+    }
+    /**
+     * Command empty state - shown when no results match
+     */
+    interface SekiCommandEmpty {
+    }
+    /**
+     * Command group - groups related items with a heading
+     */
+    interface SekiCommandGroup {
+        /**
+          * Show even when all items are filtered out
+          * @default false
+         */
+        "forceMount"?: boolean;
+        /**
+          * Group header text
+         */
+        "heading": string;
+    }
+    /**
+     * Command input - search field for filtering items
+     */
+    interface SekiCommandInput {
+        /**
+          * Emitted on input change (internal use)
+         */
+        "onSekiCommandInputChange"?: (event: SekiCommandInputCustomEvent<string>) => void;
+        /**
+          * Placeholder text
+          * @default 'Type a command or search...'
+         */
+        "placeholder"?: string;
+    }
+    /**
+     * Command item - selectable option in the command list
+     */
+    interface SekiCommandItem {
+        /**
+          * Whether the item is disabled
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Additional search terms (space-separated)
+         */
+        "keywords"?: string;
+        /**
+          * Emitted when this item is selected
+         */
+        "onSekiCommandSelect"?: (event: SekiCommandItemCustomEvent<string>) => void;
+        /**
+          * Keyboard shortcut hint (e.g., "⌘K")
+         */
+        "shortcut"?: string;
+        /**
+          * Unique value emitted on select
+         */
+        "value": string;
+    }
+    /**
+     * Command list - scrollable container for items and groups
+     */
+    interface SekiCommandList {
+    }
+    /**
+     * Command separator/divider
+     */
+    interface SekiCommandSeparator {
+    }
+    /**
+     * Context Menu component - right-click context menu with items
+     */
+    interface SekiContextMenu {
+        /**
+          * Emitted when open state changes
+         */
+        "onSekiOpenChange"?: (event: SekiContextMenuCustomEvent<boolean>) => void;
+        /**
+          * Emitted when an item is selected
+         */
+        "onSekiSelect"?: (event: SekiContextMenuCustomEvent<string>) => void;
+        /**
+          * Controlled open state
+          * @default false
+         */
+        "open"?: boolean;
+    }
+    /**
+     * Context Menu content panel - displays at cursor position
+     */
+    interface SekiContextMenuContent {
+        /**
+          * Accessible label for the menu
+         */
+        "ariaLabel"?: string;
+    }
+    /**
+     * Context Menu trigger component
+     * Handles right-click (desktop) and long-press (touch) to open context menu
+     */
+    interface SekiContextMenuTrigger {
+        /**
+          * Whether the trigger is disabled
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Duration in milliseconds for long press on touch devices
+          * @default 500
+         */
+        "longPressDuration"?: number;
+        /**
+          * Movement threshold in pixels before canceling long press
+          * @default 10
+         */
+        "moveThreshold"?: number;
+        /**
+          * Emitted when context menu should open, with position coordinates
+         */
+        "onSekiContextMenuOpen"?: (event: SekiContextMenuTriggerCustomEvent<{ x: number; y: number }>) => void;
+    }
+    interface SekiDataTable {
+        /**
+          * Buffer rows above/below viewport
+          * @default 5
+         */
+        "bufferSize"?: number;
+        /**
+          * Show column visibility picker
+          * @default false
+         */
+        "columnPicker"?: boolean;
+        /**
+          * Column definitions (JSON array)
+          * @default '[]'
+         */
+        "columns"?: string | ColumnDef[];
         /**
           * Message when no data
           * @default 'No data'
@@ -5638,6 +7953,77 @@ declare namespace LocalJSX {
     interface SekiDialogTrigger {
         "onSekiDialogTriggerClick"?: (event: SekiDialogTriggerCustomEvent<void>) => void;
     }
+    /**
+     * seki-drawer: Mobile-friendly drawer component with swipe gestures
+     * @component Drawer
+     * @example <seki-drawer>
+     *   <seki-sheet-trigger>
+     *     <seki-button>Open Drawer</seki-button>
+     *   </seki-sheet-trigger>
+     *   <seki-drawer-content direction="bottom" snap-points="0.5,1">
+     *     <seki-sheet-header>
+     *       <seki-sheet-title>Title</seki-sheet-title>
+     *     </seki-sheet-header>
+     *     Content here
+     *   </seki-drawer-content>
+     * </seki-drawer>
+     */
+    interface SekiDrawer {
+        /**
+          * Emitted when the drawer closes
+         */
+        "onDrawerClose"?: (event: SekiDrawerCustomEvent<void>) => void;
+        /**
+          * Emitted when the drawer opens
+         */
+        "onDrawerOpen"?: (event: SekiDrawerCustomEvent<void>) => void;
+        /**
+          * Emitted when the drawer snaps to a point
+         */
+        "onDrawerSnap"?: (event: SekiDrawerCustomEvent<{ point: number }>) => void;
+    }
+    /**
+     * seki-drawer-content: Container for drawer content with gesture support
+     * @component DrawerContent
+     */
+    interface SekiDrawerContent {
+        /**
+          * Accessible label for the drawer
+         */
+        "ariaLabel"?: string;
+        /**
+          * Distance threshold (0-1) to trigger close when dragging
+          * @default 0.5
+         */
+        "closeThreshold"?: number;
+        /**
+          * Direction the drawer slides in from
+          * @default 'bottom'
+         */
+        "direction"?: DrawerDirection;
+        /**
+          * Emitted to request drawer close
+         */
+        "onRequestClose"?: (event: SekiDrawerContentCustomEvent<void>) => void;
+        /**
+          * Emitted to request snap to a point
+         */
+        "onRequestSnap"?: (event: SekiDrawerContentCustomEvent<{ point: number }>) => void;
+        /**
+          * Show the drag handle indicator Default: true for bottom/top, false for left/right
+         */
+        "showHandle"?: boolean;
+        /**
+          * Comma-separated snap points (0-1). E.g., "0.5,1" for half and full open
+          * @default '1'
+         */
+        "snapPoints"?: string;
+        /**
+          * Velocity threshold (px/s) to trigger close on quick swipe
+          * @default 500
+         */
+        "velocityThreshold"?: number;
+    }
     /**
      * Dropdown Menu component - context menu with items
      */
@@ -5783,6 +8169,21 @@ declare namespace LocalJSX {
      */
     interface SekiDropdownMenuShortcut {
     }
+    /**
+     * Dropdown Menu Sub - A submenu component for nested dropdown menus
+     */
+    interface SekiDropdownMenuSub {
+        /**
+          * Delay in milliseconds before closing the submenu on mouse leave
+          * @default 100
+         */
+        "closeDelay"?: number;
+        /**
+          * Delay in milliseconds before opening the submenu on hover
+          * @default 100
+         */
+        "openDelay"?: number;
+    }
     /**
      * Dropdown Menu trigger button
      */
@@ -5845,6 +8246,125 @@ declare namespace LocalJSX {
          */
         "disabled"?: boolean;
     }
+    /**
+     * Hover Card Container Component
+     * A hover-triggered card component for previewing content (e.g., user profiles, link previews).
+     * Shows a floating card with rich content when hovering over a trigger element.
+     * This container manages state and timing, providing context to child components
+     * (seki-hover-card-trigger and seki-hover-card-content).
+     * @example ```html
+     * <seki-hover-card open-delay="100" close-delay="200">
+     *   <seki-hover-card-trigger>
+     *     <a href="/user/john">@john</a>
+     *   </seki-hover-card-trigger>
+     *   <seki-hover-card-content side="top">
+     *     <div class="user-preview">
+     *       <img src="avatar.jpg" alt="John's avatar" />
+     *       <h4>John Doe</h4>
+     *       <p>Software Engineer at Acme Inc.</p>
+     *     </div>
+     *   </seki-hover-card-content>
+     * </seki-hover-card>
+     * ```
+     */
+    interface SekiHoverCard {
+        /**
+          * Alignment along the side axis
+          * @default 'center'
+         */
+        "align"?: HoverCardAlign;
+        /**
+          * Milliseconds to delay before closing the hover card
+          * @default 300
+         */
+        "closeDelay"?: number;
+        /**
+          * Disable hover card interactions
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Emitted when open state changes
+         */
+        "onSekiOpenChange"?: (event: SekiHoverCardCustomEvent<{ open: boolean }>) => void;
+        /**
+          * Milliseconds to delay before opening the hover card
+          * @default 200
+         */
+        "openDelay"?: number;
+        /**
+          * Preferred side for hover card content placement
+          * @default 'bottom'
+         */
+        "side"?: HoverCardSide;
+    }
+    /**
+     * Hover Card Content Component
+     * The floating content panel that displays when the hover card is open.
+     * Handles positioning, viewport boundary collision, arrow placement,
+     * and interaction handlers to maintain open state while user interacts with content.
+     * @example ```html
+     * <seki-hover-card-content side="top" align="center">
+     *   <div class="user-preview">
+     *     <img src="avatar.jpg" alt="Avatar" />
+     *     <h4>John Doe</h4>
+     *     <p>Software Engineer</p>
+     *   </div>
+     * </seki-hover-card-content>
+     * ```
+     */
+    interface SekiHoverCardContent {
+        /**
+          * Override the alignment from the parent container
+         */
+        "align"?: HoverCardAlign1;
+        /**
+          * Offset along the alignment axis in pixels
+          * @default 0
+         */
+        "alignOffset"?: number;
+        /**
+          * Emitted to cancel a pending close timer
+         */
+        "onSekiHoverCardCancelClose"?: (event: SekiHoverCardContentCustomEvent<void>) => void;
+        /**
+          * Emitted to request closing the hover card (with delay)
+         */
+        "onSekiHoverCardRequestClose"?: (event: SekiHoverCardContentCustomEvent<void>) => void;
+        /**
+          * Override the side positioning from the parent container
+         */
+        "side"?: HoverCardSide1;
+        /**
+          * Distance from the trigger element in pixels
+          * @default 8
+         */
+        "sideOffset"?: number;
+    }
+    /**
+     * Hover Card Trigger Component
+     * The trigger element that activates the hover card on hover, focus, or touch.
+     * Handles mouse, keyboard, and touch interactions with appropriate behavior for each.
+     * @example ```html
+     * <seki-hover-card-trigger>
+     *   <a href="/user/john">@john</a>
+     * </seki-hover-card-trigger>
+     * ```
+     */
+    interface SekiHoverCardTrigger {
+        /**
+          * Emitted to cancel a pending close timer
+         */
+        "onSekiHoverCardCancelClose"?: (event: SekiHoverCardTriggerCustomEvent<void>) => void;
+        /**
+          * Emitted to request closing the hover card
+         */
+        "onSekiHoverCardRequestClose"?: (event: SekiHoverCardTriggerCustomEvent<void>) => void;
+        /**
+          * Emitted to request opening the hover card
+         */
+        "onSekiHoverCardRequestOpen"?: (event: SekiHoverCardTriggerCustomEvent<void>) => void;
+    }
     interface SekiInput {
         /**
           * ID of element describing this input
@@ -5907,47 +8427,347 @@ declare namespace LocalJSX {
         /**
           * Validation pattern (regex)
          */
-        "pattern"?: string;
+        "pattern"?: string;
+        /**
+          * Placeholder text
+         */
+        "placeholder"?: string;
+        /**
+          * Whether the input is readonly
+          * @default false
+         */
+        "readonly"?: boolean;
+        /**
+          * Whether the input is required
+          * @default false
+         */
+        "required"?: boolean;
+        /**
+          * Size variant
+          * @default 'md'
+         */
+        "size"?: 'sm' | 'md' | 'lg';
+        /**
+          * Step value (for number inputs)
+         */
+        "step"?: string | number;
+        /**
+          * Input type (text, email, password, number, tel, url, date, file, etc.)
+          * @default 'text'
+         */
+        "type"?: string;
+        /**
+          * Current value of the input
+          * @default ''
+         */
+        "value"?: string;
+    }
+    interface SekiInputAddon {
+        /**
+          * Size variant (usually set by parent input-group)
+          * @default 'md'
+         */
+        "size"?: 'sm' | 'md' | 'lg';
+    }
+    interface SekiInputGroup {
+        /**
+          * Accessible label for the input group
+         */
+        "ariaLabel"?: string;
+        /**
+          * Whether all children are disabled
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Size applied to all child components (input, addon, button)
+          * @default 'md'
+         */
+        "size"?: 'sm' | 'md' | 'lg';
+    }
+    interface SekiInputOtp {
+        /**
+          * ID of element describing this input
+         */
+        "ariaDescribedby"?: string;
+        /**
+          * Custom aria-label for the input
+         */
+        "ariaLabel"?: string;
+        /**
+          * Autocomplete hint for mobile keyboards
+          * @default 'one-time-code'
+         */
+        "autocomplete"?: string;
+        /**
+          * Whether the input is disabled
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Whether the input is in an invalid/error state
+          * @default false
+         */
+        "invalid"?: boolean;
+        /**
+          * Whether to mask the input (show bullets)
+          * @default false
+         */
+        "masked"?: boolean;
+        /**
+          * Total number of characters allowed
+          * @default 6
+         */
+        "maxlength"?: number;
+        /**
+          * Form field name
+         */
+        "name"?: string;
+        /**
+          * Emitted when value changes
+         */
+        "onSekiChange"?: (event: SekiInputOtpCustomEvent<{ value: string }>) => void;
+        /**
+          * Emitted when all slots are filled
+         */
+        "onSekiComplete"?: (event: SekiInputOtpCustomEvent<{ value: string }>) => void;
+        /**
+          * Emitted on each character change
+         */
+        "onSekiInput"?: (event: SekiInputOtpCustomEvent<{ value: string }>) => void;
+        /**
+          * Internal event to notify slots of state changes
+         */
+        "onSekiOtpStateChange"?: (event: SekiInputOtpCustomEvent<void>) => void;
+        /**
+          * Input pattern: 'digits' for numbers only, 'alphanumeric' for letters and numbers
+          * @default 'digits'
+         */
+        "pattern"?: 'digits' | 'alphanumeric';
+        /**
+          * Whether the input is required
+          * @default false
+         */
+        "required"?: boolean;
+        /**
+          * Current OTP value
+          * @default ''
+         */
+        "value"?: string;
+    }
+    interface SekiInputOtpGroup {
+    }
+    interface SekiInputOtpSeparator {
+    }
+    interface SekiInputOtpSlot {
+        /**
+          * The index of this slot (0-based)
+         */
+        "index": number;
+    }
+    interface SekiKbd {
+        /**
+          * Size variant of the kbd element
+          * @default 'md'
+         */
+        "size"?: 'sm' | 'md' | 'lg';
+    }
+    /**
+     * Menubar - horizontal menu bar with dropdown menus
+     */
+    interface SekiMenubar {
+        /**
+          * Whether arrow keys wrap around
+          * @default true
+         */
+        "loop"?: boolean;
+        /**
+          * Emitted when active menu changes
+         */
+        "onSekiOpenChange"?: (event: SekiMenubarCustomEvent<string | null>) => void;
+        /**
+          * Emitted when an item is selected
+         */
+        "onSekiSelect"?: (event: SekiMenubarCustomEvent<string>) => void;
+    }
+    /**
+     * Menubar checkbox item - toggleable menu option
+     */
+    interface SekiMenubarCheckbox {
+        /**
+          * Whether the checkbox is checked
+          * @default false
+         */
+        "checked"?: boolean;
+        /**
+          * Whether the item is disabled
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Emitted when checked state changes
+         */
+        "onSekiCheckedChange"?: (event: SekiMenubarCheckboxCustomEvent<boolean>) => void;
+        /**
+          * Keyboard shortcut hint
+         */
+        "shortcut"?: string;
+    }
+    /**
+     * Menubar content - dropdown content container
+     */
+    interface SekiMenubarContent {
+        /**
+          * Alignment along the side
+          * @default 'start'
+         */
+        "align"?: MenubarContentAlign;
+        /**
+          * Preferred side for placement
+          * @default 'bottom'
+         */
+        "side"?: MenubarContentSide;
+        /**
+          * Offset from trigger
+          * @default 4
+         */
+        "sideOffset"?: number;
+    }
+    /**
+     * Menubar group - groups related menu items with optional label
+     */
+    interface SekiMenubarGroup {
+        /**
+          * Optional group label
+         */
+        "label"?: string;
+    }
+    /**
+     * Menubar item - selectable menu option
+     */
+    interface SekiMenubarItem {
+        /**
+          * Whether the item is disabled
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Add left padding for alignment with icons
+          * @default false
+         */
+        "inset"?: boolean;
+        /**
+          * Emitted when item is selected
+         */
+        "onSekiMenubarSelect"?: (event: SekiMenubarItemCustomEvent<string>) => void;
+        /**
+          * Keyboard shortcut hint (e.g., "⌘K")
+         */
+        "shortcut"?: string;
+        /**
+          * Value emitted when item is selected
+         */
+        "value"?: string;
+    }
+    /**
+     * Menubar menu - individual menu container
+     */
+    interface SekiMenubarMenu {
+        /**
+          * Unique identifier for this menu
+         */
+        "menuId": string;
+    }
+    /**
+     * Menubar radio item - single-select option
+     */
+    interface SekiMenubarRadio {
+        /**
+          * Whether the item is disabled
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Emitted when radio is selected
+         */
+        "onSekiMenubarRadioSelect"?: (event: SekiMenubarRadioCustomEvent<string>) => void;
+        /**
+          * The value of this radio item
+         */
+        "value": string;
+    }
+    /**
+     * Menubar radio group - container for radio items
+     */
+    interface SekiMenubarRadioGroup {
         /**
-          * Placeholder text
+          * Emitted when selected value changes
          */
-        "placeholder"?: string;
+        "onSekiValueChange"?: (event: SekiMenubarRadioGroupCustomEvent<string>) => void;
         /**
-          * Whether the input is readonly
-          * @default false
+          * The value of the selected radio item
          */
-        "readonly"?: boolean;
+        "value"?: string;
+    }
+    /**
+     * Menubar separator - visual divider between menu items
+     */
+    interface SekiMenubarSeparator {
+    }
+    /**
+     * Menubar shortcut - displays keyboard shortcut hint
+     */
+    interface SekiMenubarShortcut {
+    }
+    /**
+     * Menubar sub - submenu container with hover behavior
+     */
+    interface SekiMenubarSub {
         /**
-          * Whether the input is required
-          * @default false
+          * Delay before closing on mouse leave (ms)
+          * @default 100
          */
-        "required"?: boolean;
+        "closeDelay"?: number;
         /**
-          * Size variant
-          * @default 'md'
+          * Delay before opening on hover (ms)
+          * @default 100
          */
-        "size"?: 'sm' | 'md' | 'lg';
+        "openDelay"?: number;
+    }
+    /**
+     * Menubar sub content - submenu content container
+     */
+    interface SekiMenubarSubContent {
         /**
-          * Step value (for number inputs)
+          * Offset from trigger
+          * @default 2
          */
-        "step"?: string | number;
+        "sideOffset"?: number;
+    }
+    /**
+     * Menubar sub trigger - opens submenu on hover
+     */
+    interface SekiMenubarSubTrigger {
         /**
-          * Input type (text, email, password, number, tel, url, date, file, etc.)
-          * @default 'text'
+          * Whether the trigger is disabled
+          * @default false
          */
-        "type"?: string;
+        "disabled"?: boolean;
         /**
-          * Current value of the input
-          * @default ''
+          * Add left padding for alignment
+          * @default false
          */
-        "value"?: string;
+        "inset"?: boolean;
     }
-    interface SekiKbd {
+    /**
+     * Menubar trigger - button that opens a menu
+     */
+    interface SekiMenubarTrigger {
         /**
-          * Size variant of the kbd element
-          * @default 'md'
+          * Whether the trigger is disabled
+          * @default false
          */
-        "size"?: 'sm' | 'md' | 'lg';
+        "disabled"?: boolean;
     }
     interface SekiNavigationMenu {
         /**
@@ -6327,6 +9147,126 @@ declare namespace LocalJSX {
          */
         "value": string;
     }
+    /**
+     * Resizable handle - draggable divider between panels
+     */
+    interface SekiResizableHandle {
+        /**
+          * Disable this handle
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Show visible grip indicator
+          * @default false
+         */
+        "withHandle"?: boolean;
+    }
+    /**
+     * Resizable panel - individual content panel with size constraints
+     */
+    interface SekiResizablePanel {
+        /**
+          * Size when collapsed (percentage)
+          * @default 0
+         */
+        "collapsedSize"?: number;
+        /**
+          * Whether panel can collapse
+          * @default false
+         */
+        "collapsible"?: boolean;
+        /**
+          * Default size as percentage (0-100)
+         */
+        "defaultSize"?: number;
+        /**
+          * Maximum size as percentage
+          * @default 100
+         */
+        "maxSize"?: number;
+        /**
+          * Minimum size as percentage
+          * @default 0
+         */
+        "minSize"?: number;
+        /**
+          * Emitted when panel collapses
+         */
+        "onSekiCollapse"?: (event: SekiResizablePanelCustomEvent<void>) => void;
+        /**
+          * Emitted when panel expands
+         */
+        "onSekiExpand"?: (event: SekiResizablePanelCustomEvent<void>) => void;
+        /**
+          * Emitted when this panel resizes
+         */
+        "onSekiResize"?: (event: SekiResizablePanelCustomEvent<number>) => void;
+    }
+    /**
+     * Resizable panel group - container that manages layout direction and coordinates panel sizes
+     */
+    interface SekiResizablePanelGroup {
+        /**
+          * ID for localStorage persistence (enables auto-save when set)
+         */
+        "autoSaveId"?: string;
+        /**
+          * Layout direction
+          * @default 'horizontal'
+         */
+        "direction"?: 'horizontal' | 'vertical';
+        /**
+          * Disable all resize interactions
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Internal event for direction changes
+         */
+        "onSekiDirectionChange"?: (event: SekiResizablePanelGroupCustomEvent<'horizontal' | 'vertical'>) => void;
+        /**
+          * Emitted when any panel size changes
+         */
+        "onSekiLayoutChange"?: (event: SekiResizablePanelGroupCustomEvent<number[]>) => void;
+    }
+    /**
+     * Scroll Area Component
+     * Augments native scroll functionality with custom, cross-browser styled scrollbars.
+     * Hides native scrollbars and provides custom scrollbar elements that sync with scroll position.
+     * @example <seki-scroll-area style="height: 200px;">
+     *   <div>Scrollable content...</div>
+     *   <seki-scroll-bar slot="scrollbar" orientation="vertical"></seki-scroll-bar>
+     * </seki-scroll-area>
+     */
+    interface SekiScrollArea {
+        /**
+          * Emitted when scroll position changes
+         */
+        "onSekiScroll"?: (event: SekiScrollAreaCustomEvent<{ scrollTop: number; scrollLeft: number }>) => void;
+        /**
+          * Delay in ms before hiding scrollbars (for auto/scroll/hover types)
+          * @default 600
+         */
+        "scrollHideDelay"?: number;
+        /**
+          * Controls when scrollbars are visible - 'always': Always visible when content overflows - 'auto': Visible on scroll, hide after delay - 'scroll': Same as auto (alias) - 'hover': Visible on hover or scroll
+          * @default 'hover'
+         */
+        "type"?: 'auto' | 'always' | 'scroll' | 'hover';
+    }
+    /**
+     * Scroll Bar Component
+     * Custom scrollbar that syncs with the parent scroll area's scroll position.
+     * Supports vertical and horizontal orientations.
+     */
+    interface SekiScrollBar {
+        /**
+          * Scrollbar orientation
+          * @default 'vertical'
+         */
+        "orientation"?: 'vertical' | 'horizontal';
+    }
     interface SekiSelect {
         /**
           * ID of element that describes this select
@@ -7157,12 +10097,59 @@ declare namespace LocalJSX {
           * @default 'md'
          */
         "size"?: 'sm' | 'md' | 'lg';
+        /**
+          * Value identifier when used inside a toggle group.
+         */
+        "value"?: string;
         /**
           * Visual style variant of the toggle.
           * @default 'default'
          */
         "variant"?: 'default' | 'outline';
     }
+    interface SekiToggleGroup {
+        /**
+          * Accessible label
+         */
+        "ariaLabel"?: string;
+        /**
+          * Initial value for uncontrolled mode
+         */
+        "defaultValue"?: string | string[];
+        /**
+          * Disable all toggles
+          * @default false
+         */
+        "disabled"?: boolean;
+        /**
+          * Emitted when value changes
+         */
+        "onSekiValueChange"?: (event: SekiToggleGroupCustomEvent<ToggleGroupValueChangeEventDetail>) => void;
+        /**
+          * Layout orientation
+          * @default 'horizontal'
+         */
+        "orientation"?: 'horizontal' | 'vertical';
+        /**
+          * Size for all toggles
+          * @default 'md'
+         */
+        "size"?: 'sm' | 'md' | 'lg';
+        /**
+          * Selection mode: single (radio-like) or multiple (checkbox-like)
+          * @default 'single'
+         */
+        "type"?: 'single' | 'multiple';
+        /**
+          * Controlled value
+         */
+        "value"?: string | string[];
+        /**
+          * Visual style variant for all toggles
+          * @default 'default'
+         */
+        "variant"?: 'default' | 'outline';
+    }
     /**
      * Tooltip Component
      * A fully accessible tooltip component that displays contextual information
@@ -7219,6 +10206,11 @@ declare namespace LocalJSX {
         "seki-accordion-trigger": SekiAccordionTrigger;
         "seki-alert": SekiAlert;
         "seki-alert-description": SekiAlertDescription;
+        "seki-alert-dialog": SekiAlertDialog;
+        "seki-alert-dialog-action": SekiAlertDialogAction;
+        "seki-alert-dialog-cancel": SekiAlertDialogCancel;
+        "seki-alert-dialog-content": SekiAlertDialogContent;
+        "seki-alert-dialog-trigger": SekiAlertDialogTrigger;
         "seki-alert-title": SekiAlertTitle;
         "seki-aspect-ratio": SekiAspectRatio;
         "seki-avatar": SekiAvatar;
@@ -7248,10 +10240,27 @@ declare namespace LocalJSX {
         "seki-carousel-item": SekiCarouselItem;
         "seki-carousel-next": SekiCarouselNext;
         "seki-carousel-previous": SekiCarouselPrevious;
+        "seki-chart": SekiChart;
         "seki-checkbox": SekiCheckbox;
         "seki-collapsible": SekiCollapsible;
         "seki-collapsible-content": SekiCollapsibleContent;
         "seki-collapsible-trigger": SekiCollapsibleTrigger;
+        "seki-combobox": SekiCombobox;
+        "seki-combobox-content": SekiComboboxContent;
+        "seki-combobox-empty": SekiComboboxEmpty;
+        "seki-combobox-group": SekiComboboxGroup;
+        "seki-combobox-input": SekiComboboxInput;
+        "seki-combobox-item": SekiComboboxItem;
+        "seki-command": SekiCommand;
+        "seki-command-empty": SekiCommandEmpty;
+        "seki-command-group": SekiCommandGroup;
+        "seki-command-input": SekiCommandInput;
+        "seki-command-item": SekiCommandItem;
+        "seki-command-list": SekiCommandList;
+        "seki-command-separator": SekiCommandSeparator;
+        "seki-context-menu": SekiContextMenu;
+        "seki-context-menu-content": SekiContextMenuContent;
+        "seki-context-menu-trigger": SekiContextMenuTrigger;
         "seki-data-table": SekiDataTable;
         "seki-date-picker": SekiDatePicker;
         "seki-dialog": SekiDialog;
@@ -7263,6 +10272,8 @@ declare namespace LocalJSX {
         "seki-dialog-overlay": SekiDialogOverlay;
         "seki-dialog-title": SekiDialogTitle;
         "seki-dialog-trigger": SekiDialogTrigger;
+        "seki-drawer": SekiDrawer;
+        "seki-drawer-content": SekiDrawerContent;
         "seki-dropdown-menu": SekiDropdownMenu;
         "seki-dropdown-menu-checkbox": SekiDropdownMenuCheckbox;
         "seki-dropdown-menu-content": SekiDropdownMenuContent;
@@ -7272,6 +10283,7 @@ declare namespace LocalJSX {
         "seki-dropdown-menu-radio-group": SekiDropdownMenuRadioGroup;
         "seki-dropdown-menu-separator": SekiDropdownMenuSeparator;
         "seki-dropdown-menu-shortcut": SekiDropdownMenuShortcut;
+        "seki-dropdown-menu-sub": SekiDropdownMenuSub;
         "seki-dropdown-menu-trigger": SekiDropdownMenuTrigger;
         "seki-field": SekiField;
         "seki-field-description": SekiFieldDescription;
@@ -7280,8 +10292,31 @@ declare namespace LocalJSX {
         "seki-field-label": SekiFieldLabel;
         "seki-field-legend": SekiFieldLegend;
         "seki-fieldset": SekiFieldset;
+        "seki-hover-card": SekiHoverCard;
+        "seki-hover-card-content": SekiHoverCardContent;
+        "seki-hover-card-trigger": SekiHoverCardTrigger;
         "seki-input": SekiInput;
+        "seki-input-addon": SekiInputAddon;
+        "seki-input-group": SekiInputGroup;
+        "seki-input-otp": SekiInputOtp;
+        "seki-input-otp-group": SekiInputOtpGroup;
+        "seki-input-otp-separator": SekiInputOtpSeparator;
+        "seki-input-otp-slot": SekiInputOtpSlot;
         "seki-kbd": SekiKbd;
+        "seki-menubar": SekiMenubar;
+        "seki-menubar-checkbox": SekiMenubarCheckbox;
+        "seki-menubar-content": SekiMenubarContent;
+        "seki-menubar-group": SekiMenubarGroup;
+        "seki-menubar-item": SekiMenubarItem;
+        "seki-menubar-menu": SekiMenubarMenu;
+        "seki-menubar-radio": SekiMenubarRadio;
+        "seki-menubar-radio-group": SekiMenubarRadioGroup;
+        "seki-menubar-separator": SekiMenubarSeparator;
+        "seki-menubar-shortcut": SekiMenubarShortcut;
+        "seki-menubar-sub": SekiMenubarSub;
+        "seki-menubar-sub-content": SekiMenubarSubContent;
+        "seki-menubar-sub-trigger": SekiMenubarSubTrigger;
+        "seki-menubar-trigger": SekiMenubarTrigger;
         "seki-navigation-menu": SekiNavigationMenu;
         "seki-navigation-menu-content": SekiNavigationMenuContent;
         "seki-navigation-menu-item": SekiNavigationMenuItem;
@@ -7303,6 +10338,11 @@ declare namespace LocalJSX {
         "seki-progress": SekiProgress;
         "seki-radio-group": SekiRadioGroup;
         "seki-radio-group-item": SekiRadioGroupItem;
+        "seki-resizable-handle": SekiResizableHandle;
+        "seki-resizable-panel": SekiResizablePanel;
+        "seki-resizable-panel-group": SekiResizablePanelGroup;
+        "seki-scroll-area": SekiScrollArea;
+        "seki-scroll-bar": SekiScrollBar;
         "seki-select": SekiSelect;
         "seki-select-content": SekiSelectContent;
         "seki-select-group": SekiSelectGroup;
@@ -7358,6 +10398,7 @@ declare namespace LocalJSX {
         "seki-textarea": SekiTextarea;
         "seki-toaster": SekiToaster;
         "seki-toggle": SekiToggle;
+        "seki-toggle-group": SekiToggleGroup;
         "seki-tooltip": SekiTooltip;
     }
 }
@@ -7406,6 +10447,37 @@ declare module "@stencil/core" {
              * </seki-alert>
              */
             "seki-alert-description": LocalJSX.SekiAlertDescription & JSXBase.HTMLAttributes<HTMLSekiAlertDescriptionElement>;
+            /**
+             * Alert Dialog root component for confirmation dialogs
+             * A modal dialog that interrupts the user with important content and expects a response.
+             * Wraps seki-dialog internally with Alert Dialog-specific behavior.
+             */
+            "seki-alert-dialog": LocalJSX.SekiAlertDialog & JSXBase.HTMLAttributes<HTMLSekiAlertDialogElement>;
+            /**
+             * Alert Dialog Action Button Component
+             * A button that confirms and closes the alert dialog. Supports default and destructive variants
+             * for different action types. Emits a sekiAction event before closing.
+             */
+            "seki-alert-dialog-action": LocalJSX.SekiAlertDialogAction & JSXBase.HTMLAttributes<HTMLSekiAlertDialogActionElement>;
+            /**
+             * Alert Dialog Cancel Button Component
+             * A button that cancels and closes the alert dialog without confirming the action.
+             * Emits a sekiCancel event before closing.
+             */
+            "seki-alert-dialog-cancel": LocalJSX.SekiAlertDialogCancel & JSXBase.HTMLAttributes<HTMLSekiAlertDialogCancelElement>;
+            /**
+             * Alert Dialog Content Component
+             * The content panel for the alert dialog with role="alertdialog".
+             * This is a modal dialog that interrupts the user with important content
+             * and expects a response. Unlike regular dialogs, it does NOT close on
+             * overlay click - users must explicitly confirm or cancel.
+             */
+            "seki-alert-dialog-content": LocalJSX.SekiAlertDialogContent & JSXBase.HTMLAttributes<HTMLSekiAlertDialogContentElement>;
+            /**
+             * Alert Dialog Trigger Component
+             * The element that opens the alert dialog when clicked.
+             */
+            "seki-alert-dialog-trigger": LocalJSX.SekiAlertDialogTrigger & JSXBase.HTMLAttributes<HTMLSekiAlertDialogTriggerElement>;
             /**
              * Title text within an alert component.
              * Renders as a heading with appropriate typography styles.
@@ -7596,6 +10668,7 @@ declare module "@stencil/core" {
              * Automatically connects to parent seki-carousel.
              */
             "seki-carousel-previous": LocalJSX.SekiCarouselPrevious & JSXBase.HTMLAttributes<HTMLSekiCarouselPreviousElement>;
+            "seki-chart": LocalJSX.SekiChart & JSXBase.HTMLAttributes<HTMLSekiChartElement>;
             /**
              * @component seki-checkbox
              * @description A checkbox control that allows users to toggle between checked, unchecked,
@@ -7614,6 +10687,63 @@ declare module "@stencil/core" {
              * Trigger button for Collapsible component
              */
             "seki-collapsible-trigger": LocalJSX.SekiCollapsibleTrigger & JSXBase.HTMLAttributes<HTMLSekiCollapsibleTriggerElement>;
+            "seki-combobox": LocalJSX.SekiCombobox & JSXBase.HTMLAttributes<HTMLSekiComboboxElement>;
+            "seki-combobox-content": LocalJSX.SekiComboboxContent & JSXBase.HTMLAttributes<HTMLSekiComboboxContentElement>;
+            /**
+             * seki-combobox-empty: Display empty/loading/error states for combobox dropdown
+             * @component ComboboxEmpty
+             * @example <seki-combobox-empty reason="no-results">
+             *   No results found.
+             * </seki-combobox-empty>
+             * @example <seki-combobox-empty reason="loading">
+             *   <span slot="loading">Loading...</span>
+             * </seki-combobox-empty>
+             */
+            "seki-combobox-empty": LocalJSX.SekiComboboxEmpty & JSXBase.HTMLAttributes<HTMLSekiComboboxEmptyElement>;
+            "seki-combobox-group": LocalJSX.SekiComboboxGroup & JSXBase.HTMLAttributes<HTMLSekiComboboxGroupElement>;
+            "seki-combobox-input": LocalJSX.SekiComboboxInput & JSXBase.HTMLAttributes<HTMLSekiComboboxInputElement>;
+            "seki-combobox-item": LocalJSX.SekiComboboxItem & JSXBase.HTMLAttributes<HTMLSekiComboboxItemElement>;
+            /**
+             * Command root component - command palette for navigation
+             */
+            "seki-command": LocalJSX.SekiCommand & JSXBase.HTMLAttributes<HTMLSekiCommandElement>;
+            /**
+             * Command empty state - shown when no results match
+             */
+            "seki-command-empty": LocalJSX.SekiCommandEmpty & JSXBase.HTMLAttributes<HTMLSekiCommandEmptyElement>;
+            /**
+             * Command group - groups related items with a heading
+             */
+            "seki-command-group": LocalJSX.SekiCommandGroup & JSXBase.HTMLAttributes<HTMLSekiCommandGroupElement>;
+            /**
+             * Command input - search field for filtering items
+             */
+            "seki-command-input": LocalJSX.SekiCommandInput & JSXBase.HTMLAttributes<HTMLSekiCommandInputElement>;
+            /**
+             * Command item - selectable option in the command list
+             */
+            "seki-command-item": LocalJSX.SekiCommandItem & JSXBase.HTMLAttributes<HTMLSekiCommandItemElement>;
+            /**
+             * Command list - scrollable container for items and groups
+             */
+            "seki-command-list": LocalJSX.SekiCommandList & JSXBase.HTMLAttributes<HTMLSekiCommandListElement>;
+            /**
+             * Command separator/divider
+             */
+            "seki-command-separator": LocalJSX.SekiCommandSeparator & JSXBase.HTMLAttributes<HTMLSekiCommandSeparatorElement>;
+            /**
+             * Context Menu component - right-click context menu with items
+             */
+            "seki-context-menu": LocalJSX.SekiContextMenu & JSXBase.HTMLAttributes<HTMLSekiContextMenuElement>;
+            /**
+             * Context Menu content panel - displays at cursor position
+             */
+            "seki-context-menu-content": LocalJSX.SekiContextMenuContent & JSXBase.HTMLAttributes<HTMLSekiContextMenuContentElement>;
+            /**
+             * Context Menu trigger component
+             * Handles right-click (desktop) and long-press (touch) to open context menu
+             */
+            "seki-context-menu-trigger": LocalJSX.SekiContextMenuTrigger & JSXBase.HTMLAttributes<HTMLSekiContextMenuTriggerElement>;
             "seki-data-table": LocalJSX.SekiDataTable & JSXBase.HTMLAttributes<HTMLSekiDataTableElement>;
             /**
              * seki-date-picker: A date picker component with popover calendar
@@ -7658,6 +10788,27 @@ declare module "@stencil/core" {
              * Dialog trigger button
              */
             "seki-dialog-trigger": LocalJSX.SekiDialogTrigger & JSXBase.HTMLAttributes<HTMLSekiDialogTriggerElement>;
+            /**
+             * seki-drawer: Mobile-friendly drawer component with swipe gestures
+             * @component Drawer
+             * @example <seki-drawer>
+             *   <seki-sheet-trigger>
+             *     <seki-button>Open Drawer</seki-button>
+             *   </seki-sheet-trigger>
+             *   <seki-drawer-content direction="bottom" snap-points="0.5,1">
+             *     <seki-sheet-header>
+             *       <seki-sheet-title>Title</seki-sheet-title>
+             *     </seki-sheet-header>
+             *     Content here
+             *   </seki-drawer-content>
+             * </seki-drawer>
+             */
+            "seki-drawer": LocalJSX.SekiDrawer & JSXBase.HTMLAttributes<HTMLSekiDrawerElement>;
+            /**
+             * seki-drawer-content: Container for drawer content with gesture support
+             * @component DrawerContent
+             */
+            "seki-drawer-content": LocalJSX.SekiDrawerContent & JSXBase.HTMLAttributes<HTMLSekiDrawerContentElement>;
             /**
              * Dropdown Menu component - context menu with items
              */
@@ -7694,6 +10845,10 @@ declare module "@stencil/core" {
              * Dropdown Menu keyboard shortcut display
              */
             "seki-dropdown-menu-shortcut": LocalJSX.SekiDropdownMenuShortcut & JSXBase.HTMLAttributes<HTMLSekiDropdownMenuShortcutElement>;
+            /**
+             * Dropdown Menu Sub - A submenu component for nested dropdown menus
+             */
+            "seki-dropdown-menu-sub": LocalJSX.SekiDropdownMenuSub & JSXBase.HTMLAttributes<HTMLSekiDropdownMenuSubElement>;
             /**
              * Dropdown Menu trigger button
              */
@@ -7705,8 +10860,119 @@ declare module "@stencil/core" {
             "seki-field-label": LocalJSX.SekiFieldLabel & JSXBase.HTMLAttributes<HTMLSekiFieldLabelElement>;
             "seki-field-legend": LocalJSX.SekiFieldLegend & JSXBase.HTMLAttributes<HTMLSekiFieldLegendElement>;
             "seki-fieldset": LocalJSX.SekiFieldset & JSXBase.HTMLAttributes<HTMLSekiFieldsetElement>;
+            /**
+             * Hover Card Container Component
+             * A hover-triggered card component for previewing content (e.g., user profiles, link previews).
+             * Shows a floating card with rich content when hovering over a trigger element.
+             * This container manages state and timing, providing context to child components
+             * (seki-hover-card-trigger and seki-hover-card-content).
+             * @example ```html
+             * <seki-hover-card open-delay="100" close-delay="200">
+             *   <seki-hover-card-trigger>
+             *     <a href="/user/john">@john</a>
+             *   </seki-hover-card-trigger>
+             *   <seki-hover-card-content side="top">
+             *     <div class="user-preview">
+             *       <img src="avatar.jpg" alt="John's avatar" />
+             *       <h4>John Doe</h4>
+             *       <p>Software Engineer at Acme Inc.</p>
+             *     </div>
+             *   </seki-hover-card-content>
+             * </seki-hover-card>
+             * ```
+             */
+            "seki-hover-card": LocalJSX.SekiHoverCard & JSXBase.HTMLAttributes<HTMLSekiHoverCardElement>;
+            /**
+             * Hover Card Content Component
+             * The floating content panel that displays when the hover card is open.
+             * Handles positioning, viewport boundary collision, arrow placement,
+             * and interaction handlers to maintain open state while user interacts with content.
+             * @example ```html
+             * <seki-hover-card-content side="top" align="center">
+             *   <div class="user-preview">
+             *     <img src="avatar.jpg" alt="Avatar" />
+             *     <h4>John Doe</h4>
+             *     <p>Software Engineer</p>
+             *   </div>
+             * </seki-hover-card-content>
+             * ```
+             */
+            "seki-hover-card-content": LocalJSX.SekiHoverCardContent & JSXBase.HTMLAttributes<HTMLSekiHoverCardContentElement>;
+            /**
+             * Hover Card Trigger Component
+             * The trigger element that activates the hover card on hover, focus, or touch.
+             * Handles mouse, keyboard, and touch interactions with appropriate behavior for each.
+             * @example ```html
+             * <seki-hover-card-trigger>
+             *   <a href="/user/john">@john</a>
+             * </seki-hover-card-trigger>
+             * ```
+             */
+            "seki-hover-card-trigger": LocalJSX.SekiHoverCardTrigger & JSXBase.HTMLAttributes<HTMLSekiHoverCardTriggerElement>;
             "seki-input": LocalJSX.SekiInput & JSXBase.HTMLAttributes<HTMLSekiInputElement>;
+            "seki-input-addon": LocalJSX.SekiInputAddon & JSXBase.HTMLAttributes<HTMLSekiInputAddonElement>;
+            "seki-input-group": LocalJSX.SekiInputGroup & JSXBase.HTMLAttributes<HTMLSekiInputGroupElement>;
+            "seki-input-otp": LocalJSX.SekiInputOtp & JSXBase.HTMLAttributes<HTMLSekiInputOtpElement>;
+            "seki-input-otp-group": LocalJSX.SekiInputOtpGroup & JSXBase.HTMLAttributes<HTMLSekiInputOtpGroupElement>;
+            "seki-input-otp-separator": LocalJSX.SekiInputOtpSeparator & JSXBase.HTMLAttributes<HTMLSekiInputOtpSeparatorElement>;
+            "seki-input-otp-slot": LocalJSX.SekiInputOtpSlot & JSXBase.HTMLAttributes<HTMLSekiInputOtpSlotElement>;
             "seki-kbd": LocalJSX.SekiKbd & JSXBase.HTMLAttributes<HTMLSekiKbdElement>;
+            /**
+             * Menubar - horizontal menu bar with dropdown menus
+             */
+            "seki-menubar": LocalJSX.SekiMenubar & JSXBase.HTMLAttributes<HTMLSekiMenubarElement>;
+            /**
+             * Menubar checkbox item - toggleable menu option
+             */
+            "seki-menubar-checkbox": LocalJSX.SekiMenubarCheckbox & JSXBase.HTMLAttributes<HTMLSekiMenubarCheckboxElement>;
+            /**
+             * Menubar content - dropdown content container
+             */
+            "seki-menubar-content": LocalJSX.SekiMenubarContent & JSXBase.HTMLAttributes<HTMLSekiMenubarContentElement>;
+            /**
+             * Menubar group - groups related menu items with optional label
+             */
+            "seki-menubar-group": LocalJSX.SekiMenubarGroup & JSXBase.HTMLAttributes<HTMLSekiMenubarGroupElement>;
+            /**
+             * Menubar item - selectable menu option
+             */
+            "seki-menubar-item": LocalJSX.SekiMenubarItem & JSXBase.HTMLAttributes<HTMLSekiMenubarItemElement>;
+            /**
+             * Menubar menu - individual menu container
+             */
+            "seki-menubar-menu": LocalJSX.SekiMenubarMenu & JSXBase.HTMLAttributes<HTMLSekiMenubarMenuElement>;
+            /**
+             * Menubar radio item - single-select option
+             */
+            "seki-menubar-radio": LocalJSX.SekiMenubarRadio & JSXBase.HTMLAttributes<HTMLSekiMenubarRadioElement>;
+            /**
+             * Menubar radio group - container for radio items
+             */
+            "seki-menubar-radio-group": LocalJSX.SekiMenubarRadioGroup & JSXBase.HTMLAttributes<HTMLSekiMenubarRadioGroupElement>;
+            /**
+             * Menubar separator - visual divider between menu items
+             */
+            "seki-menubar-separator": LocalJSX.SekiMenubarSeparator & JSXBase.HTMLAttributes<HTMLSekiMenubarSeparatorElement>;
+            /**
+             * Menubar shortcut - displays keyboard shortcut hint
+             */
+            "seki-menubar-shortcut": LocalJSX.SekiMenubarShortcut & JSXBase.HTMLAttributes<HTMLSekiMenubarShortcutElement>;
+            /**
+             * Menubar sub - submenu container with hover behavior
+             */
+            "seki-menubar-sub": LocalJSX.SekiMenubarSub & JSXBase.HTMLAttributes<HTMLSekiMenubarSubElement>;
+            /**
+             * Menubar sub content - submenu content container
+             */
+            "seki-menubar-sub-content": LocalJSX.SekiMenubarSubContent & JSXBase.HTMLAttributes<HTMLSekiMenubarSubContentElement>;
+            /**
+             * Menubar sub trigger - opens submenu on hover
+             */
+            "seki-menubar-sub-trigger": LocalJSX.SekiMenubarSubTrigger & JSXBase.HTMLAttributes<HTMLSekiMenubarSubTriggerElement>;
+            /**
+             * Menubar trigger - button that opens a menu
+             */
+            "seki-menubar-trigger": LocalJSX.SekiMenubarTrigger & JSXBase.HTMLAttributes<HTMLSekiMenubarTriggerElement>;
             "seki-navigation-menu": LocalJSX.SekiNavigationMenu & JSXBase.HTMLAttributes<HTMLSekiNavigationMenuElement>;
             "seki-navigation-menu-content": LocalJSX.SekiNavigationMenuContent & JSXBase.HTMLAttributes<HTMLSekiNavigationMenuContentElement>;
             "seki-navigation-menu-item": LocalJSX.SekiNavigationMenuItem & JSXBase.HTMLAttributes<HTMLSekiNavigationMenuItemElement>;
@@ -7803,6 +11069,34 @@ declare module "@stencil/core" {
              * @example <seki-radio-group-item value="option1">Option 1</seki-radio-group-item>
              */
             "seki-radio-group-item": LocalJSX.SekiRadioGroupItem & JSXBase.HTMLAttributes<HTMLSekiRadioGroupItemElement>;
+            /**
+             * Resizable handle - draggable divider between panels
+             */
+            "seki-resizable-handle": LocalJSX.SekiResizableHandle & JSXBase.HTMLAttributes<HTMLSekiResizableHandleElement>;
+            /**
+             * Resizable panel - individual content panel with size constraints
+             */
+            "seki-resizable-panel": LocalJSX.SekiResizablePanel & JSXBase.HTMLAttributes<HTMLSekiResizablePanelElement>;
+            /**
+             * Resizable panel group - container that manages layout direction and coordinates panel sizes
+             */
+            "seki-resizable-panel-group": LocalJSX.SekiResizablePanelGroup & JSXBase.HTMLAttributes<HTMLSekiResizablePanelGroupElement>;
+            /**
+             * Scroll Area Component
+             * Augments native scroll functionality with custom, cross-browser styled scrollbars.
+             * Hides native scrollbars and provides custom scrollbar elements that sync with scroll position.
+             * @example <seki-scroll-area style="height: 200px;">
+             *   <div>Scrollable content...</div>
+             *   <seki-scroll-bar slot="scrollbar" orientation="vertical"></seki-scroll-bar>
+             * </seki-scroll-area>
+             */
+            "seki-scroll-area": LocalJSX.SekiScrollArea & JSXBase.HTMLAttributes<HTMLSekiScrollAreaElement>;
+            /**
+             * Scroll Bar Component
+             * Custom scrollbar that syncs with the parent scroll area's scroll position.
+             * Supports vertical and horizontal orientations.
+             */
+            "seki-scroll-bar": LocalJSX.SekiScrollBar & JSXBase.HTMLAttributes<HTMLSekiScrollBarElement>;
             "seki-select": LocalJSX.SekiSelect & JSXBase.HTMLAttributes<HTMLSekiSelectElement>;
             "seki-select-content": LocalJSX.SekiSelectContent & JSXBase.HTMLAttributes<HTMLSekiSelectContentElement>;
             "seki-select-group": LocalJSX.SekiSelectGroup & JSXBase.HTMLAttributes<HTMLSekiSelectGroupElement>;
@@ -8012,6 +11306,7 @@ declare module "@stencil/core" {
              * <seki-toggle variant="outline" size="sm">Underline</seki-toggle>
              */
             "seki-toggle": LocalJSX.SekiToggle & JSXBase.HTMLAttributes<HTMLSekiToggleElement>;
+            "seki-toggle-group": LocalJSX.SekiToggleGroup & JSXBase.HTMLAttributes<HTMLSekiToggleGroupElement>;
             /**
              * Tooltip Component
              * A fully accessible tooltip component that displays contextual information