@asymmetric-effort/specifyjs 0.2.98 → 0.2.100

package/dist/types/components/math/src/quaternion.d.ts

@@ -0,0 +1,62 @@
+import type { Vec3 } from './vec';
+/** A quaternion representing a rotation, with w as the scalar component. */
+export interface Quaternion {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+}
+/** Create the identity quaternion (no rotation). */
+export declare function quatIdentity(): Quaternion;
+/**
+ * Create a quaternion from an axis and angle.
+ * @param axis - The rotation axis (will be normalized).
+ * @param radians - The rotation angle in radians.
+ */
+export declare function quatFromAxisAngle(axis: Vec3, radians: number): Quaternion;
+/**
+ * Create a quaternion from Euler angles (intrinsic ZYX / yaw-pitch-roll).
+ * @param pitch - Rotation around the X axis in radians.
+ * @param yaw - Rotation around the Y axis in radians.
+ * @param roll - Rotation around the Z axis in radians.
+ */
+export declare function quatFromEuler(pitch: number, yaw: number, roll: number): Quaternion;
+/**
+ * Multiply two quaternions (Hamilton product).
+ * Represents the composition of rotations: first b, then a.
+ */
+export declare function quatMultiply(a: Quaternion, b: Quaternion): Quaternion;
+/** Return the conjugate of a quaternion. */
+export declare function quatConjugate(q: Quaternion): Quaternion;
+/** Return the inverse of a quaternion. */
+export declare function quatInverse(q: Quaternion): Quaternion;
+/** Normalize a quaternion to unit length. */
+export declare function quatNormalize(q: Quaternion): Quaternion;
+/** Return the length (magnitude) of a quaternion. */
+export declare function quatLength(q: Quaternion): number;
+/** Compute the dot product of two quaternions. */
+export declare function quatDot(a: Quaternion, b: Quaternion): number;
+/**
+ * Spherical linear interpolation between two quaternions.
+ * @param a - Start quaternion.
+ * @param b - End quaternion.
+ * @param t - Interpolation factor (0 = a, 1 = b).
+ */
+export declare function quatSlerp(a: Quaternion, b: Quaternion, t: number): Quaternion;
+/**
+ * Rotate a Vec3 by a unit quaternion.
+ * Uses the formula: v' = q * v * q^-1 (optimized).
+ */
+export declare function quatRotateVec3(q: Quaternion, v: Vec3): Vec3;
+/**
+ * Convert a quaternion to Euler angles (pitch, yaw, roll) in radians.
+ * Uses intrinsic ZYX convention.
+ * @returns A Vec3 where x = pitch, y = yaw, z = roll.
+ */
+export declare function quatToEuler(q: Quaternion): Vec3;
+/**
+ * Create a quaternion representing a rotation that looks in the given direction.
+ * @param forward - The direction to look at (will be normalized).
+ * @param up - The up vector (will be normalized).
+ */
+export declare function quatLookAt(forward: Vec3, up: Vec3): Quaternion;

package/dist/types/components/math/src/solver.d.ts

@@ -0,0 +1,55 @@
+import type { MatN } from './mat';
+/**
+ * Solve Ax = b for x using Gaussian elimination with partial pivoting.
+ * @param A - NxN coefficient matrix.
+ * @param b - N-length right-hand side vector.
+ * @returns x - N-length solution vector, or null if A is singular.
+ */
+export declare function solve(A: MatN, b: Float64Array): Float64Array | null;
+/**
+ * LU decomposition with partial pivoting: PA = LU.
+ *
+ * Uses an iterative Doolittle algorithm (no recursion).
+ *
+ * @param A - NxN matrix to decompose.
+ * @returns Object containing L, U, and permutation vector P, or null if singular.
+ */
+export declare function luDecompose(A: MatN): {
+    L: MatN;
+    U: MatN;
+    P: number[];
+} | null;
+/**
+ * Solve a linear system using a pre-computed LU decomposition.
+ *
+ * Given PA = LU, solves Ax = b by:
+ *   1. Permute b according to P: Pb
+ *   2. Forward substitution: Ly = Pb
+ *   3. Back substitution: Ux = y
+ *
+ * @param L - Lower triangular matrix with unit diagonal.
+ * @param U - Upper triangular matrix.
+ * @param P - Permutation vector from LU decomposition.
+ * @param b - N-length right-hand side vector.
+ * @returns x - N-length solution vector.
+ */
+export declare function luSolve(L: MatN, U: MatN, P: number[], b: Float64Array): Float64Array;
+/**
+ * Compute the determinant of an NxN matrix via LU decomposition.
+ *
+ * The determinant of PA = LU is:
+ *   det(A) = (-1)^swaps * product of U diagonal
+ *
+ * @param A - NxN matrix.
+ * @returns The determinant value. Returns 0 for singular matrices.
+ */
+export declare function determinant(A: MatN): number;
+/**
+ * Compute the inverse of an NxN matrix via LU decomposition.
+ *
+ * Solves A * X_col = e_col for each column of the identity matrix.
+ *
+ * @param A - NxN matrix to invert.
+ * @returns The inverse matrix, or null if A is singular.
+ */
+export declare function inverse(A: MatN): MatN | null;

