@vinyasa/navigation 1.0.26

package/dist/esm/components/navigation-menu/NavigationMenu.d.ts

@@ -0,0 +1,69 @@
+import * as RadixNavigationMenu from '@radix-ui/react-navigation-menu';
+import { type ElementType, type ReactNode } from 'react';
+export type NavigationMenuRootProps = RadixNavigationMenu.NavigationMenuProps;
+export type NavigationMenuListProps = RadixNavigationMenu.NavigationMenuListProps;
+export type NavigationMenuItemProps = RadixNavigationMenu.NavigationMenuItemProps;
+export type NavigationMenuTriggerProps = RadixNavigationMenu.NavigationMenuTriggerProps;
+export type NavigationMenuLinkProps = RadixNavigationMenu.NavigationMenuLinkProps;
+export type NavigationMenuContentProps = RadixNavigationMenu.NavigationMenuContentProps;
+export type NavigationMenuIndicatorProps = RadixNavigationMenu.NavigationMenuIndicatorProps;
+export type NavigationMenuViewportProps = RadixNavigationMenu.NavigationMenuViewportProps;
+export interface NavigationMenuLinkSpec {
+    /** Unique within the menu — used as the React key. */
+    key: string;
+    label: ReactNode;
+    href?: string;
+    /** Shown under `label` inside a dropdown panel. Ignored on a top-level item with no `content`. */
+    description?: ReactNode;
+    /** Marks this as the current page. */
+    active?: boolean;
+}
+export interface NavigationMenuItemSpec {
+    /** Unique within the menu — used as the React key. */
+    key: string;
+    label: ReactNode;
+    /** A plain, non-dropdown item when set instead of `links`. */
+    href?: string;
+    /** Marks this as the current page. Only meaningful alongside `href` — a trigger's own open/closed state is tracked separately. */
+    active?: boolean;
+    /** Renders a dropdown panel listing these as a grid instead of a plain link. */
+    links?: NavigationMenuLinkSpec[];
+}
+export interface NavigationMenuProps extends Omit<NavigationMenuRootProps, 'children'> {
+    items: NavigationMenuItemSpec[];
+    /**
+     * Component to render an item's link with — swap in your router's own
+     * `Link` for client-side navigation instead of a plain `<a>`'s full page
+     * reload. Applies to every rendered link, top-level and inside a
+     * dropdown panel alike. Defaults to `'a'`.
+     */
+    linkComponent?: ElementType;
+}
+export declare const NavigationMenu: {
+    ({ items, linkComponent, ...rest }: NavigationMenuProps): import("react").JSX.Element;
+    displayName: string;
+} & {
+    Root: import("react").ForwardRefExoticComponent<RadixNavigationMenu.NavigationMenuProps & import("react").RefAttributes<HTMLElement>>;
+    List: {
+        ({ className, ...rest }: NavigationMenuListProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Item: import("react").ForwardRefExoticComponent<RadixNavigationMenu.NavigationMenuItemProps & import("react").RefAttributes<HTMLLIElement>>;
+    Trigger: import("react").ForwardRefExoticComponent<RadixNavigationMenu.NavigationMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Link: {
+        ({ className, ...rest }: NavigationMenuLinkProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ className, ...rest }: NavigationMenuContentProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Indicator: {
+        ({ className, ...rest }: NavigationMenuIndicatorProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Viewport: {
+        ({ className, ...rest }: NavigationMenuViewportProps): import("react").JSX.Element;
+        displayName: string;
+    };
+};

package/dist/esm/components/navigation-menu/index.d.ts

@@ -0,0 +1 @@
+export { NavigationMenu, type NavigationMenuContentProps, type NavigationMenuIndicatorProps, type NavigationMenuItemProps, type NavigationMenuItemSpec, type NavigationMenuLinkProps, type NavigationMenuLinkSpec, type NavigationMenuListProps, type NavigationMenuProps, type NavigationMenuRootProps, type NavigationMenuTriggerProps, type NavigationMenuViewportProps, } from './NavigationMenu';

package/dist/esm/components/pagination/Pagination.css.d.ts

@@ -0,0 +1,13 @@
+export declare const list: string;
+export declare const item: string;
+export declare const indicator: string;
+export declare const link: import("@vanilla-extract/recipes").RuntimeFn<{
+    active: {
+        true: {
+            color: `var(--${string})`;
+            fontWeight: `var(--${string})`;
+        };
+    };
+}>;
+export declare const ellipsis: string;
+export declare const boundaryIcon: string;

package/dist/esm/components/pagination/Pagination.d.ts

@@ -0,0 +1,69 @@
+import { type ComponentPropsWithoutRef, type ElementType, type ReactNode } from 'react';
+export type PaginationRootProps = ComponentPropsWithoutRef<'nav'>;
+export type PaginationListProps = ComponentPropsWithoutRef<'ul'>;
+export type PaginationItemProps = ComponentPropsWithoutRef<'li'>;
+export interface PaginationLinkProps extends ComponentPropsWithoutRef<'button'> {
+    /** Renders as this element/component instead of a native `<button>` — e.g. an `<a>` or your router's own `Link`, for a page reachable by real URL. */
+    as?: ElementType;
+    /** Marks this as the current page. */
+    active?: boolean;
+    /** Only meaningful when `as` renders an anchor — not part of `<button>`'s own props. */
+    href?: string;
+}
+export type PaginationEllipsisProps = ComponentPropsWithoutRef<'span'>;
+export interface PaginationPreviousProps extends Omit<PaginationLinkProps, 'active' | 'children'> {
+    children?: ReactNode;
+}
+export interface PaginationNextProps extends Omit<PaginationLinkProps, 'active' | 'children'> {
+    children?: ReactNode;
+}
+export interface PaginationProps extends Omit<PaginationRootProps, 'onChange'> {
+    /** Current page, 1-indexed. */
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    /** How many pages stay visible on each side of the current page. Defaults to 1. */
+    siblingCount?: number;
+    /** How many pages stay visible at the very start/end of the trail. Defaults to 1. */
+    boundaryCount?: number;
+    /**
+     * When given, every page (including Previous/Next) renders as a real,
+     * independently-navigable link instead of a button — `onPageChange`
+     * still fires either way, for keeping your own state in sync. Receives
+     * the target page number.
+     */
+    getHref?: (page: number) => string;
+    /**
+     * Component to render a page's link with when `getHref` is set — swap in
+     * your router's own `Link` for client-side navigation instead of a plain
+     * `<a>`'s full page reload. Defaults to `'a'`.
+     */
+    linkComponent?: ElementType;
+}
+export declare const Pagination: {
+    ({ page, totalPages, onPageChange, siblingCount, boundaryCount, getHref, linkComponent, ...rest }: PaginationProps): import("react").JSX.Element;
+    displayName: string;
+} & {
+    Root: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & import("react").RefAttributes<HTMLElement>>;
+    List: {
+        ({ className, children, ...rest }: PaginationListProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Item: {
+        ({ className, ...rest }: PaginationItemProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Link: import("react").ForwardRefExoticComponent<PaginationLinkProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Previous: {
+        ({ children, ...rest }: PaginationPreviousProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Next: {
+        ({ children, ...rest }: PaginationNextProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Ellipsis: {
+        ({ className, children, ...rest }: PaginationEllipsisProps): import("react").JSX.Element;
+        displayName: string;
+    };
+};

package/dist/esm/components/pagination/getPaginationRange.d.ts

@@ -0,0 +1,15 @@
+export declare const ELLIPSIS: "ellipsis";
+export type PaginationRangeItem = number | typeof ELLIPSIS;
+/**
+ * Computes which page numbers to render, collapsing the middle into a
+ * single ellipsis once the trail gets too long to show in full — always
+ * keeping the first/last `boundaryCount` pages and the `siblingCount`
+ * pages on either side of `page` visible.
+ *
+ * Deliberately pads the range near a boundary rather than collapsing as
+ * soon as siblingCount/boundaryCount allow: a single hidden page never
+ * becomes an ellipsis (`1 2 [3] 4 5` shows `3` directly, not `…`), which
+ * is what keeps `page=1` from looking as sparse as `1 2 … 20` — the shape
+ * this follows is the same one GitHub/MUI's pagination controls use.
+ */
+export declare const getPaginationRange: (page: number, totalPages: number, siblingCount?: number, boundaryCount?: number) => PaginationRangeItem[];

package/dist/esm/components/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export { Pagination, type PaginationEllipsisProps, type PaginationItemProps, type PaginationLinkProps, type PaginationListProps, type PaginationNextProps, type PaginationPreviousProps, type PaginationProps, type PaginationRootProps, } from './Pagination';
+export { ELLIPSIS, getPaginationRange, type PaginationRangeItem } from './getPaginationRange';

package/dist/esm/components/sidebar/Sidebar.css.d.ts

@@ -0,0 +1,60 @@
+export declare const root: import("@vanilla-extract/recipes").RuntimeFn<{
+    collapsed: {
+        true: {
+            width: "4.5rem";
+        };
+        false: {
+            width: "16rem";
+        };
+    };
+}>;
+export declare const header: string;
+export declare const truncatedContent: string;
+export declare const content: string;
+export declare const footer: string;
+export declare const section: string;
+export declare const sectionLabel: import("@vanilla-extract/recipes").RuntimeFn<{
+    collapsed: {
+        true: {
+            opacity: number;
+            pointerEvents: "none";
+        };
+        false: {
+            opacity: number;
+        };
+    };
+}>;
+export declare const item: import("@vanilla-extract/recipes").RuntimeFn<{
+    active: {
+        true: {
+            backgroundColor: `var(--${string})`;
+            color: `var(--${string})`;
+            fontWeight: `var(--${string})`;
+        };
+    };
+    collapsed: {
+        true: {
+            justifyContent: "center";
+        };
+    };
+}>;
+export declare const itemIcon: string;
+export declare const itemLabel: import("@vanilla-extract/recipes").RuntimeFn<{
+    collapsed: {
+        true: {
+            width: number;
+            opacity: number;
+        };
+        false: {
+            opacity: number;
+        };
+    };
+}>;
+export declare const collapseTrigger: string;
+export declare const collapseTriggerIcon: import("@vanilla-extract/recipes").RuntimeFn<{
+    collapsed: {
+        true: {
+            transform: "rotate(180deg)";
+        };
+    };
+}>;

package/dist/esm/components/sidebar/Sidebar.d.ts

@@ -0,0 +1,82 @@
+import { type ComponentPropsWithoutRef, type ElementType, type ReactNode } from 'react';
+/** Whether the enclosing `Sidebar.Root` is currently collapsed — for a consumer's own header/footer content to adapt to. */
+export declare const useSidebarCollapsed: () => boolean;
+export interface SidebarRootProps extends ComponentPropsWithoutRef<'nav'> {
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+}
+export type SidebarHeaderProps = ComponentPropsWithoutRef<'div'>;
+export type SidebarContentProps = ComponentPropsWithoutRef<'div'>;
+export type SidebarFooterProps = ComponentPropsWithoutRef<'div'>;
+export interface SidebarSectionProps extends ComponentPropsWithoutRef<'div'> {
+    label?: ReactNode;
+}
+export interface SidebarItemProps extends ComponentPropsWithoutRef<'button'> {
+    /** Renders as this element/component instead of a native `<button>` — e.g. your router's own `Link`, for real navigation instead of a click handler. */
+    as?: ElementType;
+    icon?: ReactNode;
+    /** Marks this as the current page/section. */
+    active?: boolean;
+    /** Only meaningful when `as="a"` (or a router `Link`) — not part of `<button>`'s own props. */
+    href?: string;
+}
+export type SidebarCollapseTriggerProps = ComponentPropsWithoutRef<'button'>;
+export interface SidebarItemSpec {
+    /** Unique within the sidebar — used as the React key. */
+    key: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    href?: string;
+    onClick?: () => void;
+}
+export interface SidebarSectionSpec {
+    /** Unique within the sidebar — used as the React key. */
+    key: string;
+    label?: ReactNode;
+    items: SidebarItemSpec[];
+}
+export interface SidebarProps extends Pick<SidebarRootProps, 'collapsed' | 'defaultCollapsed' | 'onCollapsedChange'> {
+    header?: ReactNode;
+    footer?: ReactNode;
+    sections: SidebarSectionSpec[];
+    /** Renders the built-in collapse/expand toggle in the header. Defaults to true. */
+    collapsible?: boolean;
+    /**
+     * Component to render an item with when it has an `href` — swap in your
+     * router's own `Link` for client-side navigation instead of a plain
+     * `<a>`'s full page reload. Receives `href` like a native anchor; if your
+     * router's `Link` takes `to` instead, wrap it: `({ href, ...props }) =>
+     * <RouterLink to={href} {...props} />`. Defaults to `'a'`.
+     */
+    linkComponent?: ElementType;
+}
+export declare const Sidebar: {
+    ({ header: headerContent, footer: footerContent, sections, collapsible, linkComponent, collapsed, defaultCollapsed, onCollapsedChange, }: SidebarProps): import("react").JSX.Element;
+    displayName: string;
+} & {
+    Root: import("react").ForwardRefExoticComponent<SidebarRootProps & import("react").RefAttributes<HTMLElement>>;
+    Header: {
+        ({ className, ...rest }: SidebarHeaderProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ className, ...rest }: SidebarContentProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Section: {
+        ({ label, className, children, ...rest }: SidebarSectionProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Item: import("react").ForwardRefExoticComponent<SidebarItemProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Footer: {
+        ({ className, ...rest }: SidebarFooterProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    CollapseTrigger: {
+        ({ className, ...rest }: SidebarCollapseTriggerProps): import("react").JSX.Element;
+        displayName: string;
+    };
+};

package/dist/esm/components/sidebar/index.d.ts

@@ -0,0 +1 @@
+export { Sidebar, useSidebarCollapsed, type SidebarContentProps, type SidebarFooterProps, type SidebarHeaderProps, type SidebarItemProps, type SidebarItemSpec, type SidebarProps, type SidebarRootProps, type SidebarSectionProps, type SidebarSectionSpec, } from './Sidebar';

package/dist/esm/components/stepper/Stepper.css.d.ts

@@ -0,0 +1,10 @@
+export declare const root: string;
+export declare const step: string;
+export declare const indicatorArea: string;
+export declare const connector: string;
+export declare const indicator: string;
+export declare const indicatorIcon: string;
+export declare const indicatorButton: string;
+export declare const content: string;
+export declare const label: string;
+export declare const description: string;

package/dist/esm/components/stepper/Stepper.d.ts

@@ -0,0 +1,57 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+export type StepperOrientation = 'horizontal' | 'vertical';
+export type StepperState = 'upcoming' | 'current' | 'completed' | 'error';
+export interface StepperRootProps extends ComponentPropsWithoutRef<'ol'> {
+    orientation?: StepperOrientation;
+}
+export interface StepperStepProps extends ComponentPropsWithoutRef<'li'> {
+    /** Defaults to `'upcoming'`. */
+    state?: StepperState;
+}
+export interface StepperIndicatorProps extends ComponentPropsWithoutRef<'button'> {
+    children: ReactNode;
+}
+export type StepperContentProps = ComponentPropsWithoutRef<'div'>;
+export type StepperLabelProps = ComponentPropsWithoutRef<'span'>;
+export type StepperDescriptionProps = ComponentPropsWithoutRef<'span'>;
+export interface StepperStepSpec {
+    /** Unique within the sequence — used as the React key. Defaults to the step's index. */
+    key?: string;
+    label: ReactNode;
+    description?: ReactNode;
+    /** Overrides the computed state for this one step — e.g. a validation failure on the current step. */
+    error?: boolean;
+}
+export interface StepperProps extends Omit<StepperRootProps, 'children'> {
+    steps: StepperStepSpec[];
+    /** 0-indexed: steps before this are `completed`, this one is `current`, the rest are `upcoming`. */
+    activeStep: number;
+    /** When given, every step's indicator becomes a button calling this with its index — whether jumping ahead makes sense is a decision for the consumer, not this component. */
+    onStepClick?: (index: number) => void;
+}
+export declare const Stepper: {
+    ({ steps, activeStep, onStepClick, ...rest }: StepperProps): import("react").JSX.Element;
+    displayName: string;
+} & {
+    Root: import("react").ForwardRefExoticComponent<StepperRootProps & import("react").RefAttributes<HTMLOListElement>>;
+    Step: {
+        ({ state, className, ...rest }: StepperStepProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Indicator: {
+        ({ children, onClick, className, ...rest }: StepperIndicatorProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ className, ...rest }: StepperContentProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Label: {
+        ({ className, ...rest }: StepperLabelProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        ({ className, ...rest }: StepperDescriptionProps): import("react").JSX.Element;
+        displayName: string;
+    };
+};

package/dist/esm/components/stepper/index.d.ts

@@ -0,0 +1 @@
+export { Stepper, type StepperContentProps, type StepperDescriptionProps, type StepperIndicatorProps, type StepperLabelProps, type StepperOrientation, type StepperProps, type StepperRootProps, type StepperState, type StepperStepProps, type StepperStepSpec, } from './Stepper';

package/dist/esm/components/tabs/Tabs.css.d.ts

@@ -0,0 +1,6 @@
+export declare const root: string;
+export declare const list: string;
+export declare const indicator: string;
+export declare const trigger: string;
+export declare const content: string;
+export declare const contentGroup: string;

package/dist/esm/components/tabs/Tabs.d.ts

@@ -0,0 +1,39 @@
+import * as RadixTabs from '@radix-ui/react-tabs';
+import { type ReactNode } from 'react';
+export type TabsRootProps = RadixTabs.TabsProps;
+export type TabsListProps = RadixTabs.TabsListProps;
+export type TabsTriggerProps = RadixTabs.TabsTriggerProps;
+export type TabsContentProps = Omit<RadixTabs.TabsContentProps, 'forceMount'>;
+export interface TabsContentGroupProps {
+    children: ReactNode;
+    className?: string;
+}
+export interface TabsItemSpec {
+    /** Unique within the tab list — also Radix's own selection key. */
+    value: string;
+    label: ReactNode;
+    content: ReactNode;
+    disabled?: boolean;
+}
+export interface TabsProps extends Omit<TabsRootProps, 'children'> {
+    tabs: TabsItemSpec[];
+}
+export declare const Tabs: {
+    ({ tabs, ...rest }: TabsProps): import("react").JSX.Element;
+    displayName: string;
+} & {
+    Root: import("react").ForwardRefExoticComponent<RadixTabs.TabsProps & import("react").RefAttributes<HTMLDivElement>>;
+    List: {
+        ({ className, children, ...rest }: TabsListProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Trigger: import("react").ForwardRefExoticComponent<RadixTabs.TabsTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Content: {
+        ({ className, ...rest }: TabsContentProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    ContentGroup: {
+        ({ children, className }: TabsContentGroupProps): import("react").JSX.Element;
+        displayName: string;
+    };
+};

package/dist/esm/components/tabs/index.d.ts

@@ -0,0 +1 @@
+export { Tabs, type TabsContentGroupProps, type TabsContentProps, type TabsItemSpec, type TabsListProps, type TabsProps, type TabsRootProps, type TabsTriggerProps, } from './Tabs';

package/dist/esm/components/top-navigation/TopNavigation.css.d.ts

@@ -0,0 +1,13 @@
+export declare const root: string;
+export declare const brand: string;
+export declare const content: string;
+export declare const actions: string;
+export declare const item: import("@vanilla-extract/recipes").RuntimeFn<{
+    active: {
+        true: {
+            borderBottomColor: `var(--${string})`;
+            color: `var(--${string})`;
+        };
+    };
+}>;
+export declare const mobileTrigger: string;

package/dist/esm/components/top-navigation/TopNavigation.d.ts

@@ -0,0 +1,67 @@
+import { type ComponentPropsWithoutRef, type ElementType, type ReactNode } from 'react';
+export interface TopNavigationRootProps extends ComponentPropsWithoutRef<'nav'> {
+    /** Whether the below-`md` mobile menu is open. */
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export interface TopNavigationBrandProps extends ComponentPropsWithoutRef<'a'> {
+    as?: ElementType;
+}
+export type TopNavigationContentProps = ComponentPropsWithoutRef<'div'>;
+export type TopNavigationActionsProps = ComponentPropsWithoutRef<'div'>;
+export interface TopNavigationItemProps extends ComponentPropsWithoutRef<'button'> {
+    /** Renders as this element/component instead of a native `<button>` — e.g. your router's own `Link`. */
+    as?: ElementType;
+    /** Marks this as the current page/section. */
+    active?: boolean;
+    /** Only meaningful when `as="a"` (or a router `Link`) — not part of `<button>`'s own props. */
+    href?: string;
+}
+export type TopNavigationMobileTriggerProps = ComponentPropsWithoutRef<'button'>;
+export interface TopNavigationItemSpec {
+    /** Unique within the bar — used as the React key. */
+    key: string;
+    label: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    href?: string;
+    onClick?: () => void;
+}
+export interface TopNavigationProps extends Pick<TopNavigationRootProps, 'open' | 'defaultOpen' | 'onOpenChange'> {
+    brand?: ReactNode;
+    brandHref?: string;
+    items: TopNavigationItemSpec[];
+    actions?: ReactNode;
+    /**
+     * Component to render the brand and any `href` item with — swap in your
+     * router's own `Link` for client-side navigation instead of a plain
+     * `<a>`'s full page reload. Receives `href` like a native anchor; if your
+     * router's `Link` takes `to` instead, wrap it: `({ href, ...props }) =>
+     * <RouterLink to={href} {...props} />`. Defaults to `'a'`.
+     */
+    linkComponent?: ElementType;
+}
+export declare const TopNavigation: {
+    ({ brand: brandContent, brandHref, items, actions: actionsContent, linkComponent, open, defaultOpen, onOpenChange, }: TopNavigationProps): import("react").JSX.Element;
+    displayName: string;
+} & {
+    Root: import("react").ForwardRefExoticComponent<TopNavigationRootProps & import("react").RefAttributes<HTMLElement>>;
+    Brand: {
+        ({ as: Component, className, ...rest }: TopNavigationBrandProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ className, ...rest }: TopNavigationContentProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Item: import("react").ForwardRefExoticComponent<TopNavigationItemProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Actions: {
+        ({ className, ...rest }: TopNavigationActionsProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    MobileTrigger: {
+        ({ className, ...rest }: TopNavigationMobileTriggerProps): import("react").JSX.Element;
+        displayName: string;
+    };
+};

package/dist/esm/components/top-navigation/index.d.ts

@@ -0,0 +1 @@
+export { TopNavigation, type TopNavigationActionsProps, type TopNavigationBrandProps, type TopNavigationContentProps, type TopNavigationItemProps, type TopNavigationItemSpec, type TopNavigationMobileTriggerProps, type TopNavigationProps, type TopNavigationRootProps, } from './TopNavigation';

package/dist/esm/components/tree-view/TreeView.css.d.ts

@@ -0,0 +1,8 @@
+export declare const root: string;
+export declare const group: string;
+export declare const item: string;
+export declare const row: string;
+export declare const expandTrigger: string;
+export declare const expandTriggerSpacer: string;
+export declare const icon: string;
+export declare const label: string;

package/dist/esm/components/tree-view/TreeView.d.ts

@@ -0,0 +1,43 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+export interface TreeViewRootProps extends Omit<ComponentPropsWithoutRef<'ul'>, 'onSelect'> {
+    selectedId?: string;
+    /** Called for both a click and Enter/Space on a treeitem — not the native DOM `onSelect` text-selection event `<ul>` normally has. */
+    onSelect?: (id: string) => void;
+    expandedIds?: string[];
+    defaultExpandedIds?: string[];
+    onExpandedChange?: (ids: string[]) => void;
+}
+export type TreeViewGroupProps = ComponentPropsWithoutRef<'ul'>;
+export interface TreeViewItemProps extends Omit<ComponentPropsWithoutRef<'li'>, 'id'> {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+    /** A nested `TreeView.Group` — its presence alone makes this a branch node with an expand/collapse trigger. */
+    children?: ReactNode;
+}
+export interface TreeViewNodeSpec {
+    /** Unique across the whole tree — used as the React key and passed to `onSelect`/`onExpandedChange`. */
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+    children?: TreeViewNodeSpec[];
+}
+export interface TreeViewProps extends Omit<TreeViewRootProps, 'children'> {
+    items: TreeViewNodeSpec[];
+}
+export declare const TreeView: {
+    ({ items, ...rest }: TreeViewProps): import("react").JSX.Element;
+    displayName: string;
+} & {
+    Root: import("react").ForwardRefExoticComponent<TreeViewRootProps & import("react").RefAttributes<HTMLUListElement>>;
+    Group: {
+        ({ className, children, ...rest }: TreeViewGroupProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Item: {
+        ({ id, label: labelContent, icon: iconContent, disabled, children, className, ...rest }: TreeViewItemProps): import("react").JSX.Element;
+        displayName: string;
+    };
+};

package/dist/esm/components/tree-view/index.d.ts

@@ -0,0 +1 @@
+export { TreeView, type TreeViewGroupProps, type TreeViewItemProps, type TreeViewNodeSpec, type TreeViewProps, type TreeViewRootProps, } from './TreeView';

package/dist/esm/components/workspace-switcher/WorkspaceSwitcher.css.d.ts

@@ -0,0 +1,9 @@
+export declare const avatar: string;
+export declare const avatarImage: string;
+export declare const trigger: string;
+export declare const triggerText: string;
+export declare const triggerName: string;
+export declare const triggerDescription: string;
+export declare const triggerIcon: string;
+export declare const item: string;
+export declare const itemCheck: string;

package/dist/esm/components/workspace-switcher/WorkspaceSwitcher.d.ts

@@ -0,0 +1,43 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+export { avatarImage } from './WorkspaceSwitcher.css';
+export interface WorkspaceSpec {
+    /** Unique within the list — used as the React key and passed back to `onWorkspaceChange`. */
+    id: string;
+    name: string;
+    /** Shown under `name` inside the dropdown — e.g. a plan tier or member count. Not shown on the trigger. */
+    description?: ReactNode;
+    /** A custom avatar (e.g. an `<img className={avatarImage}>`, exported alongside this type) — falls back to `name`'s initials on a solid background. */
+    avatar?: ReactNode;
+}
+export interface WorkspaceAvatarProps extends ComponentPropsWithoutRef<'span'> {
+    workspace: Pick<WorkspaceSpec, 'name' | 'avatar'>;
+}
+export interface WorkspaceSwitcherTriggerProps extends ComponentPropsWithoutRef<'button'> {
+    workspace: WorkspaceSpec;
+}
+export interface WorkspaceSwitcherItemProps {
+    workspace: WorkspaceSpec;
+    active?: boolean;
+}
+export interface WorkspaceSwitcherProps {
+    workspaces: WorkspaceSpec[];
+    activeWorkspaceId: string;
+    onWorkspaceChange: (id: string) => void;
+    /** Renders a "Create workspace" action below a separator when given. */
+    onCreateWorkspace?: () => void;
+    createWorkspaceLabel?: ReactNode;
+}
+export declare const WorkspaceSwitcher: {
+    ({ workspaces, activeWorkspaceId, onWorkspaceChange, onCreateWorkspace, createWorkspaceLabel, }: WorkspaceSwitcherProps): import("react").JSX.Element | null;
+    displayName: string;
+} & {
+    Trigger: import("react").ForwardRefExoticComponent<WorkspaceSwitcherTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Item: {
+        ({ workspace, active }: WorkspaceSwitcherItemProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Avatar: {
+        ({ workspace, className, ...rest }: WorkspaceAvatarProps): import("react").JSX.Element;
+        displayName: string;
+    };
+};

package/dist/esm/components/workspace-switcher/index.d.ts

@@ -0,0 +1 @@
+export { avatarImage, WorkspaceSwitcher, type WorkspaceAvatarProps, type WorkspaceSpec, type WorkspaceSwitcherItemProps, type WorkspaceSwitcherProps, type WorkspaceSwitcherTriggerProps, } from './WorkspaceSwitcher';