import { VariantProps } from "tailwind-variants/lite";
import "react";
import { Button } from "@base-ui/react/button";
import { useRender } from "@base-ui/react/use-render";
//#region src/lib/styled-props.d.ts
/**
 * Base UI components type `className` as `string | ((state) => string)`, but our
 * tv() recipes only accept a plain string. `StyledProps` narrows a Base UI
 * component's props to a string `className` so they can flow into a recipe.
 *
 * The state-callback form is intentionally dropped: our components express every
 * state through `data-*` variants in the recipe, so a caller never needs it.
 */
type StyledProps<P> = Omit<P, "className"> & {
  className?: string;
};
//#endregion
//#region src/lib/data-attributes.d.ts
type DataAttributes = Record<`data-${string}`, string | undefined>;
//#endregion
//#region src/components/button/button.d.ts
declare const buttonVariants: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  variant: {
    primary: {
      root: string[];
    };
    default: {
      root: string[];
    };
    information: {
      root: string[];
    };
    muted: {
      root: string[];
    };
    accent: {
      root: string[];
    };
    warning: {
      root: string[];
    };
    outline: {
      root: string[];
    };
    ghost: {
      root: string[];
    };
    link: {
      root: string[];
    };
    "danger-secondary": {
      root: string[];
    };
    danger: {
      root: string[];
    };
    "danger-outline": {
      root: string[];
    };
  };
  size: {
    xs: {
      root: string[];
    };
    sm: {
      root: string[];
    };
    md: {
      root: string[];
    };
    lg: {
      root: string[];
    };
    "icon-xs": {
      root: string[];
    };
    "icon-sm": {
      root: string[];
    };
    "icon-md": {
      root: string;
    };
    "icon-lg": {
      root: string;
    };
  };
}, {
  root: string[];
  content: string;
  loadingIndicator: string;
}, undefined, {
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  variant: {
    primary: {
      root: string[];
    };
    default: {
      root: string[];
    };
    information: {
      root: string[];
    };
    muted: {
      root: string[];
    };
    accent: {
      root: string[];
    };
    warning: {
      root: string[];
    };
    outline: {
      root: string[];
    };
    ghost: {
      root: string[];
    };
    link: {
      root: string[];
    };
    "danger-secondary": {
      root: string[];
    };
    danger: {
      root: string[];
    };
    "danger-outline": {
      root: string[];
    };
  };
  size: {
    xs: {
      root: string[];
    };
    sm: {
      root: string[];
    };
    md: {
      root: string[];
    };
    lg: {
      root: string[];
    };
    "icon-xs": {
      root: string[];
    };
    "icon-sm": {
      root: string[];
    };
    "icon-md": {
      root: string;
    };
    "icon-lg": {
      root: string;
    };
  };
}, {
  root: string[];
  content: string;
  loadingIndicator: string;
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  variant: {
    primary: {
      root: string[];
    };
    default: {
      root: string[];
    };
    information: {
      root: string[];
    };
    muted: {
      root: string[];
    };
    accent: {
      root: string[];
    };
    warning: {
      root: string[];
    };
    outline: {
      root: string[];
    };
    ghost: {
      root: string[];
    };
    link: {
      root: string[];
    };
    "danger-secondary": {
      root: string[];
    };
    danger: {
      root: string[];
    };
    "danger-outline": {
      root: string[];
    };
  };
  size: {
    xs: {
      root: string[];
    };
    sm: {
      root: string[];
    };
    md: {
      root: string[];
    };
    lg: {
      root: string[];
    };
    "icon-xs": {
      root: string[];
    };
    "icon-sm": {
      root: string[];
    };
    "icon-md": {
      root: string;
    };
    "icon-lg": {
      root: string;
    };
  };
}, {
  root: string[];
  content: string;
  loadingIndicator: string;
}>>;
type ButtonProps = StyledProps<Button.Props> & Omit<VariantProps<typeof buttonVariants>, "theme"> & DataAttributes & {
  loading?: boolean;
  loadingLabel?: string;
};
declare function Button$1({ variant, size, loading, loadingLabel, disabled, className, children, render, nativeButton, ...props }: ButtonProps): import("react").JSX.Element;
//#endregion
//#region src/components/sidebar/sidebar.d.ts
type SidebarRootProps = useRender.ComponentProps<"div">;
declare function SidebarRoot({ className, render, ...props }: SidebarRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarHeaderProps = useRender.ComponentProps<"div">;
declare function SidebarHeader({ children, className, render, ...props }: SidebarHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarHeaderTitleProps = useRender.ComponentProps<"div">;
declare function SidebarHeaderTitle({ className, render, ...props }: SidebarHeaderTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarGroupLabelProps = useRender.ComponentProps<"div">;
declare function SidebarGroupLabel({ className, render, ...props }: SidebarGroupLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarBodyProps = useRender.ComponentProps<"div">;
declare function SidebarBody({ className, render, ...props }: SidebarBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarContentProps = useRender.ComponentProps<"div">;
declare function SidebarContent({ children, className, render, ...props }: SidebarContentProps): import("react").JSX.Element;
type SidebarLiveActivityProps = useRender.ComponentProps<"div">;
declare function SidebarLiveActivity({ children, className, render, ...props }: SidebarLiveActivityProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/badge/badge.d.ts
declare const badge: import("tailwind-variants/lite").TVReturnType<{
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  appearance: {
    solid: {
      root: string;
    };
    soft: {
      root: string;
    };
    outline: {
      root: string;
    };
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
  uppercase: {
    true: {
      root: string;
    };
    false: {
      root: string;
    };
  };
}, {
  root: string[];
}, undefined, {
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  appearance: {
    solid: {
      root: string;
    };
    soft: {
      root: string;
    };
    outline: {
      root: string;
    };
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
  uppercase: {
    true: {
      root: string;
    };
    false: {
      root: string;
    };
  };
}, {
  root: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
  theme: {
    brutal: {
      root: string[];
    };
    elegant: {
      root: string[];
    };
  };
  appearance: {
    solid: {
      root: string;
    };
    soft: {
      root: string;
    };
    outline: {
      root: string;
    };
  };
  variant: {
    default: {
      root: string;
    };
    primary: {
      root: string;
    };
    information: {
      root: string;
    };
    muted: {
      root: string;
    };
    accent: {
      root: string;
    };
    success: {
      root: string;
    };
    warning: {
      root: string;
    };
    danger: {
      root: string;
    };
  };
  uppercase: {
    true: {
      root: string;
    };
    false: {
      root: string;
    };
  };
}, {
  root: string[];
}>>;
type BadgeProps = useRender.ComponentProps<"span"> & Omit<VariantProps<typeof badge>, "theme">;
declare function BadgeRoot({ appearance, variant, uppercase, className, render, ...props }: BadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
declare function Experimental(props: Omit<BadgeProps, "appearance" | "variant" | "uppercase">): import("react").JSX.Element;
declare const Badge: typeof BadgeRoot & {
  Experimental: typeof Experimental;
};
//#endregion
//#region src/components/sidebar/sidebar-item.d.ts
type SidebarItemRootProps = useRender.ComponentProps<"button"> & {
  active?: boolean;
};
declare function SidebarItemRoot({ active, className, render, ...props }: SidebarItemRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemProps = SidebarItemRootProps;
declare function SidebarItem({ className, ...props }: SidebarItemProps): import("react").JSX.Element;
type SidebarItemIconProps = useRender.ComponentProps<"span">;
declare function SidebarItemIcon({ className, render, ...props }: SidebarItemIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemChannelIconProps = useRender.ComponentProps<"span">;
declare function SidebarItemChannelIcon({ className, render, ...props }: SidebarItemChannelIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemContentProps = useRender.ComponentProps<"span"> & {
  stacked?: boolean;
};
declare function SidebarItemContent({ className, render, stacked, ...props }: SidebarItemContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemTitleProps = useRender.ComponentProps<"span">;
declare function SidebarItemTitle({ className, render, ...props }: SidebarItemTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemSubtitleProps = useRender.ComponentProps<"span">;
declare function SidebarItemSubtitle({ className, render, ...props }: SidebarItemSubtitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemMetaProps = useRender.ComponentProps<"span">;
declare function SidebarItemMeta({ className, render, ...props }: SidebarItemMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemStatusProps = useRender.ComponentProps<"span">;
declare function SidebarItemStatus({ className, render, ...props }: SidebarItemStatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemIndicatorProps = BadgeProps;
declare function SidebarItemIndicator({ appearance, className, uppercase, variant, ...props }: SidebarItemIndicatorProps): import("react").JSX.Element;
type SidebarItemMetaIconProps = useRender.ComponentProps<"span">;
declare function SidebarItemMetaIcon({ className, render, ...props }: SidebarItemMetaIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemAsideProps = useRender.ComponentProps<"span">;
declare function SidebarItemAside({ className, render, ...props }: SidebarItemAsideProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemCountProps = BadgeProps;
declare function SidebarItemCount({ appearance, className, uppercase, variant, ...props }: SidebarItemCountProps): import("react").JSX.Element;
//#endregion
//#region src/components/panel/panel.d.ts
type PanelEdge = "attached" | "inset";
type PanelProps = useRender.ComponentProps<"section"> & {
  edge?: PanelEdge;
};
declare function Panel({ className, edge, render, ...props }: PanelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelHeaderRootProps = useRender.ComponentProps<"div">;
/**
 * Bare header bar: fixed height and centered flex row, no border, fill, or padding.
 * Shared base for `PanelHeader`, `PanelSectionHeader`, and panel-specific headers
 * such as `ThreadPanelHeader` — it is not exclusive to `PanelHeader`.
 */
declare function PanelHeaderRoot({ className, render, ...props }: PanelHeaderRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelBodyProps = useRender.ComponentProps<"div">;
declare function PanelBody({ className, render, ...props }: PanelBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelScrollViewportProps = useRender.ComponentProps<"div">;
declare function PanelScrollViewport({ className, render, ...props }: PanelScrollViewportProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelScrollContentProps = useRender.ComponentProps<"div">;
declare function PanelScrollContent({ className, render, ...props }: PanelScrollContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelSectionProps = useRender.ComponentProps<"section">;
declare function PanelSection({ className, render, ...props }: PanelSectionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelFooterProps = useRender.ComponentProps<"div">;
declare function PanelFooter({ className, render, ...props }: PanelFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/panel/panel-header.d.ts
type PanelHeaderProps = useRender.ComponentProps<"div">;
declare function PanelHeader({ children, className, render, ...props }: PanelHeaderProps): import("react").JSX.Element;
type PanelSectionHeaderProps = useRender.ComponentProps<"div">;
declare function PanelSectionHeader({ children, className, render, ...props }: PanelSectionHeaderProps): import("react").JSX.Element;
type PanelHeaderIconProps = useRender.ComponentProps<"div">;
declare function PanelHeaderIcon({ className, render, ...props }: PanelHeaderIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelHeaderContentProps = useRender.ComponentProps<"div">;
declare function PanelHeaderContent({ className, render, ...props }: PanelHeaderContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelHeadingProps = useRender.ComponentProps<"div">;
declare function PanelHeading({ className, render, ...props }: PanelHeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelTitleProps = useRender.ComponentProps<"div">;
declare function PanelTitle({ className, render, ...props }: PanelTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelMetaProps = useRender.ComponentProps<"div"> & {
  size?: "sm" | "md";
};
declare function PanelMeta({ className, render, size, ...props }: PanelMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelStatusProps = useRender.ComponentProps<"span">;
/**
 * Attribute badge in a panel header, such as a muted or archived marker.
 * Use `PanelActivity` for a live status readout wrapping a `Status`.
 */
declare function PanelStatus({ className, render, ...props }: PanelStatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelActivityProps = useRender.ComponentProps<"span">;
/**
 * Live status readout in a panel header, such as agent activity or presence.
 * Wraps a `Status` and supplies header-appropriate spacing and typography;
 * use `PanelStatus` for a standalone attribute badge.
 */
declare function PanelActivity({ className, render, ...props }: PanelActivityProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelActionsProps = useRender.ComponentProps<"div">;
declare function PanelActions({ className, render, ...props }: PanelActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
export { SidebarItemProps as $, PanelScrollContent as A, SidebarItemChannelIconProps as B, PanelBodyProps as C, Button$1 as Ct, PanelHeaderRoot as D, DataAttributes as Dt, PanelFooterProps as E, VariantProps as Et, PanelSectionProps as F, SidebarItemIcon as G, SidebarItemContentProps as H, SidebarItem as I, SidebarItemIndicatorProps as J, SidebarItemIconProps as K, SidebarItemAside as L, PanelScrollViewport as M, PanelScrollViewportProps as N, PanelHeaderRootProps as O, StyledProps as Ot, PanelSection as P, SidebarItemMetaProps as Q, SidebarItemAsideProps as R, PanelBody as S, SidebarRootProps as St, PanelFooter as T, buttonVariants as Tt, SidebarItemCount as U, SidebarItemContent as V, SidebarItemCountProps as W, SidebarItemMetaIcon as X, SidebarItemMeta as Y, SidebarItemMetaIconProps as Z, PanelStatus as _, SidebarHeaderTitle as _t, PanelHeader as a, SidebarItemTitle as at, PanelTitleProps as b, SidebarLiveActivityProps as bt, PanelHeaderIcon as c, BadgeProps as ct, PanelHeading as d, SidebarContent as dt, SidebarItemRoot as et, PanelHeadingProps as f, SidebarContentProps as ft, PanelSectionHeaderProps as g, SidebarHeaderProps as gt, PanelSectionHeader as h, SidebarHeader as ht, PanelActivityProps as i, SidebarItemSubtitleProps as it, PanelScrollContentProps as j, PanelProps as k, PanelHeaderIconProps as l, SidebarBody as lt, PanelMetaProps as m, SidebarGroupLabelProps as mt, PanelActionsProps as n, SidebarItemStatusProps as nt, PanelHeaderContent as o, SidebarItemTitleProps as ot, PanelMeta as p, SidebarGroupLabel as pt, SidebarItemIndicator as q, PanelActivity as r, SidebarItemSubtitle as rt, PanelHeaderContentProps as s, Badge as st, PanelActions as t, SidebarItemStatus as tt, PanelHeaderProps as u, SidebarBodyProps as ut, PanelStatusProps as v, SidebarHeaderTitleProps as vt, PanelEdge as w, ButtonProps as wt, Panel as x, SidebarRoot as xt, PanelTitle as y, SidebarLiveActivity as yt, SidebarItemChannelIcon as z };