@pstdio/ui 0.3.1 → 0.5.0

package/dist/components/attached-panel.d.ts

@@ -0,0 +1,9 @@
+import { FlexProps } from '@chakra-ui/react';
+import { ReactNode } from 'react';
+interface AttachedPanelProps extends Omit<FlexProps, "children"> {
+    children?: ReactNode;
+    header?: ReactNode;
+    resizable?: boolean;
+}
+export declare const AttachedPanel: (props: AttachedPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/attached-panel.utils.d.ts

@@ -0,0 +1,6 @@
+interface AttachedPanelWidthBounds {
+    min: number;
+    max: number;
+}
+export declare const clampAttachedPanelWidth: (width: number, bounds: AttachedPanelWidthBounds) => number;
+export {};

package/dist/components/bubble-button.d.ts

@@ -0,0 +1,10 @@
+import { HTMLChakraProps, IconButtonProps } from '@chakra-ui/react';
+import { ReactNode } from 'react';
+type BubbleButtonStyleProps = "boxShadow" | "transition" | "_hover" | "_active" | "borderColor" | "borderWidth";
+export interface BubbleButtonProps extends Omit<IconButtonProps, BubbleButtonStyleProps> {
+    containerProps?: HTMLChakraProps<"div">;
+    isOpen?: boolean;
+    tooltip?: ReactNode;
+}
+export declare const BubbleButton: import('react').ForwardRefExoticComponent<BubbleButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/bubble-panel.d.ts

@@ -0,0 +1,18 @@
+import { HTMLChakraProps } from '@chakra-ui/react';
+import { ReactNode } from 'react';
+export interface BubblePanelProps {
+    isOpen?: boolean;
+    title?: string;
+    menu?: ReactNode;
+    onClose?: () => void;
+    closeLabel?: string;
+    onPopOut?: (() => void) | null;
+    popOutLabel?: string;
+    width?: string;
+    height?: string;
+    containerProps?: HTMLChakraProps<"section">;
+    testId?: string;
+    "aria-label"?: string;
+    children?: ReactNode;
+}
+export declare const BubblePanel: import('react').ForwardRefExoticComponent<BubblePanelProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/chat-ui/components/chat-input-actions.d.ts

@@ -0,0 +1,10 @@
+interface ChatInputActionState {
+    canInterrupt: boolean;
+    isDisabled: boolean;
+    streaming: boolean;
+    text: string;
+}
+export type ChatInputAction = "interrupt" | "none" | "submit";
+export declare const resolveChatInputKeyboardAction: (state: ChatInputActionState) => ChatInputAction;
+export declare const resolveChatInputButtonAction: (state: ChatInputActionState) => ChatInputAction;
+export {};

package/dist/components/chat-ui/components/chat-panel-sticky-user-message.d.ts

@@ -1,4 +1,4 @@
 import { SessionMessage } from './message-types';
 export declare const STICKY_USER_MESSAGE_COLLAPSE_TEXT_THRESHOLD = 360;
-export declare const STICKY_USER_MESSAGE_COLLAPSED_MAX_HEIGHT = "min(20vh, 8rem)";
+export declare const STICKY_USER_MESSAGE_COLLAPSED_MAX_HEIGHT = "min(10vh, 4rem)";
 export declare const isStickyUserMessageCollapsible: (message: SessionMessage) => boolean;

package/dist/components/chat-ui/components/chat-panel.d.ts

@@ -10,6 +10,7 @@ interface ChatPanelProps {
     chatInputPlaceholder: string;
     chatInputDefaultValue?: string;
     onSubmitMessage?: (text: string, attachments: string[]) => void;
+    onInterrupt?: () => void;
     onChatInputChange?: (text: string) => void;
     actions?: ReactNode;
     repoMenu?: ReactNode;

package/dist/components/chat-ui/tool-rendering/apply-patch-renderer.d.ts

@@ -0,0 +1,2 @@
+import { ToolRenderer } from './types';
+export declare const renderApplyPatch: ToolRenderer;

package/dist/components/chat-ui/tool-rendering/default-renderers.d.ts

@@ -1,9 +1,10 @@
-import { ToolRenderer } from './types';
 export declare const createDefaultToolRenderers: () => {
-    apply_patch: ToolRenderer;
-    read: ToolRenderer;
-    bash: ToolRenderer;
-    grep: ToolRenderer;
-    glob: ToolRenderer;
-    skill: ToolRenderer;
+    apply_patch: import('./types').ToolRenderer;
+    bash: import('./types').ToolRenderer;
+    edit: import('./types').ToolRenderer;
+    glob: import('./types').ToolRenderer;
+    grep: import('./types').ToolRenderer;
+    read: import('./types').ToolRenderer;
+    skill: import('./types').ToolRenderer;
+    todowrite: import('./types').ToolRenderer;
 };

package/dist/components/chat-ui/tool-rendering/edit-renderer.d.ts

@@ -0,0 +1,2 @@
+import { ToolRenderer } from './types';
+export declare const renderEdit: ToolRenderer;

package/dist/components/chat-ui/tool-rendering/shared.d.ts

@@ -0,0 +1,52 @@
+import { ToolPart } from '../agent-types';
+import { Block, TitleSegment } from '../components/timeline';
+export type ApplyPatchMetadataFile = {
+    filePath: string;
+    additions: number;
+    deletions: number;
+    diff?: string;
+    before?: string;
+    after?: string;
+};
+export declare const normalizeToolType: (value: string) => string;
+export declare const getToolType: (invocation: ToolPart) => string;
+export declare const getToolLabel: (value: string) => string;
+export declare const getStateLabel: (invocation: ToolPart) => string | null;
+export declare const isErrorState: (invocation: ToolPart) => boolean;
+export declare const buildIndicator: (invocation: ToolPart) => {
+    readonly type: "icon";
+    readonly icon: "search" | "dot" | "file" | "shell" | "patch" | "ls" | "read_file" | "write_file" | "delete_file" | "upload_files" | "download_file" | "move_file" | "danger" | "browser" | "terminal";
+};
+export declare const buildBaseTitle: (invocation: ToolPart, detail?: string, labelOverride?: string) => TitleSegment[];
+export declare const getInputObject: (invocation: ToolPart) => Record<string, unknown> | null;
+export declare const getOutputObject: (invocation: ToolPart) => Record<string, unknown> | null;
+export declare const getStringValue: (value: unknown) => string | null;
+export declare const getObjectValue: (value: unknown) => Record<string, unknown> | null;
+export declare const getStateObject: (invocation: ToolPart, key: string) => Record<string, unknown> | null;
+export declare const getApplyPatchMetadataFiles: (invocation: ToolPart) => ApplyPatchMetadataFile[];
+export declare const getApplyPatchDiffText: (invocation: ToolPart) => string | null;
+export declare const buildApplyPatchMetadataTitleSegments: (files: ApplyPatchMetadataFile[]) => TitleSegment[];
+export declare const getApplyPatchMetadataReferences: (files: ApplyPatchMetadataFile[]) => string[];
+export declare const getOutputText: (invocation: ToolPart) => string | null;
+export declare const parseSkillContentBlock: (value: string) => {
+    skillName: string | undefined;
+    content: string;
+} | null;
+export declare const getSkillName: (invocation: ToolPart) => string | undefined;
+export declare const buildFileLinkSegment: (filePath: string) => TitleSegment;
+export declare const prependErrorBlock: (invocation: ToolPart, blocks: Block[]) => Block[];
+export declare const getDiffBlocks: (diffText?: string | null) => {
+    type: "diff";
+    language: string;
+    original: string;
+    modified: string;
+    sideBySide: false;
+}[];
+export declare const getDiffTitleSegments: (diffText?: string | null) => {
+    kind: "diff";
+    fileName: string;
+    filePath: string;
+    additions: number;
+    deletions: number;
+}[];
+export declare const getDiffReferences: (diffText?: string | null) => string[];

package/dist/components/chat-ui/tool-rendering/standard-renderers.d.ts

@@ -0,0 +1,6 @@
+import { ToolRenderer } from './types';
+export declare const renderRead: ToolRenderer;
+export declare const renderBash: ToolRenderer;
+export declare const renderGrep: ToolRenderer;
+export declare const renderGlob: ToolRenderer;
+export declare const renderSkill: ToolRenderer;

package/dist/components/chat-ui/tool-rendering/todo-write-renderer.d.ts

@@ -0,0 +1,2 @@
+import { ToolRenderer } from './types';
+export declare const renderTodoWrite: ToolRenderer;

package/dist/components/diff-card.d.ts

@@ -9,6 +9,9 @@ export interface Diff {
 }
 interface DiffCardProps {
     diff: Diff;
+    isSelected?: boolean;
+    isExpanded?: boolean;
+    onToggleExpanded?: () => void;
 }
 export declare const DiffCard: (props: DiffCardProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/diff-drawer.d.ts

@@ -1,6 +1,7 @@
 import { Diff } from './diff-card';
 interface DiffDrawerProps {
     diffs: Diff[];
+    selectedDiffPath?: string | null;
 }
 export type { Diff };
 export declare function DiffDrawer(props: DiffDrawerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/layout.d.ts

@@ -1,7 +1,6 @@
 export declare const Layout: () => import("react/jsx-runtime").JSX.Element;
 interface PanelLayoutProps {
-    title: string;
-    menuContent?: React.ReactNode;
+    sidebar?: React.ReactNode;
     errorLabel?: string;
     children?: React.ReactNode;
 }

package/dist/components/menu-item.d.ts

@@ -1,7 +1,7 @@
 import { IconProps, Badge, MenuItem as ChakraMenuItem, Icon } from '@chakra-ui/react';
 import { ComponentProps, ReactNode } from 'react';
 type ChakraMenuItemProps = ComponentProps<typeof ChakraMenuItem>;
-type MenuItemIcon = ComponentProps<typeof Icon>["as"];
+type MenuItemIcon = ComponentProps<typeof Icon>["as"] | ReactNode;
 type MenuItemIconColor = IconProps["color"];
 type MenuItemTagColor = ComponentProps<typeof Badge>["colorPalette"];
 type MenuItemTagVariant = ComponentProps<typeof Badge>["variant"];
@@ -15,6 +15,7 @@ export interface MenuItemProps {
     isSelected?: boolean;
     primaryLabel: string;
     secondaryLabel?: string;
+    shortcutLabel?: ReactNode;
     tooltipLabel?: ReactNode;
     leftIcon?: MenuItemIcon | null;
     rightIcon?: MenuItemIcon | null;

package/dist/components/panel-header.constants.d.ts

@@ -0,0 +1 @@
+export declare const PANEL_HEADER_HEIGHT = "2.5625rem";

package/dist/components/resource-context-menu.d.ts

@@ -0,0 +1,20 @@
+import { Menu } from '@chakra-ui/react';
+import { ComponentProps, ReactNode } from 'react';
+import { MenuItem } from './menu-item';
+type MenuRootProps = ComponentProps<typeof Menu.Root>;
+export interface ResourceContextAction {
+    key: string;
+    label: string;
+    onClick: () => void;
+    isDisabled?: boolean;
+    icon?: ComponentProps<typeof MenuItem>["leftIcon"];
+}
+interface ResourceContextMenuProps {
+    actions: ResourceContextAction[];
+    children: ReactNode;
+    contentMinWidth?: string;
+    contentBackground?: string;
+    positioning?: MenuRootProps["positioning"];
+}
+export declare const ResourceContextMenu: (props: ResourceContextMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/rich-text/markdown-editor/markdown-editor.d.ts

@@ -4,6 +4,7 @@ export interface MarkdownEditorProps {
     defaultState: string;
     isEditable?: boolean;
     placeholder?: string;
+    scrollable?: boolean;
     onChange?: (value: string) => void;
 }
 export declare function MarkdownEditor(props: MarkdownEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/rich-text/prompt-input/plugins/ReferencePlugin/nodes/ReferenceNode/ReferenceNode.d.ts

@@ -1,4 +1,4 @@
-import { DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedTextNode, Spread, TextNode } from 'lexical';
+import { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedTextNode, Spread, TextNode } from 'lexical';
 type SerializedReferenceNode = Spread<{
     referenceId: string;
     name: string;
@@ -16,6 +16,7 @@ export declare class ReferenceNode extends TextNode {
     createDOM(config: EditorConfig): HTMLElement;
     updateDOM(prevNode: ReferenceNode, dom: HTMLElement): boolean;
     exportDOM(_editor: LexicalEditor): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
     static importJSON(serializedNode: SerializedReferenceNode): ReferenceNode;
     exportJSON(): SerializedReferenceNode;
     getTextContent(): string;

package/dist/components/rich-text/shared/components/content-editable.d.ts

@@ -3,6 +3,7 @@ interface ContentEditableProps {
     fullWidth?: boolean;
     padding?: string;
     isRichMessage?: boolean;
+    scrollable?: boolean;
 }
-export declare function ContentEditable({ onRef, fullWidth, padding, isRichMessage }: ContentEditableProps): import("react/jsx-runtime").JSX.Element;
+export declare function ContentEditable({ onRef, fullWidth, padding, isRichMessage, scrollable, }: ContentEditableProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/rich-text/shared/plugins/CodePlugin/CodeBlockActionsPlugin.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+export declare function CodeBlockActionsPlugin({ anchorElem }: {
+    anchorElem?: HTMLElement | null;
+}): React.JSX.Element | null;

package/dist/components/rich-text/shared/plugins/CodePlugin/CodeBlockPlugin.d.ts

@@ -1 +1,3 @@
+import { CodeNode } from '@lexical/code';
+export declare function replaceCodeNodeWithMermaidNode(node: CodeNode): boolean;
 export declare function ImportCodeBlocksPlugin(): null;

package/dist/components/rich-text/shared/plugins/CodePlugin/CodeHighlightingPlugin.d.ts

@@ -0,0 +1 @@
+export declare function CodeHighlightingPlugin(): null;

package/dist/components/rich-text/shared/plugins/FloatingTextFormatToolbarPlugin/resolve-block-type.d.ts

@@ -0,0 +1,17 @@
+import { LexicalNode } from 'lexical';
+export declare const blockTypeToBlockName: {
+    bullet: string;
+    check: string;
+    code: string;
+    h1: string;
+    h2: string;
+    h3: string;
+    h4: string;
+    h5: string;
+    h6: string;
+    number: string;
+    paragraph: string;
+    quote: string;
+};
+export type BlockType = keyof typeof blockTypeToBlockName;
+export declare const resolveBlockTypeFromAnchor: (anchorNode: LexicalNode) => "number" | "code" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "bullet" | "check" | "paragraph" | "quote" | null;

package/dist/components/rich-text/shared/plugins/FloatingTextFormatToolbarPlugin/should-show-floating-toolbar.d.ts

@@ -0,0 +1,11 @@
+interface ShouldShowFloatingToolbarParams {
+    hasSelection: boolean;
+    isRangeSelection: boolean;
+    isCollapsed: boolean;
+    hasNativeSelection: boolean;
+    hasNativeRange: boolean;
+    isAnchorInsideEditor: boolean;
+    isEditorEditable: boolean;
+}
+export declare function shouldShowFloatingToolbar(params: ShouldShowFloatingToolbarParams): boolean;
+export {};

package/dist/components/rich-text/shared/plugins/MermaidPlugin/MermaidComponent.d.ts

@@ -0,0 +1,6 @@
+interface MermaidComponentProps {
+    code: string;
+    nodeKey: string;
+}
+export default function MermaidComponent(props: MermaidComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/rich-text/shared/plugins/MermaidPlugin/MermaidNode.d.ts

@@ -0,0 +1,23 @@
+import { LexicalNode, NodeKey, SerializedLexicalNode, DecoratorNode } from 'lexical';
+import { ReactNode } from 'react';
+export interface SerializedMermaidNode extends SerializedLexicalNode {
+    type: "mermaid";
+    code: string;
+    version: 1;
+}
+export declare class MermaidNode extends DecoratorNode<ReactNode> {
+    __code: string;
+    static getType(): string;
+    static clone(node: MermaidNode): MermaidNode;
+    constructor(code: string, key?: NodeKey);
+    createDOM(): HTMLDivElement;
+    updateDOM(): boolean;
+    static importJSON(serializedNode: SerializedMermaidNode): MermaidNode;
+    exportJSON(): SerializedMermaidNode;
+    getTextContent(): string;
+    getCode(): string;
+    setCode(code: string): void;
+    decorate(): import("react/jsx-runtime").JSX.Element;
+}
+export declare function $createMermaidNode(code?: string): MermaidNode;
+export declare function $isMermaidNode(node: LexicalNode | null | undefined): node is MermaidNode;

package/dist/components/rich-text/shared/plugins/MermaidPlugin/index.d.ts

@@ -0,0 +1 @@
+export { $createMermaidNode, $isMermaidNode, MermaidNode } from './MermaidNode';

package/dist/components/rich-text/shared/transformers/markdown-transformers.d.ts

@@ -3,6 +3,7 @@ import { TextNode } from 'lexical';
 export declare const TABLE: ElementTransformer;
 export declare const UNDERLINE_INS_TAG: TextMatchTransformer;
 export declare const UNDERLINE_U_TAG: TextMatchTransformer;
+export declare const BARE_URL: TextMatchTransformer;
 export declare const TRANSFORMERS_EXTENDED: (Readonly<{
     dependencies: Array<import('lexical').Klass<import('lexical').LexicalNode>>;
     export?: (node: import('lexical').LexicalNode, exportChildren: (node: import('lexical').ElementNode) => string, exportFormat: (node: TextNode, textContent: string) => string) => string | null;

package/dist/components/rich-text/utils/markdown.d.ts

@@ -1,3 +1,4 @@
+export declare function normalizeMarkdownListIndentation(content: string): string;
 export declare function splitFrontmatter(content: string): {
     frontmatter: string;
     body: string;

package/dist/components/searchable-menu.d.ts

@@ -1,19 +1,49 @@
 import { Menu } from '@chakra-ui/react';
-import { ReactNode } from 'react';
+import { ElementType, ReactNode } from 'react';
 type MenuRootProps = React.ComponentProps<typeof Menu.Root>;
 type MenuContentProps = React.ComponentProps<typeof Menu.Content>;
 export interface SearchableMenuItem {
     id: string;
     label: string;
     searchText?: string;
+    secondaryLabel?: string;
+    tooltipLabel?: ReactNode;
+    icon?: ElementType;
+    variant?: "default" | "compact";
+    isDisabled?: boolean;
+    isSelected?: boolean;
+    onSelect?: () => void;
+}
+export interface SearchableMenuParentList<T extends SearchableMenuItem> {
+    items: T[];
+    selectedLabel: string;
+    selectedIcon?: ElementType;
+    ariaLabel?: string;
+    disabled?: boolean;
+    emptyState?: ReactNode;
+    filterItems?: (items: T[], query: string) => T[];
+    searchPlaceholder?: string;
+    showSearch?: boolean;
+    contentTestId?: string;
+    onSelect?: (item: T) => void;
+}
+interface ListConfig<T extends SearchableMenuItem> {
+    items: T[];
+    filterItems: (items: T[], query: string) => T[];
+    showSearch: boolean;
+    searchPlaceholder: string;
+    emptyState: ReactNode;
+    contentTestId?: string;
+    closeOnSelect: boolean;
+    listId: string;
 }
 interface SearchableMenuProps<T extends SearchableMenuItem> {
     trigger: ReactNode;
     items: T[];
     searchPlaceholder: string;
     emptyState: ReactNode;
-    renderItem: (item: T) => ReactNode;
     filterItems?: (items: T[], query: string) => T[];
+    listId?: string;
     header?: ReactNode;
     width?: MenuContentProps["width"];
     maxListHeight?: string;
@@ -26,7 +56,10 @@ interface SearchableMenuProps<T extends SearchableMenuItem> {
     onFocusOutside?: MenuRootProps["onFocusOutside"];
     contentTestId?: string;
     portalled?: boolean;
+    parentList?: SearchableMenuParentList<T>;
 }
 export declare const filterSearchableMenuItems: <T extends SearchableMenuItem>(items: T[], query: string) => T[];
+export declare const shouldResetSearchableMenuQuery: (currentListId?: string, nextListId?: string) => boolean;
+export declare const resolveActiveListConfig: <T extends SearchableMenuItem>(isShowingParent: boolean, parentList: SearchableMenuParentList<T> | undefined, childConfig: ListConfig<T>) => ListConfig<T>;
 export declare const SearchableMenu: <T extends SearchableMenuItem>(props: SearchableMenuProps<T>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/session-indicator.d.ts

@@ -1,8 +1,8 @@
 import { Icon } from '@chakra-ui/react';
 import { ComponentProps } from 'react';
-export type SessionCompletionStatus = "in_progress" | "awaiting_input" | "completed" | "failed";
+export type SessionCompletionStatus = "in_progress" | "awaiting_input" | "completed" | "failed" | "cancelled" | "disconnected";
 export declare const resolveSessionIndicatorIcon: (status: SessionCompletionStatus | undefined) => import('react').ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & import('react').RefAttributes<SVGSVGElement>>;
-export declare const resolveSessionIndicatorColor: (status: SessionCompletionStatus | undefined) => "fg.muted" | "fg.error" | "fg.success";
+export declare const resolveSessionIndicatorColor: (status: SessionCompletionStatus | undefined) => "fg.muted" | "fg.error" | "fg.warning" | "fg.success";
 interface SessionIndicatorProps {
     status?: SessionCompletionStatus;
     boxSize?: ComponentProps<typeof Icon>["boxSize"];

package/dist/components/sidebar/sidebar-footer.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+interface SidebarFooterProps {
+    children?: ReactNode;
+}
+export declare const SidebarFooter: (props: SidebarFooterProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/sidebar/sidebar-header.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+interface SidebarHeaderProps {
+    children?: ReactNode;
+    onClose?: () => void;
+}
+export declare const SidebarHeader: (props: SidebarHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/sidebar/sidebar-project-menu.d.ts

@@ -0,0 +1,10 @@
+interface SidebarProjectMenuProps {
+    name: string;
+    projectsLabel: string;
+    themeModeLabel: string;
+    isDarkMode: boolean;
+    onSelectProjects: () => void;
+    onToggleThemePreference: () => void;
+}
+export declare const SidebarProjectMenu: (props: SidebarProjectMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+import { SidebarProps } from './sidebar.types';
+export declare const Sidebar: (props: SidebarProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/sidebar/sidebar.store.d.ts

@@ -0,0 +1,47 @@
+interface SidebarSnapshot {
+    open: boolean;
+    expandedSections: string[];
+    expandedNodes: string[];
+}
+interface SidebarState extends SidebarSnapshot {
+    openSidebar: () => void;
+    closeSidebar: () => void;
+    toggleSidebar: () => void;
+    toggleSection: (sectionId: string) => void;
+    toggleNode: (nodeId: string) => void;
+    setSectionExpanded: (sectionId: string, expanded: boolean) => void;
+    setNodeExpanded: (nodeId: string, expanded: boolean) => void;
+    reset: () => void;
+}
+interface CreateSidebarStoreOptions {
+    storageKey: string;
+    initialState?: Partial<SidebarSnapshot>;
+}
+export declare const createSidebarStore: (options: CreateSidebarStoreOptions) => Omit<import('zustand').StoreApi<SidebarState>, "setState" | "persist"> & {
+    setState(partial: SidebarState | Partial<SidebarState> | ((state: SidebarState) => SidebarState | Partial<SidebarState>), replace?: false | undefined): unknown;
+    setState(state: SidebarState | ((state: SidebarState) => SidebarState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<SidebarState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SidebarState) => void) => () => void;
+        onFinishHydration: (fn: (state: SidebarState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<SidebarState, unknown, unknown>>;
+    };
+};
+export declare const getSidebarStore: (storageKey: string, initialState?: Partial<SidebarSnapshot>) => Omit<import('zustand').StoreApi<SidebarState>, "setState" | "persist"> & {
+    setState(partial: SidebarState | Partial<SidebarState> | ((state: SidebarState) => SidebarState | Partial<SidebarState>), replace?: false | undefined): unknown;
+    setState(state: SidebarState | ((state: SidebarState) => SidebarState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<SidebarState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SidebarState) => void) => () => void;
+        onFinishHydration: (fn: (state: SidebarState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<SidebarState, unknown, unknown>>;
+    };
+};
+export declare const useSidebarStore: <T>(storageKey: string, selector: (state: SidebarState) => T, initialState?: Partial<SidebarSnapshot>) => T;
+export {};

package/dist/components/{sidebar-next/sidebar-next.types.d.ts → sidebar/sidebar.types.d.ts}

@@ -1,13 +1,14 @@
 import { ReactNode } from 'react';
 import { SidebarLinkComponent, SidebarNavigateEvent, SidebarSection } from '../sidebar-tree/sidebar-tree.types';
-export interface SidebarNextProps {
+export interface SidebarProps {
     storageKey: string;
     sections: SidebarSection[];
-    activeNodeId?: string | null;
+    activeNodeId?: string | string[] | null;
     header?: ReactNode;
     footer?: ReactNode;
     width?: string | number;
     emptyLabel?: string;
+    defaultExpandedSections?: string[];
     linkComponent?: SidebarLinkComponent;
     onNavigate?: (event: SidebarNavigateEvent) => void;
     closable?: boolean;

package/dist/components/sidebar-tree/sidebar-node-content.d.ts

@@ -0,0 +1,9 @@
+import { SidebarNode } from './sidebar-tree.types';
+interface SidebarNodeContentProps {
+    node: SidebarNode;
+    expanded: boolean;
+    hasChildren: boolean;
+    isDisabled: boolean;
+}
+export declare const SidebarNodeContent: (props: SidebarNodeContentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/sidebar-tree/sidebar-tree.d.ts

@@ -3,7 +3,7 @@ interface SidebarTreeProps {
     sections: SidebarSection[];
     expandedSections: string[];
     expandedNodes: string[];
-    activeNodeId?: string | null;
+    activeNodeId?: string | string[] | null;
     linkComponent?: SidebarLinkComponent;
     onNavigate?: (event: SidebarNavigateEvent) => void;
     onToggleSection: (sectionId: string) => void;

package/dist/components/sidebar-tree/sidebar-tree.types.d.ts

@@ -1,3 +1,4 @@
+import { IconProps } from '@chakra-ui/react';
 import { ComponentType, ReactNode } from 'react';
 export interface SidebarNavigationIntent {
     id?: string;
@@ -11,7 +12,10 @@ export interface SidebarActionMenuItem {
     id: string;
     label: string;
     description?: string;
-    icon?: ReactNode;
+    icon?: ReactNode | ComponentType<{
+        size?: number | string;
+    }>;
+    disabled?: boolean;
     onAction?: () => void;
 }
 export interface SidebarAction {
@@ -25,20 +29,28 @@ export interface SidebarAction {
 }
 export interface SidebarNode {
     id: string;
-    label: string;
-    description?: string;
+    label: ReactNode;
+    description?: ReactNode;
     icon?: ReactNode;
+    iconColor?: IconProps["color"];
+    indicator?: {
+        icon: ReactNode;
+        color?: IconProps["color"];
+        tooltip?: string | null;
+    };
     disabled?: boolean;
     isNavigable?: boolean;
     /** URL for the node. When provided with a linkComponent, the row renders as an anchor for cmd+click support. */
     href?: string;
     navigationIntent?: SidebarNavigationIntent;
+    contextMenuItems?: SidebarActionMenuItem[];
     actions?: SidebarAction[];
     children?: SidebarNode[];
 }
 export interface SidebarSection {
     id: string;
     label?: string;
+    collapsible?: boolean;
     actions?: SidebarAction[];
     emptyState?: ReactNode;
     nodes: SidebarNode[];

package/dist/components/tickets/tag-badge.d.ts

@@ -0,0 +1,10 @@
+import { WorkspaceTagOption } from './types';
+interface TagBadgeProps {
+    value: string | null;
+    label?: string;
+    color?: string;
+    options: WorkspaceTagOption[];
+    onValueChange?: (newValue: string) => void;
+}
+export declare const TagBadge: (props: TagBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tickets/tag-option-icon.d.ts

@@ -0,0 +1,2 @@
+import { LucideIcon } from 'lucide-react';
+export declare const getTagOptionIcon: (icon: string | null | undefined) => LucideIcon | null;