teodor-new-chat-ui 4.3.399 → 4.3.401

package/dist/features/checkpoint/utils/attemptDetection.d.ts

@@ -10,7 +10,7 @@
  *
  * msg3 appears in multiple checkpoints = multiple attempts/versions
  */
-import type { HydratedCheckpointSnapshot } from "@/types/models";
+import type { HydratedCheckpointSnapshot } from "@/features/core/types";
 import type { CheckpointAttemptInfo } from "../types";
 export interface AttemptMetadata {
     attemptIndex: number;

package/dist/features/checkpoint/utils/messagePreviews.d.ts

@@ -1,12 +1,6 @@
+import type { HydratedCheckpointSnapshot } from '@/features/core/types';
 import type { ChatMessage } from '@/types';
-import type { HydratedCheckpointSnapshot } from '@/types/models';
 export declare function getPreviewForMessage(message: ChatMessage): string;
-/**
- * Legacy function: builds a map of message ID -> preview text.
- * This creates a single preview per message ID, with later occurrences overwriting earlier ones.
- * @deprecated Use buildCheckpointPreviewMap instead for per-checkpoint previews
- */
-export declare function buildMessagePreviewMap(messages: ChatMessage[]): Map<string, string>;
 /**
  * Builds a map of checkpoint ID -> preview text.
  * Each checkpoint gets its own preview based on the latest user message in that checkpoint.

package/dist/features/core/contexts/index.d.ts

@@ -1,6 +1,4 @@
 /**
  * Public API entry point for shared contexts.
  */
-export { ChatProviders, type ChatProvidersProps } from './ChatProviders';
-export { useApi } from './providers/ApiProvider';
-export { useThreadState, useStream, useThreads, useHasChatSession, } from './providers/ChatSessionProvider';
+export { ApiProvider } from './providers';

package/dist/features/core/contexts/providers/ApiProvider.d.ts

@@ -3,9 +3,9 @@
  */
 import type { ApiConfig, ApiContextValue } from '@/features/core/types';
 import { type ReactNode } from 'react';
+export declare const ApiContext: import("react").Context<ApiContextValue | null>;
 export interface ApiProviderProps {
     children: ReactNode;
     apiConfig?: ApiConfig;
 }
 export declare function ApiProvider({ children, apiConfig }: ApiProviderProps): import("react/jsx-runtime").JSX.Element;
-export declare function useApi(): ApiContextValue;

package/dist/features/core/contexts/{ChatProviders.d.ts → providers/ChatProviders.d.ts}

@@ -3,7 +3,7 @@
  *
  * Context hierarchy:
  * ApiProvider (auth token & API client)
- * └─ ChatSessionProvider (threads, messages, and streaming state)
+ * └─ StreamingProvider (threads, messages, and streaming state)
  */
 import type { ApiConfig } from '@/features/core/types';
 import type { ToolEndEvent } from '@/features/streaming';
@@ -22,5 +22,5 @@ export interface ChatProvidersProps {
     onToolEnd?: (event: ToolEndEvent) => void;
 }
 export declare function ChatProviders({ children, apiConfig, initialThreadId, initialCheckpointId, initialCheckpointNs, autoLoadInitial, onConnectionError, onError, onAuthError, onThreadChange, onToolEnd, }: ChatProvidersProps): import("react/jsx-runtime").JSX.Element;
-export { useApi } from './providers/ApiProvider';
-export { useStream, useThreads, useThreadState } from './providers/ChatSessionProvider';
+export { useApi } from '@/features/core/hooks';
+export { useStream, useThreads, useThreadState, useHasChatSession } from '@/features/streaming/contexts/StreamingProvider';

package/dist/features/core/contexts/providers/index.d.ts

@@ -0,0 +1 @@
+export { ApiProvider, ApiContext } from "./ApiProvider";

package/dist/features/core/hooks/index.d.ts

@@ -1,2 +1 @@
-export { useApi } from "../contexts/providers/ApiProvider";
-export { useHasChatSession, useStream, useThreadState, useThreads, } from "../contexts/providers/ChatSessionProvider";
+export { useApi } from './useApi';

package/dist/features/core/hooks/useApi.d.ts

@@ -0,0 +1 @@
+export declare function useApi(): import("..").ApiContextValue;

package/dist/features/core/types/context.d.ts

@@ -1,5 +1,6 @@
 import type { ChatMessage, HydratedCheckpointSnapshot, PendingInterrupt, ThreadSummary } from "@/types";
-import type { MessageStreamEvent, StreamCommand, StreamEvent, SystemStreamEvent, ThreadStreamEvent, ToolStreamEvent } from "@/features/streaming";
+import type { MessageStreamEvent, StreamEvent, SystemStreamEvent, ThreadStreamEvent, ToolStreamEvent } from "@/features/streaming";
+import type { StreamCommand } from "./requests";
 export interface ApiConfig {
     baseUrl?: string;
     apiKey?: string;

package/dist/features/core/types/index.d.ts

@@ -1,7 +1,8 @@
 /**
  * Core Infrastructure Types
  *
- * Re-exports global types from @/types for convenience.
- * Don't add feature-specific types here - keep them in their feature folders.
+ * Re-export the core domain contracts used by features and hosts.
  */
 export * from "./context";
+export * from "./models";
+export * from "./requests";

package/dist/features/core/types/models.d.ts

@@ -0,0 +1,202 @@
+export type Role = "system" | "user" | "assistant" | "tool";
+export type TextPart = {
+    type: "text";
+    text: string;
+};
+export type ImagePart = {
+    type: "image_url";
+    url: string;
+    mimeType?: string;
+    alt?: string;
+};
+export type FilePart = {
+    type: "file";
+    url: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+    sourceType?: string;
+};
+export type ToolCallPart = {
+    type: "tool_call";
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+};
+export type InterruptPart = {
+    type: "interrupt";
+    value?: any;
+    [key: string]: unknown;
+};
+export type MessagePart = TextPart | ImagePart | FilePart | ToolCallPart | InterruptPart;
+export type PlotData = {
+    format?: string;
+    content_base64?: string;
+    url?: string;
+    mimeType?: string;
+    mime_type?: string;
+    plotId?: string;
+    artifactId?: string;
+    [key: string]: unknown;
+};
+export interface MessageArtifact {
+    [key: string]: unknown;
+}
+export type ArtifactPreview = {
+    src: string;
+    alt: string;
+    label?: string;
+};
+export interface ChatMessage {
+    id: string;
+    threadId?: string;
+    role: Role;
+    content: MessagePart[];
+    createdAt: string;
+    artifacts?: MessageArtifact[];
+    artifactPreviews?: Record<string, ArtifactPreview>;
+    edited?: boolean;
+    checkpointId?: string | null;
+    checkpointNs?: string | null;
+    branchLabel?: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+    }>;
+    artifact?: MessageArtifact;
+    name?: string;
+    model?: string;
+    additionalKwargs?: Record<string, unknown>;
+    responseMetadata?: Record<string, unknown>;
+    __syntheticStreaming?: boolean;
+}
+export interface DefaultMessage {
+    type?: "default_message";
+    id?: string;
+    threadId?: string;
+    role: Role;
+    content: string;
+    createdAt?: string;
+}
+export interface PregelTask {
+    [key: string]: unknown;
+}
+export type PendingInterrupt = {
+    id: string;
+    value: unknown;
+} | null;
+export interface StateSnapshot {
+    values: Record<string, unknown>;
+    next?: string[];
+    config?: Record<string, unknown>;
+    metadata?: {
+        source?: string;
+        step?: number;
+        writes?: Record<string, unknown>;
+        execution_time?: number;
+    };
+    tasks?: PregelTask[];
+    created_at?: string;
+    createdAt?: string;
+    parentConfig?: Record<string, unknown>;
+    parent_config?: Record<string, unknown>;
+}
+export interface HydratedCheckpointSnapshot {
+    checkpointId: string | null;
+    checkpointNs: string | null;
+    parentId: string | null;
+    createdAt: string;
+    messages: ChatMessage[];
+    nextCursor: string | null;
+    nextCursorNs: string | null;
+    interrupt: PendingInterrupt;
+    metadata: {
+        step: number;
+        source: string | null;
+        [key: string]: unknown;
+    };
+    config: Record<string, unknown> | null;
+    parentConfig: Record<string, unknown> | null;
+    next: string[] | null;
+    tasks: Record<string, unknown>[] | null;
+}
+export interface HistoryPayload {
+    version: string;
+    threadId: string;
+    checkpoints: StateSnapshot[];
+}
+export interface CheckpointList {
+    checkpoints: Array<{
+        checkpoint_id: string;
+        checkpoint_ns: string | null;
+        checkpoint_config: Record<string, unknown> | null;
+    }>;
+}
+export interface StatePayload {
+    [key: string]: unknown;
+}
+export interface Envelope<T = unknown> {
+    type?: string;
+    data?: T;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ThreadSummary {
+    threadId: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+    lastMessage?: string | null;
+    created?: boolean | null;
+    ready?: boolean | null;
+}
+export interface SharedThreadSummary extends ThreadSummary {
+    sharedAt: string;
+    sharedBy?: string;
+    sharedByUserId?: string;
+}
+export interface ThreadShareResponse {
+    success: boolean;
+    threadId: string;
+    shareUrl?: string;
+    message?: string;
+}
+export interface ThreadShareTarget {
+    type: "email" | "link" | "user";
+    value: string;
+    id?: string;
+    label?: string;
+    secondaryLabel?: string;
+    sharedByUserId?: string;
+}
+export interface ThreadInfo extends ThreadSummary {
+    description?: string;
+    isArchived?: boolean;
+    tags?: string[];
+}
+export interface AgentSummary {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AgentDetail extends AgentSummary {
+    description?: string;
+    schema?: Record<string, unknown>;
+    uiDefaultMessage?: string;
+    [key: string]: unknown;
+}
+export interface AgentList {
+    items?: AgentDetail[];
+    [key: string]: unknown;
+}
+export interface AgentSchemaInfo {
+    schema?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type TokenListener = (token: string | null) => void;
+export interface ExcelUploadResponse {
+    [key: string]: unknown;
+}

package/dist/features/core/types/requests.d.ts

@@ -0,0 +1,22 @@
+export type StreamCommand = {
+    kind: "resume";
+    value: unknown;
+} | {
+    kind: "goto";
+    node: string;
+    value?: unknown;
+};
+import type { TimelineCheckpoint } from "@/features/checkpoint/types";
+export interface ChatRequest {
+    threadId?: string | null;
+    payload?: Record<string, unknown>;
+    checkpointId?: string | null;
+    checkpointNs?: string | null;
+    nodeFilter?: string | string[] | null;
+    config?: Record<string, unknown>;
+    edit?: boolean;
+    branchLabel?: string;
+    active_agent?: string;
+    command?: StreamCommand | null;
+    timelineCheckpoints?: TimelineCheckpoint[];
+}

package/dist/features/messaging/components/{chat/ChatApp.d.ts → ChatApp.d.ts}

@@ -2,7 +2,7 @@
  * Chat App - Complete chat application with sidebar layout
  * Combines all chat components into a ready-to-use chat interface
  */
-import { type ChatProvidersProps } from "@/features/core";
+import { type ChatProvidersProps } from "@/features/streaming";
 export interface ChatAppProps extends Omit<ChatProvidersProps, 'children'> {
     layout?: 'sidebar' | 'fullscreen' | 'tabs';
     layoutSize?: 'phone' | 'tablet' | 'desktop' | 'half-screen';

package/dist/features/messaging/components/message/artifacts/ResearchTaskArtifact.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Custom artifact renderer for research_task_info type
+ * Displays research task status with links and metadata
+ */
+export interface ResearchTaskInfo {
+    type: "research_task_info";
+    task_id: string;
+    progress_url: string;
+    query?: string;
+    status?: "pending" | "processing" | "completed" | "failed";
+    createdAt?: string;
+    [key: string]: unknown;
+}
+export interface ResearchTaskArtifactProps {
+    artifact: ResearchTaskInfo;
+}
+/**
+ * Renders a research task artifact with status badge and action buttons
+ */
+export declare function ResearchTaskArtifact({ artifact }: ResearchTaskArtifactProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/messaging/index.d.ts

@@ -1,12 +1,12 @@
-export * from "./components/chat/ChatApp";
-export { ChatInput } from "./components/chat/ChatInput";
-export type { ChatInputProps } from "./components/chat/ChatInput";
-export { ChatInterface } from "./components/chat/ChatInterface";
-export type { ChatInterfaceProps } from "./components/chat/ChatInterface";
-export { MessageComponent } from "./components/chat/MessageComponent";
-export type { MessageComponentProps } from "./components/chat/MessageComponent";
-export { MessageList } from "./components/chat/MessageList";
-export type { MessageListProps } from "./components/chat/MessageList";
-export { MarkdownContent } from "./components/chat/MarkdownContent";
-export { FileViewerModal } from "./components/chat/FileViewerModal";
-export { ThreadManager } from "./components/chat/ThreadManager";
+export * from "./components/ChatApp";
+export { ChatInput } from "./components/ChatInput";
+export type { ChatInputProps } from "./components/ChatInput";
+export { ChatInterface } from "./components/ChatInterface";
+export type { ChatInterfaceProps } from "./components/ChatInterface";
+export { MessageComponent } from "./components/MessageComponent";
+export type { MessageComponentProps } from "./components/MessageComponent";
+export { MessageList } from "./components/MessageList";
+export type { MessageListProps } from "./components/MessageList";
+export { MarkdownContent } from "./components/MarkdownContent";
+export { FileViewerModal } from "./components/FileViewerModal";
+export { ThreadManager } from "./components/ThreadManager";

package/dist/features/messaging/utils/markdown.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/streaming/contexts/index.d.ts

@@ -1,3 +1,2 @@
 export { StreamingProvider } from "./StreamingProvider";
 export { useStream, useThreads, useThreadState, useHasChatSession } from "./StreamingProvider";
-export { useChatStreamingService } from "./services/use-streaming-service";

package/dist/features/streaming/contexts/types.d.ts

@@ -0,0 +1,57 @@
+import type { ChatMessage, HydratedCheckpointSnapshot, PendingInterrupt, SharedThreadSummary, ThreadSummary } from "@/types";
+import type { CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
+import type { TimelineCheckpoint } from "@/features/checkpoint/types";
+import type { StreamContextValue, ThreadStateMetadata } from "@/features/core/types";
+export interface ThreadsContextValue {
+    threads: ThreadSummary[];
+    currentThreadId: string | null;
+    setCurrentThreadId: (id: string | null) => void;
+    isLoading: boolean;
+    error: string | null;
+    sharedThreads: SharedThreadSummary[];
+    isLoadingSharedThreads: boolean;
+    actions: {
+        createThread: (title?: string) => Promise<string | null>;
+        deleteThread: (threadId: string) => Promise<void>;
+        renameThread: (threadId: string, title: string) => Promise<void>;
+        refreshThreads: () => Promise<void>;
+        refreshSharedThreads: () => Promise<void>;
+        shareThread: (threadId: string, sharedWithUserId: string) => Promise<void>;
+        unshareThread: (threadId: string, shareId: string) => Promise<void>;
+    };
+    shareInFlight: boolean;
+    shareStatus: string | null;
+    clearShareStatus: () => void;
+}
+export interface ThreadStateContextValue {
+    threadId: string | null;
+    messages: ChatMessage[];
+    interrupt: PendingInterrupt;
+    checkpoint: {
+        id: string | null;
+        namespace: string | null;
+    };
+    checkpoints: HydratedCheckpointSnapshot[];
+    checkpointIndex: CheckpointIndex;
+    timelineCheckpoints: TimelineCheckpoint[];
+    metadata: ThreadStateMetadata | null;
+    isLoading: boolean;
+    isHistoryLoading: boolean;
+    isLoadingCheckpoint: boolean;
+    error: string | null;
+    hasMore: boolean;
+    loadOlder: () => Promise<void>;
+    clearState: () => void;
+    navigateToCheckpoint: (checkpointId: string, checkpointNs?: string | null) => Promise<void>;
+    setCurrentCheckpointId: (checkpointId: string | null, checkpointNs?: string | null) => void;
+    returnToLatest: () => Promise<void>;
+    loadThread: (threadId: string, checkpointId?: string, options?: {
+        clearProgress?: boolean;
+    }) => Promise<void>;
+    clearThread: () => Promise<void>;
+    respondToInterrupt: (interruptId: string, approved: boolean, value?: unknown) => Promise<void>;
+    messagePreviews: Map<string, string>;
+}
+export declare const ThreadContext: import("react").Context<ThreadsContextValue | null>;
+export declare const ThreadStateContext: import("react").Context<ThreadStateContextValue | null>;
+export declare const StreamContext: import("react").Context<StreamContextValue | null>;

package/dist/features/streaming/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./utils";
 export * from "./contexts";
-export { useStream } from "./hooks/use-stream";
+export { useStream as useStreamingHook, type UseStreamApi, type UseChatStreamOptions } from "./hooks/use-stream";
+export { ChatProviders, type ChatProvidersProps } from "../core/contexts/providers/ChatProviders";

package/dist/features/streaming/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const MAX_BUFFERED_EVENTS = 200;

package/dist/features/streaming/utils/types.d.ts

@@ -1,12 +1,4 @@
 import type { MessagePart, HistoryPayload } from "@/types";
-export type StreamCommand = {
-    kind: "resume";
-    value: unknown;
-} | {
-    kind: "goto";
-    node: string;
-    value?: unknown;
-};
 type ToolEventIdentity = {
     id: string;
     call_id?: string;

package/dist/features/thread/hooks/useThreadHistoryState.d.ts

@@ -2,7 +2,7 @@ import type { ChatApi } from "@/features/core";
 import type { StateHistoryEvent } from "@/features/streaming";
 import type { ChatMessage, HydratedCheckpointSnapshot } from "@/types";
 import type { TimelineCheckpoint } from "@/features/checkpoint/types";
-import type { PendingInterrupt } from "@/types/models";
+import type { PendingInterrupt } from "@/features/core/types";
 import type { CheckpointIndex } from "@/features/checkpoint/utils/checkpointIndex";
 interface UseThreadHistoryStateOptions {
     api: ChatApi;

package/dist/features/ui/components/ui/accordion.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/features/ui/components/ui/alert-dialog.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/features/ui/components/ui/alert.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Alert, AlertTitle, AlertDescription };

package/dist/features/ui/components/ui/aspect-ratio.d.ts

@@ -0,0 +1,3 @@
+import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
+declare const AspectRatio: import("react").ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & import("react").RefAttributes<HTMLDivElement>>;
+export { AspectRatio };

package/dist/features/ui/components/ui/avatar.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/features/ui/components/ui/breadcrumb.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/dist/features/ui/components/ui/calendar.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { DayPicker } from "react-day-picker";
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

package/dist/features/ui/components/ui/carousel.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import useEmblaCarousel, { type UseEmblaCarouselType } from "embla-carousel-react";
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+};
+declare const Carousel: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & CarouselProps & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselPrevious: React.ForwardRefExoticComponent<Omit<import("./button").ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const CarouselNext: React.ForwardRefExoticComponent<Omit<import("./button").ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext, };