@qwen-code/web-shell 0.24.1-preview.0

package/dist/types/components/ui/data-table.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentProps, ReactNode } from 'react';
+import { type Row, type Table as TanStackTable } from '@tanstack/react-table';
+export interface DataTableColumnMeta<TData = unknown> {
+    headerClassName?: string;
+    width?: number;
+    fixedWidth?: boolean;
+    fluidWeight?: number;
+    fixed?: 'left' | 'right';
+    fixedOffset?: number;
+    fixedEdge?: boolean;
+    stopRowClick?: boolean;
+    truncate?: boolean | ((row: TData) => boolean);
+    tooltip?: (row: TData) => ReactNode;
+}
+export declare function DataTable<TData>({ table, className, emptyContent, onRowClick, rowClassName, ...props }: Omit<ComponentProps<'div'>, 'children' | 'onClick' | 'onScrollCapture' | 'ref'> & {
+    table: TanStackTable<TData>;
+    emptyContent?: ReactNode;
+    onRowClick?: (row: Row<TData>) => void;
+    rowClassName?: string | ((row: Row<TData>) => string | undefined);
+}): import("react/jsx-runtime").JSX.Element;
+export declare function DataTablePagination<TData>({ table, pageSizes, labels, onPageSizeChange, }: {
+    table: TanStackTable<TData>;
+    pageSizes: readonly number[];
+    labels: {
+        rowsPerPage: string;
+        previous: ReactNode;
+        next: ReactNode;
+        page: (current: number, total: number) => ReactNode;
+    };
+    onPageSizeChange?: (pageSize: number) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ui/dialog.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { Dialog as DialogPrimitive } from 'radix-ui';
+declare function Dialog({ ...props }: React.ComponentProps<typeof DialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DialogTrigger({ ...props }: React.ComponentProps<typeof DialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DialogPortal({ container, ...props }: React.ComponentProps<typeof DialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DialogClose({ ...props }: React.ComponentProps<typeof DialogPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type DialogContentProps = React.ComponentProps<typeof DialogPrimitive.Content> & {
+    showCloseButton?: boolean;
+    overlayProps?: React.ComponentProps<typeof DialogPrimitive.Overlay>;
+};
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function DialogFooter({ className, showCloseButton, children, ...props }: React.ComponentProps<'div'> & {
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DialogDescription({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };

package/dist/types/components/ui/drawer.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Drawer as DrawerPrimitive } from 'vaul';
+declare function Drawer({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerTrigger({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerPortal({ container, ...props }: React.ComponentProps<typeof DrawerPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerClose({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
+declare const DrawerOverlay: React.ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-dialog").DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type DrawerContentProps = React.ComponentProps<typeof DrawerPrimitive.Content> & {
+    overlayProps?: React.ComponentProps<typeof DrawerPrimitive.Overlay>;
+};
+declare const DrawerContent: React.ForwardRefExoticComponent<Omit<DrawerContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function DrawerHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerTitle({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function DrawerDescription({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+export { Drawer, DrawerPortal, DrawerOverlay, DrawerTrigger, DrawerClose, DrawerContent, DrawerHeader, DrawerFooter, DrawerTitle, DrawerDescription, };

package/dist/types/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { DropdownMenu as DropdownMenuPrimitive } from 'radix-ui';
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuPortal({ container, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare function DropdownMenuContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: 'default' | 'destructive';
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/types/components/ui/empty.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from 'class-variance-authority';
+declare function Empty({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function EmptyHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function EmptyMedia({ className, variant, ...props }: React.ComponentProps<'div'> & VariantProps<typeof emptyMediaVariants>): import("react/jsx-runtime").JSX.Element;
+declare function EmptyTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function EmptyDescription({ className, ...props }: React.ComponentProps<'p'>): import("react/jsx-runtime").JSX.Element;
+declare function EmptyContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Empty, EmptyHeader, EmptyTitle, EmptyDescription, EmptyContent, EmptyMedia, };

package/dist/types/components/ui/field.d.ts

@@ -0,0 +1,24 @@
+import { type VariantProps } from 'class-variance-authority';
+import { Label } from '@/components/ui/label';
+declare function FieldSet({ className, ...props }: React.ComponentProps<'fieldset'>): import("react/jsx-runtime").JSX.Element;
+declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<'legend'> & {
+    variant?: 'legend' | 'label';
+}): import("react/jsx-runtime").JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Field({ className, orientation, ...props }: React.ComponentProps<'div'> & VariantProps<typeof fieldVariants>): import("react/jsx-runtime").JSX.Element;
+declare function FieldContent({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): import("react/jsx-runtime").JSX.Element;
+declare function FieldTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function FieldDescription({ className, ...props }: React.ComponentProps<'p'>): import("react/jsx-runtime").JSX.Element;
+declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<'div'> & {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<'div'> & {
+    errors?: Array<{
+        message?: string;
+    } | undefined>;
+}): import("react/jsx-runtime").JSX.Element | null;
+export { Field, FieldLabel, FieldDescription, FieldError, FieldGroup, FieldLegend, FieldSeparator, FieldSet, FieldContent, FieldTitle, };

package/dist/types/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/types/components/ui/label.d.ts

@@ -0,0 +1,4 @@
+import type * as React from 'react';
+import { Label as LabelPrimitive } from 'radix-ui';
+declare function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Label };

package/dist/types/components/ui/management-notice.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+export type ManagementNoticeTone = 'error' | 'success' | 'info' | 'progress';
+interface ManagementNoticeProps {
+    children: ReactNode;
+    closeLabel: string;
+    noticeKey: string;
+    onDismiss: () => void;
+    tone: ManagementNoticeTone;
+    className?: string;
+}
+export declare function ManagementNotice({ children, closeLabel, noticeKey, onDismiss, tone, className, }: ManagementNoticeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/ui/popover.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { Popover as PopoverPrimitive } from 'radix-ui';
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+type PopoverContentProps = React.ComponentProps<typeof PopoverPrimitive.Content> & {
+    showArrow?: boolean;
+};
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTitle({ className, ...props }: React.ComponentProps<'h2'>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverDescription({ className, ...props }: React.ComponentProps<'p'>): import("react/jsx-runtime").JSX.Element;
+export { Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, };

package/dist/types/components/ui/radio-group.d.ts

@@ -0,0 +1,5 @@
+import type * as React from 'react';
+import { RadioGroup as RadioGroupPrimitive } from 'radix-ui';
+declare function RadioGroup({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function RadioGroupItem({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+export { RadioGroup, RadioGroupItem };

package/dist/types/components/ui/scroll-area.d.ts

@@ -0,0 +1,5 @@
+import type * as React from 'react';
+import { ScrollArea as ScrollAreaPrimitive } from 'radix-ui';
+declare function ScrollArea({ className, children, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): import("react/jsx-runtime").JSX.Element;
+export { ScrollArea, ScrollBar };

package/dist/types/components/ui/select.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Select as SelectPrimitive } from 'radix-ui';
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SelectGroup({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+type SelectTriggerProps = React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: 'sm' | 'default';
+};
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare function SelectContent({ className, children, position, align, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/types/components/ui/separator.d.ts

@@ -0,0 +1,4 @@
+import type * as React from 'react';
+import { Separator as SeparatorPrimitive } from 'radix-ui';
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Separator };

package/dist/types/components/ui/skeleton.d.ts

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

package/dist/types/components/ui/spinner.d.ts

@@ -0,0 +1,2 @@
+declare function Spinner({ className, ...props }: React.ComponentProps<'svg'>): import("react/jsx-runtime").JSX.Element;
+export { Spinner };

package/dist/types/components/ui/switch.d.ts

@@ -0,0 +1,6 @@
+import type * as React from 'react';
+import { Switch as SwitchPrimitive } from 'radix-ui';
+declare function Switch({ className, size, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root> & {
+    size?: 'sm' | 'default';
+}): import("react/jsx-runtime").JSX.Element;
+export { Switch };

package/dist/types/components/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+declare const Table: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "ref"> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "ref"> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/types/components/ui/tabs.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentProps } from 'react';
+import { type VariantProps } from 'class-variance-authority';
+import { Tabs as TabsPrimitive } from 'radix-ui';
+declare function Tabs({ className, orientation, ...props }: ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare const tabsListVariants: (props?: ({
+    variant?: "default" | "line" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const TabsList: import("react").ForwardRefExoticComponent<Omit<Omit<TabsPrimitive.TabsListProps & import("react").RefAttributes<HTMLDivElement>, "ref">, "asChild"> & VariantProps<(props?: ({
+    variant?: "default" | "line" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & import("react").RefAttributes<HTMLDivElement>>;
+declare function TabsTrigger({ className, ...props }: ComponentProps<typeof TabsPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TabsContent({ className, ...props }: ComponentProps<typeof TabsPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

package/dist/types/components/ui/textarea.d.ts

@@ -0,0 +1,3 @@
+import type * as React from 'react';
+declare function Textarea({ className, ...props }: React.ComponentProps<'textarea'>): import("react/jsx-runtime").JSX.Element;
+export { Textarea };

package/dist/types/components/ui/toggle-group.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+import { ToggleGroup as ToggleGroupPrimitive } from 'radix-ui';
+import { toggleVariants } from '@/components/ui/toggle';
+declare function ToggleGroup({ className, variant, size, spacing, orientation, children, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+    orientation?: 'horizontal' | 'vertical';
+}): import("react/jsx-runtime").JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+export { ToggleGroup, ToggleGroupItem };

package/dist/types/components/ui/toggle.d.ts

@@ -0,0 +1,9 @@
+import type * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+import { Toggle as TogglePrimitive } from 'radix-ui';
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Toggle({ className, variant, size, ...props }: React.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+export { Toggle, toggleVariants };

package/dist/types/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { Tooltip as TooltipPrimitive } from 'radix-ui';
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/types/components/workflow/SessionWorkflowCockpit.d.ts

@@ -0,0 +1,17 @@
+import type { DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall, TodoItem } from '../../adapters/types';
+interface SessionWorkflowCockpitProps {
+    sessionId: string;
+    connected: boolean;
+    sessionName?: string;
+    workspaceCwd?: string;
+    todos: readonly TodoItem[];
+    tools: readonly ACPToolCall[];
+    tasks: readonly DaemonSessionTaskStatus[];
+    selectedTodoId?: string;
+    onSelectedTodoIdChange: (todoId: string | undefined) => void;
+    onBackToChat: () => void;
+    onOpenSubagent: (tool: ACPToolCall) => void;
+}
+export declare function SessionWorkflowCockpit({ sessionId, connected, sessionName, workspaceCwd, todos, tools, tasks, selectedTodoId, onSelectedTodoIdChange, onBackToChat, onOpenSubagent, }: SessionWorkflowCockpitProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/workflow/SessionWorkflowInspector.d.ts

@@ -0,0 +1,15 @@
+import type { DaemonSessionArtifact, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall, TodoItem } from '../../adapters/types';
+export interface SessionWorkflowInspectorProps {
+    todos: readonly TodoItem[];
+    tools: readonly ACPToolCall[];
+    tasks: readonly DaemonSessionTaskStatus[];
+    artifacts: readonly DaemonSessionArtifact[];
+    selectedTodoId?: string;
+    onSelectedTodoIdChange: (todoId: string | undefined) => void;
+    onExpandGraph: () => void;
+    onOpenSubagent: (tool: ACPToolCall) => void;
+    onOpenArtifact?: (artifactId: string) => void;
+    canvasMode?: boolean;
+}
+export declare function SessionWorkflowInspector({ todos, tools, tasks, artifacts, selectedTodoId, onSelectedTodoIdChange, onExpandGraph, onOpenSubagent, onOpenArtifact, canvasMode, }: SessionWorkflowInspectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workflow/session-workflow-model.d.ts

@@ -0,0 +1,32 @@
+import type { DaemonSessionAgentTaskStatus, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall, TodoItem } from '../../adapters/types';
+import { type PlanNodeStatus } from '../messages/PlanExecutionView';
+export interface SessionWorkflowProjection {
+    todosById: ReadonlyMap<string, TodoItem>;
+    toolsByTaskId: ReadonlyMap<string, ACPToolCall>;
+    toolsByTodo: ReadonlyMap<string, readonly ACPToolCall[]>;
+    agentToolsByTodo: ReadonlyMap<string, readonly ACPToolCall[]>;
+    tasksByTool: ReadonlyMap<ACPToolCall, DaemonSessionAgentTaskStatus>;
+    states: ReadonlyMap<string, {
+        status: PlanNodeStatus;
+        attention: boolean;
+    }>;
+    /**
+     * Steps each step unblocks. Derived here so the inspector does not rescan
+     * every todo's `blockedBy` to answer the same question the graph already
+     * answers for its edges.
+     */
+    dependentsByTodo: ReadonlyMap<string, readonly TodoItem[]>;
+    attentionTodos: readonly TodoItem[];
+    activeAgents: readonly DaemonSessionAgentTaskStatus[];
+    activity: readonly DaemonSessionAgentTaskStatus[];
+    completedCount: number;
+    progressPercent: number;
+    taskStatusI18nKey: 'workflow.task.attention' | 'workflow.task.running' | 'workflow.task.completed' | 'workflow.task.waitingExecution';
+    taskStatusTone: 'attention' | 'running' | 'completed' | 'waiting';
+}
+export declare function buildSessionWorkflowProjection(todos: readonly TodoItem[], tools: readonly ACPToolCall[], tasks: readonly DaemonSessionTaskStatus[]): SessionWorkflowProjection;
+export declare function getDefaultWorkflowTodoId(todos: readonly TodoItem[], projection: SessionWorkflowProjection): string | undefined;
+export declare function workflowTaskStatusKey(status: DaemonSessionAgentTaskStatus['status']): "workflow.status.running" | "workflow.status.paused" | "workflow.status.completed" | "workflow.status.failed" | "workflow.status.cancelled";
+export declare function workflowInitials(value: string): string;
+export declare function workflowClock(timestamp?: number, language?: string): string;

package/dist/types/components/workflows/WorkflowRunsPage.d.ts

@@ -0,0 +1,6 @@
+interface WorkflowRunsPageProps {
+    onCreateViaChat: () => void;
+    onWorkflowRunStarted?: () => void;
+}
+export declare function WorkflowRunsPage({ onCreateViaChat, onWorkflowRunStarted, }: WorkflowRunsPageProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/workspaces/WorkspaceRemovalDialog.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { WorkspaceRemovalController } from './useWorkspaceRemoval';
+export interface WorkspaceRemovalDialogProps {
+    removal: WorkspaceRemovalController;
+    /**
+     * The forced retry targets the workspace the active session lives in; the
+     * dialog explains and disables it. Mirrored by the hook's `blockForce`.
+     */
+    currentSessionInCandidate: boolean;
+}
+/**
+ * Confirm dialog for removing a workspace, shared by the sidebar rows and
+ * the Workspaces panel. Renders nothing until the controller holds a
+ * candidate.
+ */
+export declare function WorkspaceRemovalDialog({ removal, currentSessionInCandidate, }: WorkspaceRemovalDialogProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/workspaces/WorkspacesOverviewPanel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Ref } from 'react';
+export interface WorkspacesOverviewPanelProps {
+    onClose: () => void;
+    /** Starts a new draft in the row's workspace (every row names one). */
+    onNewSession: (workspaceCwd: string) => Promise<boolean> | boolean;
+    /** Opens the existing Add-workspace dialog; hidden when not registered. */
+    onAddWorkspace?: () => void;
+    onError?: (error: unknown, message: string) => void;
+    initialFocusRef?: Ref<HTMLHeadingElement>;
+}
+/**
+ * Full-page table of every registered workspace: name, path, session counts,
+ * MCP health, branch and last activity, with the per-row actions the sidebar
+ * offers in its `⋮` menu. Layer B2 of the workspace-overview plan.
+ */
+export declare function WorkspacesOverviewPanel({ onClose, onNewSession, onAddWorkspace, onError, initialFocusRef, }: WorkspacesOverviewPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspaces/useWorkspaceRemoval.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonWorkspaceCapability, DaemonWorkspaceRemovalActivity } from '@qwen-code/sdk/daemon';
+export interface UseWorkspaceRemovalOptions {
+    /** The daemon mutation; the sidebar and the Workspaces panel share it. */
+    removeWorkspace: (workspaceId: string, options: {
+        force: boolean;
+    }) => Promise<unknown>;
+    /**
+     * Runs after the daemon confirmed the removal (directly, or via the
+     * `workspace_mismatch` answer that means it was already gone). The caller
+     * reconciles its own view — capability refresh, catalog invalidation,
+     * selection. The hook clears its dialog state afterwards.
+     */
+    onRemoved: (removed: DaemonWorkspaceCapability) => Promise<void> | void;
+    onError: (error: unknown, message: string) => void;
+    /** Localized message for `onError`; the hook itself renders no text. */
+    errorMessage: string;
+    /**
+     * Refuses the forced retry for a candidate (e.g. the active session lives
+     * in it). Mirrors the dialog's disabled state so a stale click cannot
+     * bypass it.
+     */
+    blockForce?: (candidate: DaemonWorkspaceCapability) => boolean;
+}
+export interface WorkspaceRemovalController {
+    candidate: DaemonWorkspaceCapability | null;
+    activity: DaemonWorkspaceRemovalActivity | null;
+    submitting: boolean;
+    remoteInProgress: boolean;
+    /** Opens the dialog for one workspace; ignored while a removal runs. */
+    request: (candidate: DaemonWorkspaceCapability) => void;
+    confirm: () => Promise<void>;
+    dismiss: () => void;
+}
+/**
+ * The workspace-removal flow shared by the sidebar rows and the Workspaces
+ * panel: confirm → remove, `workspace_busy` (409) surfaces the daemon's
+ * activity report and arms a forced retry, `workspace_mismatch` (400) means
+ * the workspace is already gone and reconciles, and
+ * `workspace_removal_in_progress` / `workspace_registration_in_progress`
+ * retry briefly while another writer converges.
+ */
+export declare function useWorkspaceRemoval(options: UseWorkspaceRemovalOptions): WorkspaceRemovalController;

package/dist/types/config/daemon.d.ts

@@ -0,0 +1,41 @@
+export declare function getDaemonBaseUrl(): string;
+/**
+ * Whether host-local affordances are safe to offer here: true only when this
+ * page was served from a loopback host AND the shell is not pointed at a
+ * different daemon origin. Deliberately narrower than "the browser and the
+ * daemon are on the same machine": it is the same-origin form of that question.
+ * A remote browser reaching a forwarded loopback daemon is excluded because its
+ * page host is not loopback, and an explicit `?daemon=` naming another origin
+ * is treated as remote even when that origin is loopback too — the shell cannot
+ * prove a same-machine pair from a different origin.
+ */
+export declare function isLocalDaemon(): boolean;
+/**
+ * Whether the connected daemon is the page's own origin. This gates the
+ * browser-local file bridge: widening `?daemon=` past loopback made a
+ * cross-origin target reachable for every consumer, and handing a client
+ * directory to a remote daemon contradicts the bridge's "files stay on your
+ * computer" promise. Keyed on the daemon's identity relative to the page —
+ * never on loopback-ness — so the documented same-origin SSH-tunnel
+ * deployment keeps working.
+ */
+export declare function isPageOriginDaemon(baseUrl: string | undefined): boolean;
+export declare function persistDaemonToken(token: string, baseUrl?: string): void;
+/**
+ * Whether a fresh load of this page could still authenticate: a token in the
+ * URL or in the per-tab persisted copy survives a reload. Retry affordances
+ * that reload the page must check this first — when the token lives only in
+ * this module's memory (URL stripped at boot, persist threw), a reload
+ * strands the shell unauthenticated. Must not consult `getDaemonToken()`:
+ * its in-memory cache always reports a token after boot.
+ */
+export declare function hasReloadSurvivableDaemonToken(): boolean;
+export declare function getDaemonToken(baseUrl?: string): string | undefined;
+export declare function waitForDaemonTokenMessage(timeoutMs?: number): Promise<string | undefined>;
+export declare function removeDaemonTokenFromUrl(): void;
+export declare function getDaemonAuthHeaders(): HeadersInit | undefined;
+export declare function getAllowedDaemonOrigin(raw: string): string;
+export declare function buildDaemonConnectionUrl(raw: string, currentHref: string): string | undefined;
+export declare function confirmDaemonTarget(origin: string): void;
+export declare function isKnownDaemonTarget(origin: string): boolean;
+export declare function navigateToDaemon(raw: string, token?: string): boolean;

package/dist/types/config/standalone.d.ts

@@ -0,0 +1 @@
+export declare const StandaloneContext: import("react").Context<boolean>;

package/dist/types/constants/loadingPhrases.d.ts

@@ -0,0 +1,4 @@
+export declare const PHRASE_CHANGE_INTERVAL_MS = 15000;
+export declare const WITTY_LOADING_PHRASES_EN: string[];
+export declare const WITTY_LOADING_PHRASES_ZH: string[];
+export declare function getLoadingPhrases(language?: string): string[];

package/dist/types/constants/localCommands.d.ts

@@ -0,0 +1,27 @@
+import type { CommandInfo } from '../adapters/types';
+import type { useI18n } from '../i18n';
+type Translate = ReturnType<typeof useI18n>['t'];
+/**
+ * Commands that should always appear in the slash-command completion menu,
+ * regardless of what ACP sends (ACP filters most BUILT_IN commands to
+ * 'interactive' mode only). These are merged with ACP-provided commands,
+ * with ACP taking precedence on duplicates.
+ */
+export declare function getLocalCommands(t: Translate, options?: {
+    sideTaskAvailable?: boolean;
+}): CommandInfo[];
+/**
+ * i18n key for a known skill's localized menu description, or undefined for a
+ * skill we don't ship a translation for (leave its authored description).
+ */
+export declare function skillDescriptionKey(name: string): string | undefined;
+/**
+ * Re-localize built-in command descriptions by name so the slash menu matches
+ * the web-shell UI language even when the daemon advertises them in its own
+ * process language. Translates when source is explicitly 'builtin-command' or
+ * when no source is set (daemon may omit _meta.source in some event paths).
+ * Commands with a non-builtin source (e.g. 'skill', 'custom') are left alone.
+ * (Skills are localized separately in the skill-tagging step.)
+ */
+export declare function localizeBuiltinDescriptions(commands: CommandInfo[], t: Translate): CommandInfo[];
+export {};

package/dist/types/constants/sessions.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Shared session configuration used by Web Shell surfaces so pagination and
+ * retention limits cannot drift between the main and split views.
+ */
+export declare const SESSION_LIST_PAGE_SIZE = 1000;
+export declare const SIDEBAR_SESSION_PREVIEW_LIMIT = 5;
+export declare const SESSION_ORGANIZATION_FEATURE = "session_organization";
+export declare const SESSION_LIVE_STATE_FEATURE = "workspace_session_live_state";
+export declare const SESSION_TRANSCRIPT_PAGINATION_FEATURE = "session_transcript_pagination";
+export declare const SESSION_TURN_NAVIGATION_FEATURE = "session_turn_navigation";
+export declare const SESSION_TIMELINE_MIN_VISIBLE_ENTRIES = 4;
+export declare const SESSION_MONITOR_TOOL_CORRELATION_FEATURE = "session_monitor_tool_correlation";
+export declare const SESSION_SIDE_TASK_FEATURE = "session_side_task";
+export declare const WEB_SHELL_SESSION_SOURCE_TYPE = "default";
+export declare const WEB_SHELL_SIDE_TASK_SOURCE_TYPE = "side_task";
+export declare const WEB_SHELL_HISTORY_PAGE_SIZE = 200;
+export declare const WEB_SHELL_TRANSCRIPT_RELOAD_BLOCKS = 500;
+export declare const WEB_SHELL_TURN_INDEX_PAGE_SIZE = 200;
+export declare const WEB_SHELL_TURN_INDEX_MAX_PAGES = 16;
+export declare const WEB_SHELL_TURN_INDEX_MAX_BYTES: number;
+export declare const WEB_SHELL_HISTORICAL_MAX_PAGES = 5;
+export declare const WEB_SHELL_HISTORICAL_MAX_BYTES: number;
+/**
+ * Upper bound on transcript blocks retained in memory per Web Shell session
+ * (the main chat and each split pane). The daemon stays the authoritative
+ * full-transcript source; this only caps the client's in-memory window.
+ *
+ * Intentionally equal to the provider's `DEFAULT_MAX_BLOCKS`; the equality is
+ * enforced by `sessions.test.ts` (importing the constant here instead of the
+ * provider would pull the browser UI barrel into every importer's module graph and
+ * break the enumerative `daemon-react-sdk` mocks in component tests). Bounding
+ * the window keeps very long sessions responsive: the per-dispatch reducer
+ * cost (a full block-array copy) and the full-list message normalization turn
+ * a burst of buffered SSE events — e.g. the stream catching up when the tab
+ * returns from being hidden — into a long main-thread block on large
+ * transcripts.
+ */
+export declare const WEB_SHELL_MAX_TRANSCRIPT_BLOCKS = 50000;

package/dist/types/constants/toolNames.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Canonical wire name of the Agent (sub-agent) tool. */
+export declare const AGENT_TOOL_NAME = "agent";
+/** Whether a tool name identifies the Agent (sub-agent) tool. */
+export declare function isAgentTool(toolName: string | undefined): boolean;