package/dist/types/components/math/src/vec.d.ts

@@ -0,0 +1,54 @@
+/** A 2D vector with x and y components. */
+export interface Vec2 {
+    readonly x: number;
+    readonly y: number;
+}
+/** A 3D vector with x, y, and z components. */
+export interface Vec3 {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+/** Create a new Vec2. */
+export declare function vec2(x: number, y: number): Vec2;
+/** Add two Vec2 vectors. */
+export declare function vec2Add(a: Vec2, b: Vec2): Vec2;
+/** Subtract Vec2 b from Vec2 a. */
+export declare function vec2Sub(a: Vec2, b: Vec2): Vec2;
+/** Scale a Vec2 by a scalar. */
+export declare function vec2Scale(v: Vec2, s: number): Vec2;
+/** Compute the dot product of two Vec2 vectors. */
+export declare function vec2Dot(a: Vec2, b: Vec2): number;
+/** Compute the length (magnitude) of a Vec2. */
+export declare function vec2Length(v: Vec2): number;
+/**
+ * Normalize a Vec2 to unit length.
+ * Returns a zero vector if the input has zero length.
+ */
+export declare function vec2Normalize(v: Vec2): Vec2;
+/** Compute the Euclidean distance between two Vec2 points. */
+export declare function vec2Dist(a: Vec2, b: Vec2): number;
+/**
+ * Linearly interpolate between two Vec2 vectors.
+ * @param t - Interpolation factor (0 = a, 1 = b).
+ */
+export declare function vec2Lerp(a: Vec2, b: Vec2, t: number): Vec2;
+/** Create a new Vec3. */
+export declare function vec3(x: number, y: number, z: number): Vec3;
+/** Add two Vec3 vectors. */
+export declare function vec3Add(a: Vec3, b: Vec3): Vec3;
+/** Subtract Vec3 b from Vec3 a. */
+export declare function vec3Sub(a: Vec3, b: Vec3): Vec3;
+/** Scale a Vec3 by a scalar. */
+export declare function vec3Scale(v: Vec3, s: number): Vec3;
+/** Compute the dot product of two Vec3 vectors. */
+export declare function vec3Dot(a: Vec3, b: Vec3): number;
+/** Compute the cross product of two Vec3 vectors. */
+export declare function vec3Cross(a: Vec3, b: Vec3): Vec3;
+/** Compute the length (magnitude) of a Vec3. */
+export declare function vec3Length(v: Vec3): number;
+/**
+ * Normalize a Vec3 to unit length.
+ * Returns a zero vector if the input has zero length.
+ */
+export declare function vec3Normalize(v: Vec3): Vec3;

package/dist/types/components/media/carousel/src/Carousel.d.ts

@@ -0,0 +1,23 @@
+export interface CarouselItem {
+    content: unknown;
+    caption?: string;
+}
+export interface CarouselProps {
+    /** Carousel items */
+    items: CarouselItem[];
+    /** Enable auto-advance */
+    autoPlay?: boolean;
+    /** Auto-advance interval in ms (default: 5000) */
+    interval?: number;
+    /** Show dot indicators (default: true) */
+    showDots?: boolean;
+    /** Show prev/next arrows (default: true) */
+    showArrows?: boolean;
+    /** Loop from last to first (default: true) */
+    loop?: boolean;
+    /** Transition animation type */
+    animation?: 'slide' | 'fade';
+    /** Called when the active index changes */
+    onChange?: (index: number) => void;
+}
+export declare function Carousel(props: CarouselProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/media/carousel/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Carousel } from './Carousel';
+export type { CarouselProps } from './Carousel';

package/dist/types/components/media/image/src/Image.d.ts

@@ -0,0 +1,23 @@
+export interface ImageProps {
+    /** Image source URL */
+    src: string;
+    /** Alt text */
+    alt?: string;
+    /** Width (CSS value or number) */
+    width?: string | number;
+    /** Height (CSS value or number) */
+    height?: string | number;
+    /** Fallback URL or element shown on error */
+    fallback?: string | unknown;
+    /** Placeholder shown while loading: 'blur', 'skeleton', or element */
+    placeholder?: 'blur' | 'skeleton' | unknown;
+    /** Enable lazy loading (default: true) */
+    lazy?: boolean;
+    /** CSS object-fit value */
+    objectFit?: string;
+    /** CSS border-radius value */
+    borderRadius?: string;
+    /** Caption text rendered below the image */
+    caption?: string;
+}
+export declare function Image(props: ImageProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/media/image/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Image } from './Image';
+export type { ImageProps } from './Image';

package/dist/types/components/media/video-player/src/VideoPlayer.d.ts

@@ -0,0 +1,27 @@
+export interface VideoPlayerProps {
+    /** Video source URL */
+    src: string;
+    /** Poster image URL */
+    poster?: string;
+    /** Width (CSS value or number) */
+    width?: string | number;
+    /** Height (CSS value or number) */
+    height?: string | number;
+    /** Auto-play video */
+    autoPlay?: boolean;
+    /** Loop playback */
+    loop?: boolean;
+    /** Muted */
+    muted?: boolean;
+    /** Show custom controls (default: true) */
+    controls?: boolean;
+    /** Play callback */
+    onPlay?: () => void;
+    /** Pause callback */
+    onPause?: () => void;
+    /** Ended callback */
+    onEnded?: () => void;
+    /** Time update callback */
+    onTimeUpdate?: (currentTime: number, duration: number) => void;
+}
+export declare function VideoPlayer(props: VideoPlayerProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/media/video-player/src/index.d.ts

@@ -0,0 +1,2 @@
+export { VideoPlayer } from './VideoPlayer';
+export type { VideoPlayerProps } from './VideoPlayer';

package/dist/types/components/nav/accordion/src/Accordion.d.ts

@@ -0,0 +1,52 @@
+import type { NavWrapperStyle } from '../../wrapper/src/NavWrapper';
+export interface AccordionSection {
+    /** Unique identifier for the section */
+    id: string;
+    /** Text displayed in the section header */
+    header: string;
+    /** Content rendered when the section is expanded */
+    content: unknown;
+    /** Optional icon displayed in the header */
+    icon?: string;
+    /** When true, section cannot be toggled */
+    disabled?: boolean;
+}
+export interface AccordionHeaderStyle {
+    padding?: string;
+    backgroundColor?: string;
+    hoverBackground?: string;
+    color?: string;
+    fontWeight?: string;
+    fontSize?: string;
+    borderBottom?: string;
+}
+export interface AccordionContentStyle {
+    padding?: string;
+    backgroundColor?: string;
+    borderBottom?: string;
+}
+export interface AccordionProps {
+    /** Array of sections to render */
+    sections: AccordionSection[];
+    /** IDs of sections that should be expanded on initial render */
+    defaultExpanded?: string[];
+    /** Allow multiple sections to be open at the same time (default: false) */
+    allowMultiple?: boolean;
+    /** Styling for section headers */
+    headerStyle?: AccordionHeaderStyle;
+    /** Styling for section content panels */
+    contentStyle?: AccordionContentStyle;
+    /** Styling passed through to the NavWrapper container */
+    wrapperStyle?: NavWrapperStyle;
+    /** Icon shown on collapsed sections (default: '+') */
+    expandIcon?: string;
+    /** Icon shown on expanded sections (default: '\u2212') */
+    collapseIcon?: string;
+    /** Position of the expand/collapse icon (default: 'right') */
+    iconPosition?: 'left' | 'right';
+    /** Enable smooth open/close animation via max-height transition (default: true) */
+    animated?: boolean;
+    /** Callback fired with the array of currently expanded section IDs */
+    onChange?: (expandedIds: string[]) => void;
+}
+export declare function Accordion(props: AccordionProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/accordion/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Accordion } from './Accordion';
+export type { AccordionSection, AccordionProps, AccordionHeaderStyle, AccordionContentStyle } from './Accordion';

package/dist/types/components/nav/breadcrumb/src/Breadcrumb.d.ts

@@ -0,0 +1,20 @@
+export interface BreadcrumbItem {
+    /** Display label */
+    label: string;
+    /** Optional link href — if omitted, rendered as plain text */
+    href?: string;
+    /** Optional click handler */
+    onClick?: () => void;
+}
+export type BreadcrumbSize = 'sm' | 'md' | 'lg';
+export interface BreadcrumbProps {
+    /** Ordered list of breadcrumb items (first = root, last = current page) */
+    items: BreadcrumbItem[];
+    /** Separator between items (default: '/') */
+    separator?: string | unknown;
+    /** When set, collapses middle items to '...' if items exceed this count */
+    maxItems?: number;
+    /** Size variant (default: 'md') */
+    size?: BreadcrumbSize;
+}
+export declare function Breadcrumb(props: BreadcrumbProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/breadcrumb/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Breadcrumb } from './Breadcrumb';
+export type { BreadcrumbProps, BreadcrumbItem, BreadcrumbSize } from './Breadcrumb';

package/dist/types/components/nav/dock/src/Dock.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Dock -- Application launcher bar component.
+ *
+ * A configurable vertical or horizontal icon bar that displays application
+ * launchers with active/running indicators, badges, tooltips, and
+ * click-to-open behavior. Inspired by the Ubuntu Unity launcher and macOS dock.
+ */
+import { type SpecNode } from '../../../../core/src/index';
+export interface DockItem {
+    /** Unique identifier for this dock entry */
+    id: string;
+    /** Icon source -- URL to an image/SVG, or an emoji/text character */
+    icon: string;
+    /** Tooltip label shown on hover */
+    label: string;
+    /** Whether this item's application is currently running/open. Displays a dot indicator. Default: false */
+    active?: boolean;
+    /** Optional badge count (e.g., unread messages). Renders a small number badge on the icon. */
+    badge?: number;
+    /** Whether this icon is disabled (greyed out, non-clickable). Default: false */
+    disabled?: boolean;
+}
+export interface DockProps {
+    /** The dock items to display */
+    items: DockItem[];
+    /** Orientation of the dock. Default: 'vertical' */
+    orientation?: 'vertical' | 'horizontal';
+    /** Position on the screen edge. Default: 'left' */
+    position?: 'left' | 'right' | 'top' | 'bottom';
+    /** Icon size in pixels. Default: 36 */
+    iconSize?: number;
+    /** Whether to auto-hide the dock (slides out on hover, hidden otherwise). Default: false */
+    autoHide?: boolean;
+    /** Whether to show a separator before the last item (e.g., "Show Applications" grid button). Default: false */
+    showTrailingSeparator?: boolean;
+    /** Called when a dock item is clicked */
+    onItemClick?: (id: string) => void;
+    /** Called when a dock item is right-clicked (for context menu integration) */
+    onItemContextMenu?: (id: string, event: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Extra children rendered at the bottom/end of the dock (e.g., a "Show Applications" button) */
+    children?: unknown;
+}
+export declare function Dock(props: DockProps): SpecNode;

package/dist/types/components/nav/dock/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Dock } from './Dock';
+export type { DockProps, DockItem } from './Dock';

package/dist/types/components/nav/dropdown/src/Dropdown.d.ts

@@ -0,0 +1,36 @@
+import type { NavWrapperStyle, NavItemStyle } from '../../wrapper/src/NavWrapper';
+export interface DropdownItem {
+    /** Unique identifier for the item */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional icon rendered as a text span before the label (emoji or text) */
+    icon?: string;
+    /** Whether the item is disabled (grayed out, non-interactive) */
+    disabled?: boolean;
+    /** Render as a thin horizontal divider instead of a menu item */
+    divider?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Nested submenu items — shows a right chevron and expands on hover */
+    children?: DropdownItem[];
+}
+export interface DropdownProps {
+    /** Trigger button text */
+    label: string;
+    /** Menu items */
+    items: DropdownItem[];
+    /** Custom styles for the trigger button */
+    triggerStyle?: Record<string, string>;
+    /** Styling passed to NavWrapper for the dropdown panel */
+    menuStyle?: NavWrapperStyle;
+    /** Styling for menu items */
+    itemStyle?: NavItemStyle;
+    /** Placement of the dropdown relative to the trigger (default: 'bottom-start') */
+    placement?: 'bottom-start' | 'bottom-end';
+    /** Close the dropdown when an item is selected (default: true) */
+    closeOnSelect?: boolean;
+    /** Width of the dropdown panel (default: '220px') */
+    width?: string | number;
+}
+export declare function Dropdown(props: DropdownProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/dropdown/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Dropdown } from './Dropdown';
+export type { DropdownProps, DropdownItem } from './Dropdown';

package/dist/types/components/nav/menubar/src/Menubar.d.ts

@@ -0,0 +1,27 @@
+export interface MenuItem {
+    /** Display label */
+    label: string;
+    /** Click handler */
+    onClick?: () => void;
+    /** Keyboard shortcut hint (e.g. 'Ctrl+S') */
+    shortcut?: string;
+    /** Icon text (emoji or character) */
+    icon?: string;
+    /** Render as a divider line */
+    divider?: boolean;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Nested submenu items */
+    children?: MenuItem[];
+}
+export interface MenuDefinition {
+    /** Top-level menu label */
+    label: string;
+    /** Items in this menu */
+    items: MenuItem[];
+}
+export interface MenubarProps {
+    /** Array of top-level menu definitions */
+    menus: MenuDefinition[];
+}
+export declare function Menubar(props: MenubarProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/menubar/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Menubar } from './Menubar';
+export type { MenubarProps, MenuDefinition, MenuItem } from './Menubar';

package/dist/types/components/nav/pagination/src/Pagination.d.ts

@@ -0,0 +1,19 @@
+export interface PaginationProps {
+    /** Total number of items */
+    total: number;
+    /** Items per page */
+    pageSize: number;
+    /** Current active page (1-based) */
+    currentPage: number;
+    /** Called when page changes */
+    onChange: (page: number) => void;
+    /** Number of sibling pages shown around the current page (default: 1) */
+    siblingCount?: number;
+    /** Show First/Last buttons (default: true) */
+    showFirstLast?: boolean;
+    /** Show Prev/Next buttons (default: true) */
+    showPrevNext?: boolean;
+    /** Disable all controls */
+    disabled?: boolean;
+}
+export declare function Pagination(props: PaginationProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/pagination/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Pagination } from './Pagination';
+export type { PaginationProps } from './Pagination';

package/dist/types/components/nav/sidebar/src/Sidebar.d.ts

@@ -0,0 +1,29 @@
+export interface SidebarItem {
+    /** Unique identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional icon (emoji or text character) */
+    icon?: string;
+    /** Nested child items */
+    children?: SidebarItem[];
+    /** Optional badge text (e.g. count) */
+    badge?: string;
+}
+export interface SidebarProps {
+    /** Navigation items */
+    items: SidebarItem[];
+    /** Whether the sidebar is collapsed to icon-only mode */
+    collapsed?: boolean;
+    /** Called to toggle collapse state */
+    onToggleCollapse?: () => void;
+    /** Currently selected item id */
+    selectedId?: string;
+    /** Called when an item is selected */
+    onSelect?: (id: string) => void;
+    /** Expanded width (default: '240px') */
+    width?: string | number;
+    /** Collapsed width (default: '56px') */
+    collapsedWidth?: string | number;
+}
+export declare function Sidebar(props: SidebarProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/sidebar/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Sidebar } from './Sidebar';
+export type { SidebarProps, SidebarItem } from './Sidebar';

package/dist/types/components/nav/stepper/src/Stepper.d.ts

@@ -0,0 +1,25 @@
+export interface StepItem {
+    /** Step label */
+    label: string;
+    /** Optional description shown below the label */
+    description?: string;
+    /** Optional icon text (emoji or character) shown inside the circle */
+    icon?: string;
+}
+export type StepperOrientation = 'horizontal' | 'vertical';
+export type StepperVariant = 'circle' | 'dot';
+export interface StepperProps {
+    /** Array of step definitions */
+    steps: StepItem[];
+    /** Current active step (0-based index) */
+    currentStep: number;
+    /** Orientation (default: 'horizontal') */
+    orientation?: StepperOrientation;
+    /** Called when a step is clicked — receives the step index */
+    onChange?: (step: number) => void;
+    /** Whether steps are clickable (default: false) */
+    clickable?: boolean;
+    /** Visual variant (default: 'circle') */
+    variant?: StepperVariant;
+}
+export declare function Stepper(props: StepperProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/stepper/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Stepper } from './Stepper';
+export type { StepperProps, StepItem, StepperOrientation, StepperVariant } from './Stepper';

package/dist/types/components/nav/system-tray/src/SystemTray.d.ts

@@ -0,0 +1,47 @@
+export interface SystemTrayIndicator {
+    /** Unique identifier */
+    id: string;
+    /** Icon -- emoji, text character, or image URL */
+    icon: string;
+    /** Optional label shown next to the icon */
+    label?: string;
+    /** Click handler */
+    onClick?: () => void;
+}
+export interface SystemTrayUser {
+    /** Display name */
+    name: string;
+    /** Avatar URL or emoji fallback */
+    avatar?: string;
+}
+export interface SystemTrayProps {
+    /** Text shown on the left -- typically the active application name */
+    activeAppName?: string;
+    /** Optional left-most button (e.g., "Activities"). Fires onClick. */
+    activitiesButton?: {
+        label: string;
+        onClick: () => void;
+    };
+    /** Clock format. Default: '24h'. Options: '12h', '24h' */
+    clockFormat?: '12h' | '24h';
+    /** Whether to show seconds in the clock. Default: true */
+    showSeconds?: boolean;
+    /** Whether to show the date below/beside the clock. Default: true */
+    showDate?: boolean;
+    /** System status indicators displayed in the right section */
+    indicators?: SystemTrayIndicator[];
+    /** User profile -- shown at the far right with avatar and name */
+    user?: SystemTrayUser;
+    /** Items in the user dropdown menu (shown on click) */
+    userMenuItems?: Array<{
+        label: string;
+        icon?: string;
+        onClick: () => void;
+        divider?: boolean;
+    }>;
+    /** Panel height in pixels. Default: 28 */
+    height?: number;
+    /** Children -- additional elements to render in the center area */
+    children?: unknown;
+}
+export declare function SystemTray(props: SystemTrayProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/system-tray/src/index.d.ts

@@ -0,0 +1,2 @@
+export { SystemTray } from './SystemTray';
+export type { SystemTrayProps, SystemTrayIndicator, SystemTrayUser, } from './SystemTray';

package/dist/types/components/nav/toolbar/src/Toolbar.d.ts

@@ -0,0 +1,27 @@
+export interface ToolbarItem {
+    /** Unique identifier */
+    id: string;
+    /** Display label (optional if icon provided) */
+    label?: string;
+    /** Icon text (emoji or character) */
+    icon?: string;
+    /** Item type — 'button' has momentary press, 'toggle' stays pressed until clicked again */
+    type: 'button' | 'toggle' | 'separator' | 'dropdown' | 'spacer';
+    /** Click handler */
+    onClick?: () => void;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Whether the item is in an active/pressed state (used by toggle) */
+    active?: boolean;
+}
+export type ToolbarSize = 'sm' | 'md' | 'lg';
+export type ToolbarVariant = 'flat' | 'raised';
+export interface ToolbarProps {
+    /** Toolbar items */
+    items: ToolbarItem[];
+    /** Size (default: 'md') */
+    size?: ToolbarSize;
+    /** Visual variant (default: 'flat') */
+    variant?: ToolbarVariant;
+}
+export declare function Toolbar(props: ToolbarProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/nav/toolbar/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Toolbar } from './Toolbar';
+export type { ToolbarProps, ToolbarItem, ToolbarSize, ToolbarVariant } from './Toolbar';