raft-ui
Version:
React UI components for Raft.
5,622 lines • 293 kB
text/typescript
import { cn } from "./cn.mjs";
import { Dialog as Dialog$1 } from "@base-ui/react/dialog";
import { VariantProps } from "tailwind-variants/lite";
import { CSSProperties, ComponentProps, ComponentPropsWithRef, ComponentPropsWithoutRef, CompositionEventHandler, FocusEventHandler, FormEventHandler, HTMLAttributes, KeyboardEventHandler, PointerEvent, ReactNode, RefObject, SVGProps } from "react";
import { Button as Button$1 } from "@base-ui/react/button";
import { useRender } from "@base-ui/react/use-render";
import { Drawer as Drawer$1 } from "@base-ui/react/drawer";
import { Tooltip as Tooltip$1 } from "@base-ui/react/tooltip";
import { Checkbox as Checkbox$1 } from "@base-ui/react/checkbox";
import { ScrollArea as ScrollArea$1 } from "@base-ui/react/scroll-area";
import { Collapsible } from "@base-ui/react/collapsible";
import { Avatar as Avatar$1, ContextMenu as ContextMenu$1 } from "@base-ui/react";
import { Menu } from "@base-ui/react/menu";
import { Popover as Popover$1 } from "@base-ui/react/popover";
import { PreviewCard as PreviewCard$1 } from "@base-ui/react/preview-card";
import { Input as Input$1 } from "@base-ui/react/input";
import { Field as Field$1 } from "@base-ui/react/field";
import { Combobox as Combobox$1 } from "@base-ui/react/combobox";
import { Select as Select$1 } from "@base-ui/react/select";
import { Radio } from "@base-ui/react/radio";
import { RadioGroup as RadioGroup$1 } from "@base-ui/react/radio-group";
import { Switch as Switch$1 } from "@base-ui/react/switch";
import { Toggle } from "@base-ui/react/toggle";
import { ToggleGroup as ToggleGroup$1 } from "@base-ui/react/toggle-group";
import { Toolbar } from "@base-ui/react/toolbar";
import { Progress as Progress$1 } from "@base-ui/react/progress";
import { DragCancelEvent, DragEndEvent, DragMoveEvent, DragOverEvent, DragStartEvent, UniqueIdentifier } from "@dnd-kit/core";
import { Toast } from "@base-ui/react/toast";
import { Tabs as Tabs$1 } from "@base-ui/react/tabs";
import { Separator as Separator$1 } from "@base-ui/react/separator";
import { GroupProps, PanelProps as PanelProps$1, SeparatorProps as SeparatorProps$1 } from "react-resizable-panels";
//#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" | "style"> & {
className?: string;
style?: CSSProperties;
};
//#endregion
//#region src/lib/data-attributes.d.ts
type DataAttributes$1 = Record<`data-${string}`, string | undefined>;
//#endregion
//#region src/components/button/button.d.ts
export 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[];
};
success: {
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[];
};
inline: {
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[];
};
success: {
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[];
};
inline: {
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[];
};
success: {
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[];
};
inline: {
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$1.Props> & Omit<VariantProps<typeof buttonVariants>, "theme"> & DataAttributes$1 & {
loading?: boolean;
loadingLabel?: string;
};
export declare function Button({ variant, size, loading, loadingLabel, disabled, className, children, render, nativeButton, ...props }: ButtonProps): import("react").JSX.Element;
//#endregion
//#region src/components/alert-dialog/alert-dialog.d.ts
type AlertDialogProps = Dialog$1.Root.Props;
export declare function AlertDialog(props: AlertDialogProps): import("react").JSX.Element;
type AlertDialogTriggerProps = Dialog$1.Trigger.Props;
export declare function AlertDialogTrigger(props: AlertDialogTriggerProps): import("react").JSX.Element;
type AlertDialogPortalProps = Dialog$1.Portal.Props;
export declare function AlertDialogPortal(props: AlertDialogPortalProps): import("react").JSX.Element;
type AlertDialogCloseProps = Omit<Dialog$1.Close.Props, "render"> & Pick<ButtonProps, "variant" | "size"> & {
className?: string;
children?: ReactNode;
};
export declare function AlertDialogClose({ className, variant, size, children, "aria-label": ariaLabel, ...props }: AlertDialogCloseProps): import("react").JSX.Element;
type AlertDialogOverlayProps = StyledProps<Dialog$1.Backdrop.Props>;
export declare function AlertDialogOverlay({ className, ...props }: AlertDialogOverlayProps): import("react").JSX.Element;
type AlertDialogContentProps = StyledProps<Dialog$1.Popup.Props> & {
portalProps?: AlertDialogPortalProps;
overlay?: false | AlertDialogOverlayProps;
};
export declare function AlertDialogContent({ className, children, portalProps, overlay, ...props }: AlertDialogContentProps): import("react").JSX.Element;
type AlertDialogHeaderProps = ComponentPropsWithRef<"div">;
export declare function AlertDialogHeader({ className, ...props }: AlertDialogHeaderProps): import("react").JSX.Element;
type AlertDialogBodyProps = ComponentPropsWithRef<"div">;
export declare function AlertDialogBody({ className, ...props }: AlertDialogBodyProps): import("react").JSX.Element;
type AlertDialogFooterProps = ComponentPropsWithRef<"div">;
export declare function AlertDialogFooter({ className, ...props }: AlertDialogFooterProps): import("react").JSX.Element;
type AlertDialogTitleProps = StyledProps<Dialog$1.Title.Props>;
export declare function AlertDialogTitle({ className, ...props }: AlertDialogTitleProps): import("react").JSX.Element;
type AlertDialogDescriptionProps = StyledProps<Dialog$1.Description.Props>;
export declare function AlertDialogDescription({ className, ...props }: AlertDialogDescriptionProps): import("react").JSX.Element;
type AlertDialogActionProps = ButtonProps;
export declare function AlertDialogAction(props: AlertDialogActionProps): import("react").JSX.Element;
type AlertDialogCancelProps = Omit<Dialog$1.Close.Props, "render"> & Pick<ButtonProps, "variant" | "size"> & {
className?: string;
};
export declare function AlertDialogCancel({ className, variant, size, ...props }: AlertDialogCancelProps): import("react").JSX.Element;
//#endregion
//#region src/components/dialog/dialog.d.ts
type DialogProps = Dialog$1.Root.Props;
export declare function Dialog(props: DialogProps): import("react").JSX.Element;
type DialogTriggerProps = Dialog$1.Trigger.Props;
export declare function DialogTrigger(props: DialogTriggerProps): import("react").JSX.Element;
type DialogPortalProps = Dialog$1.Portal.Props;
export declare function DialogPortal(props: DialogPortalProps): import("react").JSX.Element;
type DialogOverlayProps = StyledProps<Dialog$1.Backdrop.Props> & {
layer?: 0 | 1;
};
export declare function DialogOverlay({ className, layer, ...props }: DialogOverlayProps): import("react").JSX.Element;
type DialogContentProps = StyledProps<Dialog$1.Popup.Props> & {
portalProps?: DialogPortalProps;
overlay?: false | DialogOverlayProps;
size?: "sm" | "md" | "lg";
layer?: 0 | 1;
};
export declare function DialogContent({ className, children, portalProps, overlay, size, layer, ...props }: DialogContentProps): import("react").JSX.Element;
type DialogCloseProps = Dialog$1.Close.Props & Pick<ButtonProps, "variant" | "size"> & {
className?: string;
children?: ReactNode;
};
export declare function DialogClose({ className, variant, size, children, render, "aria-label": ariaLabel, ...props }: DialogCloseProps): import("react").JSX.Element;
type DialogHeaderProps = ComponentPropsWithRef<"div">;
export declare function DialogHeader({ className, ...props }: DialogHeaderProps): import("react").JSX.Element;
type DialogBodyProps = ComponentPropsWithRef<"div">;
export declare function DialogBody({ className, ...props }: DialogBodyProps): import("react").JSX.Element;
type DialogFooterProps = ComponentPropsWithRef<"div">;
export declare function DialogFooter({ className, ...props }: DialogFooterProps): import("react").JSX.Element;
type DialogTitleProps = StyledProps<Dialog$1.Title.Props>;
export declare function DialogTitle({ className, ...props }: DialogTitleProps): import("react").JSX.Element;
type DialogDescriptionProps = StyledProps<Dialog$1.Description.Props>;
export declare function DialogDescription({ className, ...props }: DialogDescriptionProps): import("react").JSX.Element;
//#endregion
//#region src/components/drawer/drawer.d.ts
type DrawerProps = Drawer$1.Root.Props;
export declare function Drawer({ modal, snapPoints, swipeDirection, ...props }: DrawerProps): import("react").JSX.Element;
type DrawerTriggerProps = Drawer$1.Trigger.Props;
export declare function DrawerTrigger(props: DrawerTriggerProps): import("react").JSX.Element;
type DrawerPortalProps = Drawer$1.Portal.Props;
export declare function DrawerPortal(props: DrawerPortalProps): import("react").JSX.Element;
type DrawerOverlayProps = StyledProps<Drawer$1.Backdrop.Props>;
export declare function DrawerOverlay({ className, ...props }: DrawerOverlayProps): import("react").JSX.Element;
type DrawerContentProps = StyledProps<Drawer$1.Popup.Props> & {
portalProps?: DrawerPortalProps;
};
export declare function DrawerContent({ className, children, portalProps, ...props }: DrawerContentProps): import("react").JSX.Element;
type DrawerCloseProps = StyledProps<Drawer$1.Close.Props> & Pick<ButtonProps, "variant" | "size">;
export declare function DrawerClose({ className, variant, size, children, render, "aria-label": ariaLabel, ...props }: DrawerCloseProps): import("react").JSX.Element;
type DrawerHeaderProps = useRender.ComponentProps<"div">;
export declare function DrawerHeader({ className, render, ...props }: DrawerHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DrawerFooterProps = useRender.ComponentProps<"div">;
export declare function DrawerFooter({ className, render, ...props }: DrawerFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DrawerBodyProps = useRender.ComponentProps<"div">;
export declare function DrawerBody({ className, render, ...props }: DrawerBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DrawerActionsProps = useRender.ComponentProps<"div">;
export declare function DrawerActions({ className, render, children, ...props }: DrawerActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DrawerTitleProps = StyledProps<Drawer$1.Title.Props>;
export declare function DrawerTitle({ className, ...props }: DrawerTitleProps): import("react").JSX.Element;
type DrawerDescriptionProps = StyledProps<Drawer$1.Description.Props>;
export declare function DrawerDescription({ className, ...props }: DrawerDescriptionProps): import("react").JSX.Element;
//#endregion
//#region src/components/float-button/float-button.position.d.ts
type FloatButtonPosition = "fixed" | "absolute" | "relative";
type FloatButtonSide = "bottom-right" | "bottom-left" | "top-right" | "top-left";
type FloatButtonOffset = number | string | [number | string, number | string];
//#endregion
//#region src/components/float-button/float-button.d.ts
type FloatButtonVariant = "default" | "primary" | "accent" | "outline" | "ghost" | "warning" | "danger";
type FloatButtonShape = "circle" | "square" | "pill";
type FloatButtonSize = "xs" | "sm" | "md" | "lg";
type FloatButtonGroupDirection = "vertical" | "horizontal";
interface FloatButtonProps extends StyledProps<Button$1.Props> {
variant?: FloatButtonVariant;
shape?: FloatButtonShape;
size?: FloatButtonSize;
icon?: ReactNode;
description?: ReactNode;
tooltip?: ReactNode;
position?: FloatButtonPosition;
side?: FloatButtonSide;
offset?: FloatButtonOffset;
}
export declare function FloatButton({ icon, description, tooltip, variant, shape: shapeProp, size: sizeProp, position, side, offset, className, style, children, nativeButton: nativeButtonProp, render, ...props }: FloatButtonProps): import("react").JSX.Element;
type FloatButtonGroupProps = useRender.ComponentProps<"div"> & {
direction?: FloatButtonGroupDirection;
attached?: boolean;
shape?: FloatButtonShape;
size?: FloatButtonSize;
position?: FloatButtonPosition;
side?: FloatButtonSide;
offset?: FloatButtonOffset;
gap?: number | string;
};
export declare function FloatButtonGroup({ direction, attached, shape, size, position, side, offset, gap, className, style, render, children, ...props }: FloatButtonGroupProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/card/card.recipe.d.ts
declare const card: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
leading: string[];
title: string[];
description: string[];
footer: string[];
};
elegant: {
leading: string[];
title: string[];
description: string[];
footer: string[];
};
};
variant: {
default: {};
/** A selectable option INSIDE a form, not a panel on top of one.
*
* `default` is panel chrome: brutal gives it `shadow-raft-md` (4px) while
* every control in a form — Input, SelectTrigger — sits at
* `shadow-raft-sm` (2px). In brutal the shadow offset IS the elevation,
* so a default Card used as a checkbox row renders one step above the
* fields around it and reads as a floating panel rather than a boxed
* choice. `option` puts it back in the control plane and drops the title
* from the card-title scale to the field scale, so it cannot outrank the
* field label above it. */
option: {};
inset: {};
};
}, {
root: string[];
header: string[];
title: string[];
leading: string[];
description: string[];
trailing: string[];
content: string[];
footer: string[];
}, undefined, {
theme: {
brutal: {
leading: string[];
title: string[];
description: string[];
footer: string[];
};
elegant: {
leading: string[];
title: string[];
description: string[];
footer: string[];
};
};
variant: {
default: {};
/** A selectable option INSIDE a form, not a panel on top of one.
*
* `default` is panel chrome: brutal gives it `shadow-raft-md` (4px) while
* every control in a form — Input, SelectTrigger — sits at
* `shadow-raft-sm` (2px). In brutal the shadow offset IS the elevation,
* so a default Card used as a checkbox row renders one step above the
* fields around it and reads as a floating panel rather than a boxed
* choice. `option` puts it back in the control plane and drops the title
* from the card-title scale to the field scale, so it cannot outrank the
* field label above it. */
option: {};
inset: {};
};
}, {
root: string[];
header: string[];
title: string[];
leading: string[];
description: string[];
trailing: string[];
content: string[];
footer: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
leading: string[];
title: string[];
description: string[];
footer: string[];
};
elegant: {
leading: string[];
title: string[];
description: string[];
footer: string[];
};
};
variant: {
default: {};
/** A selectable option INSIDE a form, not a panel on top of one.
*
* `default` is panel chrome: brutal gives it `shadow-raft-md` (4px) while
* every control in a form — Input, SelectTrigger — sits at
* `shadow-raft-sm` (2px). In brutal the shadow offset IS the elevation,
* so a default Card used as a checkbox row renders one step above the
* fields around it and reads as a floating panel rather than a boxed
* choice. `option` puts it back in the control plane and drops the title
* from the card-title scale to the field scale, so it cannot outrank the
* field label above it. */
option: {};
inset: {};
};
}, {
root: string[];
header: string[];
title: string[];
leading: string[];
description: string[];
trailing: string[];
content: string[];
footer: string[];
}>>;
//#endregion
//#region src/components/card/card.d.ts
type CardProps = useRender.ComponentProps<"div"> & Omit<VariantProps<typeof card>, "theme">;
export declare function Card({ className, render, variant, ...props }: CardProps): import("react").JSX.Element;
type CardHeaderProps = useRender.ComponentProps<"div">;
export declare function CardHeader({ className, render, ...props }: CardHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardTitleProps = useRender.ComponentProps<"div">;
export declare function CardTitle({ className, render, ...props }: CardTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardLeadingProps = useRender.ComponentProps<"div">;
export declare function CardLeading({ className, render, ...props }: CardLeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardDescriptionProps = useRender.ComponentProps<"div">;
export declare function CardDescription({ className, render, ...props }: CardDescriptionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardTrailingProps = useRender.ComponentProps<"div">;
export declare function CardTrailing({ className, render, ...props }: CardTrailingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardContentProps = useRender.ComponentProps<"div">;
export declare function CardContent({ className, render, ...props }: CardContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CardFooterProps = useRender.ComponentProps<"div">;
export declare function CardFooter({ className, render, ...props }: CardFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/status/status.d.ts
declare const status$1: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {};
elegant: {};
};
size: {
xs: {
root: string;
};
sm: {
root: string;
};
md: {
root: string;
};
lg: {
root: string;
};
};
pulse: {
true: {
root: string;
};
false: {
root: string;
};
};
attention: {
true: {
root: string;
};
false: {
root: string;
};
};
}, undefined, undefined, {
theme: {
brutal: {
root: string;
};
elegant: {};
};
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;
};
};
}, {
root: string[];
}, import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string;
};
elegant: {};
};
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;
};
};
}, {
root: string[];
}, undefined, {
theme: {
brutal: {
root: string;
};
elegant: {};
};
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;
};
};
}, {
root: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string;
};
elegant: {};
};
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;
};
};
}, {
root: string[];
}>>>;
type StatusProps = Omit<useRender.ComponentProps<"span">, "children"> & Omit<VariantProps<typeof status$1>, "theme">;
declare function StatusRoot({ size, variant, pulse, attention, className, render, ...props }: StatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare const Status: typeof StatusRoot;
//#endregion
//#region src/components/app-rail/app-rail.d.ts
type AppRailRootProps = useRender.ComponentProps<"div">;
export declare function AppRailRoot({ className, render, ...props }: AppRailRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailHeaderProps = useRender.ComponentProps<"div">;
export declare function AppRailHeader({ className, render, ...props }: AppRailHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailNavProps = useRender.ComponentProps<"nav">;
export declare function AppRailNav({ className, render, ...props }: AppRailNavProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemProps = useRender.ComponentProps<"button"> & {
nativeButton?: boolean;
selected?: boolean;
};
export declare function AppRailItem({ nativeButton, selected, disabled, className, render, ...props }: AppRailItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemIconProps = useRender.ComponentProps<"span">;
export declare function AppRailItemIcon({ className, render, ...props }: AppRailItemIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemAttentionProps = {
title?: string;
children: ReactNode;
};
export declare function AppRailItemAttention({ title, children }: AppRailItemAttentionProps): import("react").JSX.Element;
type AppRailItemAttentionMaskProps = useRender.ComponentProps<"span">;
export declare function AppRailItemAttentionMask({ className, render, ...props }: AppRailItemAttentionMaskProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemLabelProps = useRender.ComponentProps<"span">;
export declare function AppRailItemLabel({ className, render, ...props }: AppRailItemLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemBadgeProps = useRender.ComponentProps<"span">;
export declare function AppRailItemBadge({ className, render, ...props }: AppRailItemBadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppRailItemIndicatorProps = StatusProps;
export declare function AppRailItemIndicator({ className, size, variant, attention, ...props }: AppRailItemIndicatorProps): import("react").JSX.Element;
type AppRailFooterProps = useRender.ComponentProps<"div">;
export declare function AppRailFooter({ className, render, ...props }: AppRailFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/copyable-code/copyable-code.d.ts
declare const copyableCode: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
code: string[];
codeInner: string;
};
elegant: {
code: string[];
codeInner: string[];
action: string[];
};
};
size: {
sm: {
code: string;
};
md: {
code: string;
};
};
}, {
root: string[];
code: string[];
codeInner: string[];
action: string[];
iconSwap: string[];
}, undefined, {
theme: {
brutal: {
code: string[];
codeInner: string;
};
elegant: {
code: string[];
codeInner: string[];
action: string[];
};
};
size: {
sm: {
code: string;
};
md: {
code: string;
};
};
}, {
root: string[];
code: string[];
codeInner: string[];
action: string[];
iconSwap: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
code: string[];
codeInner: string;
};
elegant: {
code: string[];
codeInner: string[];
action: string[];
};
};
size: {
sm: {
code: string;
};
md: {
code: string;
};
};
}, {
root: string[];
code: string[];
codeInner: string[];
action: string[];
iconSwap: string[];
}>>;
type CopyableCodeRootProps = Omit<ComponentPropsWithRef<"div">, "onCopy" | "onError"> & Pick<VariantProps<typeof copyableCode>, "size"> & {
copied?: boolean;
/** Called with the copied text only after a write that actually landed. */
onCopy?: (value: string) => void | Promise<void>;
/** Called when every copy strategy failed, so the consumer can tell the user. */
onError?: (error: Error) => void;
};
export declare function CopyableCodeRoot({ copied, onCopy, onError, size, className, ...props }: CopyableCodeRootProps): import("react").JSX.Element;
type CopyableCodeProps = ComponentPropsWithRef<"code"> & {
truncate?: boolean;
};
export declare function CopyableCode({ children, className, truncate, ...props }: CopyableCodeProps): import("react").JSX.Element;
type CopyableCodeActionProps = Omit<ButtonProps, "children" | "className"> & {
buttonClassName?: string;
className?: string;
children?: ReactNode | ((state: {
copied: boolean;
}) => ReactNode);
};
export declare function CopyableCodeAction({ children, buttonClassName, className, onClick, size, variant, ...props }: CopyableCodeActionProps): import("react").JSX.Element;
//#endregion
//#region src/components/checkbox/checkbox.d.ts
declare const checkbox: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {};
elegant: {
root: string[];
graphic: string[];
};
};
variant: {
default: {};
primary: {};
};
color: {
default: {};
primary: {};
};
size: {
sm: {
root: string;
};
md: {
root: string;
};
lg: {
root: string;
};
};
}, {
root: string[];
indicator: string[];
graphic: string[];
outerRect: string[];
overlayRect: string[];
mark: string[];
checkMark: string[];
indeterminateMark: string[];
}, undefined, {
theme: {
brutal: {};
elegant: {
root: string[];
graphic: string[];
};
};
variant: {
default: {};
primary: {};
};
color: {
default: {};
primary: {};
};
size: {
sm: {
root: string;
};
md: {
root: string;
};
lg: {
root: string;
};
};
}, {
root: string[];
indicator: string[];
graphic: string[];
outerRect: string[];
overlayRect: string[];
mark: string[];
checkMark: string[];
indeterminateMark: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {};
elegant: {
root: string[];
graphic: string[];
};
};
variant: {
default: {};
primary: {};
};
color: {
default: {};
primary: {};
};
size: {
sm: {
root: string;
};
md: {
root: string;
};
lg: {
root: string;
};
};
}, {
root: string[];
indicator: string[];
graphic: string[];
outerRect: string[];
overlayRect: string[];
mark: string[];
checkMark: string[];
indeterminateMark: string[];
}>>;
type CheckboxProps = StyledProps<Checkbox$1.Root.Props> & Omit<VariantProps<typeof checkbox>, "theme"> & {
shape?: "square" | "circle";
};
export declare function Checkbox({ size, color, variant, shape, className, ...props }: CheckboxProps): import("react").JSX.Element;
//#endregion
//#region src/components/sidebar/sidebar.d.ts
type SidebarRootProps = useRender.ComponentProps<"div">;
export declare function SidebarRoot({ className, render, ...props }: SidebarRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarHeaderProps = useRender.ComponentProps<"div">;
export declare function SidebarHeader({ children, className, render, ...props }: SidebarHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarHeaderTitleProps = useRender.ComponentProps<"div">;
export declare function SidebarHeaderTitle({ className, render, ...props }: SidebarHeaderTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarGroupLabelProps = useRender.ComponentProps<"div">;
export declare function SidebarGroupLabel({ className, render, ...props }: SidebarGroupLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarBodyProps = useRender.ComponentProps<"div">;
export declare function SidebarBody({ className, render, ...props }: SidebarBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarContentProps = useRender.ComponentProps<"div">;
export declare function SidebarContent({ children, className, render, ...props }: SidebarContentProps): import("react").JSX.Element;
type SidebarLiveActivityProps = useRender.ComponentProps<"div">;
export declare function SidebarLiveActivity({ children, className, render, ...props }: SidebarLiveActivityProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/sidebar/sidebar-menu.d.ts
type SidebarMenuProps = useRender.ComponentProps<"button">;
export declare function SidebarMenu({ className, render, ...props }: SidebarMenuProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarMenuIconProps = useRender.ComponentProps<"span">;
export declare function SidebarMenuIcon({ className, render, ...props }: SidebarMenuIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarMenuTitleProps = useRender.ComponentProps<"span">;
export declare function SidebarMenuTitle({ className, render, ...props }: SidebarMenuTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarMenuAsideProps = useRender.ComponentProps<"span">;
export declare function SidebarMenuAside({ className, render, ...props }: SidebarMenuAsideProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarMenuCountProps = useRender.ComponentProps<"span">;
export declare function SidebarMenuCount({ className, render, ...props }: SidebarMenuCountProps): 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;
export declare const Badge: typeof BadgeRoot & {
Experimental: typeof Experimental;
};
//#endregion
//#region src/components/sidebar/sidebar-item.recipe.d.ts
declare const sidebarItemRecipe: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
sidebarItem: string[];
sidebarItemTitle: string;
sidebarItemChannelIcon: string;
sidebarItemSubtitle: string;
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string;
sidebarItemCount: string[];
};
elegant: {
sidebarItem: string[];
sidebarItemTitle: string;
sidebarItemIcon: string;
sidebarItemChannelIcon: string;
sidebarItemSubtitle: string;
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string;
sidebarItemCount: string[];
};
};
variant: {
default: {};
primary: {};
accent: {};
};
stacked: {
false: {
sidebarItemContent: string[];
};
true: {
sidebarItemContent: string[];
};
};
}, {
sidebarItem: string[];
sidebarItemIcon: string[];
sidebarItemChannelIcon: string[];
sidebarItemContent: string[];
sidebarItemTitle: string[];
sidebarItemSubtitle: string[];
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string[];
sidebarItemAside: string[];
sidebarItemCount: string[];
}, undefined, {
theme: {
brutal: {
sidebarItem: string[];
sidebarItemTitle: string;
sidebarItemChannelIcon: string;
sidebarItemSubtitle: string;
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string;
sidebarItemCount: string[];
};
elegant: {
sidebarItem: string[];
sidebarItemTitle: string;
sidebarItemIcon: string;
sidebarItemChannelIcon: string;
sidebarItemSubtitle: string;
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string;
sidebarItemCount: string[];
};
};
variant: {
default: {};
primary: {};
accent: {};
};
stacked: {
false: {
sidebarItemContent: string[];
};
true: {
sidebarItemContent: string[];
};
};
}, {
sidebarItem: string[];
sidebarItemIcon: string[];
sidebarItemChannelIcon: string[];
sidebarItemContent: string[];
sidebarItemTitle: string[];
sidebarItemSubtitle: string[];
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string[];
sidebarItemAside: string[];
sidebarItemCount: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
sidebarItem: string[];
sidebarItemTitle: string;
sidebarItemChannelIcon: string;
sidebarItemSubtitle: string;
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string;
sidebarItemCount: string[];
};
elegant: {
sidebarItem: string[];
sidebarItemTitle: string;
sidebarItemIcon: string;
sidebarItemChannelIcon: string;
sidebarItemSubtitle: string;
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string;
sidebarItemCount: string[];
};
};
variant: {
default: {};
primary: {};
accent: {};
};
stacked: {
false: {
sidebarItemContent: string[];
};
true: {
sidebarItemContent: string[];
};
};
}, {
sidebarItem: string[];
sidebarItemIcon: string[];
sidebarItemChannelIcon: string[];
sidebarItemContent: string[];
sidebarItemTitle: string[];
sidebarItemSubtitle: string[];
sidebarItemMeta: string[];
sidebarItemStatus: string[];
sidebarItemIndicator: string[];
sidebarItemMetaIcon: string[];
sidebarItemAside: string[];
sidebarItemCount: string[];
}>>;
//#endregion
//#region src/components/sidebar/sidebar-item.d.ts
type SidebarItemRootProps = useRender.ComponentProps<"button"> & {
active?: boolean;
};
type SidebarItemVariant = NonNullable<VariantProps<typeof sidebarItemRecipe>["variant"]>;
type SidebarItemProps = SidebarItemRootProps & Pick<VariantProps<typeof sidebarItemRecipe>, "variant">;
export declare function SidebarItem({ className, variant, ...props }: SidebarItemProps): import("react").JSX.Element;
type SidebarItemIconProps = useRender.ComponentProps<"span">;
export declare function SidebarItemIcon({ className, render, ...props }: SidebarItemIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemChannelIconProps = useRender.ComponentProps<"span">;
export declare function SidebarItemChannelIcon({ className, render, ...props }: SidebarItemChannelIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemContentProps = useRender.ComponentProps<"span"> & {
stacked?: boolean;
};
export declare function SidebarItemContent({ className, render, stacked, ...props }: SidebarItemContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemTitleProps = useRender.ComponentProps<"span">;
export declare function SidebarItemTitle({ className, render, ...props }: SidebarItemTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemSubtitleProps = useRender.ComponentProps<"span">;
export declare function SidebarItemSubtitle({ className, render, ...props }: SidebarItemSubtitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemMetaProps = useRender.ComponentProps<"span">;
export declare function SidebarItemMeta({ className, render, ...props }: SidebarItemMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemStatusProps = useRender.ComponentProps<"span">;
export declare function SidebarItemStatus({ className, render, ...props }: SidebarItemStatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemIndicatorProps = BadgeProps;
export declare function SidebarItemIndicator({ appearance, className, uppercase, variant, ...props }: SidebarItemIndicatorProps): import("react").JSX.Element;
type SidebarItemMetaIconProps = useRender.ComponentProps<"span">;
export declare function SidebarItemMetaIcon({ className, render, ...props }: SidebarItemMetaIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemAsideProps = useRender.ComponentProps<"span">;
export declare function SidebarItemAside({ className, render, ...props }: SidebarItemAsideProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarItemCountProps = BadgeProps;
export declare function SidebarItemCount({ appearance, className, uppercase, variant, ...props }: SidebarItemCountProps): import("react").JSX.Element;
//#endregion
//#region src/components/sidebar/sidebar-section.d.ts
type SidebarSectionProps = Omit<ComponentProps<typeof Collapsible.Root>, "className"> & {
className?: string;
};
export declare function SidebarSection({ className, defaultOpen, render, ...props }: SidebarSectionProps): import("react").JSX.Element;
type SidebarListProps = Omit<ComponentProps<typeof Collapsible.Panel>, "className"> & {
className?: string;
};
export declare function SidebarList({ className, render, ...props }: SidebarListProps): import("react").JSX.Element;
type SidebarSectionEmptyProps = Omit<ComponentProps<typeof Collapsible.Panel>, "className"> & {
className?: string;
};
export declare function SidebarSectionEmpty({ className, render, ...props }: SidebarSectionEmptyProps): import("react").JSX.Element;
type SidebarSectionHeaderProps = useRender.ComponentProps<"div">;
export declare function SidebarSectionHeader({ className, render, ...props }: SidebarSectionHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionDisclosureProps = useRender.ComponentProps<"button">;
export declare function SidebarSectionDisclosure({ className, render, ...props }: SidebarSectionDisclosureProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionChevronProps = useRender.ComponentProps<"svg">;
export declare function SidebarSectionChevron({ className, render, ...props }: SidebarSectionChevronProps): import("react").JSX.Element;
type SidebarSectionTitleProps = useRender.ComponentProps<"span">;
export declare function SidebarSectionTitle({ className, render, ...props }: SidebarSectionTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionCountProps = useRender.ComponentProps<"span">;
export declare function SidebarSectionCount({ className, render, ...props }: SidebarSectionCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionAttentionProps = StatusProps;
export declare function SidebarSectionAttention({ className, size, variant, ...props }: SidebarSectionAttentionProps): import("react").JSX.Element;
type SidebarSectionTrailingProps = useRender.ComponentProps<"div">;
type SidebarSectionControlsProps = useRender.ComponentProps<"div">;
export declare function SidebarSectionTrailing({ className, render, ...props }: SidebarSectionTrailingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function SidebarSectionControls({ className, render, ...props }: SidebarSectionControlsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SidebarSectionControlProps = useRender.ComponentProps<"button"> & Pick<ButtonProps, "size" | "variant" | "loading" | "loadingLabel">;
export declare function SidebarSectionControl({ className, render, size, variant, loading, loadingLabel, children, disabled, ...props }: SidebarSectionControlProps): import("react").JSX.Element;
type SidebarControlProps = SidebarSectionControlProps;
export declare const SidebarControl: typeof SidebarSectionControl;
//#endregion
//#region src/components/panel/panel.d.ts
type PanelEdge = "attached" | "inset";
type PanelProps = useRender.ComponentProps<"section"> & {
edge?: PanelEdge;
};
export 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`.
*/
export declare function PanelHeaderRoot({ className, render, ...props }: PanelHeaderRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelBodyProps = useRender.ComponentProps<"div">;
export declare function PanelBody({ className, render, ...props }: PanelBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelScrollViewportProps = useRender.ComponentProps<"div">;
export declare function PanelScrollViewport({ className, render, ...props }: PanelScrollViewportProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelScrollContentProps = useRender.ComponentProps<"div">;
export declare function PanelScrollContent({ className, render, ...props }: PanelScrollContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelSectionProps = useRender.ComponentProps<"section">;
export declare function PanelSection({ className, render, ...props }: PanelSectionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelFooterProps = useRender.ComponentProps<"div">;
export declare function PanelFooter({ className, render, ...props }: PanelFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/conversation-panel/conversation-panel.d.ts
type ConversationPanelRootProps = useRender.ComponentProps<"section"> & {
edge?: PanelEdge;
};
export declare function ConversationPanelRoot({ className, edge, render, ...props }: ConversationPanelRootProps): import("react").JSX.Element;
type ConversationPanelContentProps = useRender.ComponentProps<"div">;
/**
* Content region below the conversation header. A single container hosting tabs,
* body, and footer; elegant mobile sits flush to the bottom with top radius
* and top gap only; desktop keeps the left inset / rounded-tl treatment.
*/
export declare function ConversationPanelContent({ className, render, ...props }: ConversationPanelContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ConversationPanelBodyProps = useRender.ComponentProps<"div">;
export declare function ConversationPanelBody({ className, render, ...props }: ConversationPanelBodyProps): import("react").JSX.Element;
type ConversationPanelTabsProps = useRender.ComponentProps<"div">;
export declare function ConversationPanelTabs({ className, render, ...props }: ConversationPanelTabsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ConversationPanelFooterProps = useRender.ComponentProps<"div">;
export declare function ConversationPanelFooter({ className, render, ...props }: ConversationPanelFooterProps): import("react").JSX.Element;
//#endregion
//#region src/components/conversation-panel/conversation-panel-empty-state.d.ts
type ConversationPanelEmptyStateProps = useRender.ComponentProps<"div">;
export declare function ConversationPanelEmptyState({ className, render, ...props }: ConversationPanelEmptyStateProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ConversationPanelEmptyStateBrandProps = useRender.ComponentProps<"div">;
export declare function ConversationPanelEmptyStateBrand({ className, render, ...props }: ConversationPanelEmptyStateBrandProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ConversationPanelEmptyStateBrandMarkProps = useRender.ComponentProps<"div">;
export declare function ConversationPanelEmptyStateBrandMark({ className, render, ...props }: ConversationPanelEmptyStateBrandMarkProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/kbd/kbd.d.ts
type KbdProps = ComponentPropsWithRef<"kbd">;
export declare function Kbd({ className, ...props }: KbdProps): import("react").JSX.Element;
type KbdGroupProps = ComponentPropsWithRef<"span">;
export declare function KbdGroup({ className, ...props }: KbdGroupProps): import("react").JSX.Element;
//#endregion
//#region src/components/context-menu/context-menu.d.ts
type ContextMenuProps = ContextMenu$1.Root.Props;
export declare function ContextMenu(props: ContextMenuProps): import("react").JSX.Element;
type ContextMenuSubmenuProps = ContextMenu$1.SubmenuRoot.Props;
export declare function ContextMenuSubmenu(props: ContextMenuSubmenuProps): import("react").JSX.Element;
type ContextMenuTriggerProps = StyledProps<ContextMenu$1.Trigger.Props>;
export declare function ContextMenuTrigger({ className, ...props }: ContextMenuTriggerProps): import("react").JSX.Element;
type ContextMenuPortalProps = ContextMenu$1.Portal.Props;
export declare function ContextMenuPortal(props: ContextMenuPortalProps): import("react").JSX.Element;
type ContextMenuContentProps = StyledProps<ContextMenu$1.Popup.Props> & Partial<Pick<ContextMenu$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky">> & {
portalProps?: ContextMenuPortalProps;
};
export declare function ContextMenuContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, portalProps, className, ...props }: ContextMenuContentProps): import("react").JSX.Element;
type ContextMenuPopupProps = ComponentPropsWithRef<"div">;
export declare function ContextMenuPopup({ className, ...props }: ContextMenuPopupProps): import("react").JSX.Element;
type ContextMenuItemProps = StyledProps<ContextMenu$1.Item.Props>;
export declare function ContextMenuItem({ className, ...props }: ContextMenuItemProps): import("react").JSX.Element;
type ContextMenuItemLabelProps = StyledProps<ComponentPropsWithRef<"span">>;
export declare function ContextMenuItemLabel({ className, ...props }: ContextMenuItemLabelProps): import("react").JSX.Element;
type ContextMenuFooterProps = StyledProps<ComponentPropsWithRef<"div">>;
export declare function ContextMenuFooter({ className, ...props }: ContextMenuFooterProps): import("react").JSX.Element;
type ContextMenuSubmenuTriggerProps = StyledProps<ContextMenu$1.SubmenuTrigger.Props>;
export declare function ContextMenuSubmenuTrigger({ className, ...props }: ContextMenuSubmenuTriggerProps): import("react").JSX.Element;
type ContextMenuLabelProps = StyledProps<ComponentPropsWithRef<"div">>;
export declare function ContextMenuLabel({ className, ...props }: ContextMenuLabelProps): import("react").JSX.Element;
type ContextMenuShortcutProps = KbdProps;
export declare function ContextMenuShortcut({ className, ...props }: ContextMenuShortcutProps): import("react").JSX.Element;
type ContextMenuSeparatorProps = StyledProps<ContextMenu$1.Separator.Props>;
export declare function ContextMenuSeparator({ className, ...props }: ContextMenuSeparatorProps): import("react").JSX.Element;
type ContextMenuRadioGroupProps = StyledProps<ContextMenu$1.RadioGroup.Props>;
export declare function ContextMenuRadioGroup({ ...props }: ContextMenuRadioGroupProps): import("react").JSX.Element;
type ContextMenuRadioItemProps = StyledProps<ContextMenu$1.RadioItem.Props>;
export declare function ContextMenuRadioItem({ className, children, ...props }: ContextMenuRadioItemProps): import("react").JSX.Element;
type ContextMenuRadioItemIndicatorProps = StyledProps<ContextMenu$1.RadioItemIndicator.Props>;
export declare function ContextMenuRadioItemIndicator({ className, ...props }: ContextMenuRadioItemIndicatorProps): import("react").JSX.Element;
type ContextMenuCheckboxItemProps = StyledProps<ContextMenu$1.CheckboxItem.Props>;
export declare function ContextMenuCheckboxItem({ className, children, ...props }: ContextMenuCheckboxItemProps): import("react").JSX.Element;
type ContextMenuCheckboxItemIndicatorProps = StyledProps<ContextMenu$1.CheckboxItemIndicator.Props>;
export declare function ContextMenuCheckboxItemIndicator({ className, ...props }: ContextMenuCheckboxItemIndicatorProps): import("react").JSX.Element;
//#endregion
//#region src/components/dropdown-menu/dropdown-menu.d.ts
type DropdownMenuProps = Menu.Root.Props;
export declare function DropdownMenu(props: DropdownMenuProps): import("react").JSX.Element;
type DropdownMenuSubmenuProps = Menu.SubmenuRoot.Props;
export declare function DropdownMenuSubmenu(props: DropdownMenuSubmenuProps): import("react").JSX.Element;
type DropdownMenuTriggerProps = StyledProps<Menu.Trigger.Props>;
export declare function DropdownMenuTrigger({ className, render, ...props }: DropdownMenuTriggerProps): import("react").JSX.Element;
type DropdownMenuPortalProps = Menu.Portal.Props;
export declare function DropdownMenuPortal(props: DropdownMenuPortalProps): import("react").JSX.Element;
type DropdownMenuPopupProps = ComponentPropsWithRef<"div">;
export declare function DropdownMenuPopup({ className, ...props }: DropdownMenuPopupProps): import("react").JSX.Element;
type DropdownMenuContentProps = StyledProps<Menu.Popup.Props> & Pick<Menu.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
portalProps?: DropdownMenuPortalProps;
};
export declare function DropdownMenuContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, portalProps, className, ...props }: DropdownMenuContentProps): import("react").JSX.Element;
type DropdownMenuItemProps = StyledProps<Menu.Item.Props>;
export declare function DropdownMenuItem({ className, ...props }: DropdownMenuItemProps): import("react").JSX.Element;
type DropdownMenuItemLabelProps = StyledProps<ComponentPropsWithRef<"span">>;
export declare function DropdownMenuItemLabel({ className, ...props }: DropdownMenuItemLabelProps): import("react").JSX.Element;
type DropdownMenuFooterProps = StyledProps<ComponentPropsWithRef<"div">>;
export declare function DropdownMenuFooter({ className, ...props }: DropdownMenuFooterProps): import("react").JSX.Element;
type DropdownMenuSubmenuTriggerProps = StyledProps<Menu.SubmenuTrigger.Props>;
export declare function DropdownMenuSubmenuTrigger({ className, ...props }: DropdownMenuSubmenuTriggerProps): import("react").JSX.Element;
type DropdownMenuLabelProps = StyledProps<ComponentPropsWithRef<"div">>;
export declare function DropdownMenuLabel({ className, ...props }: DropdownMenuLabelProps): import("react").JSX.Element;
type DropdownMenuShortcutProps = KbdProps;
export declare function DropdownMenuShortcut({ className, ...props }: DropdownMenuShortcutProps): import("react").JSX.Element;
type DropdownMenuItemCountProps = BadgeProps;
export declare function DropdownMenuItemCount({ className, ...props }: DropdownMenuItemCountProps): import("react").JSX.Element;
type DropdownMenuSeparatorProps = StyledProps<Menu.Separator.Props>;
export declare function DropdownMenuSeparator({ className, ...props }: DropdownMenuSeparatorProps): import("react").JSX.Element;
type DropdownMenuRadioGroupProps = StyledProps<Menu.RadioGroup.Props>;
export declare function DropdownMenuRadioGroup({ ...props }: DropdownMenuRadioGroupProps): import("react").JSX.Element;
type DropdownMenuRadioItemProps = StyledProps<Menu.RadioItem.Props>;
export declare function DropdownMenuRadioItem({ className, children, ...props }: DropdownMenuRadioItemProps): import("react").JSX.Element;
type DropdownMenuRadioItemIndicatorProps = StyledProps<Menu.RadioItemIndicator.Props>;
export declare function DropdownMenuRadioItemIndicator({ className, ...props }: DropdownMenuRadioItemIndicatorProps): import("react").JSX.Element;
type DropdownMenuCheckboxItemProps = StyledProps<Menu.CheckboxItem.Props>;
export declare function DropdownMenuCheckboxItem({ className, children, ...props }: DropdownMenuCheckboxItemProps): import("react").JSX.Element;
type DropdownMenuCheckboxItemIndicatorProps = StyledProps<Menu.CheckboxItemIndicator.Props>;
export declare function DropdownMenuCheckboxItemIndicator({ className, ...props }: DropdownMenuCheckboxItemIndicatorProps): import("react").JSX.Element;
//#endregion
//#region src/components/lightbox/lightbox.d.ts
type LightboxProps<Payload = unknown> = Omit<Dialog$1.Root.Props<Payload>, "actionsRef" | "children" | "handle"> & {
children?: ReactNode;
closeOnModW?: boolean;
};
export declare function Lightbox<Payload = unknown>({ closeOnModW, defaultOpen, modal, onOpenChange, open, children, ...props }: LightboxProps<Payload>): import("react").JSX.Element;
type LightboxTriggerProps = Dialog$1.Trigger.Props;
export declare function LightboxTrigger(props: LightboxTriggerProps): import("react").JSX.Element;
type LightboxPortalProps = Dialog$1.Portal.Props;
export declare function LightboxPortal(props: LightboxPortalProps): import("react").JSX.Element;
type LightboxContentProps = StyledProps<Dialog$1.Popup.Props>;
export declare function LightboxContent({ className, initialFocus, finalFocus, ...props }: LightboxContentProps): import("react").JSX.Element;
type LightboxHeaderProps = useRender.ComponentProps<"div">;
export declare function LightboxHeader({ render, className, ...props }: LightboxHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxToolbarProps = useRender.ComponentProps<"div">;
export declare function LightboxToolbar({ render, className, ...props }: LightboxToolbarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxHeaderMetaProps = useRender.ComponentProps<"div">;
export declare function LightboxHeaderMeta({ render, className, ...props }: LightboxHeaderMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxHeaderLabelProps = useRender.ComponentProps<"span">;
export declare function LightboxHeaderLabel({ render, className, ...props }: LightboxHeaderLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxTitleProps = useRender.ComponentProps<"div">;
export declare function LightboxTitle({ render, className, ...props }: LightboxTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxActionsProps = useRender.ComponentProps<"div">;
export declare function LightboxActions({ render, className, ...props }: LightboxActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxStageProps = useRender.ComponentProps<"div">;
export declare function LightboxStage({ render, className, ...props }: LightboxStageProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxMediaProps = useRender.ComponentProps<"div">;
export declare function LightboxMedia({ render, className, ...props }: LightboxMediaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxNavigationButtonProps = Omit<ButtonProps, "disabled" | "loading" | "size" | "variant"> & {
direction: "next" | "previous";
disabled?: boolean;
};
export declare function LightboxNavigationButton({ className, direction, disabled, onClick, type, ...props }: LightboxNavigationButtonProps): import("react").JSX.Element;
type LightboxInfoDockProps = useRender.ComponentProps<"div">;
export declare function LightboxInfoDock({ render, className, ...props }: LightboxInfoDockProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxInfoBarProps = useRender.ComponentProps<"div">;
export declare function LightboxInfoBar({ render, className, ...props }: LightboxInfoBarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxInfoTitleProps = useRender.ComponentProps<"div">;
export declare function LightboxInfoTitle({ render, className, ...props }: LightboxInfoTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxInfoActionsProps = useRender.ComponentProps<"div">;
export declare function LightboxInfoActions({ render, className, ...props }: LightboxInfoActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxThumbnailStripProps = useRender.ComponentProps<"div">;
export declare function LightboxThumbnailStrip({ render, className, ...props }: LightboxThumbnailStripProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxThumbnailProps = useRender.ComponentProps<"button"> & {
active?: boolean;
};
export declare function LightboxThumbnail({ active, className, render, type, children, ...props }: LightboxThumbnailProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LightboxCloseProps = StyledProps<Dialog$1.Close.Props>;
export declare function LightboxClose({ className, render, ...props }: LightboxCloseProps): import("react").JSX.Element;
//#endregion
//#region src/components/logo/raft-logo.d.ts
type RaftLogoProps = ComponentPropsWithoutRef<"svg">;
export declare function RaftLogo(props: RaftLogoProps): import("react").JSX.Element;
type RaftWordmarkProps = ComponentPropsWithoutRef<"svg">;
export declare function RaftWordmark(props: RaftWordmarkProps): import("react").JSX.Element;
type RaftLogoLockupProps = ComponentPropsWithoutRef<"svg">;
export declare function RaftLogoLockup(props: RaftLogoLockupProps): import("react").JSX.Element;
//#endregion
//#region src/components/mobile-nav/mobile-nav.d.ts
type MobileNavRootProps = useRender.ComponentProps<"nav">;
export declare function MobileNavRoot({ className, render, ...props }: MobileNavRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MobileNavItemProps = useRender.ComponentProps<"button"> & {
nativeButton?: boolean;
selected?: boolean;
};
export declare function MobileNavItem({ nativeButton, selected, className, render, ...props }: MobileNavItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MobileNavLabelProps = useRender.ComponentProps<"span">;
export declare function MobileNavLabel({ className, render, ...props }: MobileNavLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/tooltip/tooltip.d.ts
type TooltipProviderProps = Tooltip$1.Provider.Props;
export declare function TooltipProvider({ delay, ...props }: TooltipProviderProps): import("react").JSX.Element;
type TooltipProps = Tooltip$1.Root.Props;
export declare function Tooltip(props: TooltipProps): import("react").JSX.Element;
type TooltipTriggerProps = StyledProps<Tooltip$1.Trigger.Props>;
export declare function TooltipTrigger({ className, ...props }: TooltipTriggerProps): import("react").JSX.Element;
type TooltipPortalProps = Tooltip$1.Portal.Props;
export declare function TooltipPortal(props: TooltipPortalProps): import("react").JSX.Element;
type TooltipContentProps = StyledProps<Tooltip$1.Popup.Props> & Pick<Tooltip$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
container?: TooltipPortalProps["container"];
portalProps?: TooltipPortalProps;
};
export declare function TooltipContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, container, portalProps, className, children, ...props }: TooltipContentProps): import("react").JSX.Element;
//#endregion
//#region src/components/popover/popover.d.ts
type PopoverProps = Popover$1.Root.Props;
export declare function Popover(props: PopoverProps): import("react").JSX.Element;
type PopoverTriggerProps = StyledProps<Popover$1.Trigger.Props>;
export declare function PopoverTrigger({ className, ...props }: PopoverTriggerProps): import("react").JSX.Element;
type PopoverPortalProps = Popover$1.Portal.Props;
export declare function PopoverPortal(props: PopoverPortalProps): import("react").JSX.Element;
type PopoverPopupProps = ComponentPropsWithRef<"div">;
export declare function PopoverPopup({ className, ...props }: PopoverPopupProps): import("react").JSX.Element;
type PopoverContentProps = StyledProps<Popover$1.Popup.Props> & Pick<Popover$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
container?: PopoverPortalProps["container"];
portalProps?: PopoverPortalProps;
};
export declare function PopoverContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, container, portalProps, className, ...props }: PopoverContentProps): import("react").JSX.Element;
type PopoverViewportProps = StyledProps<Popover$1.Viewport.Props>;
export declare function PopoverViewport({ className, ...props }: PopoverViewportProps): import("react").JSX.Element;
type PopoverHeaderProps = ComponentPropsWithRef<"div">;
export declare function PopoverHeader({ className, ...props }: PopoverHeaderProps): import("react").JSX.Element;
type PopoverSeparatorProps = StyledProps<ComponentPropsWithRef<"div">>;
export declare function PopoverSeparator({ className, ...props }: PopoverSeparatorProps): import("react").JSX.Element;
type PopoverTitleProps = StyledProps<Popover$1.Title.Props>;
export declare function PopoverTitle({ className, ...props }: PopoverTitleProps): import("react").JSX.Element;
type PopoverDescriptionProps = StyledProps<Popover$1.Description.Props>;
export declare function PopoverDescription({ className, ...props }: PopoverDescriptionProps): import("react").JSX.Element;
type PopoverCloseProps = StyledProps<Popover$1.Close.Props>;
export declare function PopoverClose({ className, ...props }: PopoverCloseProps): import("react").JSX.Element;
type PopoverArrowProps = StyledProps<Popover$1.Arrow.Props>;
export declare function PopoverArrow({ className, ...props }: PopoverArrowProps): import("react").JSX.Element;
type PopoverBackdropProps = StyledProps<Popover$1.Backdrop.Props>;
export declare function PopoverBackdrop({ className, ...props }: PopoverBackdropProps): import("react").JSX.Element;
//#endregion
//#region src/components/preview-card/preview-card.d.ts
type PreviewCardProps = PreviewCard$1.Root.Props;
export declare function PreviewCard(props: PreviewCardProps): import("react").JSX.Element;
type PreviewCardTriggerProps = StyledProps<PreviewCard$1.Trigger.Props>;
export declare function PreviewCardTrigger({ delay, closeDelay, className, ...props }: PreviewCardTriggerProps): import("react").JSX.Element;
type PreviewCardPortalProps = PreviewCard$1.Portal.Props;
export declare function PreviewCardPortal(props: PreviewCardPortalProps): import("react").JSX.Element;
type PreviewCardPopupProps = ComponentPropsWithRef<"div">;
export declare function PreviewCardPopup({ className, ...props }: PreviewCardPopupProps): import("react").JSX.Element;
type PreviewCardContentProps = StyledProps<PreviewCard$1.Popup.Props> & Pick<PreviewCard$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
portalProps?: PreviewCardPortalProps;
};
export declare function PreviewCardContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, portalProps, className, ...props }: PreviewCardContentProps): import("react").JSX.Element;
type PreviewCardHeaderProps = ComponentPropsWithRef<"div">;
export declare function PreviewCardHeader({ className, ...props }: PreviewCardHeaderProps): import("react").JSX.Element;
type PreviewCardSeparatorProps = StyledProps<ComponentPropsWithRef<"div">>;
export declare function PreviewCardSeparator({ className, ...props }: PreviewCardSeparatorProps): import("react").JSX.Element;
type PreviewCardTitleProps = ComponentPropsWithRef<"p">;
export declare function PreviewCardTitle({ className, ...props }: PreviewCardTitleProps): import("react").JSX.Element;
type PreviewCardDescriptionProps = ComponentPropsWithRef<"p">;
export declare function PreviewCardDescription({ className, ...props }: PreviewCardDescriptionProps): import("react").JSX.Element;
type PreviewCardArrowProps = StyledProps<PreviewCard$1.Arrow.Props>;
export declare function PreviewCardArrow({ className, ...props }: PreviewCardArrowProps): import("react").JSX.Element;
//#endregion
//#region src/components/label/label.d.ts
declare const label$1: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string;
sub: string;
};
elegant: {
root: string;
sub: string;
};
};
size: {
sm: {
root: string;
};
md: {
root: string;
};
};
}, {
root: string[];
asterisk: string[];
sub: string[];
}, undefined, {
theme: {
brutal: {
root: string;
sub: string;
};
elegant: {
root: string;
sub: string;
};
};
size: {
sm: {
root: string;
};
md: {
root: string;
};
};
}, {
root: string[];
asterisk: string[];
sub: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string;
sub: string;
};
elegant: {
root: string;
sub: string;
};
};
size: {
sm: {
root: string;
};
md: {
root: string;
};
};
}, {
root: string[];
asterisk: string[];
sub: string[];
}>>;
type LabelProps = useRender.ComponentProps<"label"> & Omit<VariantProps<typeof label$1>, "theme"> & {
disabled?: boolean;
};
declare function LabelRoot({ size, disabled, className, render, ...props }: LabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LabelAsteriskProps = ComponentPropsWithRef<"span">;
export declare function LabelAsterisk({ className, children, ...props }: LabelAsteriskProps): import("react").JSX.Element;
type LabelSubProps = ComponentPropsWithRef<"span">;
export declare function LabelSub({ className, ...props }: LabelSubProps): import("react").JSX.Element;
type LabelOptionalProps = LabelSubProps;
export declare function LabelOptional({ children, ...props }: LabelOptionalProps): import("react").JSX.Element;
export declare const Label: typeof LabelRoot & {
Asterisk: typeof LabelAsterisk;
Optional: typeof LabelOptional;
Sub: typeof LabelSub;
};
//#endregion
//#region src/lib/without-children.d.ts
/**
* Element props without `children` — for leaf components (dots, markers) that
* render no caller content. React ships `ComponentPropsWithoutRef` but no
* equivalent that subtracts children, so this names the one-off `Omit`.
*/
type WithoutChildren<P> = Omit<P, "children">;
//#endregion
//#region src/components/input/input.d.ts
type InputBehaviorProps = {
/**
* Add common password-manager ignore hints for non-credential fields where
* extension overlays would obscure custom UI.
*/
suppressPasswordManager?: boolean;
};
type InputProps = WithoutChildren<StyledProps<Input$1.Props>> & InputBehaviorProps & DataAttributes$1;
export declare function Input({ suppressPasswordManager, className, "data-invalid": dataInvalid, ...props }: InputProps): import("react").JSX.Element;
//#endregion
//#region src/components/field/field.d.ts
declare const field: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string[];
label: string[];
description: string[];
error: string[];
};
elegant: {
label: string[];
description: string[];
error: string[];
};
};
size: {
sm: {
label: string;
};
md: {
label: string;
};
};
}, {
root: string[];
item: string[];
label: string[];
description: string[];
error: string[];
}, undefined, {
theme: {
brutal: {
root: string[];
label: string[];
description: string[];
error: string[];
};
elegant: {
label: string[];
description: string[];
error: string[];
};
};
size: {
sm: {
label: string;
};
md: {
label: string;
};
};
}, {
root: string[];
item: string[];
label: string[];
description: string[];
error: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string[];
label: string[];
description: string[];
error: string[];
};
elegant: {
label: string[];
description: string[];
error: string[];
};
};
size: {
sm: {
label: string;
};
md: {
label: string;
};
};
}, {
root: string[];
item: string[];
label: string[];
description: string[];
error: string[];
}>>;
type FieldProps = StyledProps<Field$1.Root.Props>;
export declare function Field({ className, ...props }: FieldProps): import("react").JSX.Element;
type FieldItemProps = StyledProps<Field$1.Item.Props>;
export declare function FieldItem({ className, ...props }: FieldItemProps): import("react").JSX.Element;
type LabelMarker = {
required?: boolean;
optional?: never;
} | {
optional?: boolean;
required?: never;
};
type FieldLabelProps = StyledProps<Field$1.Label.Props> & Omit<VariantProps<typeof field>, "theme"> & LabelMarker;
export declare function FieldLabel({ size, required, optional, className, children, ...props }: FieldLabelProps): import("react").JSX.Element;
type FieldDescriptionProps = StyledProps<Field$1.Description.Props>;
export declare function FieldDescription({ className, ...props }: FieldDescriptionProps): import("react").JSX.Element;
type FieldErrorProps = StyledProps<Field$1.Error.Props>;
export declare function FieldError({ className, role, ...props }: FieldErrorProps): import("react").JSX.Element;
type FieldControlProps = Field$1.Control.Props;
export declare function FieldControl(props: FieldControlProps): import("react").JSX.Element;
type FieldValidityProps = Field$1.Validity.Props;
export declare function FieldValidity(props: FieldValidityProps): import("react").JSX.Element;
//#endregion
//#region src/components/input-group/input-group.d.ts
declare const inputGroup: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string[];
addon: string[];
text: string[];
control: string[];
};
elegant: {
root: string[];
addon: string[];
text: string[];
control: string[];
};
};
align: {
"inline-start": {
addon: string;
text: string;
};
"inline-end": {
addon: string;
text: string;
};
};
variant: {
default: {};
container: {
addon: string[];
text: string[];
};
};
}, {
root: string[];
addon: string[];
text: string[];
control: string[];
}, undefined, {
theme: {
brutal: {
root: string[];
addon: string[];
text: string[];
control: string[];
};
elegant: {
root: string[];
addon: string[];
text: string[];
control: string[];
};
};
align: {
"inline-start": {
addon: string;
text: string;
};
"inline-end": {
addon: string;
text: string;
};
};
variant: {
default: {};
container: {
addon: string[];
text: string[];
};
};
}, {
root: string[];
addon: string[];
text: string[];
control: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string[];
addon: string[];
text: string[];
control: string[];
};
elegant: {
root: string[];
addon: string[];
text: string[];
control: string[];
};
};
align: {
"inline-start": {
addon: string;
text: string;
};
"inline-end": {
addon: string;
text: string;
};
};
variant: {
default: {};
container: {
addon: string[];
text: string[];
};
};
}, {
root: string[];
addon: string[];
text: string[];
control: string[];
}>>;
type InputGroupProps = ComponentPropsWithRef<"div">;
export declare function InputGroup({ className, ...props }: InputGroupProps): import("react").JSX.Element;
type InputGroupAddonProps = ComponentPropsWithRef<"div"> & Pick<VariantProps<typeof inputGroup>, "align" | "variant">;
declare function InputGroupAddonRoot({ align, variant, className, ...props }: InputGroupAddonProps): import("react").JSX.Element;
type InputGroupAddonTextProps = ComponentPropsWithRef<"span"> & Pick<VariantProps<typeof inputGroup>, "align" | "variant">;
declare function TextAddon({ align, variant, className, ...props }: InputGroupAddonTextProps): import("react").JSX.Element;
export declare const InputGroupAddon: typeof InputGroupAddonRoot & {
Text: typeof TextAddon;
};
type InputGroupInputProps = WithoutChildren<StyledProps<Input$1.Props>> & InputBehaviorProps & DataAttributes$1;
export declare function InputGroupInput({ className, suppressPasswordManager, "data-invalid": dataInvalid, ...props }: InputGroupInputProps): import("react").JSX.Element;
//#endregion
//#region src/components/combobox/combobox.d.ts
type ComboboxProps<Value, Multiple extends boolean | undefined = false> = Combobox$1.Root.Props<Value, Multiple>;
export declare function Combobox<Value, Multiple extends boolean | undefined = false>({ defaultInputValue, defaultValue, inputValue, onInputValueChange, onValueChange, value, ...props }: ComboboxProps<Value, Multiple>): import("react").JSX.Element;
type ComboboxLabelProps = StyledProps<Combobox$1.Label.Props>;
export declare function ComboboxLabel({ className, ...props }: ComboboxLabelProps): import("react").JSX.Element;
type ComboboxValueProps = Combobox$1.Value.Props;
export declare function ComboboxValue(props: ComboboxValueProps): import("react").JSX.Element;
type ComboboxTriggerProps = StyledProps<Combobox$1.Trigger.Props>;
export declare function ComboboxTrigger({ className, children, render, ...props }: ComboboxTriggerProps): import("react").JSX.Element;
type ComboboxTriggerCountProps = StyledProps<ComponentPropsWithRef<"span">>;
export declare function ComboboxTriggerCount({ className, ...props }: ComboboxTriggerCountProps): import("react").JSX.Element;
type ComboboxTriggerIndicatorProps = StyledProps<ComponentPropsWithRef<"span">>;
export declare function ComboboxTriggerIndicator({ className, ...props }: ComboboxTriggerIndicatorProps): import("react").JSX.Element;
type ComboboxInputGroupProps = StyledProps<Combobox$1.InputGroup.Props>;
export declare function ComboboxInputGroup({ className, ...props }: ComboboxInputGroupProps): import("react").JSX.Element;
type ComboboxControlProps = StyledProps<Combobox$1.InputGroup.Props>;
export declare function ComboboxControl({ className, ...props }: ComboboxControlProps): import("react").JSX.Element;
type ComboboxInputProps = StyledProps<Combobox$1.Input.Props> & {
suppressPasswordManager?: boolean;
};
export declare function ComboboxInput({ suppressPasswordManager, className, ...props }: ComboboxInputProps): import("react").JSX.Element;
type ComboboxPortalProps = Combobox$1.Portal.Props;
export declare function ComboboxPortal(props: ComboboxPortalProps): import("react").JSX.Element;
type ComboboxPopupProps = ComponentPropsWithRef<"div">;
export declare function ComboboxPopup({ className, ...props }: ComboboxPopupProps): import("react").JSX.Element;
type ComboboxHeaderProps = ComponentPropsWithRef<"div">;
export declare function ComboboxHeader({ className, ...props }: ComboboxHeaderProps): import("react").JSX.Element;
type ComboboxSeparatorProps = StyledProps<ComponentPropsWithRef<"div">>;
export declare function ComboboxSeparator({ className, ...props }: ComboboxSeparatorProps): import("react").JSX.Element;
type ComboboxContentProps = StyledProps<Combobox$1.Popup.Props> & Pick<Combobox$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
portalProps?: ComboboxPortalProps;
};
export declare function ComboboxContent({ align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, portalProps, className, initialFocus, finalFocus, ...props }: ComboboxContentProps): import("react").JSX.Element;
type ComboboxListProps = StyledProps<Combobox$1.List.Props>;
export declare function ComboboxList({ className, ...props }: ComboboxListProps): import("react").JSX.Element;
type ComboboxItemProps = StyledProps<Combobox$1.Item.Props>;
export declare function ComboboxItem({ className, ...props }: ComboboxItemProps): import("react").JSX.Element;
type ComboboxItemIndicatorProps = StyledProps<Combobox$1.ItemIndicator.Props>;
export declare function ComboboxItemIndicator({ className, children, ...props }: ComboboxItemIndicatorProps): import("react").JSX.Element;
type ComboboxClearProps = StyledProps<Combobox$1.Clear.Props>;
export declare function ComboboxClear({ className, children, keepMounted, ...props }: ComboboxClearProps): import("react").JSX.Element;
type ComboboxEmptyProps = StyledProps<Combobox$1.Empty.Props>;
export declare function ComboboxEmpty({ className, children, ...props }: ComboboxEmptyProps): import("react").JSX.Element;
type ComboboxGroupProps = StyledProps<Combobox$1.Group.Props>;
export declare function ComboboxGroup({ className, ...props }: ComboboxGroupProps): import("react").JSX.Element;
type ComboboxGroupLabelProps = StyledProps<Combobox$1.GroupLabel.Props>;
export declare function ComboboxGroupLabel({ className, ...props }: ComboboxGroupLabelProps): import("react").JSX.Element;
type ComboboxRowProps = StyledProps<Combobox$1.Row.Props>;
export declare function ComboboxRow({ className, ...props }: ComboboxRowProps): import("react").JSX.Element;
type ComboboxCollectionProps = Combobox$1.Collection.Props;
export declare function ComboboxCollection(props: ComboboxCollectionProps): import("react").JSX.Element;
type ComboboxChipsProps = StyledProps<Combobox$1.Chips.Props>;
export declare function ComboboxChips({ className, ...props }: ComboboxChipsProps): import("react").JSX.Element;
type ComboboxChipProps = StyledProps<Combobox$1.Chip.Props>;
export declare function ComboboxChip({ className, ...props }: ComboboxChipProps): import("react").JSX.Element;
type ComboboxChipRemoveProps = StyledProps<Combobox$1.ChipRemove.Props>;
export declare function ComboboxChipRemove({ className, children, ...props }: ComboboxChipRemoveProps): import("react").JSX.Element;
//#endregion
//#region src/components/picker-trigger-button/picker-trigger-button.d.ts
type PickerTriggerButtonProps = StyledProps<Button$1.Props> & DataAttributes$1;
export declare function PickerTriggerButton({ className, render, nativeButton, ...props }: PickerTriggerButtonProps): import("react").JSX.Element;
//#endregion
//#region src/components/select/select.d.ts
type SelectChrome = "default" | "field";
type SelectProps<Value, Multiple extends boolean | undefined = false> = Select$1.Root.Props<Value, Multiple> & {
/**
* `field` opts this Select into the field metric axis, so it reads as a form
* field rather than a button. Defaults to `default`, leaving every existing
* Select untouched.
*/
chrome?: SelectChrome;
};
export declare function Select<Value, Multiple extends boolean | undefined = false>({ chrome, ...props }: SelectProps<Value, Multiple>): import("react").JSX.Element;
type SelectTriggerProps = StyledProps<Select$1.Trigger.Props> & DataAttributes$1;
export declare function SelectTrigger({ className, children, render, "data-invalid": dataInvalid, ...props }: SelectTriggerProps): import("react").JSX.Element;
type SelectValueProps = StyledProps<Select$1.Value.Props>;
export declare function SelectValue({ className, ...props }: SelectValueProps): import("react").JSX.Element;
type SelectIconProps = StyledProps<Select$1.Icon.Props>;
export declare function SelectIcon({ className, children, ...props }: SelectIconProps): import("react").JSX.Element;
type SelectPortalProps = Select$1.Portal.Props;
export declare function SelectPortal(props: SelectPortalProps): import("react").JSX.Element;
type SelectPopupProps = ComponentPropsWithRef<"div">;
export declare function SelectPopup({ className, ...props }: SelectPopupProps): import("react").JSX.Element;
type SelectContentProps = StyledProps<Select$1.Popup.Props> & Pick<Select$1.Positioner.Props, "align" | "alignItemWithTrigger" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
portalProps?: SelectPortalProps;
};
export declare function SelectContent({ align, alignItemWithTrigger, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, portalProps, className, ...props }: SelectContentProps): import("react").JSX.Element;
type SelectListProps = StyledProps<Select$1.List.Props>;
export declare function SelectList({ className, ...props }: SelectListProps): import("react").JSX.Element;
type SelectItemProps = StyledProps<Select$1.Item.Props>;
export declare function SelectItem({ className, ...props }: SelectItemProps): import("react").JSX.Element;
type SelectItemLeadingProps = StyledProps<ComponentPropsWithRef<"span">>;
export declare function SelectItemLeading({ className, ...props }: SelectItemLeadingProps): import("react").JSX.Element;
type SelectItemIndicatorProps = StyledProps<Select$1.ItemIndicator.Props>;
export declare function SelectItemIndicator({ className, children, ...props }: SelectItemIndicatorProps): import("react").JSX.Element;
type SelectItemTextProps = StyledProps<Select$1.ItemText.Props>;
export declare function SelectItemText({ className, ...props }: SelectItemTextProps): import("react").JSX.Element;
type SelectLabelProps = StyledProps<Select$1.Label.Props>;
export declare function SelectLabel({ className, ...props }: SelectLabelProps): import("react").JSX.Element;
type SelectGroupProps = StyledProps<Select$1.Group.Props>;
export declare function SelectGroup({ className, ...props }: SelectGroupProps): import("react").JSX.Element;
type SelectGroupLabelProps = StyledProps<Select$1.GroupLabel.Props>;
export declare function SelectGroupLabel({ className, ...props }: SelectGroupLabelProps): import("react").JSX.Element;
type SelectSeparatorProps = StyledProps<ComponentPropsWithRef<"div">>;
export declare function SelectSeparator({ className, ...props }: SelectSeparatorProps): import("react").JSX.Element;
type SelectScrollUpArrowProps = StyledProps<Select$1.ScrollUpArrow.Props>;
export declare function SelectScrollUpArrow({ className, children, ...props }: SelectScrollUpArrowProps): import("react").JSX.Element;
type SelectScrollDownArrowProps = StyledProps<Select$1.ScrollDownArrow.Props>;
export declare function SelectScrollDownArrow({ className, children, ...props }: SelectScrollDownArrowProps): import("react").JSX.Element;
type SelectArrowProps = StyledProps<Select$1.Arrow.Props>;
export declare function SelectArrow({ className, ...props }: SelectArrowProps): import("react").JSX.Element;
//#endregion
//#region src/components/radio-group/radio-group.d.ts
type RadioGroupProps<T extends string = string> = StyledProps<RadioGroup$1.Props<T>>;
export declare function RadioGroup<T extends string = string>({ className, ...props }: RadioGroupProps<T>): import("react").JSX.Element;
type RadioGroupIndicatorProps = StyledProps<Radio.Indicator.Props>;
export declare function RadioGroupIndicator({ className, children, ...props }: RadioGroupIndicatorProps): import("react").JSX.Element;
type RadioGroupItemProps<T extends string = string> = StyledProps<Radio.Root.Props<T>> & {
appearance?: "default" | "none";
};
export declare function RadioGroupItem<T extends string = string>({ appearance, className, children, ...props }: RadioGroupItemProps<T>): import("react").JSX.Element;
//#endregion
//#region src/components/switch/switch.d.ts
declare const switchRecipe: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string[];
thumb: string[];
};
elegant: {
root: string[];
thumb: string[];
};
};
size: {
sm: {
root: string;
thumb: string;
};
md: {
root: string;
thumb: string;
};
};
}, {
root: string[];
thumb: string[];
}, undefined, {
theme: {
brutal: {
root: string[];
thumb: string[];
};
elegant: {
root: string[];
thumb: string[];
};
};
size: {
sm: {
root: string;
thumb: string;
};
md: {
root: string;
thumb: string;
};
};
}, {
root: string[];
thumb: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string[];
thumb: string[];
};
elegant: {
root: string[];
thumb: string[];
};
};
size: {
sm: {
root: string;
thumb: string;
};
md: {
root: string;
thumb: string;
};
};
}, {
root: string[];
thumb: string[];
}>>;
type SwitchProps = StyledProps<Switch$1.Root.Props> & Omit<VariantProps<typeof switchRecipe>, "theme">;
export declare function Switch({ size, className, children, ...props }: SwitchProps): import("react").JSX.Element;
type SwitchThumbProps = StyledProps<Switch$1.Thumb.Props> & Omit<VariantProps<typeof switchRecipe>, "theme">;
export declare function SwitchThumb({ size, className, ...props }: SwitchThumbProps): import("react").JSX.Element;
//#endregion
//#region src/components/segmented-control/segmented-control.d.ts
declare const segmentedControl: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
item: string[];
count: string[];
};
elegant: {
root: string[];
item: string[];
count: string[];
};
};
disabled: {
true: {
root: string;
};
false: {
root: string;
};
};
}, {
root: string[];
item: string[];
label: string[];
count: string[];
}, undefined, {
theme: {
brutal: {
item: string[];
count: string[];
};
elegant: {
root: string[];
item: string[];
count: string[];
};
};
disabled: {
true: {
root: string;
};
false: {
root: string;
};
};
}, {
root: string[];
item: string[];
label: string[];
count: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
item: string[];
count: string[];
};
elegant: {
root: string[];
item: string[];
count: string[];
};
};
disabled: {
true: {
root: string;
};
false: {
root: string;
};
};
}, {
root: string[];
item: string[];
label: string[];
count: string[];
}>>;
type SegmentedControlProps<T extends string = string> = StyledProps<RadioGroup$1.Props<T>> & Omit<VariantProps<typeof segmentedControl>, "theme">;
export declare function SegmentedControl<T extends string = string>({ disabled, className, ...props }: SegmentedControlProps<T>): import("react").JSX.Element;
type SegmentedControlItemProps<T extends string = string> = StyledProps<Radio.Root.Props<T>>;
export declare function SegmentedControlItem<T extends string = string>({ className, ...props }: SegmentedControlItemProps<T>): import("react").JSX.Element;
type SegmentedControlLabelProps = ComponentPropsWithRef<"span">;
export declare function SegmentedControlLabel({ className, ...props }: SegmentedControlLabelProps): import("react").JSX.Element;
type SegmentedControlCountProps = ComponentPropsWithRef<"span">;
export declare function SegmentedControlCount({ className, ...props }: SegmentedControlCountProps): import("react").JSX.Element;
//#endregion
//#region src/components/toggle-group/toggle-group.d.ts
type ToggleGroupProps<T extends string = string> = StyledProps<ToggleGroup$1.Props<T>>;
export declare function ToggleGroup<T extends string = string>({ className, ...props }: ToggleGroupProps<T>): import("react").JSX.Element;
type ToggleGroupItemProps<T extends string = string> = StyledProps<Omit<Toggle.Props<T>, "defaultPressed" | "pressed">> & {
value: T;
};
export declare function ToggleGroupItem<T extends string = string>({ className, nativeButton, render, ...props }: ToggleGroupItemProps<T>): import("react").JSX.Element;
type ToggleGroupLabelProps = ComponentPropsWithRef<"span">;
export declare function ToggleGroupLabel({ className, ...props }: ToggleGroupLabelProps): import("react").JSX.Element;
//#endregion
//#region src/components/textarea/textarea.d.ts
type TextareaProps = WithoutChildren<ComponentPropsWithRef<"textarea">> & DataAttributes$1;
type TextareaGroupProps = ComponentPropsWithRef<"div">;
export declare function TextareaGroup({ className, ...props }: TextareaGroupProps): import("react").JSX.Element;
export declare function Textarea({ className, "data-invalid": dataInvalid, ...props }: TextareaProps): import("react").JSX.Element;
interface TextareaCounterProps extends WithoutChildren<ComponentPropsWithRef<"span">> {
value?: string;
count?: number;
limit: number;
getLength?: (value: string) => number;
}
export declare function TextareaCounter({ value, count, limit, getLength, className, ...props }: TextareaCounterProps): import("react").JSX.Element;
//#endregion
//#region src/components/description-list/description-list.d.ts
declare const descriptionList: import("tailwind-variants/lite").TVReturnType<{
direction: {
vertical: {};
horizontal: {
root: string[];
};
};
theme: {
brutal: {
term: string;
details: string;
};
elegant: {
term: string[];
details: string;
};
};
}, {
root: string[];
item: string[];
term: string[];
details: string[];
}, undefined, {
direction: {
vertical: {};
horizontal: {
root: string[];
};
};
theme: {
brutal: {
term: string;
details: string;
};
elegant: {
term: string[];
details: string;
};
};
}, {
root: string[];
item: string[];
term: string[];
details: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
direction: {
vertical: {};
horizontal: {
root: string[];
};
};
theme: {
brutal: {
term: string;
details: string;
};
elegant: {
term: string[];
details: string;
};
};
}, {
root: string[];
item: string[];
term: string[];
details: string[];
}>>;
type DescriptionListDirection = NonNullable<VariantProps<typeof descriptionList>["direction"]>;
type DescriptionListProps = useRender.ComponentProps<"dl"> & Pick<VariantProps<typeof descriptionList>, "direction">;
export declare function DescriptionList({ direction, className, render, ...props }: DescriptionListProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DescriptionItemProps = useRender.ComponentProps<"div">;
export declare function DescriptionItem({ className, render, ...props }: DescriptionItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DescriptionTermProps = useRender.ComponentProps<"dt">;
export declare function DescriptionTerm({ className, render, ...props }: DescriptionTermProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type DescriptionDetailsProps = useRender.ComponentProps<"dd">;
export declare function DescriptionDetails({ className, render, ...props }: DescriptionDetailsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/avatar/avatar.d.ts
declare const avatar: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string;
fallback: string;
badge: string[];
dot: string[];
group: string[];
};
elegant: {
root: string[];
image: string[];
fallback: string[];
badge: string[];
dot: string[];
group: string[];
};
};
type: {
agent: {};
human: {};
};
size: {
xl: {
root: string;
};
lg: {
root: string;
};
md: {
root: string;
};
sm: {
root: string;
};
xs: {
root: string;
};
"2xs": {
root: string;
};
"3xs": {
root: string;
};
};
}, {
root: string[];
image: string[];
fallback: string[];
badge: string[];
dot: string[];
group: string[];
}, undefined, {
theme: {
brutal: {
root: string;
fallback: string;
badge: string[];
dot: string[];
group: string[];
};
elegant: {
root: string[];
image: string[];
fallback: string[];
badge: string[];
dot: string[];
group: string[];
};
};
type: {
agent: {};
human: {};
};
size: {
xl: {
root: string;
};
lg: {
root: string;
};
md: {
root: string;
};
sm: {
root: string;
};
xs: {
root: string;
};
"2xs": {
root: string;
};
"3xs": {
root: string;
};
};
}, {
root: string[];
image: string[];
fallback: string[];
badge: string[];
dot: string[];
group: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string;
fallback: string;
badge: string[];
dot: string[];
group: string[];
};
elegant: {
root: string[];
image: string[];
fallback: string[];
badge: string[];
dot: string[];
group: string[];
};
};
type: {
agent: {};
human: {};
};
size: {
xl: {
root: string;
};
lg: {
root: string;
};
md: {
root: string;
};
sm: {
root: string;
};
xs: {
root: string;
};
"2xs": {
root: string;
};
"3xs": {
root: string;
};
};
}, {
root: string[];
image: string[];
fallback: string[];
badge: string[];
dot: string[];
group: string[];
}>>;
type AvatarSize = NonNullable<VariantProps<typeof avatar>["size"]>;
type AvatarProps = StyledProps<Avatar$1.Root.Props> & Required<Pick<VariantProps<typeof avatar>, "size" | "type">>;
export declare function Avatar({ size, type, className, children, ...props }: AvatarProps): import("react").JSX.Element;
type AvatarImageProps = StyledProps<Avatar$1.Image.Props>;
export declare function AvatarImage({ className, ...props }: AvatarImageProps): import("react").JSX.Element;
type AvatarFallbackProps = StyledProps<Avatar$1.Fallback.Props>;
export declare function AvatarFallback({ className, children, ...props }: AvatarFallbackProps): import("react").JSX.Element;
type AvatarBadgeProps = useRender.ComponentProps<"span">;
export declare function AvatarBadge({ className, render, ...props }: AvatarBadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AvatarGroupProps = ComponentPropsWithRef<"div">;
export declare function AvatarGroup({ className, ...props }: AvatarGroupProps): import("react").JSX.Element;
type AvatarGroupCountProps = ComponentPropsWithRef<"span"> & {
/** Matches the frame scale of the sibling avatars. */
size: AvatarSize;
};
export declare function AvatarGroupCount({ size, className, ...props }: AvatarGroupCountProps): import("react").JSX.Element;
//#endregion
//#region src/components/code-block/code-block.d.ts
type CodeBlockProps = useRender.ComponentProps<"div">;
/** Framed code surface. Compose a header and a body inside it. */
export declare function CodeBlock({ className, render, ...props }: CodeBlockProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CodeBlockHeaderProps = useRender.ComponentProps<"div">;
export declare function CodeBlockHeader({ className, render, ...props }: CodeBlockHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CodeBlockTitleProps = useRender.ComponentProps<"span">;
export declare function CodeBlockTitle({ className, render, ...props }: CodeBlockTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CodeBlockActionsProps = useRender.ComponentProps<"div">;
/** Trailing action region. Placed inside the body it floats over the code panel. */
export declare function CodeBlockActions({ className, render, ...props }: CodeBlockActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CodeBlockActionProps = useRender.ComponentProps<"button">;
/** Styled action shell. The consumer owns the icon and the behavior. */
export declare function CodeBlockAction({ className, render, ...props }: CodeBlockActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type CodeBlockBodyProps = useRender.ComponentProps<"div">;
/** Inner code panel. Render the complete pre and code as children. */
export declare function CodeBlockBody({ children, className, render, ...props }: CodeBlockBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/inline-code/inline-code.d.ts
type InlineCodeProps = ComponentPropsWithRef<"code"> & {
/** `message` renders the borderless, baseline-aligned in-message treatment. */
appearance?: "default" | "message";
};
export declare function InlineCode({ className, appearance, ...props }: InlineCodeProps): import("react").JSX.Element;
//#endregion
//#region src/components/markdown/markdown-parts.d.ts
declare const HEADING_TAGS: {
readonly 1: "h1";
readonly 2: "h2";
readonly 3: "h3";
readonly 4: "h4";
readonly 5: "h5";
readonly 6: "h6";
};
type MarkdownHeadingLevel = keyof typeof HEADING_TAGS;
type MarkdownHeadingProps = ComponentPropsWithRef<"h1"> & {
level: MarkdownHeadingLevel;
};
export declare function MarkdownHeading({ className, level, ...props }: MarkdownHeadingProps): import("react").JSX.Element;
type MarkdownParagraphProps = ComponentPropsWithRef<"p">;
export declare function MarkdownParagraph({ className, ...props }: MarkdownParagraphProps): import("react").JSX.Element;
type MarkdownLinkProps = ComponentPropsWithRef<"a">;
export declare function MarkdownLink({ className, ...props }: MarkdownLinkProps): import("react").JSX.Element;
type MarkdownMarkProps = ComponentPropsWithRef<"mark">;
export declare function MarkdownMark({ className, ...props }: MarkdownMarkProps): import("react").JSX.Element;
type MarkdownListProps = ComponentPropsWithRef<"ul">;
export declare function MarkdownList({ className, ...props }: MarkdownListProps): import("react").JSX.Element;
type MarkdownOrderedListProps = ComponentPropsWithRef<"ol">;
export declare function MarkdownOrderedList({ className, ...props }: MarkdownOrderedListProps): import("react").JSX.Element;
type MarkdownListItemProps = ComponentPropsWithRef<"li">;
export declare function MarkdownListItem({ className, ...props }: MarkdownListItemProps): import("react").JSX.Element;
type MarkdownBlockquoteProps = ComponentPropsWithRef<"blockquote">;
export declare function MarkdownBlockquote({ className, ...props }: MarkdownBlockquoteProps): import("react").JSX.Element;
type MarkdownRuleProps = ComponentPropsWithRef<"hr">;
export declare function MarkdownRule({ className, ...props }: MarkdownRuleProps): import("react").JSX.Element;
type MarkdownTableScrollProps = ComponentPropsWithRef<"div">;
/** Horizontal scroll container for wide tables. */
export declare function MarkdownTableScroll({ className, ...props }: MarkdownTableScrollProps): import("react").JSX.Element;
type MarkdownTableProps = ComponentPropsWithRef<"table">;
export declare function MarkdownTable({ className, ...props }: MarkdownTableProps): import("react").JSX.Element;
type MarkdownTableRowProps = ComponentPropsWithRef<"tr">;
export declare function MarkdownTableRow({ className, ...props }: MarkdownTableRowProps): import("react").JSX.Element;
type MarkdownHeaderCellProps = ComponentPropsWithRef<"th">;
export declare function MarkdownHeaderCell({ className, ...props }: MarkdownHeaderCellProps): import("react").JSX.Element;
type MarkdownCellProps = ComponentPropsWithRef<"td">;
export declare function MarkdownCell({ className, ...props }: MarkdownCellProps): import("react").JSX.Element;
type MarkdownImageProps = ComponentPropsWithRef<"img">;
export declare function MarkdownImage({ className, ...props }: MarkdownImageProps): import("react").JSX.Element;
type MarkdownInlineCodeProps = InlineCodeProps;
export declare function MarkdownInlineCode({ className, ...props }: MarkdownInlineCodeProps): import("react").JSX.Element;
type MarkdownCheckboxProps = CheckboxProps;
/** Task-list checkbox. Markdown task items are display-only, so it defaults to read-only. */
export declare function MarkdownCheckbox({ className, ...props }: MarkdownCheckboxProps): import("react").JSX.Element;
//#endregion
//#region src/components/message-item/message-item.recipe.d.ts
declare const messageItem: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string[];
continuationTime: string;
content: string;
header: string;
sender: string[];
meta: string;
time: string;
inlineStatus: string;
body: string;
toolbar: string[];
toolbarButton: string[];
};
elegant: {
root: string[];
gutter: string;
avatarSlot: string[];
continuationTime: string[];
content: string;
header: string;
sender: string[];
meta: string;
time: string;
inlineStatus: string;
body: string[];
toolbar: string[];
toolbarButton: string[];
footer: string;
};
};
compact: {
true: {};
};
}, {
root: string[];
gutter: string[];
avatarSlot: string[];
continuationTime: string[];
content: string[];
header: string[];
sender: string[];
senderBadges: string[];
meta: string[];
time: string[];
inlineStatus: string[];
body: string[];
searchMatch: string[];
embedded: string[];
attachments: string[];
footer: string[];
toolbar: string[];
toolbarButton: string[];
}, undefined, {
theme: {
brutal: {
root: string[];
continuationTime: string;
content: string;
header: string;
sender: string[];
meta: string;
time: string;
inlineStatus: string;
body: string;
toolbar: string[];
toolbarButton: string[];
};
elegant: {
root: string[];
gutter: string;
avatarSlot: string[];
continuationTime: string[];
content: string;
header: string;
sender: string[];
meta: string;
time: string;
inlineStatus: string;
body: string[];
toolbar: string[];
toolbarButton: string[];
footer: string;
};
};
compact: {
true: {};
};
}, {
root: string[];
gutter: string[];
avatarSlot: string[];
continuationTime: string[];
content: string[];
header: string[];
sender: string[];
senderBadges: string[];
meta: string[];
time: string[];
inlineStatus: string[];
body: string[];
searchMatch: string[];
embedded: string[];
attachments: string[];
footer: string[];
toolbar: string[];
toolbarButton: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string[];
continuationTime: string;
content: string;
header: string;
sender: string[];
meta: string;
time: string;
inlineStatus: string;
body: string;
toolbar: string[];
toolbarButton: string[];
};
elegant: {
root: string[];
gutter: string;
avatarSlot: string[];
continuationTime: string[];
content: string;
header: string;
sender: string[];
meta: string;
time: string;
inlineStatus: string;
body: string[];
toolbar: string[];
toolbarButton: string[];
footer: string;
};
};
compact: {
true: {};
};
}, {
root: string[];
gutter: string[];
avatarSlot: string[];
continuationTime: string[];
content: string[];
header: string[];
sender: string[];
senderBadges: string[];
meta: string[];
time: string[];
inlineStatus: string[];
body: string[];
searchMatch: string[];
embedded: string[];
attachments: string[];
footer: string[];
toolbar: string[];
toolbarButton: string[];
}>>;
type MessageItemVariantProps = VariantProps<typeof messageItem>;
//#endregion
//#region src/components/message-item/message-item-root.d.ts
type MessageItemProps = useRender.ComponentProps<"div"> & Pick<MessageItemVariantProps, "compact">;
export declare function MessageItem({ className, compact, render, ...props }: MessageItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-item/message-item-gutter.d.ts
type MessageItemGutterProps = useRender.ComponentProps<"div">;
export declare function MessageItemGutter({ className, render, ...props }: MessageItemGutterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemAvatarSlotProps = useRender.ComponentProps<"div">;
export declare function MessageItemAvatarSlot({ className, render, ...props }: MessageItemAvatarSlotProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemContinuationTimeProps = useRender.ComponentProps<"span">;
/** Left-gutter hover clock for continuation rows. Pass 24h `HH:MM` (no AM/PM). */
export declare function MessageItemContinuationTime({ className, render, ...props }: MessageItemContinuationTimeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-item/message-item-content.d.ts
type MessageItemContentProps = useRender.ComponentProps<"div">;
export declare function MessageItemContent({ className, render, ...props }: MessageItemContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemBodyProps = useRender.ComponentProps<"div">;
export declare function MessageItemBody({ className, render, ...props }: MessageItemBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemSearchMatchProps = useRender.ComponentProps<"mark">;
export declare function MessageItemSearchMatch({ className, render, ...props }: MessageItemSearchMatchProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemEmbeddedProps = useRender.ComponentProps<"div">;
export declare function MessageItemEmbedded({ className, render, ...props }: MessageItemEmbeddedProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemAttachmentsProps = useRender.ComponentProps<"div">;
export declare function MessageItemAttachments({ className, render, ...props }: MessageItemAttachmentsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemFooterProps = useRender.ComponentProps<"div">;
export declare function MessageItemFooter({ className, render, ...props }: MessageItemFooterProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-item/message-item-header.d.ts
type MessageItemHeaderProps = useRender.ComponentProps<"div">;
export declare function MessageItemHeader({ className, render, ...props }: MessageItemHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemSenderProps = useRender.ComponentProps<"span">;
export declare function MessageItemSender({ className, render, ...props }: MessageItemSenderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemSenderButtonProps = useRender.ComponentProps<"button">;
export declare function MessageItemSenderButton({ className, render, ...props }: MessageItemSenderButtonProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemSenderBadgesProps = useRender.ComponentProps<"span">;
export declare function MessageItemSenderBadges({ className, render, ...props }: MessageItemSenderBadgesProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemMetaProps = useRender.ComponentProps<"span">;
export declare function MessageItemMeta({ className, render, ...props }: MessageItemMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemTimeProps = useRender.ComponentProps<"span">;
export declare function MessageItemTime({ className, render, ...props }: MessageItemTimeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemInlineStatusProps = useRender.ComponentProps<"span">;
export declare function MessageItemInlineStatus({ className, render, ...props }: MessageItemInlineStatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-item/message-item-toolbar.d.ts
type MessageItemToolbarProps = useRender.ComponentProps<"div">;
export declare function MessageItemToolbar({ className, render, ...props }: MessageItemToolbarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemToolbarButtonProps = useRender.ComponentProps<"button"> & {
active?: boolean;
};
export declare function MessageItemToolbarButton({ active, className, render, ...props }: MessageItemToolbarButtonProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-item/message-footer.d.ts
type MessageItemBadgeStatus = "read" | "unread";
type MessageItemBadgeProps = useRender.ComponentProps<"span"> & {
status?: MessageItemBadgeStatus;
};
export declare function MessageItemBadge({ className, status, ...props }: MessageItemBadgeProps): import("react").JSX.Element;
type MessageItemBadgeSeparatorProps = useRender.ComponentProps<"span">;
export declare function MessageItemBadgeSeparator({ className, render, ...props }: MessageItemBadgeSeparatorProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemSavedIndicatorElevation = "none" | "xs" | "sm";
type MessageItemSavedIndicatorProps = useRender.ComponentProps<"span"> & {
/**
* Shadow elevation. The default `"none"` renders the passive state-marker
* form (white surface + border, no shadow); `"xs"`/`"sm"` opt into
* `shadow-raft-xs`/`shadow-raft-sm` for callers that need a raised badge.
*/
elevation?: MessageItemSavedIndicatorElevation;
/**
* Square icon-only affordance. Replaces the old `data-icon-only`
* attribute contract with an explicit prop.
*/
iconOnly?: boolean;
};
export declare function MessageItemSavedIndicator({ className, elevation, iconOnly, render, ...props }: MessageItemSavedIndicatorProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageItemReadReceiptProps = useRender.ComponentProps<"span">;
export declare function MessageItemReadReceipt({ className, render, ...props }: MessageItemReadReceiptProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-item/message-reaction.d.ts
type MessageReactionChipProps = Omit<StyledProps<Toggle.Props>, "type">;
export declare function MessageReactionChip({ className, ...props }: MessageReactionChipProps): import("react").JSX.Element;
type MessageReactionErrorIndicatorProps = useRender.ComponentProps<"span">;
export declare function MessageReactionErrorIndicator({ className, render, ...props }: MessageReactionErrorIndicatorProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionGlyphProps = useRender.ComponentProps<"span">;
export declare function MessageReactionGlyph({ className, render, ...props }: MessageReactionGlyphProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionCountProps = useRender.ComponentProps<"span">;
export declare function MessageReactionCount({ children, className, render, ...props }: MessageReactionCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionAddButtonProps = useRender.ComponentProps<"button">;
export declare function MessageReactionAddButton({ className, render, ...props }: MessageReactionAddButtonProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionQuickRowProps = useRender.ComponentProps<"div">;
export declare function MessageReactionQuickRow({ className, render, ...props }: MessageReactionQuickRowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionQuickButtonProps = useRender.ComponentProps<"button">;
export declare function MessageReactionQuickButton({ className, render, ...props }: MessageReactionQuickButtonProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionPickerStaticProps = useRender.ComponentProps<"div">;
export declare function MessageReactionPickerStatic({ className, render, ...props }: MessageReactionPickerStaticProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionPickerContentProps = DropdownMenuContentProps;
export declare function MessageReactionPickerContent({ className, ...props }: MessageReactionPickerContentProps): import("react").JSX.Element;
type MessageReactionTooltipContentProps = TooltipContentProps;
export declare function MessageReactionTooltipContent({ className, ...props }: MessageReactionTooltipContentProps): import("react").JSX.Element;
type MessageReactionTooltipNamesProps = useRender.ComponentProps<"span">;
export declare function MessageReactionTooltipNames({ className, render, ...props }: MessageReactionTooltipNamesProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionTooltipNameProps = useRender.ComponentProps<"span">;
export declare function MessageReactionTooltipName({ className, render, ...props }: MessageReactionTooltipNameProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionTooltipNameTextProps = useRender.ComponentProps<"span">;
export declare function MessageReactionTooltipNameText({ className, render, ...props }: MessageReactionTooltipNameTextProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionTooltipSeparatorProps = useRender.ComponentProps<"span">;
export declare function MessageReactionTooltipSeparator({ className, render, ...props }: MessageReactionTooltipSeparatorProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReactionTooltipMetaProps = useRender.ComponentProps<"span">;
export declare function MessageReactionTooltipMeta({ className, render, ...props }: MessageReactionTooltipMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-item/message-reference.recipe.d.ts
/** Chip variants the public `MessageReferenceChip` prop accepts. */
type MessageReferenceChipVariant = "accent" | "muted" | "info" | "link";
/** Visual variants the public `MessageReferenceText` prop accepts. */
type MessageReferenceTextVariant = "primary" | "secondary";
//#endregion
//#region src/components/message-item/message-reference.d.ts
type SpanProps$2 = useRender.ComponentProps<"span">;
type MessageReferenceTextProps = SpanProps$2 & {
variant?: MessageReferenceTextVariant;
};
export declare function MessageReferenceText({ className, render, variant, ...props }: MessageReferenceTextProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReferenceIndicatorProps = useRender.ComponentProps<"span">;
export declare function MessageReferenceIndicator({ className, render, ...props }: MessageReferenceIndicatorProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReferenceChipProps = SpanProps$2 & {
variant?: MessageReferenceChipVariant;
};
export declare function MessageReferenceChip({ className, render, variant, ...props }: MessageReferenceChipProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReferenceLabelProps = useRender.ComponentProps<"span">;
export declare function MessageReferenceLabel({ className, render, ...props }: MessageReferenceLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReferenceBadgeProps = useRender.ComponentProps<"span">;
export declare function MessageReferenceBadge({ className, render, ...props }: MessageReferenceBadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReferencePendingProps = SpanProps$2;
export declare function MessageReferencePending({ className, render, ...props }: MessageReferencePendingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageReferenceUnavailableProps = SpanProps$2;
export declare function MessageReferenceUnavailable({ className, render, ...props }: MessageReferenceUnavailableProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-item/message-multi-select.d.ts
type MessageMultiSelectProps = useRender.ComponentProps<"div">;
export declare function MessageMultiSelect({ className, render, ...props }: MessageMultiSelectProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageMultiSelectToolbarProps = useRender.ComponentProps<"div">;
/** Shared select-mode toolbar shell. Consumers compose the count and actions as children. */
export declare function MessageMultiSelectToolbar({ className, render, ...props }: MessageMultiSelectToolbarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageMultiSelectCheckboxProps = CheckboxProps;
export declare function MessageMultiSelectCheckbox({ className, ...props }: MessageMultiSelectCheckboxProps): import("react").JSX.Element;
//#endregion
//#region src/components/message-item/message-text-selection-toolbar.d.ts
type MessageTextSelectionToolbarProps = StyledProps<Toolbar.Root.Props>;
export declare function MessageTextSelectionToolbar({ className, ...props }: MessageTextSelectionToolbarProps): import("react").JSX.Element;
type MessageTextSelectionToolbarButtonProps = StyledProps<Toolbar.Button.Props>;
export declare function MessageTextSelectionToolbarButton({ className, ...props }: MessageTextSelectionToolbarButtonProps): import("react").JSX.Element;
type MessageTextSelectionToolbarSeparatorProps = StyledProps<Toolbar.Separator.Props>;
export declare function MessageTextSelectionToolbarSeparator({ className, ...props }: MessageTextSelectionToolbarSeparatorProps): import("react").JSX.Element;
//#endregion
//#region src/components/system-message/system-message.d.ts
type SystemMessageProps = useRender.ComponentProps<"div">;
export declare function SystemMessage({ className, render, ...props }: SystemMessageProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SystemMessageTimeProps = useRender.ComponentProps<"span">;
export declare function SystemMessageTime({ className, render, ...props }: SystemMessageTimeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SystemMessageContentProps = useRender.ComponentProps<"span">;
export declare function SystemMessageContent({ children, className, render, title, ...props }: SystemMessageContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SystemMessageGroupProps = Omit<ComponentProps<typeof Collapsible.Root>, "className"> & {
className?: string;
};
export declare function SystemMessageGroup({ className, render, ...props }: SystemMessageGroupProps): import("react").JSX.Element;
type SystemMessageGroupHeaderProps = useRender.ComponentProps<"div">;
export declare function SystemMessageGroupHeader({ className, render, ...props }: SystemMessageGroupHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SystemMessageGroupDisclosureProps = useRender.ComponentProps<"button">;
export declare function SystemMessageGroupDisclosure({ className, render, ...props }: SystemMessageGroupDisclosureProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SystemMessageGroupSummaryProps = useRender.ComponentProps<"span">;
export declare function SystemMessageGroupSummary({ className, render, ...props }: SystemMessageGroupSummaryProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SystemMessageGroupChevronProps = useRender.ComponentProps<"svg">;
export declare function SystemMessageGroupChevron({ className, render, ...props }: SystemMessageGroupChevronProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SystemMessageGroupPanelProps = Omit<ComponentProps<typeof Collapsible.Panel>, "className"> & {
className?: string;
};
export declare function SystemMessageGroupPanel({ className, render, ...props }: SystemMessageGroupPanelProps): import("react").JSX.Element;
//#endregion
//#region src/components/message-quoted-preview/message-quoted-preview.d.ts
type DivProps$2 = useRender.ComponentProps<"div">;
type SpanProps$1 = useRender.ComponentProps<"span">;
type MessageQuotedPreviewProps = DivProps$2;
export declare function MessageQuotedPreview({ className, render, ...props }: MessageQuotedPreviewProps): import("react").JSX.Element;
type MessageQuotedPreviewContentProps = DivProps$2;
export declare function MessageQuotedPreviewContent({ className, render, ...props }: MessageQuotedPreviewContentProps): import("react").JSX.Element;
type MessageQuotedPreviewHeaderProps = DivProps$2;
export declare function MessageQuotedPreviewHeader({ className, render, ...props }: MessageQuotedPreviewHeaderProps): import("react").JSX.Element;
type MessageQuotedPreviewChannelProps = SpanProps$1;
export declare function MessageQuotedPreviewChannel({ className, render, ...props }: MessageQuotedPreviewChannelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewThreadProps = SpanProps$1;
export declare function MessageQuotedPreviewThread({ className, render, ...props }: MessageQuotedPreviewThreadProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewAuthorProps = SpanProps$1;
export declare function MessageQuotedPreviewAuthor({ className, render, ...props }: MessageQuotedPreviewAuthorProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewAuthorNameProps = SpanProps$1;
export declare function MessageQuotedPreviewAuthorName({ className, render, ...props }: MessageQuotedPreviewAuthorNameProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewAuthorMetaProps = SpanProps$1;
export declare function MessageQuotedPreviewAuthorMeta({ className, render, ...props }: MessageQuotedPreviewAuthorMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewTimestampProps = SpanProps$1;
export declare function MessageQuotedPreviewTimestamp({ className, render, ...props }: MessageQuotedPreviewTimestampProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewTextProps = DivProps$2;
export declare function MessageQuotedPreviewText({ className, render, ...props }: MessageQuotedPreviewTextProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewAttachmentsProps = DivProps$2;
export declare function MessageQuotedPreviewAttachments({ className, render, ...props }: MessageQuotedPreviewAttachmentsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewAttachmentProps = SpanProps$1;
export declare function MessageQuotedPreviewAttachment({ className, render, ...props }: MessageQuotedPreviewAttachmentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageQuotedPreviewLoadingProps = DivProps$2;
export declare function MessageQuotedPreviewLoading({ className, render, ...props }: MessageQuotedPreviewLoadingProps): import("react").JSX.Element;
type MessageQuotedPreviewUnavailableProps = DivProps$2;
export declare function MessageQuotedPreviewUnavailable({ className, render, ...props }: MessageQuotedPreviewUnavailableProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-replies/message-replies.d.ts
type MessageRepliesProps = useRender.ComponentProps<"button">;
export declare function MessageReplies({ className, render, ...props }: MessageRepliesProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageRepliesSummaryProps = useRender.ComponentProps<"span">;
export declare function MessageRepliesSummary({ className, render, ...props }: MessageRepliesSummaryProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageRepliesSummaryItemProps = useRender.ComponentProps<"span">;
export declare function MessageRepliesSummaryItem({ className, render, ...props }: MessageRepliesSummaryItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageRepliesItemProps = useRender.ComponentProps<"span">;
export declare function MessageRepliesItem({ className, render, ...props }: MessageRepliesItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageRepliesItemSenderProps = useRender.ComponentProps<"span">;
export declare function MessageRepliesItemSender({ className, render, ...props }: MessageRepliesItemSenderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageRepliesItemContentProps = useRender.ComponentProps<"span">;
export declare function MessageRepliesItemContent({ className, render, ...props }: MessageRepliesItemContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageRepliesItemTimeProps = useRender.ComponentProps<"time">;
export declare function MessageRepliesItemTime({ className, render, ...props }: MessageRepliesItemTimeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-action-card/message-action-card.d.ts
export declare function MessageActionCard({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").JSX.Element;
export declare function MessageActionCardContent({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").JSX.Element;
export declare function MessageActionCardHeader({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").JSX.Element;
export declare function MessageActionCardHeaderStatus({ className, render, ...props }: useRender.ComponentProps<"span">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardProperties({ className, render, ...props }: useRender.ComponentProps<"dl">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardProperty({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardPropertyLabel({ className, render, ...props }: useRender.ComponentProps<"dt">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardPropertyValue({ className, render, ...props }: useRender.ComponentProps<"dd">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardScopeList({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardScopeListLabel({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardScope({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardScopeName({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardScopeDescription({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardHint({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardCompletion({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageActionCardActions({ className, render, ...props }: useRender.ComponentProps<"div">): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageActionCardProps = useRender.ComponentProps<"div">;
type MessageActionCardContentProps = useRender.ComponentProps<"div">;
type MessageActionCardHeaderProps = useRender.ComponentProps<"div">;
type MessageActionCardHeaderStatusProps = useRender.ComponentProps<"span">;
type MessageActionCardPropertiesProps = useRender.ComponentProps<"dl">;
type MessageActionCardPropertyProps = useRender.ComponentProps<"div">;
type MessageActionCardPropertyLabelProps = useRender.ComponentProps<"dt">;
type MessageActionCardPropertyValueProps = useRender.ComponentProps<"dd">;
type MessageActionCardScopeListProps = useRender.ComponentProps<"div">;
type MessageActionCardScopeListLabelProps = useRender.ComponentProps<"div">;
type MessageActionCardScopeProps = useRender.ComponentProps<"div">;
type MessageActionCardScopeNameProps = useRender.ComponentProps<"div">;
type MessageActionCardScopeDescriptionProps = useRender.ComponentProps<"div">;
type MessageActionCardHintProps = useRender.ComponentProps<"div">;
type MessageActionCardCompletionProps = useRender.ComponentProps<"div">;
type MessageActionCardActionsProps = useRender.ComponentProps<"div">;
//#endregion
//#region src/components/message-attachment/message-attachment.d.ts
type MessageAttachmentGroupProps = useRender.ComponentProps<"div">;
export declare function MessageAttachmentGroup({ className, render, ...props }: MessageAttachmentGroupProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentCardProps = useRender.ComponentProps<"div">;
export declare function MessageAttachmentCard({ className, render, ...props }: MessageAttachmentCardProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentTitleProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentTitle({ className, render, ...props }: MessageAttachmentTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentMetaProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentMeta({ className, render, ...props }: MessageAttachmentMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentMetaStartProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentMetaStart({ className, render, ...props }: MessageAttachmentMetaStartProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentMetaEndProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentMetaEnd({ className, render, ...props }: MessageAttachmentMetaEndProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentSummaryProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentSummary({ className, render, ...props }: MessageAttachmentSummaryProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentCommentSummaryProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentCommentSummary({ className, render, ...props }: MessageAttachmentCommentSummaryProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentDiffSummaryProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentDiffSummary({ className, render, ...props }: MessageAttachmentDiffSummaryProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentDiffAdditionProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentDiffAddition({ className, render, ...props }: MessageAttachmentDiffAdditionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentDiffDeletionProps = useRender.ComponentProps<"span">;
export declare function MessageAttachmentDiffDeletion({ className, render, ...props }: MessageAttachmentDiffDeletionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageAttachmentActionProps = useRender.ComponentProps<"button">;
export declare function MessageAttachmentAction({ className, render, ...props }: MessageAttachmentActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-attachment/message-image-gallery.d.ts
type MessageImageGalleryProps = useRender.ComponentProps<"div">;
export declare function MessageImageGallery({ className, render, ...props }: MessageImageGalleryProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageImageGalleryItemProps = useRender.ComponentProps<"div">;
export declare function MessageImageGalleryItem({ className, render, ...props }: MessageImageGalleryItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageImageGalleryMediaProps = useRender.ComponentProps<"div">;
export declare function MessageImageGalleryMedia({ className, render, ...props }: MessageImageGalleryMediaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageImageGalleryOverlayProps = useRender.ComponentProps<"div">;
export declare function MessageImageGalleryOverlay({ className, render, ...props }: MessageImageGalleryOverlayProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageImageGalleryActionProps = useRender.ComponentProps<"button">;
type MessageImageGalleryPreviewProps = useRender.ComponentProps<"button">;
export declare function MessageImageGalleryPreview({ className, render, ...props }: MessageImageGalleryPreviewProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageImageGalleryAction({ className, render, ...props }: MessageImageGalleryActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-attachment/message-video-preview.d.ts
type MessageVideoPreviewProps = useRender.ComponentProps<"div">;
export declare function MessageVideoPreview({ className, render, ...props }: MessageVideoPreviewProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageVideoPreviewMediaProps = useRender.ComponentProps<"video">;
export declare function MessageVideoPreviewMedia({ className, render, ...props }: MessageVideoPreviewMediaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageVideoPreviewFallbackProps = useRender.ComponentProps<"div">;
export declare function MessageVideoPreviewFallback({ className, render, ...props }: MessageVideoPreviewFallbackProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageVideoPreviewFailureContentProps = useRender.ComponentProps<"div">;
export declare function MessageVideoPreviewFailureContent({ className, render, ...props }: MessageVideoPreviewFailureContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageVideoPreviewFailureIconProps = useRender.ComponentProps<"span">;
export declare function MessageVideoPreviewFailureIcon({ className, render, ...props }: MessageVideoPreviewFailureIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageVideoPreviewFailureTitleProps = useRender.ComponentProps<"span">;
export declare function MessageVideoPreviewFailureTitle({ className, render, ...props }: MessageVideoPreviewFailureTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageVideoPreviewFailureActionProps = useRender.ComponentProps<"button">;
export declare function MessageVideoPreviewFailureAction({ className, render, ...props }: MessageVideoPreviewFailureActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageVideoPreviewActionProps = useRender.ComponentProps<"button">;
export declare function MessageVideoPreviewAction({ className, render, ...props }: MessageVideoPreviewActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/message-embed/message-embed.d.ts
type DivProps$1 = useRender.ComponentProps<"div">;
export declare function MessageEmbed({ className, render, ...props }: DivProps$1): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageEmbedHeader({ className, render, ...props }: DivProps$1): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageEmbedContent({ className, render, ...props }: DivProps$1): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare function MessageEmbedFooter({ className, render, ...props }: DivProps$1): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageEmbedProps = DivProps$1;
type MessageEmbedHeaderProps = DivProps$1;
type MessageEmbedContentProps = DivProps$1;
type MessageEmbedFooterProps = DivProps$1;
//#endregion
//#region src/components/message-forwarded-bundle/message-forwarded-bundle.d.ts
type DivProps = useRender.ComponentProps<"div">;
type SpanProps = useRender.ComponentProps<"span">;
type ButtonProps$1 = useRender.ComponentProps<"button">;
type ArticleProps = useRender.ComponentProps<"article">;
type MessageForwardedBundleProps = DivProps;
export declare function MessageForwardedBundle({ className, render, ...props }: MessageForwardedBundleProps): import("react").JSX.Element;
type MessageForwardedBundleHeaderProps = DivProps;
export declare function MessageForwardedBundleHeader({ className, render, ...props }: MessageForwardedBundleHeaderProps): import("react").JSX.Element;
type MessageForwardedBundleHeaderContentProps = DivProps;
export declare function MessageForwardedBundleHeaderContent({ className, render, ...props }: MessageForwardedBundleHeaderContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleHeaderLabelProps = SpanProps;
export declare function MessageForwardedBundleHeaderLabel({ className, render, ...props }: MessageForwardedBundleHeaderLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleHeaderCountProps = SpanProps;
export declare function MessageForwardedBundleHeaderCount({ className, render, ...props }: MessageForwardedBundleHeaderCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleItemsProps = DivProps & {
collapsed?: boolean;
};
export declare function MessageForwardedBundleItems({ className, collapsed, render, ...props }: MessageForwardedBundleItemsProps): import("react").JSX.Element;
type MessageForwardedBundleItemProps = ArticleProps;
export declare function MessageForwardedBundleItem({ className, render, ...props }: MessageForwardedBundleItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleItemMetaProps = DivProps;
export declare function MessageForwardedBundleItemMeta({ className, render, ...props }: MessageForwardedBundleItemMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleItemAuthorProps = SpanProps;
export declare function MessageForwardedBundleItemAuthor({ className, render, ...props }: MessageForwardedBundleItemAuthorProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleAttachmentsProps = DivProps;
export declare function MessageForwardedBundleAttachments({ className, render, ...props }: MessageForwardedBundleAttachmentsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleAttachmentProps = SpanProps;
export declare function MessageForwardedBundleAttachment({ className, render, ...props }: MessageForwardedBundleAttachmentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleAttachmentNameProps = SpanProps;
export declare function MessageForwardedBundleAttachmentName({ className, render, ...props }: MessageForwardedBundleAttachmentNameProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleAttachmentMetaProps = SpanProps;
export declare function MessageForwardedBundleAttachmentMeta({ className, render, ...props }: MessageForwardedBundleAttachmentMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleFooterProps = DivProps;
export declare function MessageForwardedBundleFooter({ className, render, ...props }: MessageForwardedBundleFooterProps): import("react").JSX.Element;
type MessageForwardedBundleSourceProps = ButtonProps$1;
export declare function MessageForwardedBundleSource({ className, render, ...props }: MessageForwardedBundleSourceProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleSourceLabelProps = SpanProps;
export declare function MessageForwardedBundleSourceLabel({ className, render, ...props }: MessageForwardedBundleSourceLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageForwardedBundleFooterActionProps = ButtonProps$1;
export declare function MessageForwardedBundleFooterAction({ className, render, ...props }: MessageForwardedBundleFooterActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/progress/progress.d.ts
declare const progress: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string[];
label: string[];
value: string[];
track: string[];
};
elegant: {
root: string[];
label: string[];
value: string[];
track: string[];
indicator: string[];
};
};
variant: {
primary: {
root: string[];
};
information: {
root: string[];
};
accent: {
root: string[];
};
success: {
root: string[];
};
warning: {
root: string[];
};
danger: {
root: string[];
};
};
size: {
sm: {};
md: {};
lg: {};
};
}, {
root: string[];
header: string[];
label: string[];
value: string[];
track: string[];
indicator: string[];
}, undefined, {
theme: {
brutal: {
root: string[];
label: string[];
value: string[];
track: string[];
};
elegant: {
root: string[];
label: string[];
value: string[];
track: string[];
indicator: string[];
};
};
variant: {
primary: {
root: string[];
};
information: {
root: string[];
};
accent: {
root: string[];
};
success: {
root: string[];
};
warning: {
root: string[];
};
danger: {
root: string[];
};
};
size: {
sm: {};
md: {};
lg: {};
};
}, {
root: string[];
header: string[];
label: string[];
value: string[];
track: string[];
indicator: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string[];
label: string[];
value: string[];
track: string[];
};
elegant: {
root: string[];
label: string[];
value: string[];
track: string[];
indicator: string[];
};
};
variant: {
primary: {
root: string[];
};
information: {
root: string[];
};
accent: {
root: string[];
};
success: {
root: string[];
};
warning: {
root: string[];
};
danger: {
root: string[];
};
};
size: {
sm: {};
md: {};
lg: {};
};
}, {
root: string[];
header: string[];
label: string[];
value: string[];
track: string[];
indicator: string[];
}>>;
type ProgressProps = StyledProps<Progress$1.Root.Props> & Omit<VariantProps<typeof progress>, "theme">;
export declare function Progress({ size, variant, className, ...props }: ProgressProps): import("react").JSX.Element;
type ProgressHeaderProps = ComponentPropsWithRef<"div">;
export declare function ProgressHeader({ className, ...props }: ProgressHeaderProps): import("react").JSX.Element;
type ProgressLabelProps = StyledProps<Progress$1.Label.Props>;
export declare function ProgressLabel({ className, ...props }: ProgressLabelProps): import("react").JSX.Element;
type ProgressValueProps = StyledProps<Progress$1.Value.Props>;
export declare function ProgressValue({ className, ...props }: ProgressValueProps): import("react").JSX.Element;
type ProgressTrackProps = StyledProps<Progress$1.Track.Props>;
export declare function ProgressTrack({ className, ...props }: ProgressTrackProps): import("react").JSX.Element;
type ProgressIndicatorProps = StyledProps<Progress$1.Indicator.Props>;
export declare function ProgressIndicator({ className, ...props }: ProgressIndicatorProps): import("react").JSX.Element;
//#endregion
//#region src/components/message-translation/message-translation.d.ts
type MessageItemTranslationOriginalProps = MarkdownBlockquoteProps;
export declare function MessageItemTranslationOriginal({ className, ...props }: MessageItemTranslationOriginalProps): import("react").JSX.Element;
type MessageItemTranslationOriginalLabelProps = ComponentProps<"div">;
export declare function MessageItemTranslationOriginalLabel({ className, ...props }: MessageItemTranslationOriginalLabelProps): import("react").JSX.Element;
type MessageItemTranslationStatusProps = ComponentProps<"div">;
export declare function MessageItemTranslationStatus({ className, ...props }: MessageItemTranslationStatusProps): import("react").JSX.Element;
type MessageItemTranslationProgressTrackProps = ProgressTrackProps;
export declare function MessageItemTranslationProgressTrack({ className, ...props }: MessageItemTranslationProgressTrackProps): import("react").JSX.Element;
type MessageItemTranslationFailedStatusProps = ComponentProps<"div">;
export declare function MessageItemTranslationFailedStatus({ className, ...props }: MessageItemTranslationFailedStatusProps): import("react").JSX.Element;
type MessageItemTranslationActionProps = ComponentProps<"button">;
export declare function MessageItemTranslationAction({ className, ...props }: MessageItemTranslationActionProps): import("react").JSX.Element;
type MessageItemTranslationRetryActionProps = ComponentProps<"button">;
export declare function MessageItemTranslationRetryAction({ className, ...props }: MessageItemTranslationRetryActionProps): import("react").JSX.Element;
//#endregion
//#region src/components/message-list/message-list.d.ts
type MessageListProps = useRender.ComponentProps<"div"> & {
rootClassName?: string;
};
export declare function MessageList({ children, className, render, rootClassName, ...props }: MessageListProps): import("react").JSX.Element;
//#endregion
//#region src/components/message-list/message-list-markers.d.ts
type MessageListDateDividerProps = useRender.ComponentProps<"div">;
export declare function MessageListDateDivider({ children, className, render, ...props }: MessageListDateDividerProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageListNoticeProps = useRender.ComponentProps<"div"> & {
tone?: "faint" | "muted";
};
export declare function MessageListNotice({ className, render, tone, ...props }: MessageListNoticeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type MessageListHistoryLimitedProps = useRender.ComponentProps<"span">;
export declare function MessageListHistoryLimited({ className, render, ...props }: MessageListHistoryLimitedProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/text/text.d.ts
declare const heading: import("tailwind-variants/lite").TVReturnType<{
level: {
1: string[];
2: string[];
3: string[];
4: string[];
5: string[];
6: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined, string[], {
level: {
1: string[];
2: string[];
3: string[];
4: string[];
5: string[];
6: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined, import("tailwind-variants/lite").TVReturnTypeLike<{
level: {
1: string[];
2: string[];
3: string[];
4: string[];
5: string[];
6: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined>>;
declare const sans: import("tailwind-variants/lite").TVReturnType<{
size: {
large: string[];
body: string[];
small: string[];
caption: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined, string[], {
size: {
large: string[];
body: string[];
small: string[];
caption: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined, import("tailwind-variants/lite").TVReturnTypeLike<{
size: {
large: string[];
body: string[];
small: string[];
caption: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined>>;
declare const mono: import("tailwind-variants/lite").TVReturnType<{
size: {
code: string[];
meta: string[];
eyebrow: string[];
tabular: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined, string[], {
size: {
code: string[];
meta: string[];
eyebrow: string[];
tabular: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined, import("tailwind-variants/lite").TVReturnTypeLike<{
size: {
code: string[];
meta: string[];
eyebrow: string[];
tabular: string[];
};
variant: {
default: string[];
primary: string[];
information: string[];
muted: string[];
placeholder: string[];
accent: string[];
success: string[];
warning: string[];
danger: string[];
};
}, undefined>>;
type TextHeadingProps = useRender.ComponentProps<"h1"> & VariantProps<typeof heading>;
export declare function TextHeading({ level, variant, className, render, ...props }: TextHeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TextSansProps = useRender.ComponentProps<"p"> & VariantProps<typeof sans>;
export declare function TextSans({ size, variant, className, render, ...props }: TextSansProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TextMonoProps = useRender.ComponentProps<"p"> & VariantProps<typeof mono>;
export declare function TextMono({ size, variant, className, render, ...props }: TextMonoProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export declare const Text: {
Heading: typeof TextHeading;
Sans: typeof TextSans;
Mono: typeof TextMono;
};
//#endregion
//#region src/components/scroll-area/scroll-area.d.ts
type ScrollAreaProps = StyledProps<ScrollArea$1.Root.Props>;
export declare function ScrollArea({ className, ...props }: ScrollAreaProps): import("react").JSX.Element;
type ScrollAreaViewportProps = StyledProps<ScrollArea$1.Viewport.Props>;
export declare function ScrollAreaViewport({ className, ...props }: ScrollAreaViewportProps): import("react").JSX.Element;
type ScrollAreaContentProps = StyledProps<ScrollArea$1.Content.Props>;
export declare function ScrollAreaContent({ className, ...props }: ScrollAreaContentProps): import("react").JSX.Element;
type ScrollAreaScrollbarProps = StyledProps<ScrollArea$1.Scrollbar.Props>;
export declare function ScrollAreaScrollbar({ className, orientation, ...props }: ScrollAreaScrollbarProps): import("react").JSX.Element;
type ScrollAreaThumbProps = StyledProps<ScrollArea$1.Thumb.Props>;
export declare function ScrollAreaThumb({ className, ...props }: ScrollAreaThumbProps): import("react").JSX.Element;
type ScrollAreaCornerProps = StyledProps<ScrollArea$1.Corner.Props>;
export declare function ScrollAreaCorner({ className, ...props }: ScrollAreaCornerProps): import("react").JSX.Element;
//#endregion
//#region src/components/spinner/spinner.d.ts
declare const spinner: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {};
elegant: {};
};
size: {
xs: {};
sm: {};
md: {};
lg: {};
};
variant: {
default: {};
inverse: {};
};
}, {
root: string[];
ring: string;
}, undefined, {
theme: {
brutal: {};
elegant: {};
};
size: {
xs: {};
sm: {};
md: {};
lg: {};
};
variant: {
default: {};
inverse: {};
};
}, {
root: string[];
ring: string;
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {};
elegant: {};
};
size: {
xs: {};
sm: {};
md: {};
lg: {};
};
variant: {
default: {};
inverse: {};
};
}, {
root: string[];
ring: string;
}>>;
type SpinnerProps = WithoutChildren<useRender.ComponentProps<"span">> & Omit<VariantProps<typeof spinner>, "theme">;
export declare function Spinner({ size, variant, className, render, ...props }: SpinnerProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/file-preview/file-preview.d.ts
type FilePreviewProps = useRender.ComponentProps<"span">;
export declare function FilePreview({ className, render, ...props }: FilePreviewProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type FilePreviewDocumentProps = useRender.ComponentProps<"span">;
export declare function FilePreviewDocument({ children, className, render, ...props }: FilePreviewDocumentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type FilePreviewFileProps = useRender.ComponentProps<"span">;
export declare function FilePreviewFile({ children, className, render, ...props }: FilePreviewFileProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type FilePreviewCodeProps = useRender.ComponentProps<"span">;
export declare function FilePreviewCode({ children, className, render, ...props }: FilePreviewCodeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type FilePreviewBadgeColor = "rose" | "blue" | "amber" | "emerald" | "violet" | "neutral";
/** Semantic file kinds mapped onto `FilePreviewBadgeColor` (not a `tv` variant). */
type FilePreviewBadgeType = "pdf" | "doc" | "docx" | "txt" | "md" | "csv" | "json" | "zip" | "html" | "code" | "img" | "png" | "jpg" | "jpeg" | "gif" | "webp" | "svg" | "mp4" | "mov";
type FilePreviewBadgeProps = useRender.ComponentProps<"span"> & ({
type: FilePreviewBadgeType;
color?: never;
} | {
type?: never;
color?: FilePreviewBadgeColor;
});
export declare function FilePreviewBadge({ className, render, color, type, ...props }: FilePreviewBadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type FilePreviewMediaProps = useRender.ComponentProps<"span">;
export declare function FilePreviewMedia({ children, className, render, ...props }: FilePreviewMediaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/files/files.d.ts
type FileTag = "button" | "div" | "img" | "section" | "span";
type DataAttributes = Record<`data-${string}`, string | undefined>;
type FileSlotProps<Tag extends FileTag> = useRender.ComponentProps<Tag> & DataAttributes;
export type FilesPanelProps = FileSlotProps<"section">;
export declare function FilesPanel(props: FilesPanelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FilesViewportProps = FileSlotProps<"div">;
export declare function FilesViewport(props: FilesViewportProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FilesListProps = FileSlotProps<"div">;
export declare function FilesList(props: FilesListProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileRowProps = FileSlotProps<"div">;
export declare function FileRow(props: FileRowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileRowOpenProps = FileSlotProps<"button">;
export declare function FileRowOpen(props: FileRowOpenProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileThumbnailProps = FileSlotProps<"span">;
export declare function FileThumbnail(props: FileThumbnailProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileImageProps = FileSlotProps<"img"> & {
fit?: "contain" | "cover";
};
export declare function FileImage({ fit, ...props }: FileImageProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileContentProps = FileSlotProps<"span">;
export declare function FileContent(props: FileContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileNameProps = FileSlotProps<"span">;
export declare function FileName(props: FileNameProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileMetaProps = FileSlotProps<"span">;
export declare function FileMeta(props: FileMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileMetaItemProps = FileSlotProps<"span">;
export declare function FileMetaItem(props: FileMetaItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileActionsProps = FileSlotProps<"span">;
export declare function FileActions(props: FileActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type FileActionProps = Omit<ButtonProps, "variant" | "size"> & Pick<Partial<ButtonProps>, "variant" | "size">;
export declare function FileAction({ variant, size, ...props }: FileActionProps): import("react").JSX.Element;
//#endregion
//#region src/components/composer/composer.d.ts
type ComposerProps = useRender.ComponentProps<"div">;
export declare function Composer({ className, render, ...props }: ComposerProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerInputProps = useRender.ComponentProps<"textarea">;
export declare function ComposerInput({ className, render, ...props }: ComposerInputProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerToolbarProps = useRender.ComponentProps<"div">;
export declare function ComposerToolbar({ className, render, ...props }: ComposerToolbarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerActionsProps = useRender.ComponentProps<"div">;
export declare function ComposerActions({ className, render, ...props }: ComposerActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerMetaProps = useRender.ComponentProps<"div">;
export declare function ComposerMeta({ className, render, ...props }: ComposerMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerIconButtonProps = Omit<ButtonProps, "className" | "size" | "variant"> & {
className?: string;
};
export declare function ComposerIconButton({ className, ...props }: ComposerIconButtonProps): import("react").JSX.Element;
type ComposerSubmitProps = Omit<ButtonProps, "variant">;
export declare function ComposerSubmit({ type, ...props }: ComposerSubmitProps): import("react").JSX.Element;
//#endregion
//#region src/components/composer/composer-attachments.d.ts
type ComposerAttachmentsProps = useRender.ComponentProps<"div">;
export declare function ComposerAttachments({ className, render, ...props }: ComposerAttachmentsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentProps = useRender.ComponentProps<"div">;
export declare function ComposerAttachment({ className, render, ...props }: ComposerAttachmentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentFileProps = useRender.ComponentProps<"span">;
export declare function ComposerAttachmentFile({ className, render, ...props }: ComposerAttachmentFileProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentImageProps = useRender.ComponentProps<"span">;
export declare function ComposerAttachmentImage({ className, render, ...props }: ComposerAttachmentImageProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentBodyProps = useRender.ComponentProps<"span">;
export declare function ComposerAttachmentBody({ className, render, ...props }: ComposerAttachmentBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentTitleProps = useRender.ComponentProps<"span">;
export declare function ComposerAttachmentTitle({ className, render, ...props }: ComposerAttachmentTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentMetaProps = useRender.ComponentProps<"span">;
export declare function ComposerAttachmentMeta({ className, render, ...props }: ComposerAttachmentMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentUploadingOverlayProps = useRender.ComponentProps<"span">;
export declare function ComposerAttachmentUploadingOverlay({ className, render, ...props }: ComposerAttachmentUploadingOverlayProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentUploadProgressBarProps = Omit<useRender.ComponentProps<"span">, "children"> & {
value: number;
};
export declare function ComposerAttachmentUploadProgressBar({ className, render, value, ...props }: ComposerAttachmentUploadProgressBarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentFailedOverlayProps = useRender.ComponentProps<"span">;
export declare function ComposerAttachmentFailedOverlay({ className, render, ...props }: ComposerAttachmentFailedOverlayProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerAttachmentRemoveProps = useRender.ComponentProps<"button">;
export declare function ComposerAttachmentRemove({ className, render, ...props }: ComposerAttachmentRemoveProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/composer/composer-attachments-scroll-area.d.ts
type ComposerAttachmentsScrollAreaProps = ComponentPropsWithoutRef<"div">;
export declare function ComposerAttachmentsScrollArea({ children, className, onMouseEnter, onMouseLeave, ...props }: ComposerAttachmentsScrollAreaProps): import("react").JSX.Element;
//#endregion
//#region src/components/composer/sortable-composer-attachments.d.ts
type SortableComposerAttachmentsProps = {
items: readonly string[];
onReorder: (items: string[]) => void;
children: ReactNode;
};
/** Wrap / flex-pack attachment reorder (mixed widths). */
export declare function SortableComposerAttachments(props: SortableComposerAttachmentsProps): import("react").JSX.Element;
/** Horizontal scroll strip reorder — wraps `ComposerAttachmentsScrollArea`. */
export declare function SortableComposerAttachmentsScroll(props: SortableComposerAttachmentsProps): import("react").JSX.Element;
type SortableComposerAttachmentProps = {
id: string;
label: string;
children: ReactNode;
};
/**
* Sized placeholder stays in the flex flow (opacity 0). DragOverlay is the
* pointer ghost — the root reads these `children` for it. Live draft reorder
* moves this slot to the drop index; wrap skips strategy transforms so siblings
* FLIP via layout instead of wrong gaps.
*/
export declare function SortableComposerAttachment({ id, label, children }: SortableComposerAttachmentProps): import("react").JSX.Element;
//#endregion
//#region src/components/composer/composer-drop-overlay.d.ts
type ComposerDropOverlayProps = useRender.ComponentProps<"div">;
export declare function ComposerDropOverlay({ className, render, ...props }: ComposerDropOverlayProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerDropOverlayLabelProps = useRender.ComponentProps<"span">;
export declare function ComposerDropOverlayLabel({ className, render, ...props }: ComposerDropOverlayLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerDropOverlayPromptProps = ComposerDropOverlayLabelProps;
export declare function ComposerDropOverlayPrompt({ children, ...props }: ComposerDropOverlayPromptProps): import("react").JSX.Element;
//#endregion
//#region src/components/composer/composer-suggestion-list.d.ts
declare const composerSuggestionList: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string;
groupLabel: string;
item: string[];
meta: string;
};
elegant: {
root: string[];
group: string;
groupLabel: string[];
item: string[];
meta: string;
};
};
separated: {
true: {
group: string;
};
false: {};
};
iconVariant: {
avatar: {};
framed: {};
auxiliary: {
icon: string;
};
inline: {
icon: string;
};
};
metaVariant: {
text: {
meta: string;
};
code: {
meta: string;
};
};
}, {
root: string;
group: never[];
groupLabel: string[];
item: string[];
content: string[];
icon: string[];
title: string[];
aside: string[];
meta: never[];
}, undefined, {
theme: {
brutal: {
root: string;
groupLabel: string;
item: string[];
meta: string;
};
elegant: {
root: string[];
group: string;
groupLabel: string[];
item: string[];
meta: string;
};
};
separated: {
true: {
group: string;
};
false: {};
};
iconVariant: {
avatar: {};
framed: {};
auxiliary: {
icon: string;
};
inline: {
icon: string;
};
};
metaVariant: {
text: {
meta: string;
};
code: {
meta: string;
};
};
}, {
root: string;
group: never[];
groupLabel: string[];
item: string[];
content: string[];
icon: string[];
title: string[];
aside: string[];
meta: never[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string;
groupLabel: string;
item: string[];
meta: string;
};
elegant: {
root: string[];
group: string;
groupLabel: string[];
item: string[];
meta: string;
};
};
separated: {
true: {
group: string;
};
false: {};
};
iconVariant: {
avatar: {};
framed: {};
auxiliary: {
icon: string;
};
inline: {
icon: string;
};
};
metaVariant: {
text: {
meta: string;
};
code: {
meta: string;
};
};
}, {
root: string;
group: never[];
groupLabel: string[];
item: string[];
content: string[];
icon: string[];
title: string[];
aside: string[];
meta: never[];
}>>;
type ComposerSuggestionListProps = useRender.ComponentProps<"div">;
export declare function ComposerSuggestionList({ className, render, ...props }: ComposerSuggestionListProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerSuggestionListVariantProps = Omit<VariantProps<typeof composerSuggestionList>, "theme">;
type ComposerSuggestionGroupProps = useRender.ComponentProps<"div"> & Pick<ComposerSuggestionListVariantProps, "separated">;
export declare function ComposerSuggestionGroup({ separated, className, render, ...props }: ComposerSuggestionGroupProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerSuggestionGroupLabelProps = useRender.ComponentProps<"div">;
export declare function ComposerSuggestionGroupLabel({ className, render, ...props }: ComposerSuggestionGroupLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerSuggestionOptionProps = useRender.ComponentProps<"div">;
export declare function ComposerSuggestionOption({ className, render, ...props }: ComposerSuggestionOptionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerSuggestionContentProps = useRender.ComponentProps<"div">;
export declare function ComposerSuggestionContent({ className, render, ...props }: ComposerSuggestionContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerSuggestionIconProps = useRender.ComponentProps<"span"> & {
variant?: ComposerSuggestionListVariantProps["iconVariant"];
};
export declare function ComposerSuggestionIcon({ variant, className, render, ...props }: ComposerSuggestionIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerSuggestionTitleProps = useRender.ComponentProps<"span">;
export declare function ComposerSuggestionTitle({ className, render, ...props }: ComposerSuggestionTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerSuggestionAsideProps = useRender.ComponentProps<"span">;
export declare function ComposerSuggestionAside({ className, render, ...props }: ComposerSuggestionAsideProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ComposerSuggestionMetaProps = useRender.ComponentProps<"span"> & {
variant?: ComposerSuggestionListVariantProps["metaVariant"];
};
export declare function ComposerSuggestionMeta({ variant, className, render, ...props }: ComposerSuggestionMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/composer/composer-root.d.ts
type ComposerRootProps = useRender.ComponentProps<"form">;
export declare function ComposerRoot({ className, render, ...props }: ComposerRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/composer/composer-toolbar-label.d.ts
type ComposerToolbarLabelProps = useRender.ComponentProps<"label">;
export declare function ComposerToolbarLabel({ className, render, ...props }: ComposerToolbarLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/composer/use-composer-suggestions.d.ts
interface ComposerSuggestionTriggerMatch {
/** The trigger marker that opened the list, e.g. "@" or "#". */
marker: string;
/** The query typed after the marker, excluding the marker. */
query: string;
/** Caret index in the value where the marker begins. */
start: number;
}
interface UseComposerSuggestionsParams<TItem extends object> {
/** Controlled value of the composer input. */
value: string;
/** Called when typing or an inserted suggestion changes the value. */
onValueChange: (value: string) => void;
/** Detect an active trigger in the text before the caret; return null when inactive. */
detectTrigger: (textBeforeCaret: string) => ComposerSuggestionTriggerMatch | null;
/** Items offered for the active trigger. An empty list closes the popup. */
getItems: (match: ComposerSuggestionTriggerMatch) => readonly TItem[];
/** Text inserted in place of the trigger token when an item is chosen, e.g. "@handle ". */
getItemText: (item: TItem) => string;
/** Optional predicate marking an item as non-selectable. */
isItemDisabled?: (item: TItem) => boolean;
}
type ComposerSuggestionsInputProps = Omit<ComponentPropsWithoutRef<"textarea">, "aria-activedescendant" | "aria-autocomplete" | "aria-controls" | "role" | "value">;
type ComposerSuggestionsListProps = Omit<ComponentPropsWithoutRef<"div">, "aria-label" | "aria-labelledby" | "id" | "role"> & ({
"aria-label": string;
"aria-labelledby"?: never;
} | {
"aria-label"?: never;
"aria-labelledby": string;
});
type ComposerSuggestionsOptionProps = Omit<ComponentPropsWithoutRef<"div">, "aria-disabled" | "aria-selected" | "data-disabled" | "data-composer-suggestion-index" | "data-highlighted" | "id" | "role">;
interface ComposerSuggestionsInputInternalProps {
"aria-activedescendant": string | undefined;
"aria-autocomplete": "list";
"aria-controls": string | undefined;
ref: RefObject<HTMLTextAreaElement | null>;
value: string;
onBlur: FocusEventHandler<HTMLTextAreaElement>;
onChange: FormEventHandler<HTMLTextAreaElement>;
onCompositionEnd: CompositionEventHandler<HTMLTextAreaElement>;
onCompositionStart: () => void;
onKeyDown: KeyboardEventHandler<HTMLTextAreaElement>;
onSelect: FormEventHandler<HTMLTextAreaElement>;
}
interface ComposerSuggestionsListInternalProps {
id: string;
ref: RefObject<HTMLDivElement | null>;
role: "listbox";
}
interface ComposerSuggestionsOptionInternalProps {
"aria-disabled": boolean;
"aria-selected": boolean;
"data-disabled": boolean;
"data-composer-suggestion-index": number;
"data-highlighted": boolean;
id: string;
onClick: () => void;
onPointerDown: (event: PointerEvent<HTMLDivElement>) => void;
role: "option";
}
/**
* Headless behavior for an inline trigger-driven suggestion popup (@mention, #channel)
* layered over a composer textarea. Owns open state, highlighted option, keyboard
* navigation, IME guarding, and caret-preserving insertion. The consumer supplies
* trigger detection, item data, insertion text, and textarea/listbox option semantics.
*/
export declare function useComposerSuggestions<TItem extends object>({ value, onValueChange, detectTrigger, getItems, getItemText, isItemDisabled }: UseComposerSuggestionsParams<TItem>): {
open: boolean;
items: readonly TItem[];
highlightedIndex: number;
activeItem: TItem | undefined;
inputRef: RefObject<HTMLTextAreaElement | null>;
listRef: RefObject<HTMLDivElement | null>;
getInputProps: (props?: ComposerSuggestionsInputProps) => ComposerSuggestionsInputInternalProps & ComposerSuggestionsInputProps;
getListProps: (props: ComposerSuggestionsListProps) => ComposerSuggestionsListInternalProps & ComposerSuggestionsListProps;
getOptionProps: (item: TItem, index: number, props?: ComposerSuggestionsOptionProps) => ComposerSuggestionsOptionInternalProps & ComposerSuggestionsOptionProps;
select: (item: TItem) => void;
insert: (text: string) => void;
clear: () => void;
};
//#endregion
//#region src/components/skeleton/skeleton.d.ts
declare const skeleton: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string[];
};
elegant: {
root: string[];
};
};
variant: {
line: {
root: string;
};
block: {
root: string;
};
circle: {
root: string;
};
};
}, {
root: string[];
}, undefined, {
theme: {
brutal: {
root: string[];
};
elegant: {
root: string[];
};
};
variant: {
line: {
root: string;
};
block: {
root: string;
};
circle: {
root: string;
};
};
}, {
root: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string[];
};
elegant: {
root: string[];
};
};
variant: {
line: {
root: string;
};
block: {
root: string;
};
circle: {
root: string;
};
};
}, {
root: string[];
}>>;
type SkeletonVariant = NonNullable<VariantProps<typeof skeleton>["variant"]>;
type SkeletonProps = HTMLAttributes<HTMLDivElement> & Omit<VariantProps<typeof skeleton>, "theme">;
export declare function Skeleton({ variant, className, ...props }: SkeletonProps): import("react").JSX.Element;
//#endregion
//#region src/components/banner/banner.d.ts
declare const banner: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string[];
title: string[];
description: string[];
action: string[];
};
elegant: {
root: string[];
title: string[];
description: string[];
action: string[];
};
};
status: {
default: {};
destructive: {};
warning: {};
info: {};
success: {};
};
size: {
sm: {};
md: {};
lg: {};
};
}, {
root: string[];
title: string[];
description: string[];
action: string[];
}, undefined, {
theme: {
brutal: {
root: string[];
title: string[];
description: string[];
action: string[];
};
elegant: {
root: string[];
title: string[];
description: string[];
action: string[];
};
};
status: {
default: {};
destructive: {};
warning: {};
info: {};
success: {};
};
size: {
sm: {};
md: {};
lg: {};
};
}, {
root: string[];
title: string[];
description: string[];
action: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string[];
title: string[];
description: string[];
action: string[];
};
elegant: {
root: string[];
title: string[];
description: string[];
action: string[];
};
};
status: {
default: {};
destructive: {};
warning: {};
info: {};
success: {};
};
size: {
sm: {};
md: {};
lg: {};
};
}, {
root: string[];
title: string[];
description: string[];
action: string[];
}>>;
type BannerStatus = NonNullable<VariantProps<typeof banner>["status"]>;
type BannerProps = useRender.ComponentProps<"div"> & Omit<VariantProps<typeof banner>, "theme" | "align"> & {
status: BannerStatus;
};
export declare function Banner({ status, size, className, render, ...props }: BannerProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type BannerTitleProps = useRender.ComponentProps<"div">;
export declare function BannerTitle({ render, className, ...props }: BannerTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type BannerDescriptionProps = useRender.ComponentProps<"div">;
export declare function BannerDescription({ render, className, ...props }: BannerDescriptionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type BannerActionProps = Omit<useRender.ComponentProps<"div">, "align">;
export declare function BannerAction({ render, className, ...props }: BannerActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/empty-state/empty-state.d.ts
type EmptyStateProps = useRender.ComponentProps<"div">;
export declare function EmptyState({ render, className, ...props }: EmptyStateProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type EmptyStateContentProps = useRender.ComponentProps<"div">;
export declare function EmptyStateContent({ render, className, ...props }: EmptyStateContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type EmptyStateIconProps = useRender.ComponentProps<"div">;
export declare function EmptyStateIcon({ render, className, ...props }: EmptyStateIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type EmptyStateTitleProps = useRender.ComponentProps<"div">;
export declare function EmptyStateTitle({ render, className, ...props }: EmptyStateTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type EmptyStateDescriptionProps = useRender.ComponentProps<"div">;
export declare function EmptyStateDescription({ render, className, ...props }: EmptyStateDescriptionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type EmptyStateActionsProps = useRender.ComponentProps<"div">;
export declare function EmptyStateActions({ render, className, ...props }: EmptyStateActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/notification-center/notification-center.d.ts
declare const notificationCenter: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
trigger: string[];
popup: string[];
header: string[];
title: string[];
count: string[];
list: string[];
itemRow: string[];
itemIcon: string[];
itemTitle: string[];
actionButton: never[];
};
elegant: {
trigger: string[];
triggerIcon: string[];
triggerBell: string[];
triggerBellGlow: string[];
triggerDot: string[];
popup: string[];
header: string[];
scroller: string[];
title: string[];
count: string[];
list: string[];
itemRow: string[];
itemIcon: string[];
itemTitle: string[];
itemBody: string[];
actionButton: string[];
};
};
viewport: {
desktop: {
popup: string;
};
mobile: {
popup: string;
};
};
size: {
sm: {
popup: string;
};
md: {
popup: string;
};
lg: {
popup: string;
};
};
read: {
true: {
item: string;
};
false: {
item: string;
};
};
status: {
error: {};
warning: {};
info: {};
success: {};
};
actionVariant: {
primary: {};
secondary: {};
};
}, {
trigger: never[];
triggerIcon: never[];
triggerBell: never[];
triggerBellGlow: never[];
triggerDot: never[];
popup: string[];
header: string[];
title: string[];
count: string[];
scroller: string[];
list: string[];
item: string[];
itemRow: string[];
itemIcon: string[];
itemContent: string[];
itemTitle: string[];
itemBody: string[];
itemActions: string[];
actionButton: never[];
}, undefined, {
theme: {
brutal: {
trigger: string[];
popup: string[];
header: string[];
title: string[];
count: string[];
list: string[];
itemRow: string[];
itemIcon: string[];
itemTitle: string[];
actionButton: never[];
};
elegant: {
trigger: string[];
triggerIcon: string[];
triggerBell: string[];
triggerBellGlow: string[];
triggerDot: string[];
popup: string[];
header: string[];
scroller: string[];
title: string[];
count: string[];
list: string[];
itemRow: string[];
itemIcon: string[];
itemTitle: string[];
itemBody: string[];
actionButton: string[];
};
};
viewport: {
desktop: {
popup: string;
};
mobile: {
popup: string;
};
};
size: {
sm: {
popup: string;
};
md: {
popup: string;
};
lg: {
popup: string;
};
};
read: {
true: {
item: string;
};
false: {
item: string;
};
};
status: {
error: {};
warning: {};
info: {};
success: {};
};
actionVariant: {
primary: {};
secondary: {};
};
}, {
trigger: never[];
triggerIcon: never[];
triggerBell: never[];
triggerBellGlow: never[];
triggerDot: never[];
popup: string[];
header: string[];
title: string[];
count: string[];
scroller: string[];
list: string[];
item: string[];
itemRow: string[];
itemIcon: string[];
itemContent: string[];
itemTitle: string[];
itemBody: string[];
itemActions: string[];
actionButton: never[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
trigger: string[];
popup: string[];
header: string[];
title: string[];
count: string[];
list: string[];
itemRow: string[];
itemIcon: string[];
itemTitle: string[];
actionButton: never[];
};
elegant: {
trigger: string[];
triggerIcon: string[];
triggerBell: string[];
triggerBellGlow: string[];
triggerDot: string[];
popup: string[];
header: string[];
scroller: string[];
title: string[];
count: string[];
list: string[];
itemRow: string[];
itemIcon: string[];
itemTitle: string[];
itemBody: string[];
actionButton: string[];
};
};
viewport: {
desktop: {
popup: string;
};
mobile: {
popup: string;
};
};
size: {
sm: {
popup: string;
};
md: {
popup: string;
};
lg: {
popup: string;
};
};
read: {
true: {
item: string;
};
false: {
item: string;
};
};
status: {
error: {};
warning: {};
info: {};
success: {};
};
actionVariant: {
primary: {};
secondary: {};
};
}, {
trigger: never[];
triggerIcon: never[];
triggerBell: never[];
triggerBellGlow: never[];
triggerDot: never[];
popup: string[];
header: string[];
title: string[];
count: string[];
scroller: string[];
list: string[];
item: string[];
itemRow: string[];
itemIcon: string[];
itemContent: string[];
itemTitle: string[];
itemBody: string[];
itemActions: string[];
actionButton: never[];
}>>;
type NotificationCenterProps = Popover$1.Root.Props;
export declare function NotificationCenter({ modal, ...props }: NotificationCenterProps): import("react").JSX.Element;
type NotificationCenterTriggerProps = StyledProps<Popover$1.Trigger.Props>;
export declare function NotificationCenterTrigger({ className, children, ...props }: NotificationCenterTriggerProps): import("react").JSX.Element;
type NotificationCenterPortalProps = Popover$1.Portal.Props;
type NotificationCenterPopupProps = StyledProps<Popover$1.Popup.Props> & Pick<VariantProps<typeof notificationCenter>, "size" | "viewport"> & Pick<Popover$1.Positioner.Props, "align" | "alignOffset" | "anchor" | "arrowPadding" | "collisionAvoidance" | "collisionBoundary" | "collisionPadding" | "disableAnchorTracking" | "positionMethod" | "side" | "sideOffset" | "sticky"> & {
portalProps?: NotificationCenterPortalProps;
};
export declare function NotificationCenterPopup({ viewport, size, className, initialFocus, align, alignOffset, anchor, arrowPadding, collisionAvoidance, collisionBoundary, collisionPadding, disableAnchorTracking, positionMethod, side, sideOffset, sticky, portalProps, ...props }: NotificationCenterPopupProps): import("react").JSX.Element;
type NotificationCenterHeaderProps = useRender.ComponentProps<"div">;
export declare function NotificationCenterHeader({ render, className, ...props }: NotificationCenterHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterTitleProps = useRender.ComponentProps<"span">;
export declare function NotificationCenterTitle({ render, className, ...props }: NotificationCenterTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterCountProps = useRender.ComponentProps<"span">;
export declare function NotificationCenterCount({ render, className, ...props }: NotificationCenterCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterScrollerProps = useRender.ComponentProps<"div">;
export declare function NotificationCenterScroller({ render, className, ...props }: NotificationCenterScrollerProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterListProps = useRender.ComponentProps<"ul">;
export declare function NotificationCenterList({ render, className, ...props }: NotificationCenterListProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterItemProps = useRender.ComponentProps<"li"> & Pick<VariantProps<typeof notificationCenter>, "read">;
export declare function NotificationCenterItem({ read, render, className, ...props }: NotificationCenterItemProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterItemRowProps = useRender.ComponentProps<"div">;
export declare function NotificationCenterItemRow({ render, className, ...props }: NotificationCenterItemRowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterItemIconProps = useRender.ComponentProps<"div"> & Pick<VariantProps<typeof notificationCenter>, "status">;
export declare function NotificationCenterItemIcon({ status, render, className, children, ...props }: NotificationCenterItemIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterItemContentProps = useRender.ComponentProps<"div">;
export declare function NotificationCenterItemContent({ render, className, ...props }: NotificationCenterItemContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterItemTitleProps = useRender.ComponentProps<"div">;
export declare function NotificationCenterItemTitle({ render, className, ...props }: NotificationCenterItemTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterItemBodyProps = useRender.ComponentProps<"div">;
export declare function NotificationCenterItemBody({ render, className, ...props }: NotificationCenterItemBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterItemActionsProps = useRender.ComponentProps<"div">;
export declare function NotificationCenterItemActions({ render, className, ...props }: NotificationCenterItemActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type NotificationCenterActionButtonProps = Omit<ButtonProps, "className" | "size" | "variant"> & {
className?: string;
variant?: VariantProps<typeof notificationCenter>["actionVariant"];
};
export declare function NotificationCenterActionButton({ variant, className, ...props }: NotificationCenterActionButtonProps): import("react").JSX.Element;
type NotificationCenterEmptyStateProps = EmptyStateProps;
export declare function NotificationCenterEmptyState(props: NotificationCenterEmptyStateProps): import("react").JSX.Element;
//#endregion
//#region src/components/toast/toast.d.ts
declare const toastStyles: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
root: string[];
content: string[];
icon: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: string[];
};
elegant: {
root: string[];
content: string[];
icon: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: never[];
};
};
placement: {
"bottom-center": {
viewport: string;
};
"bottom-right": {
viewport: string;
};
"top-center": {
viewport: string;
};
"top-right": {
viewport: string;
};
none: {
viewport: string;
};
};
strategy: {
fixed: {
viewport: string;
};
absolute: {
viewport: string;
};
};
layout: {
stacked: {
root: string[];
};
inline: {
root: string[];
};
};
tone: {
info: {};
success: {};
warning: {};
error: {};
};
}, {
viewport: string[];
positioner: string[];
root: string[];
content: string[];
icon: string[];
body: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: string[];
}, undefined, {
theme: {
brutal: {
root: string[];
content: string[];
icon: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: string[];
};
elegant: {
root: string[];
content: string[];
icon: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: never[];
};
};
placement: {
"bottom-center": {
viewport: string;
};
"bottom-right": {
viewport: string;
};
"top-center": {
viewport: string;
};
"top-right": {
viewport: string;
};
none: {
viewport: string;
};
};
strategy: {
fixed: {
viewport: string;
};
absolute: {
viewport: string;
};
};
layout: {
stacked: {
root: string[];
};
inline: {
root: string[];
};
};
tone: {
info: {};
success: {};
warning: {};
error: {};
};
}, {
viewport: string[];
positioner: string[];
root: string[];
content: string[];
icon: string[];
body: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
root: string[];
content: string[];
icon: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: string[];
};
elegant: {
root: string[];
content: string[];
icon: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: never[];
};
};
placement: {
"bottom-center": {
viewport: string;
};
"bottom-right": {
viewport: string;
};
"top-center": {
viewport: string;
};
"top-right": {
viewport: string;
};
none: {
viewport: string;
};
};
strategy: {
fixed: {
viewport: string;
};
absolute: {
viewport: string;
};
};
layout: {
stacked: {
root: string[];
};
inline: {
root: string[];
};
};
tone: {
info: {};
success: {};
warning: {};
error: {};
};
}, {
viewport: string[];
positioner: string[];
root: string[];
content: string[];
icon: string[];
body: string[];
title: string[];
description: string[];
actions: string[];
progress: string[];
close: string[];
arrow: string[];
}>>;
export declare const createToastManager: typeof Toast.createToastManager;
export declare const useToastManager: typeof Toast.useToastManager;
type ToastIntent = "info" | "success" | "warning" | "error";
type ToastData = {
intent?: ToastIntent;
hasClose?: boolean;
hasIcon?: boolean;
hasProgress?: boolean;
contentClassName?: string;
};
type ToastObject<Data extends object = object> = Toast.Root.ToastObject<Data>;
type ToastCommandOptions<Data extends object = ToastData> = Omit<Partial<ToastObject<Data>>, "actionProps" | "data" | "title" | "type"> & {
action?: {
label: ReactNode;
onClick?: ComponentPropsWithRef<"button">["onClick"];
};
contentClassName?: string;
dismissible?: boolean;
icon?: boolean;
progress?: boolean;
};
export declare const toast: {
add(options: ToastCommandOptions<ToastData> & {
title: string;
type?: ToastIntent;
}): string;
info(title: string, options?: ToastCommandOptions<ToastData>): string;
success(title: string, options?: ToastCommandOptions<ToastData>): string;
warning(title: string, options?: ToastCommandOptions<ToastData>): string;
error(title: string, options?: ToastCommandOptions<ToastData>): string;
dismiss(id?: string): void;
};
type ToastProviderProps = Toast.Provider.Props & {
portalContainer?: Toast.Portal.Props["container"];
renderViewport?: boolean;
viewportClassName?: string;
viewportPlacement?: ToastViewportProps["placement"];
viewportStrategy?: ToastViewportProps["strategy"];
};
export declare function ToastProvider({ children, portalContainer, renderViewport, toastManager, timeout, viewportClassName, viewportPlacement, viewportStrategy, ...props }: ToastProviderProps): import("react").JSX.Element;
type ToastPortalProps = Toast.Portal.Props;
export declare function ToastPortal(props: ToastPortalProps): import("react").JSX.Element;
type ToastViewportProps = StyledProps<Toast.Viewport.Props> & Pick<VariantProps<typeof toastStyles>, "placement" | "strategy">;
export declare function ToastViewport({ placement, strategy, className, ...props }: ToastViewportProps): import("react").JSX.Element;
type ToastPositionerProps = StyledProps<Toast.Positioner.Props>;
export declare function ToastPositioner({ className, ...props }: ToastPositionerProps): import("react").JSX.Element;
type ToastRootProps = StyledProps<Toast.Root.Props> & Pick<VariantProps<typeof toastStyles>, "layout">;
export declare function ToastRoot({ layout, className, toast: toastObject, ...props }: ToastRootProps): import("react").JSX.Element;
type ToastContentProps = StyledProps<Toast.Content.Props>;
export declare function ToastContent({ children, className, ...props }: ToastContentProps): import("react").JSX.Element;
type ToastIconProps = ComponentPropsWithRef<"div">;
export declare function ToastIcon({ className, ...props }: ToastIconProps): import("react").JSX.Element;
type ToastBodyProps = ComponentPropsWithRef<"div">;
export declare function ToastBody({ className, ...props }: ToastBodyProps): import("react").JSX.Element;
type ToastActionsProps = ComponentPropsWithRef<"div">;
export declare function ToastActions({ className, ...props }: ToastActionsProps): import("react").JSX.Element;
type ToastProgressProps = ComponentPropsWithRef<"div"> & {
duration?: number;
};
export declare function ToastProgress({ className, duration, style, ...props }: ToastProgressProps): import("react").JSX.Element;
type ToastTitleProps = StyledProps<Toast.Title.Props>;
export declare function ToastTitle({ className, ...props }: ToastTitleProps): import("react").JSX.Element;
type ToastDescriptionProps = StyledProps<Toast.Description.Props>;
export declare function ToastDescription({ className, ...props }: ToastDescriptionProps): import("react").JSX.Element;
type ToastActionProps = StyledProps<Toast.Action.Props> & {
loading?: boolean;
loadingLabel?: string;
};
export declare function ToastAction({ className, children, disabled, loading, loadingLabel, render, ...props }: ToastActionProps): import("react").JSX.Element;
type ToastCloseProps = StyledProps<Toast.Close.Props>;
export declare function ToastClose({ className, children, ...props }: ToastCloseProps): import("react").JSX.Element;
type ToastArrowProps = StyledProps<Toast.Arrow.Props>;
export declare function ToastArrow({ className, ...props }: ToastArrowProps): import("react").JSX.Element | null;
//#endregion
//#region src/components/tabs/tabs.d.ts
declare const tabs: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: {
list: string[];
background: string;
tab: string[];
};
elegant: {};
};
variant: {
default: {};
underline: {};
};
}, {
root: string[];
list: string[];
background: string[];
tab: string[];
content: string[];
label: string[];
panel: string[];
indicator: string[];
}, undefined, {
theme: {
brutal: {
list: string[];
background: string;
tab: string[];
};
elegant: {};
};
variant: {
default: {};
underline: {};
};
}, {
root: string[];
list: string[];
background: string[];
tab: string[];
content: string[];
label: string[];
panel: string[];
indicator: string[];
}, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: {
list: string[];
background: string;
tab: string[];
};
elegant: {};
};
variant: {
default: {};
underline: {};
};
}, {
root: string[];
list: string[];
background: string[];
tab: string[];
content: string[];
label: string[];
panel: string[];
indicator: string[];
}>>;
type TabsListVariant = "default" | "underline";
type TabsProps<T extends string = string> = StyledProps<Omit<Tabs$1.Root.Props, "defaultValue" | "onValueChange" | "value">> & Omit<VariantProps<typeof tabs>, "theme"> & {
value?: T;
defaultValue?: T;
onValueChange?: (value: T, eventDetails: Tabs$1.Root.ChangeEventDetails) => void;
};
export declare function Tabs<T extends string = string>({ value, defaultValue, onValueChange, className, ...props }: TabsProps<T>): import("react").JSX.Element;
type TabsListProps = StyledProps<Tabs$1.List.Props> & {
variant?: TabsListVariant;
};
export declare function TabsList({ className, children, variant, ...props }: TabsListProps): import("react").JSX.Element;
type SortableTabsListProps<T extends string = string> = TabsListProps & {
value: readonly T[];
onReorder: (value: T[]) => void;
};
export declare function SortableTabsList<T extends string = string>({ value, onReorder, children, variant, ...props }: SortableTabsListProps<T>): import("react").JSX.Element;
type TabsTabProps<T extends string = string> = StyledProps<Tabs$1.Tab.Props> & {
value: T;
};
export declare function TabsTab<T extends string = string>({ value, ...props }: TabsTabProps<T>): import("react").JSX.Element;
type SortableTabsTabProps<T extends string = string> = TabsTabProps<T>;
export declare function SortableTabsTab<T extends string = string>({ value, ...props }: SortableTabsTabProps<T>): import("react").JSX.Element;
type TabsLabelProps = ComponentPropsWithRef<"span">;
export declare function TabsLabel({ className, ...props }: TabsLabelProps): import("react").JSX.Element;
type TabsPanelProps = StyledProps<Tabs$1.Panel.Props>;
export declare function TabsPanel({ className, ...props }: TabsPanelProps): import("react").JSX.Element;
type TabsBackgroundProps = ComponentPropsWithRef<"span">;
export declare function TabsBackground({ className, ...props }: TabsBackgroundProps): import("react").JSX.Element;
type TabsIndicatorProps = StyledProps<Tabs$1.Indicator.Props>;
export declare function TabsIndicator({ className, ...props }: TabsIndicatorProps): import("react").JSX.Element;
type OrderedTabItem<T extends string = string> = {
id: T;
};
export declare function useOrderedTabs<T extends OrderedTabItem<string>>(items: readonly T[], storedOrder: readonly string[]): T[];
//#endregion
//#region src/components/separator/separator.d.ts
type SeparatorProps = StyledProps<Separator$1.Props> & {
children?: ReactNode;
};
export declare function Separator({ children, className, orientation, ...props }: SeparatorProps): import("react").JSX.Element;
//#endregion
//#region src/components/app-shell/app-shell.d.ts
type AppShellRootProps = useRender.ComponentProps<"div"> & {
defaultSidebarOpen?: boolean;
onSidebarOpenChange?: (open: boolean) => void;
sidebarCollapsible?: boolean;
sidebarOpen?: boolean;
};
export declare function AppShellRoot({ className, defaultSidebarOpen, onSidebarOpenChange, render, sidebarCollapsible, sidebarOpen: sidebarOpenProp, style, ...props }: AppShellRootProps): import("react").JSX.Element;
type AppShellRailSlotProps = useRender.ComponentProps<"aside">;
export declare function AppShellRailSlot({ className, render, ...props }: AppShellRailSlotProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppShellSidebarSlotProps = useRender.ComponentProps<"aside">;
export declare function AppShellSidebarSlot({ className, render, ...props }: AppShellSidebarSlotProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppShellPanelSlotProps = useRender.ComponentProps<"aside">;
export declare function AppShellPanelSlot({ className, render, ...props }: AppShellPanelSlotProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppShellOverlaySlotProps = useRender.ComponentProps<"div">;
export declare function AppShellOverlaySlot({ className, render, ...props }: AppShellOverlaySlotProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppShellMainSlotProps = useRender.ComponentProps<"main"> & {
overlay?: boolean;
};
export declare function AppShellMainSlot({ className, overlay, render, ...props }: AppShellMainSlotProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type AppShellSidebarTriggerProps = useRender.ComponentProps<"button"> & {
children: ReactNode;
};
export declare function AppShellSidebarTrigger(props: AppShellSidebarTriggerProps): import("react").JSX.Element | null;
//#endregion
//#region src/components/resizable/resizable.d.ts
type ResizableGroupProps = Omit<GroupProps, "className"> & {
className?: string;
};
export declare function ResizableGroup({ className, orientation, ...props }: ResizableGroupProps): import("react").JSX.Element;
type ResizablePanelProps = Omit<PanelProps$1, "className"> & {
className?: string;
};
export declare function ResizablePanel({ className, ...props }: ResizablePanelProps): import("react").JSX.Element;
type ResizableHandleProps = Omit<SeparatorProps$1, "className"> & {
className?: string;
};
export declare function ResizableHandle({ className, ...props }: ResizableHandleProps): import("react").JSX.Element;
//#endregion
//#region src/components/panel/panel-header.d.ts
type PanelHeaderProps = useRender.ComponentProps<"div">;
export declare function PanelHeader({ children, className, render, ...props }: PanelHeaderProps): import("react").JSX.Element;
type PanelSectionHeaderProps = useRender.ComponentProps<"div">;
export declare function PanelSectionHeader({ children, className, render, ...props }: PanelSectionHeaderProps): import("react").JSX.Element;
type PanelHeaderIconProps = useRender.ComponentProps<"div">;
export declare function PanelHeaderIcon({ className, render, ...props }: PanelHeaderIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelHeaderContentProps = useRender.ComponentProps<"div">;
export declare function PanelHeaderContent({ className, render, ...props }: PanelHeaderContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelHeadingProps = useRender.ComponentProps<"div">;
export declare function PanelHeading({ className, render, ...props }: PanelHeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelTitleProps = useRender.ComponentProps<"div">;
export declare function PanelTitle({ className, render, ...props }: PanelTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelMetaProps = useRender.ComponentProps<"div"> & {
size?: "sm" | "md";
};
export 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`.
*/
export 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.
*/
export declare function PanelActivity({ className, render, ...props }: PanelActivityProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type PanelActionsProps = useRender.ComponentProps<"div">;
export declare function PanelActions({ className, render, ...props }: PanelActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/panel/panel-action.d.ts
type PanelActionProps = Omit<StyledProps<Button$1.Props>, "type"> & DataAttributes$1;
export declare function PanelAction({ className, render, nativeButton, ...props }: PanelActionProps): import("react").JSX.Element;
//#endregion
//#region src/components/panel/panel-toggle-action.d.ts
type PanelToggleActionProps = Omit<StyledProps<Toggle.Props>, "type">;
export declare function PanelToggleAction({ className, ...props }: PanelToggleActionProps): import("react").JSX.Element;
//#endregion
//#region src/components/profile-panel/profile-panel.d.ts
type ProfilePanelProps = PanelProps;
export declare function ProfilePanel({ className, edge, ...props }: ProfilePanelProps): import("react").JSX.Element;
type ProfilePanelHeaderProps = PanelHeaderProps;
export declare function ProfilePanelHeader({ className, ...props }: ProfilePanelHeaderProps): import("react").JSX.Element;
type ProfilePanelHeaderContentProps = PanelHeaderContentProps;
export declare function ProfilePanelHeaderContent({ className, ...props }: ProfilePanelHeaderContentProps): import("react").JSX.Element;
type ProfilePanelBodyProps = PanelBodyProps;
export declare function ProfilePanelBody({ className, ...props }: ProfilePanelBodyProps): import("react").JSX.Element;
type ProfilePanelSectionProps = PanelSectionProps;
export declare function ProfilePanelSection({ className, ...props }: ProfilePanelSectionProps): import("react").JSX.Element;
//#endregion
//#region src/components/thread-panel/thread-panel.d.ts
type ThreadPanelRootProps = useRender.ComponentProps<"section">;
export declare function ThreadPanelRoot({ className, render, ...props }: ThreadPanelRootProps): import("react").JSX.Element;
type ThreadPanelHeaderProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelHeader({ className, render, ...props }: ThreadPanelHeaderProps): import("react").JSX.Element;
type ThreadPanelContentProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelContent({ className, render, ...props }: ThreadPanelContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ThreadPanelTitleProps = useRender.ComponentProps<"h2">;
export declare function ThreadPanelTitle({ className, render, ...props }: ThreadPanelTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ThreadPanelTitleMetaProps = useRender.ComponentProps<"span">;
export declare function ThreadPanelTitleMeta({ className, render, ...props }: ThreadPanelTitleMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ThreadPanelActionsProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelActions({ className, render, ...props }: ThreadPanelActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ThreadPanelBodyProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelBody({ className, render, ...props }: ThreadPanelBodyProps): import("react").JSX.Element;
type ThreadPanelOriginalMessageProps = Omit<useRender.ComponentProps<"div">, "render">;
export declare function ThreadPanelOriginalMessage({ className, ...props }: ThreadPanelOriginalMessageProps): import("react").JSX.Element;
type ThreadPanelReplySummaryProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelReplySummary({ className, render, ...props }: ThreadPanelReplySummaryProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ThreadPanelReplyCountProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelReplyCount({ className, render, ...props }: ThreadPanelReplyCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ThreadPanelFooterProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelFooter({ className, render, ...props }: ThreadPanelFooterProps): import("react").JSX.Element;
type ThreadPanelSearchProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelSearch({ className, render, ...props }: ThreadPanelSearchProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ThreadPanelSearchTrailingProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelSearchTrailing({ className, render, ...props }: ThreadPanelSearchTrailingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type ThreadPanelSearchCountProps = useRender.ComponentProps<"div">;
export declare function ThreadPanelSearchCount({ className, render, ...props }: ThreadPanelSearchCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/live-agent-activity-bar/live-agent-activity-bar.d.ts
type LiveAgentActivityBarProps = useRender.ComponentProps<"div"> & {
beam?: boolean;
};
export declare function LiveAgentActivityBar({ beam, children, className, render, ...props }: LiveAgentActivityBarProps): import("react").JSX.Element | null;
type LiveAgentActivityBarRowProps = useRender.ComponentProps<"div">;
export declare function LiveAgentActivityBarRow({ className, render, ...props }: LiveAgentActivityBarRowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LiveAgentActivityBarAvatarProps = Omit<AvatarProps, "size" | "type">;
export declare function LiveAgentActivityBarAvatar({ children, className, render, ...props }: LiveAgentActivityBarAvatarProps): import("react").JSX.Element;
type LiveAgentActivityBarContentProps = useRender.ComponentProps<"div">;
export declare function LiveAgentActivityBarContent({ className, render, ...props }: LiveAgentActivityBarContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LiveAgentActivityBarStatusProps = Omit<StatusProps, "attention" | "pulse" | "size" | "variant">;
export declare function LiveAgentActivityBarStatus({ className, ...props }: LiveAgentActivityBarStatusProps): import("react").JSX.Element;
type LiveAgentActivityBarTextProps = useRender.ComponentProps<"span">;
export declare function LiveAgentActivityBarText({ className, render, ...props }: LiveAgentActivityBarTextProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/tasks/task-status.recipe.d.ts
type TaskStatusId = "todo" | "in-progress" | "in-review" | "done" | "closed";
export declare const taskStatus: import("tailwind-variants/lite").TVReturnType<{
theme: {
brutal: "";
elegant: "";
};
status: {
todo: "";
"in-progress": "";
"in-review": "";
done: "";
closed: "";
};
}, undefined, undefined, {
theme: {
brutal: "";
elegant: "";
};
status: {
todo: "";
"in-progress": "";
"in-review": "";
done: "";
closed: "";
};
}, undefined, import("tailwind-variants/lite").TVReturnTypeLike<{
theme: {
brutal: "";
elegant: "";
};
status: {
todo: "";
"in-progress": "";
"in-review": "";
done: "";
closed: "";
};
}, undefined>>;
//#endregion
//#region src/components/task-board/task-board.d.ts
type TaskBoardRootProps = useRender.ComponentProps<"div">;
export declare function TaskBoardRoot({ className, render, ...props }: TaskBoardRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnProps = Omit<ComponentProps<typeof Collapsible.Root>, "className"> & {
className?: string;
};
export declare function TaskBoardColumn({ className, render, ...props }: TaskBoardColumnProps): import("react").JSX.Element;
type TaskBoardColumnTriggerProps = Omit<ComponentProps<typeof Collapsible.Trigger>, "className"> & {
className?: string;
};
export declare function TaskBoardColumnTrigger({ className, ...props }: TaskBoardColumnTriggerProps): import("react").JSX.Element;
type TaskBoardColumnHeadingProps = useRender.ComponentProps<"span">;
export declare function TaskBoardColumnHeading({ className, render, ...props }: TaskBoardColumnHeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnBadgeProps = useRender.ComponentProps<"span"> & {
status: TaskStatusId;
};
export declare function TaskBoardColumnBadge({ status, children, className, render, ...props }: TaskBoardColumnBadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnCountProps = useRender.ComponentProps<"span">;
export declare function TaskBoardColumnCount({ className, render, ...props }: TaskBoardColumnCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnChevronProps = useRender.ComponentProps<"span">;
export declare function TaskBoardColumnChevron({ className, render, ...props }: TaskBoardColumnChevronProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnPanelProps = Omit<ComponentProps<typeof Collapsible.Panel>, "className"> & {
className?: string;
};
export declare function TaskBoardColumnPanel({ className, ...props }: TaskBoardColumnPanelProps): import("react").JSX.Element;
type TaskBoardColumnItemsProps = useRender.ComponentProps<"div">;
export declare function TaskBoardColumnItems({ className, render, ...props }: TaskBoardColumnItemsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnEmptyProps = useRender.ComponentProps<"div">;
export declare function TaskBoardColumnEmpty({ className, render, ...props }: TaskBoardColumnEmptyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnEmptyIdleProps = useRender.ComponentProps<"span">;
export declare function TaskBoardColumnEmptyIdle({ className, render, ...props }: TaskBoardColumnEmptyIdleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnEmptyAllowedProps = useRender.ComponentProps<"span">;
export declare function TaskBoardColumnEmptyAllowed({ className, render, ...props }: TaskBoardColumnEmptyAllowedProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskBoardColumnEmptyBlockedProps = useRender.ComponentProps<"span">;
export declare function TaskBoardColumnEmptyBlocked({ className, render, ...props }: TaskBoardColumnEmptyBlockedProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/task-card/task-card.d.ts
type TaskCardProps = useRender.ComponentProps<"article"> & {
busy?: boolean;
disabled?: boolean;
};
export declare function TaskCard({ busy, disabled, className, render, ...props }: TaskCardProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardRowProps = useRender.ComponentProps<"div">;
export declare function TaskCardRow({ className, render, ...props }: TaskCardRowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardBodyProps = useRender.ComponentProps<"div">;
export declare function TaskCardBody({ className, render, ...props }: TaskCardBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardMetaProps = useRender.ComponentProps<"div">;
export declare function TaskCardMeta({ className, render, ...props }: TaskCardMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardChannelProps = useRender.ComponentProps<"span">;
export declare function TaskCardChannel({ className, render, ...props }: TaskCardChannelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardNumberProps = useRender.ComponentProps<"span">;
export declare function TaskCardNumber({ className, render, ...props }: TaskCardNumberProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardLegacyProps = useRender.ComponentProps<"span">;
export declare function TaskCardLegacy({ className, render, ...props }: TaskCardLegacyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardTitleProps = useRender.ComponentProps<"p">;
export declare function TaskCardTitle({ className, render, ...props }: TaskCardTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardDescriptionProps = useRender.ComponentProps<"p">;
export declare function TaskCardDescription({ className, render, ...props }: TaskCardDescriptionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskCardStatusProps = useRender.ComponentProps<"button"> & {
busy?: boolean;
status: TaskStatusId;
};
export declare function TaskCardStatus({ busy, status, className, render, children, ...props }: TaskCardStatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/task-dnd/task-dnd.d.ts
type TaskDropState = "idle" | "allowed" | "blocked";
type TaskDropPlacement = "before" | "after";
type TaskDropData = Record<string, unknown>;
type TaskMoveDetails = {
activeId: UniqueIdentifier;
overId: UniqueIdentifier;
overData: TaskDropData | undefined;
placement: TaskDropPlacement | null;
};
type TaskDndProviderProps = {
children: ReactNode;
disabled?: boolean;
isDropAllowed?: (activeId: UniqueIdentifier, overId: UniqueIdentifier, overData: TaskDropData | undefined) => boolean;
onMove?: (details: TaskMoveDetails) => void | Promise<void>;
onMoveError?: (error: unknown, details: TaskMoveDetails) => void;
onDragStart?: (event: DragStartEvent) => void;
onDragMove?: (event: DragMoveEvent) => void;
onDragOver?: (event: DragOverEvent) => void;
onDragCancel?: (event: DragCancelEvent) => void;
onDragEnd?: (event: DragEndEvent) => void;
};
export declare function TaskDndProvider({ children, disabled, isDropAllowed, onMove, onMoveError, onDragStart, onDragMove, onDragOver, onDragCancel, onDragEnd }: TaskDndProviderProps): import("react").JSX.Element;
type TaskDraggableProps = ComponentPropsWithRef<"div"> & {
id: UniqueIdentifier;
disabled?: boolean;
dropId?: UniqueIdentifier;
dropData?: TaskDropData;
dropDisabled?: boolean;
};
export declare function TaskDraggable({ id, disabled, dropId, dropData, dropDisabled, className, ref: consumerRef, style, ...props }: TaskDraggableProps): import("react").JSX.Element;
type TaskDropZoneState = {
dropState: TaskDropState;
};
type TaskDropZoneProps = useRender.ComponentProps<"div", TaskDropZoneState> & {
id: UniqueIdentifier;
disabled?: boolean;
data?: TaskDropData;
};
export declare function TaskDropZone({ id, data, disabled, render, ...props }: TaskDropZoneProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskDropPlaceholderProps = useRender.ComponentProps<"div", TaskDropZoneState> & {
id: UniqueIdentifier;
placement?: TaskDropPlacement;
};
export declare function TaskDropPlaceholder({ id, placement, className, render, style, ...props }: TaskDropPlaceholderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskDragOverlayProps = {
children?: ReactNode;
className?: string;
};
export declare function TaskDragOverlay({ children, className }: TaskDragOverlayProps): import("react").JSX.Element;
//#endregion
//#region src/components/task-list/task-list.d.ts
type TaskListRootProps = useRender.ComponentProps<"div">;
export declare function TaskListRoot({ className, render, ...props }: TaskListRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskSectionProps = Omit<ComponentProps<typeof Collapsible.Root>, "className"> & {
className?: string;
};
export declare function TaskSection({ className, render, ...props }: TaskSectionProps): import("react").JSX.Element;
type TaskSectionTriggerProps = Omit<ComponentProps<typeof Collapsible.Trigger>, "className"> & {
className?: string;
};
export declare function TaskSectionTrigger({ className, ...props }: TaskSectionTriggerProps): import("react").JSX.Element;
type TaskSectionHeadingProps = useRender.ComponentProps<"span">;
export declare function TaskSectionHeading({ className, render, ...props }: TaskSectionHeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskSectionBadgeProps = useRender.ComponentProps<"span"> & {
status: TaskStatusId;
};
export declare function TaskSectionBadge({ status, children, className, render, ...props }: TaskSectionBadgeProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskSectionCountProps = useRender.ComponentProps<"span">;
export declare function TaskSectionCount({ className, render, ...props }: TaskSectionCountProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskSectionChevronProps = useRender.ComponentProps<"span">;
export declare function TaskSectionChevron({ className, render, ...props }: TaskSectionChevronProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskSectionPanelProps = Omit<ComponentProps<typeof Collapsible.Panel>, "className"> & {
className?: string;
};
export declare function TaskSectionPanel({ className, ...props }: TaskSectionPanelProps): import("react").JSX.Element;
type TaskSectionItemsProps = useRender.ComponentProps<"div">;
export declare function TaskSectionItems({ className, render, ...props }: TaskSectionItemsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskSectionEmptyProps = useRender.ComponentProps<"div">;
export declare function TaskSectionEmpty({ className, render, ...props }: TaskSectionEmptyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/icons/conversation-icons.d.ts
type ConversationIconProps = SVGProps<SVGSVGElement>;
export declare function MessageIcon(props: ConversationIconProps): import("react").JSX.Element;
export declare function ChatIcon(props: ConversationIconProps): import("react").JSX.Element;
export declare function DirectMessageIcon(props: ConversationIconProps): import("react").JSX.Element;
export declare function ThreadIcon(props: ConversationIconProps): import("react").JSX.Element;
//#endregion
//#region src/components/tasks/tasks-panel.d.ts
type TasksPanelRootProps = useRender.ComponentProps<"section">;
export declare function TasksPanelRoot({ className, render, ...props }: TasksPanelRootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TasksPanelToolbarProps = useRender.ComponentProps<"div">;
export declare function TasksPanelToolbar({ className, render, ...props }: TasksPanelToolbarProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
/** Generic toolbar cluster. Prefer NewTask / Filters / View for responsive layout. */
type TasksPanelToolbarGroupProps = useRender.ComponentProps<"div">;
export declare function TasksPanelToolbarGroup({ className, render, ...props }: TasksPanelToolbarGroupProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TasksPanelToolbarNewTaskProps = useRender.ComponentProps<"div">;
export declare function TasksPanelToolbarNewTask({ className, render, ...props }: TasksPanelToolbarNewTaskProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TasksPanelToolbarFiltersProps = useRender.ComponentProps<"div">;
export declare function TasksPanelToolbarFilters({ className, render, ...props }: TasksPanelToolbarFiltersProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TasksPanelToolbarViewProps = useRender.ComponentProps<"div">;
export declare function TasksPanelToolbarView({ className, render, ...props }: TasksPanelToolbarViewProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TasksPanelToolbarLabelProps = useRender.ComponentProps<"span">;
export declare function TasksPanelToolbarLabel({ className, render, ...props }: TasksPanelToolbarLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TasksPanelViewportProps = useRender.ComponentProps<"div">;
export declare function TasksPanelViewport({ className, render, ...props }: TasksPanelViewportProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TasksPanelEmptyProps = useRender.ComponentProps<"div">;
export declare function TasksPanelEmpty({ className, render, ...props }: TasksPanelEmptyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/tasks/task-loading.d.ts
type TaskLoadingListProps = useRender.ComponentProps<"div">;
export declare function TaskLoadingList({ className, render, ...props }: TaskLoadingListProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type TaskLoadingRowProps = useRender.ComponentProps<"div">;
export declare function TaskLoadingRow({ className, render, ...props }: TaskLoadingRowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/tasks/task-chip.d.ts
type TaskChipVariant = "default" | "inline";
type TaskChipProps = useRender.ComponentProps<"span"> & {
status: TaskStatusId;
loading?: boolean;
variant?: TaskChipVariant;
};
export declare function TaskChip({ status, loading, variant, className, render, children, ...props }: TaskChipProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/tasks/task-status-icon.d.ts
export declare function TaskTodoIcon(props: {
className?: string;
}): import("react").JSX.Element;
export declare function TaskInProgressIcon(props: {
className?: string;
}): import("react").JSX.Element;
export declare function TaskInReviewIcon(props: {
className?: string;
}): import("react").JSX.Element;
export declare function TaskDoneIcon(props: {
className?: string;
}): import("react").JSX.Element;
export declare function TaskClosedIcon(props: {
className?: string;
}): import("react").JSX.Element;
export declare function TaskStatusIcon({ status, className }: {
status: TaskStatusId;
className?: string;
}): import("react").JSX.Element;
//#endregion
//#region src/components/legacy-task-panel/legacy-task-panel.d.ts
type LegacyTaskPanelRootProps = useRender.ComponentProps<"div"> & {
/** Docs preview chrome. Shell hosts (Playground) leave this off. */
framed?: boolean;
};
export declare function LegacyTaskPanelRoot({ className, framed, render, children, ...props }: LegacyTaskPanelRootProps): import("react").JSX.Element;
type LegacyTaskPanelHeaderProps = useRender.ComponentProps<"div">;
export declare function LegacyTaskPanelHeader({ className, ...props }: LegacyTaskPanelHeaderProps): import("react").JSX.Element;
type LegacyTaskPanelIconProps = useRender.ComponentProps<"div">;
export declare function LegacyTaskPanelIcon({ className, render, children, ...props }: LegacyTaskPanelIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelTitleProps = useRender.ComponentProps<"h2">;
export declare function LegacyTaskPanelTitle({ className, ...props }: LegacyTaskPanelTitleProps): import("react").JSX.Element;
type LegacyTaskPanelTitleMetaProps = useRender.ComponentProps<"span">;
export declare function LegacyTaskPanelTitleMeta({ className, ...props }: LegacyTaskPanelTitleMetaProps): import("react").JSX.Element;
type LegacyTaskPanelActionsProps = useRender.ComponentProps<"div">;
export declare function LegacyTaskPanelActions({ className, ...props }: LegacyTaskPanelActionsProps): import("react").JSX.Element;
type LegacyTaskPanelBodyProps = useRender.ComponentProps<"div">;
export declare function LegacyTaskPanelBody({ className, children, ...props }: LegacyTaskPanelBodyProps): import("react").JSX.Element;
type LegacyTaskPanelStatusProps = useRender.ComponentProps<"div">;
export declare function LegacyTaskPanelStatus({ className, render, ...props }: LegacyTaskPanelStatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelSectionProps = useRender.ComponentProps<"section">;
export declare function LegacyTaskPanelSection({ className, render, ...props }: LegacyTaskPanelSectionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelFieldProps = useRender.ComponentProps<"div">;
export declare function LegacyTaskPanelField({ className, render, ...props }: LegacyTaskPanelFieldProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelFieldLabelProps = useRender.ComponentProps<"p">;
export declare function LegacyTaskPanelFieldLabel({ className, render, ...props }: LegacyTaskPanelFieldLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelFieldTitleProps = useRender.ComponentProps<"h3">;
export declare function LegacyTaskPanelFieldTitle({ className, render, ...props }: LegacyTaskPanelFieldTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelFieldTextProps = useRender.ComponentProps<"p">;
export declare function LegacyTaskPanelFieldText({ className, render, ...props }: LegacyTaskPanelFieldTextProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelMetaProps = useRender.ComponentProps<"section">;
export declare function LegacyTaskPanelMeta({ className, render, ...props }: LegacyTaskPanelMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelMetaRowProps = useRender.ComponentProps<"div">;
export declare function LegacyTaskPanelMetaRow({ className, render, ...props }: LegacyTaskPanelMetaRowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelMetaLabelProps = useRender.ComponentProps<"span">;
export declare function LegacyTaskPanelMetaLabel({ className, render, ...props }: LegacyTaskPanelMetaLabelProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type LegacyTaskPanelMetaValueProps = useRender.ComponentProps<"span">;
export declare function LegacyTaskPanelMetaValue({ className, render, ...props }: LegacyTaskPanelMetaValueProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/activity-inbox/activity-inbox-shell.d.ts
export type ActivityInboxPanelProps = ComponentPropsWithRef<typeof Panel>;
export declare function ActivityInboxPanel({ className, ...props }: ActivityInboxPanelProps): import("react").JSX.Element;
export type ActivityInboxViewportProps = ComponentPropsWithRef<"div">;
export declare function ActivityInboxViewport({ className, ...props }: ActivityInboxViewportProps): import("react").JSX.Element;
export type ActivityInboxLoadingMoreProps = ComponentPropsWithRef<"div">;
export declare function ActivityInboxLoadingMore({ className, ...props }: ActivityInboxLoadingMoreProps): import("react").JSX.Element;
//#endregion
//#region src/components/activity-inbox/activity-inbox-sidebar.d.ts
export type ActivityInboxSidebarProps = ComponentPropsWithRef<typeof SidebarRoot>;
export declare function ActivityInboxSidebar({ className, children, ...props }: ActivityInboxSidebarProps): import("react").JSX.Element;
//#endregion
//#region src/components/activity-inbox/activity-inbox-toolbar.d.ts
export type ActivityInboxControlsProps = ComponentPropsWithRef<"div">;
export declare function ActivityInboxControls({ className, ...props }: ActivityInboxControlsProps): import("react").JSX.Element;
export type ActivityInboxSelectionToolbarProps = ComponentPropsWithRef<"div">;
export declare function ActivityInboxSelectionToolbar({ className, ...props }: ActivityInboxSelectionToolbarProps): import("react").JSX.Element;
export type ActivityInboxSelectionCountProps = ComponentPropsWithRef<"span">;
export declare function ActivityInboxSelectionCount({ className, ...props }: ActivityInboxSelectionCountProps): import("react").JSX.Element;
//#endregion
//#region src/components/inbox-item/inbox-item.d.ts
type InboxItemProps = useRender.ComponentProps<"div"> & {
active?: boolean;
disabled?: boolean;
};
export declare function InboxItem({ active, className, disabled, render, ...props }: InboxItemProps): import("react").JSX.Element;
type InboxItemTriggerProps = Omit<useRender.ComponentProps<"button">, "type">;
export declare function InboxItemTrigger({ className, onClick, render, ...props }: InboxItemTriggerProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemSelectionProps = useRender.ComponentProps<"div">;
export declare function InboxItemSelection({ className, render, ...props }: InboxItemSelectionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemContentProps = useRender.ComponentProps<"div">;
export declare function InboxItemContent({ className, render, ...props }: InboxItemContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemContextProps = useRender.ComponentProps<"div">;
export declare function InboxItemContext({ className, render, ...props }: InboxItemContextProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemSubtitleProps = useRender.ComponentProps<"div">;
export declare function InboxItemSubtitle({ className, render, ...props }: InboxItemSubtitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemHeadingProps = useRender.ComponentProps<"div">;
export declare function InboxItemHeading({ className, render, ...props }: InboxItemHeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemTitleProps = useRender.ComponentProps<"div">;
export declare function InboxItemTitle({ className, render, ...props }: InboxItemTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemTrailingProps = useRender.ComponentProps<"div">;
export declare function InboxItemTrailing({ className, render, ...props }: InboxItemTrailingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemTimestampProps = useRender.ComponentProps<"span">;
export declare function InboxItemTimestamp({ className, render, ...props }: InboxItemTimestampProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemBodyProps = useRender.ComponentProps<"p">;
export declare function InboxItemBody({ className, render, ...props }: InboxItemBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemMessageProps = useRender.ComponentProps<"p">;
export declare function InboxItemMessage({ className, render, ...props }: InboxItemMessageProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemSenderProps = useRender.ComponentProps<"span">;
export declare function InboxItemSender({ className, render, ...props }: InboxItemSenderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemMetadataProps = useRender.ComponentProps<"div">;
export declare function InboxItemMetadata({ className, render, ...props }: InboxItemMetadataProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type InboxItemActionsProps = useRender.ComponentProps<"div">;
export declare function InboxItemActions({ className, render, ...props }: InboxItemActionsProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/search/search.d.ts
export type SearchShellRootProps = useRender.ComponentProps<"div"> & {
edge?: ComponentPropsWithRef<typeof Panel>["edge"];
};
export declare function SearchShellRoot({ className, edge, render, ...props }: SearchShellRootProps): import("react").JSX.Element;
export type SearchShellFiltersProps = ComponentPropsWithRef<"div">;
export declare function SearchShellFilters({ className, ...props }: SearchShellFiltersProps): import("react").JSX.Element;
export type SearchShellViewportProps = ComponentPropsWithRef<"div">;
export declare function SearchShellViewport({ className, ...props }: SearchShellViewportProps): import("react").JSX.Element;
export type SearchResultsSummaryProps = useRender.ComponentProps<"span">;
export declare function SearchResultsSummary({ className, render, ...props }: SearchResultsSummaryProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchResultsSectionProps = useRender.ComponentProps<"div">;
export declare function SearchResultsSection({ className, render, ...props }: SearchResultsSectionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchResultsSectionHeadingProps = useRender.ComponentProps<"div">;
export declare function SearchResultsSectionHeading({ className, render, ...props }: SearchResultsSectionHeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchResultsListProps = useRender.ComponentProps<"div">;
export declare function SearchResultsList({ className, render, ...props }: SearchResultsListProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/search/search-entity.d.ts
export type SearchEntityResultProps = useRender.ComponentProps<"button"> & {
selected?: boolean;
};
export declare function SearchEntityResult({ selected, className, render, ...props }: SearchEntityResultProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchEntityResultContentProps = useRender.ComponentProps<"div">;
export declare function SearchEntityResultContent({ className, render, ...props }: SearchEntityResultContentProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchEntityResultHeaderProps = useRender.ComponentProps<"div">;
export declare function SearchEntityResultHeader({ className, render, ...props }: SearchEntityResultHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchEntityResultLeadingProps = useRender.ComponentProps<"div">;
export declare function SearchEntityResultLeading({ className, render, ...props }: SearchEntityResultLeadingProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchEntityResultIconProps = useRender.ComponentProps<"div">;
export declare function SearchEntityResultIcon({ className, render, ...props }: SearchEntityResultIconProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchEntityResultActivityProps = useRender.ComponentProps<"span">;
export declare function SearchEntityResultActivity({ className, render, ...props }: SearchEntityResultActivityProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
type SearchEntityResultTextProps = useRender.ComponentProps<"span"> & {
muted?: boolean;
};
export type SearchEntityResultTitleProps = SearchEntityResultTextProps;
export declare function SearchEntityResultTitle({ muted, className, render, ...props }: SearchEntityResultTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchEntityResultDescriptionProps = SearchEntityResultTextProps;
export declare function SearchEntityResultDescription({ muted, className, render, ...props }: SearchEntityResultDescriptionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/search/search-message.d.ts
type SearchMessageResultBaseProps = useRender.ComponentProps<"button"> & {
selected?: boolean;
nested?: boolean;
};
export type SearchMessageResultProps = Omit<SearchMessageResultBaseProps, "nested">;
export declare function SearchMessageResult(props: SearchMessageResultProps): import("react").JSX.Element;
export type SearchThreadMessageResultProps = Omit<SearchMessageResultBaseProps, "nested">;
export declare function SearchThreadMessageResult(props: SearchThreadMessageResultProps): import("react").JSX.Element;
export type SearchMessageResultHeaderProps = useRender.ComponentProps<"div">;
export declare function SearchMessageResultHeader({ className, render, ...props }: SearchMessageResultHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchMessageResultBodyProps = useRender.ComponentProps<"div">;
export declare function SearchMessageResultBody({ className, render, ...props }: SearchMessageResultBodyProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchMessageResultMetaProps = useRender.ComponentProps<"span">;
export declare function SearchMessageResultMeta({ className, render, ...props }: SearchMessageResultMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchMessageResultThreadMetaProps = useRender.ComponentProps<"span">;
export declare function SearchMessageResultThreadMeta({ className, render, ...props }: SearchMessageResultThreadMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchMessageResultSenderProps = useRender.ComponentProps<"span">;
export declare function SearchMessageResultSender({ className, render, ...props }: SearchMessageResultSenderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchMessageResultTimestampProps = useRender.ComponentProps<"span">;
export declare function SearchMessageResultTimestamp({ className, render, ...props }: SearchMessageResultTimestampProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchMessageResultMatchProps = useRender.ComponentProps<"mark">;
export declare function SearchMessageResultMatch({ className, render, ...props }: SearchMessageResultMatchProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/search/search-thread.d.ts
export type SearchThreadResultProps = useRender.ComponentProps<"div"> & {
selected?: boolean;
};
export declare function SearchThreadResult({ selected, className, render, ...props }: SearchThreadResultProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchThreadResultHeaderProps = useRender.ComponentProps<"div">;
export declare function SearchThreadResultHeader({ className, render, ...props }: SearchThreadResultHeaderProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchThreadResultMetaProps = useRender.ComponentProps<"div">;
export declare function SearchThreadResultMeta({ className, render, ...props }: SearchThreadResultMetaProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchThreadResultTimestampProps = useRender.ComponentProps<"span">;
export declare function SearchThreadResultTimestamp({ className, render, ...props }: SearchThreadResultTimestampProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchThreadResultTitleProps = useRender.ComponentProps<"div">;
export declare function SearchThreadResultTitle({ className, render, ...props }: SearchThreadResultTitleProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
export type SearchThreadResultMessagesProps = useRender.ComponentProps<"div">;
export declare function SearchThreadResultMessages({ className, render, ...props }: SearchThreadResultMessagesProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
//#endregion
//#region src/components/theme-only/theme-only.d.ts
type ThemeOnlyProps = {
children?: ReactNode;
};
/** Render children only while the elegant theme family is active. */
export declare function ElegantOnly({ children }: ThemeOnlyProps): ReactNode;
/** Render children only while the brutal theme family is active. */
export declare function BrutalOnly({ children }: ThemeOnlyProps): ReactNode;
//#endregion
//#region src/lib/theme/theme-context.d.ts
/** Visual style family. Mode (light/dark/system) is a separate axis. */
type Theme = "brutal" | "elegant";
type ThemeMode = "light" | "dark" | "system";
type ResolvedThemeMode = Exclude<ThemeMode, "system">;
type SetThemeOptions = {
mode?: ThemeMode;
};
type SetTheme = {
(theme: "brutal"): void;
(theme: "elegant", options?: SetThemeOptions): void;
};
type ThemeState = {
theme: Theme;
setTheme: SetTheme;
mode: ThemeMode;
resolvedMode: ResolvedThemeMode;
};
//#endregion
//#region src/lib/theme/theme-provider.d.ts
interface ThemeProviderProps {
/**
* Controlled visual style family. Keep using this for isolated previews and
* component matrix surfaces that should not own global DOM state.
*/
theme?: Theme;
defaultTheme?: Theme;
onThemeChange?: (theme: Theme) => void;
/** Controlled light/dark behavior for the elegant family. */
mode?: ThemeMode;
defaultMode?: ThemeMode;
onModeChange?: (mode: ThemeMode) => void;
/**
* Persist uncontrolled family and mode selections. The mode key appends
* "-mode" unless `modeStorageKey` is provided.
*/
storageKey?: string;
modeStorageKey?: string;
/**
* Sync the active family/mode onto `document.documentElement`.
* Defaults to true for app-level providers. Set to false for nested previews
* or component islands that should not mutate the app root.
*/
syncDom?: boolean;
children: ReactNode;
}
export declare function ThemeProvider({ theme, defaultTheme, onThemeChange, mode, defaultMode, onModeChange, storageKey, modeStorageKey, syncDom, children }: ThemeProviderProps): import("react").JSX.Element;
//#endregion
//#region src/lib/theme/use-theme.d.ts
/** Read the active style family for theme-aware component recipes. */
export declare function useThemeFamily(): Theme;
/** Read and update the application-level RUI theme selection. */
export declare function useTheme(): ThemeState;
//#endregion
export { type AlertDialogActionProps, type AlertDialogBodyProps, type AlertDialogCancelProps, type AlertDialogCloseProps, type AlertDialogContentProps, type AlertDialogDescriptionProps, type AlertDialogFooterProps, type AlertDialogHeaderProps, type AlertDialogOverlayProps, type AlertDialogPortalProps, type AlertDialogProps, type AlertDialogTitleProps, type AlertDialogTriggerProps, type AppRailFooterProps, type AppRailHeaderProps, type AppRailItemAttentionMaskProps, type AppRailItemAttentionProps, type AppRailItemBadgeProps, type AppRailItemIconProps, type AppRailItemIndicatorProps, type AppRailItemLabelProps, type AppRailItemProps, type AppRailNavProps, type AppRailRootProps, type AppShellMainSlotProps, type AppShellOverlaySlotProps, type AppShellPanelSlotProps, type AppShellRailSlotProps, type AppShellRootProps, type AppShellSidebarSlotProps, type AppShellSidebarTriggerProps, type AvatarBadgeProps, type AvatarFallbackProps, type AvatarGroupCountProps, type AvatarGroupProps, type AvatarImageProps, type AvatarProps, type AvatarSize, type BadgeProps, type BannerActionProps, type BannerDescriptionProps, type BannerProps, type BannerStatus, type BannerTitleProps, type ButtonProps, type CardContentProps, type CardDescriptionProps, type CardFooterProps, type CardHeaderProps, type CardLeadingProps, type CardProps, type CardTitleProps, type CardTrailingProps, type CheckboxProps, type CodeBlockActionProps, type CodeBlockActionsProps, type CodeBlockBodyProps, type CodeBlockHeaderProps, type CodeBlockProps, type CodeBlockTitleProps, type ComboboxChipProps, type ComboboxChipRemoveProps, type ComboboxChipsProps, type ComboboxClearProps, type ComboboxCollectionProps, type ComboboxContentProps, type ComboboxControlProps, type ComboboxEmptyProps, type ComboboxGroupLabelProps, type ComboboxGroupProps, type ComboboxHeaderProps, type ComboboxInputGroupProps, type ComboboxInputProps, type ComboboxItemIndicatorProps, type ComboboxItemProps, type ComboboxLabelProps, type ComboboxListProps, type ComboboxPopupProps, type ComboboxPortalProps, type ComboboxProps, type ComboboxRowProps, type ComboboxSeparatorProps, type ComboboxTriggerCountProps, type ComboboxTriggerIndicatorProps, type ComboboxTriggerProps, type ComboboxValueProps, type ComposerActionsProps, type ComposerAttachmentBodyProps, type ComposerAttachmentFailedOverlayProps, type ComposerAttachmentFileProps, type ComposerAttachmentImageProps, type ComposerAttachmentMetaProps, type ComposerAttachmentProps, type ComposerAttachmentRemoveProps, type ComposerAttachmentTitleProps, type ComposerAttachmentUploadProgressBarProps, type ComposerAttachmentUploadingOverlayProps, type ComposerAttachmentsProps, type ComposerAttachmentsScrollAreaProps, type ComposerDropOverlayLabelProps, type ComposerDropOverlayPromptProps, type ComposerDropOverlayProps, type ComposerIconButtonProps, type ComposerInputProps, type ComposerMetaProps, type ComposerProps, type ComposerRootProps, type ComposerSubmitProps, type ComposerSuggestionAsideProps, type ComposerSuggestionContentProps, type ComposerSuggestionGroupLabelProps, type ComposerSuggestionGroupProps, type ComposerSuggestionIconProps, type ComposerSuggestionListProps, type ComposerSuggestionMetaProps, type ComposerSuggestionOptionProps, type ComposerSuggestionTitleProps, type ComposerSuggestionTriggerMatch, type ComposerSuggestionsInputProps, type ComposerSuggestionsListProps, type ComposerSuggestionsOptionProps, type ComposerToolbarLabelProps, type ComposerToolbarProps, type ContextMenuCheckboxItemIndicatorProps, type ContextMenuCheckboxItemProps, type ContextMenuContentProps, type ContextMenuFooterProps, type ContextMenuItemLabelProps, type ContextMenuItemProps, type ContextMenuLabelProps, type ContextMenuPopupProps, type ContextMenuPortalProps, type ContextMenuProps, type ContextMenuRadioGroupProps, type ContextMenuRadioItemIndicatorProps, type ContextMenuRadioItemProps, type ContextMenuSeparatorProps, type ContextMenuShortcutProps, type ContextMenuSubmenuProps, type ContextMenuSubmenuTriggerProps, type ContextMenuTriggerProps, type ConversationIconProps, type ConversationPanelBodyProps, type ConversationPanelContentProps, type ConversationPanelEmptyStateBrandMarkProps, type ConversationPanelEmptyStateBrandProps, type ConversationPanelEmptyStateProps, type ConversationPanelFooterProps, type ConversationPanelRootProps, type ConversationPanelTabsProps, type CopyableCodeActionProps, type CopyableCodeProps, type CopyableCodeRootProps, type DescriptionDetailsProps, type DescriptionItemProps, type DescriptionListDirection, type DescriptionListProps, type DescriptionTermProps, type DialogBodyProps, type DialogCloseProps, type DialogContentProps, type DialogDescriptionProps, type DialogFooterProps, type DialogHeaderProps, type DialogOverlayProps, type DialogPortalProps, type DialogProps, type DialogTitleProps, type DialogTriggerProps, type DrawerActionsProps, type DrawerBodyProps, type DrawerCloseProps, type DrawerContentProps, type DrawerDescriptionProps, type DrawerFooterProps, type DrawerHeaderProps, type DrawerOverlayProps, type DrawerPortalProps, type DrawerProps, type DrawerTitleProps, type DrawerTriggerProps, type DropdownMenuCheckboxItemIndicatorProps, type DropdownMenuCheckboxItemProps, type DropdownMenuContentProps, type DropdownMenuFooterProps, type DropdownMenuItemCountProps, type DropdownMenuItemLabelProps, type DropdownMenuItemProps, type DropdownMenuLabelProps, type DropdownMenuPopupProps, type DropdownMenuPortalProps, type DropdownMenuProps, type DropdownMenuRadioGroupProps, type DropdownMenuRadioItemIndicatorProps, type DropdownMenuRadioItemProps, type DropdownMenuSeparatorProps, type DropdownMenuShortcutProps, type DropdownMenuSubmenuProps, type DropdownMenuSubmenuTriggerProps, type DropdownMenuTriggerProps, type EmptyStateActionsProps, type EmptyStateContentProps, type EmptyStateDescriptionProps, type EmptyStateIconProps, type EmptyStateProps, type EmptyStateTitleProps, type FieldControlProps, type FieldDescriptionProps, type FieldErrorProps, type FieldItemProps, type FieldLabelProps, type FieldProps, type FieldValidityProps, type FilePreviewBadgeColor, type FilePreviewBadgeProps, type FilePreviewBadgeType, type FilePreviewCodeProps, type FilePreviewDocumentProps, type FilePreviewFileProps, type FilePreviewMediaProps, type FilePreviewProps, type FloatButtonGroupDirection, type FloatButtonGroupProps, type FloatButtonOffset, type FloatButtonPosition, type FloatButtonProps, type FloatButtonShape, type FloatButtonSide, type FloatButtonSize, type FloatButtonVariant, type InboxItemActionsProps, type InboxItemBodyProps, type InboxItemContentProps, type InboxItemContextProps, type InboxItemHeadingProps, type InboxItemMessageProps, type InboxItemMetadataProps, type InboxItemProps, type InboxItemSelectionProps, type InboxItemSenderProps, type InboxItemSubtitleProps, type InboxItemTimestampProps, type InboxItemTitleProps, type InboxItemTrailingProps, type InboxItemTriggerProps, type InlineCodeProps, type InputGroupAddonProps, type InputGroupAddonTextProps, type InputGroupInputProps, type InputGroupProps, type InputProps, type KbdGroupProps, type KbdProps, type LabelAsteriskProps, type LabelOptionalProps, type LabelProps, type LabelSubProps, type LegacyTaskPanelActionsProps, type LegacyTaskPanelBodyProps, type LegacyTaskPanelFieldLabelProps, type LegacyTaskPanelFieldProps, type LegacyTaskPanelFieldTextProps, type LegacyTaskPanelFieldTitleProps, type LegacyTaskPanelHeaderProps, type LegacyTaskPanelIconProps, type LegacyTaskPanelMetaLabelProps, type LegacyTaskPanelMetaProps, type LegacyTaskPanelMetaRowProps, type LegacyTaskPanelMetaValueProps, type LegacyTaskPanelRootProps, type LegacyTaskPanelSectionProps, type LegacyTaskPanelStatusProps, type LegacyTaskPanelTitleMetaProps, type LegacyTaskPanelTitleProps, type LightboxActionsProps, type LightboxCloseProps, type LightboxContentProps, type LightboxHeaderLabelProps, type LightboxHeaderMetaProps, type LightboxHeaderProps, type LightboxInfoActionsProps, type LightboxInfoBarProps, type LightboxInfoDockProps, type LightboxInfoTitleProps, type LightboxMediaProps, type LightboxNavigationButtonProps, type LightboxPortalProps, type LightboxProps, type LightboxStageProps, type LightboxThumbnailProps, type LightboxThumbnailStripProps, type LightboxTitleProps, type LightboxToolbarProps, type LightboxTriggerProps, type LiveAgentActivityBarAvatarProps, type LiveAgentActivityBarContentProps, type LiveAgentActivityBarProps, type LiveAgentActivityBarRowProps, type LiveAgentActivityBarStatusProps, type LiveAgentActivityBarTextProps, type MarkdownBlockquoteProps, type MarkdownCellProps, type MarkdownCheckboxProps, type MarkdownHeaderCellProps, type MarkdownHeadingLevel, type MarkdownHeadingProps, type MarkdownImageProps, type MarkdownInlineCodeProps, type MarkdownLinkProps, type MarkdownListItemProps, type MarkdownListProps, type MarkdownMarkProps, type MarkdownOrderedListProps, type MarkdownParagraphProps, type MarkdownRuleProps, type MarkdownTableProps, type MarkdownTableRowProps, type MarkdownTableScrollProps, type MessageActionCardActionsProps, type MessageActionCardCompletionProps, type MessageActionCardContentProps, type MessageActionCardHeaderProps, type MessageActionCardHeaderStatusProps, type MessageActionCardHintProps, type MessageActionCardPropertiesProps, type MessageActionCardPropertyLabelProps, type MessageActionCardPropertyProps, type MessageActionCardPropertyValueProps, type MessageActionCardProps, type MessageActionCardScopeDescriptionProps, type MessageActionCardScopeListLabelProps, type MessageActionCardScopeListProps, type MessageActionCardScopeNameProps, type MessageActionCardScopeProps, type MessageAttachmentActionProps, type MessageAttachmentCardProps, type MessageAttachmentCommentSummaryProps, type MessageAttachmentDiffAdditionProps, type MessageAttachmentDiffDeletionProps, type MessageAttachmentDiffSummaryProps, type MessageAttachmentGroupProps, type MessageAttachmentMetaEndProps, type MessageAttachmentMetaProps, type MessageAttachmentMetaStartProps, type MessageAttachmentSummaryProps, type MessageAttachmentTitleProps, type MessageEmbedContentProps, type MessageEmbedFooterProps, type MessageEmbedHeaderProps, type MessageEmbedProps, type MessageForwardedBundleAttachmentMetaProps, type MessageForwardedBundleAttachmentNameProps, type MessageForwardedBundleAttachmentProps, type MessageForwardedBundleAttachmentsProps, type MessageForwardedBundleFooterActionProps, type MessageForwardedBundleFooterProps, type MessageForwardedBundleHeaderContentProps, type MessageForwardedBundleHeaderCountProps, type MessageForwardedBundleHeaderLabelProps, type MessageForwardedBundleHeaderProps, type MessageForwardedBundleItemAuthorProps, type MessageForwardedBundleItemMetaProps, type MessageForwardedBundleItemProps, type MessageForwardedBundleItemsProps, type MessageForwardedBundleProps, type MessageForwardedBundleSourceLabelProps, type MessageForwardedBundleSourceProps, type MessageImageGalleryActionProps, type MessageImageGalleryItemProps, type MessageImageGalleryMediaProps, type MessageImageGalleryOverlayProps, type MessageImageGalleryPreviewProps, type MessageImageGalleryProps, type MessageItemAttachmentsProps, type MessageItemAvatarSlotProps, type MessageItemBadgeProps, type MessageItemBadgeSeparatorProps, type MessageItemBadgeStatus, type MessageItemBodyProps, type MessageItemContentProps, type MessageItemContinuationTimeProps, type MessageItemEmbeddedProps, type MessageItemFooterProps, type MessageItemGutterProps, type MessageItemHeaderProps, type MessageItemInlineStatusProps, type MessageItemMetaProps, type MessageItemProps, type MessageItemReadReceiptProps, type MessageItemSavedIndicatorElevation, type MessageItemSavedIndicatorProps, type MessageItemSearchMatchProps, type MessageItemSenderBadgesProps, type MessageItemSenderButtonProps, type MessageItemSenderProps, type MessageItemTimeProps, type MessageItemToolbarButtonProps, type MessageItemToolbarProps, type MessageItemTranslationActionProps, type MessageItemTranslationFailedStatusProps, type MessageItemTranslationOriginalLabelProps, type MessageItemTranslationOriginalProps, type MessageItemTranslationProgressTrackProps, type MessageItemTranslationRetryActionProps, type MessageItemTranslationStatusProps, type MessageListDateDividerProps, type MessageListHistoryLimitedProps, type MessageListNoticeProps, type MessageListProps, type MessageMultiSelectCheckboxProps, type MessageMultiSelectProps, type MessageMultiSelectToolbarProps, type MessageQuotedPreviewAttachmentProps, type MessageQuotedPreviewAttachmentsProps, type MessageQuotedPreviewAuthorMetaProps, type MessageQuotedPreviewAuthorNameProps, type MessageQuotedPreviewAuthorProps, type MessageQuotedPreviewChannelProps, type MessageQuotedPreviewContentProps, type MessageQuotedPreviewHeaderProps, type MessageQuotedPreviewLoadingProps, type MessageQuotedPreviewProps, type MessageQuotedPreviewTextProps, type MessageQuotedPreviewThreadProps, type MessageQuotedPreviewTimestampProps, type MessageQuotedPreviewUnavailableProps, type MessageReactionAddButtonProps, type MessageReactionChipProps, type MessageReactionCountProps, type MessageReactionErrorIndicatorProps, type MessageReactionGlyphProps, type MessageReactionPickerContentProps, type MessageReactionPickerStaticProps, type MessageReactionQuickButtonProps, type MessageReactionQuickRowProps, type MessageReactionTooltipContentProps, type MessageReactionTooltipMetaProps, type MessageReactionTooltipNameProps, type MessageReactionTooltipNameTextProps, type MessageReactionTooltipNamesProps, type MessageReactionTooltipSeparatorProps, type MessageReferenceBadgeProps, type MessageReferenceChipProps, type MessageReferenceChipVariant, type MessageReferenceIndicatorProps, type MessageReferenceLabelProps, type MessageReferencePendingProps, type MessageReferenceTextProps, type MessageReferenceTextVariant, type MessageReferenceUnavailableProps, type MessageRepliesItemContentProps, type MessageRepliesItemProps, type MessageRepliesItemSenderProps, type MessageRepliesItemTimeProps, type MessageRepliesProps, type MessageRepliesSummaryItemProps, type MessageRepliesSummaryProps, type MessageTextSelectionToolbarButtonProps, type MessageTextSelectionToolbarProps, type MessageTextSelectionToolbarSeparatorProps, type MessageVideoPreviewActionProps, type MessageVideoPreviewFailureActionProps, type MessageVideoPreviewFailureContentProps, type MessageVideoPreviewFailureIconProps, type MessageVideoPreviewFailureTitleProps, type MessageVideoPreviewFallbackProps, type MessageVideoPreviewMediaProps, type MessageVideoPreviewProps, type MobileNavItemProps, type MobileNavLabelProps, type MobileNavRootProps, type NotificationCenterActionButtonProps, type NotificationCenterCountProps, type NotificationCenterEmptyStateProps, type NotificationCenterHeaderProps, type NotificationCenterItemActionsProps, type NotificationCenterItemBodyProps, type NotificationCenterItemContentProps, type NotificationCenterItemIconProps, type NotificationCenterItemProps, type NotificationCenterItemRowProps, type NotificationCenterItemTitleProps, type NotificationCenterListProps, type NotificationCenterPopupProps, type NotificationCenterPortalProps, type NotificationCenterProps, type NotificationCenterScrollerProps, type NotificationCenterTitleProps, type NotificationCenterTriggerProps, type OrderedTabItem, type PanelActionProps, type PanelActionsProps, type PanelActivityProps, type PanelBodyProps, type PanelEdge, type PanelFooterProps, type PanelHeaderContentProps, type PanelHeaderIconProps, type PanelHeaderProps, type PanelHeaderRootProps, type PanelHeadingProps, type PanelMetaProps, type PanelProps, type PanelScrollContentProps, type PanelScrollViewportProps, type PanelSectionHeaderProps, type PanelSectionProps, type PanelStatusProps, type PanelTitleProps, type PanelToggleActionProps, type PickerTriggerButtonProps, type PopoverArrowProps, type PopoverBackdropProps, type PopoverCloseProps, type PopoverContentProps, type PopoverDescriptionProps, type PopoverHeaderProps, type PopoverPopupProps, type PopoverPortalProps, type PopoverProps, type PopoverSeparatorProps, type PopoverTitleProps, type PopoverTriggerProps, type PopoverViewportProps, type PreviewCardArrowProps, type PreviewCardContentProps, type PreviewCardDescriptionProps, type PreviewCardHeaderProps, type PreviewCardPopupProps, type PreviewCardPortalProps, type PreviewCardProps, type PreviewCardSeparatorProps, type PreviewCardTitleProps, type PreviewCardTriggerProps, type ProfilePanelBodyProps, type ProfilePanelHeaderContentProps, type ProfilePanelHeaderProps, type ProfilePanelProps, type ProfilePanelSectionProps, type ProgressHeaderProps, type ProgressIndicatorProps, type ProgressLabelProps, type ProgressProps, type ProgressTrackProps, type ProgressValueProps, type RadioGroupIndicatorProps, type RadioGroupItemProps, type RadioGroupProps, type RaftLogoLockupProps, type RaftLogoProps, type RaftWordmarkProps, type ResizableGroupProps, type ResizableHandleProps, type ResizablePanelProps, type ResolvedThemeMode, type ScrollAreaContentProps, type ScrollAreaCornerProps, type ScrollAreaProps, type ScrollAreaScrollbarProps, type ScrollAreaThumbProps, type ScrollAreaViewportProps, type SegmentedControlCountProps, type SegmentedControlItemProps, type SegmentedControlLabelProps, type SegmentedControlProps, type SelectArrowProps, type SelectContentProps, type SelectGroupLabelProps, type SelectGroupProps, type SelectIconProps, type SelectItemIndicatorProps, type SelectItemLeadingProps, type SelectItemProps, type SelectItemTextProps, type SelectLabelProps, type SelectListProps, type SelectPopupProps, type SelectPortalProps, type SelectProps, type SelectScrollDownArrowProps, type SelectScrollUpArrowProps, type SelectSeparatorProps, type SelectTriggerProps, type SelectValueProps, type SeparatorProps, type SetTheme, type SetThemeOptions, type SidebarBodyProps, type SidebarContentProps, type SidebarControlProps, type SidebarGroupLabelProps, type SidebarHeaderProps, type SidebarHeaderTitleProps, type SidebarItemAsideProps, type SidebarItemChannelIconProps, type SidebarItemContentProps, type SidebarItemCountProps, type SidebarItemIconProps, type SidebarItemIndicatorProps, type SidebarItemMetaIconProps, type SidebarItemMetaProps, type SidebarItemProps, type SidebarItemStatusProps, type SidebarItemSubtitleProps, type SidebarItemTitleProps, type SidebarItemVariant, type SidebarListProps, type SidebarLiveActivityProps, type SidebarMenuAsideProps, type SidebarMenuCountProps, type SidebarMenuIconProps, type SidebarMenuProps, type SidebarMenuTitleProps, type SidebarRootProps, type SidebarSectionAttentionProps, type SidebarSectionChevronProps, type SidebarSectionControlProps, type SidebarSectionControlsProps, type SidebarSectionCountProps, type SidebarSectionDisclosureProps, type SidebarSectionEmptyProps, type SidebarSectionHeaderProps, type SidebarSectionProps, type SidebarSectionTitleProps, type SidebarSectionTrailingProps, type SkeletonProps, type SkeletonVariant, type SortableComposerAttachmentProps, type SortableComposerAttachmentsProps, type SortableTabsListProps, type SortableTabsTabProps, type SpinnerProps, type StatusProps, type SwitchProps, type SwitchThumbProps, type SystemMessageContentProps, type SystemMessageGroupChevronProps, type SystemMessageGroupDisclosureProps, type SystemMessageGroupHeaderProps, type SystemMessageGroupPanelProps, type SystemMessageGroupProps, type SystemMessageGroupSummaryProps, type SystemMessageProps, type SystemMessageTimeProps, type TabsBackgroundProps, type TabsIndicatorProps, type TabsLabelProps, type TabsListProps, type TabsPanelProps, type TabsProps, type TabsTabProps, type TaskBoardColumnBadgeProps, type TaskBoardColumnChevronProps, type TaskBoardColumnCountProps, type TaskBoardColumnEmptyAllowedProps, type TaskBoardColumnEmptyBlockedProps, type TaskBoardColumnEmptyIdleProps, type TaskBoardColumnEmptyProps, type TaskBoardColumnHeadingProps, type TaskBoardColumnItemsProps, type TaskBoardColumnPanelProps, type TaskBoardColumnProps, type TaskBoardColumnTriggerProps, type TaskBoardRootProps, type TaskCardBodyProps, type TaskCardChannelProps, type TaskCardDescriptionProps, type TaskCardLegacyProps, type TaskCardMetaProps, type TaskCardNumberProps, type TaskCardProps, type TaskCardRowProps, type TaskCardStatusProps, type TaskCardTitleProps, type TaskChipProps, type TaskChipVariant, type TaskDndProviderProps, type TaskDragOverlayProps, type TaskDraggableProps, type TaskDropData, type TaskDropPlaceholderProps, type TaskDropPlacement, type TaskDropState, type TaskDropZoneProps, type TaskDropZoneState, type TaskListRootProps, type TaskLoadingListProps, type TaskLoadingRowProps, type TaskMoveDetails, type TaskSectionBadgeProps, type TaskSectionChevronProps, type TaskSectionCountProps, type TaskSectionEmptyProps, type TaskSectionHeadingProps, type TaskSectionItemsProps, type TaskSectionPanelProps, type TaskSectionProps, type TaskSectionTriggerProps, type TaskStatusId, type TasksPanelEmptyProps, type TasksPanelRootProps, type TasksPanelToolbarFiltersProps, type TasksPanelToolbarGroupProps, type TasksPanelToolbarLabelProps, type TasksPanelToolbarNewTaskProps, type TasksPanelToolbarProps, type TasksPanelToolbarViewProps, type TasksPanelViewportProps, type TextHeadingProps, type TextMonoProps, type TextSansProps, type TextareaCounterProps, type TextareaGroupProps, type TextareaProps, type Theme, type ThemeMode, type ThemeOnlyProps, type ThemeProviderProps, type ThemeState, type ThreadPanelActionsProps, type ThreadPanelBodyProps, type ThreadPanelContentProps, type ThreadPanelFooterProps, type ThreadPanelHeaderProps, type ThreadPanelOriginalMessageProps, type ThreadPanelReplyCountProps, type ThreadPanelReplySummaryProps, type ThreadPanelRootProps, type ThreadPanelSearchCountProps, type ThreadPanelSearchProps, type ThreadPanelSearchTrailingProps, type ThreadPanelTitleMetaProps, type ThreadPanelTitleProps, type ToastActionProps, type ToastActionsProps, type ToastArrowProps, type ToastBodyProps, type ToastCloseProps, type ToastContentProps, type ToastData, type ToastDescriptionProps, type ToastIconProps, type ToastIntent, type ToastObject, type ToastPortalProps, type ToastPositionerProps, type ToastProgressProps, type ToastProviderProps, type ToastRootProps, type ToastTitleProps, type ToastViewportProps, type ToggleGroupItemProps, type ToggleGroupLabelProps, type ToggleGroupProps, type TooltipContentProps, type TooltipPortalProps, type TooltipProps, type TooltipProviderProps, type TooltipTriggerProps, type UseComposerSuggestionsParams, cn };