@connectycube/chat-widget 0.39.1 → 0.39.3

package/dist/types/App.d.ts

@@ -1,15 +1,16 @@
+import { default as React } from 'react';
 import { Config } from '@connectycube/react';
 import { AppPresets } from './hooks/useAppPresets';
-import * as React from 'react';
 export type AppProps = AppPresets & {
     appId: number | string;
     authKey: string;
     config?: Config.Options;
     userId?: string;
     userName?: string;
+    userEmail?: string;
     userAvatar?: string;
     userProfileLink?: string;
-    translation?: 'en' | 'el' | 'ua';
+    translation?: string;
     disableClickOutside?: boolean;
     disableEscKeyPress?: boolean;
     hideWidgetButton?: boolean;

package/dist/types/components/connectycube-ui/alert-dialog.d.ts

@@ -0,0 +1,27 @@
+import { ButtonProps } from './button';
+import * as React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+interface AlertDialogProps extends AlertDialogPrimitive.AlertDialogProps {
+    title?: string;
+    description?: string;
+    cancelTitle?: string;
+    actionTitle?: string;
+    onCancel?: () => void;
+    onConfirm?: () => void;
+    rootProps?: AlertDialogPrimitive.AlertDialogProps;
+    triggerElement: React.ReactElement;
+    triggerProps?: AlertDialogPrimitive.AlertDialogTriggerProps;
+    portalProps?: AlertDialogPrimitive.AlertDialogPortalProps;
+    overlayProps?: AlertDialogPrimitive.AlertDialogOverlayProps;
+    contentProps?: AlertDialogPrimitive.AlertDialogContentProps;
+    headerProps?: React.ComponentProps<'div'>;
+    titleProps?: AlertDialogPrimitive.AlertDialogTitleProps;
+    descriptionProps?: AlertDialogPrimitive.AlertDialogDescriptionProps;
+    footerProps?: React.ComponentProps<'div'>;
+    cancelProps?: AlertDialogPrimitive.AlertDialogCancelProps;
+    cancelButtonProps?: ButtonProps;
+    actionProps?: AlertDialogPrimitive.AlertDialogActionProps;
+    actionButtonProps?: ButtonProps;
+}
+declare const AlertDialog: React.ForwardRefExoticComponent<AlertDialogProps & React.RefAttributes<HTMLDivElement>>;
+export { AlertDialog, type AlertDialogProps };

package/dist/types/components/connectycube-ui/attachment.d.ts

@@ -0,0 +1,43 @@
+import { LucideProps } from 'lucide-react';
+import * as React from 'react';
+interface AttachmentProps {
+    pending?: boolean;
+    uid?: string;
+    url?: string;
+    mimeType?: string;
+    onReady?: () => void;
+    linkProps?: AttachmentLinkProps;
+    containerProps?: React.ComponentProps<'div'>;
+}
+interface AttachmentLinkProps extends React.ComponentProps<'a'>, Omit<AttachmentProps, 'url' & 'containerProps' & 'mimeType'> {
+}
+interface AttachmentImageProps extends React.ComponentProps<'img'>, Omit<AttachmentProps, 'containerProps' & 'mimeType'> {
+}
+interface AttachmentAudioProps extends React.ComponentProps<'audio'>, Omit<AttachmentProps, 'linkProps' & 'mimeType'> {
+}
+interface AttachmentVideoProps extends React.ComponentProps<'video'>, Omit<AttachmentProps, 'linkProps' & 'mimeType'> {
+    maxSize?: number;
+}
+interface AttachmentFileProps extends LucideProps, Omit<AttachmentProps, 'containerProps' & 'mimeType'> {
+    name?: string | undefined;
+    iconElement?: React.ReactNode;
+}
+interface AttachmentFailedProps extends LucideProps, Omit<AttachmentProps, 'linkProps' & 'mimeType'> {
+    name?: string | undefined;
+    iconElement?: React.ReactNode;
+}
+declare const AttachmentLink: React.ForwardRefExoticComponent<Omit<AttachmentLinkProps, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+declare const AttachmentAudio: React.ForwardRefExoticComponent<Omit<AttachmentAudioProps, "ref"> & React.RefAttributes<HTMLAudioElement>>;
+declare const AttachmentVideo: React.ForwardRefExoticComponent<Omit<AttachmentVideoProps, "ref"> & React.RefAttributes<HTMLVideoElement>>;
+declare const AttachmentImage: React.ForwardRefExoticComponent<Omit<AttachmentImageProps, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare function AttachmentFile({ url, name, pending, iconElement, linkProps, ...props }: AttachmentFileProps): import("react/jsx-runtime").JSX.Element;
+declare namespace AttachmentFile {
+    var displayName: string;
+}
+declare function AttachmentFailed({ name, pending, iconElement, containerProps, ...props }: AttachmentFailedProps): import("react/jsx-runtime").JSX.Element;
+declare namespace AttachmentFailed {
+    var displayName: string;
+}
+declare function AttachmentBase({ mimeType, onReady, containerProps, linkProps, ...props }: AttachmentProps): import("react/jsx-runtime").JSX.Element;
+declare const Attachment: React.MemoExoticComponent<typeof AttachmentBase>;
+export { Attachment, AttachmentLink, AttachmentImage, AttachmentAudio, AttachmentVideo, AttachmentFile, AttachmentFailed, type AttachmentLinkProps, type AttachmentImageProps, type AttachmentAudioProps, type AttachmentVideoProps, type AttachmentFileProps, type AttachmentFailedProps, type AttachmentProps, };

package/dist/types/components/connectycube-ui/avatar.d.ts

@@ -0,0 +1,16 @@
+import { PresenceStatus, PresenceBadgeProps } from './presence';
+import * as React from 'react';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+interface AvatarProps extends AvatarPrimitive.AvatarProps {
+    src?: string | undefined;
+    name?: string | undefined;
+    fallbackIconElement?: React.ReactNode | undefined;
+    online?: boolean | undefined;
+    presence?: PresenceStatus;
+    onlineProps?: React.ComponentProps<'div'>;
+    presenceProps?: PresenceBadgeProps;
+    imageProps?: AvatarPrimitive.AvatarImageProps;
+    fallbackProps?: AvatarPrimitive.AvatarFallbackProps;
+}
+declare const Avatar: React.NamedExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+export { Avatar, type AvatarProps };

package/dist/types/components/{shadcn-ui → connectycube-ui}/badge.d.ts

@@ -1,9 +1,10 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from 'react';
+interface BadgeProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof badgeVariants> {
+    asChild?: boolean;
+}
 declare const badgeVariants: (props?: ({
     variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<'span'> & VariantProps<typeof badgeVariants> & {
-    asChild?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
-export { Badge, badgeVariants };
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLElement>>;
+export { Badge, type BadgeProps };

package/dist/types/components/connectycube-ui/button.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+interface ButtonProps extends React.ComponentProps<'button'>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const Button: React.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants, type ButtonProps };

package/dist/types/components/connectycube-ui/chat-bubble.d.ts

@@ -0,0 +1,31 @@
+import { AvatarProps } from './avatar';
+import { FormattedDateProps } from './formatted-date';
+import { StatusSentProps } from './status-sent';
+import * as React from 'react';
+interface ChatBubbleProps extends React.ComponentProps<'div'> {
+    onView?: () => void;
+    isLast?: boolean;
+    date?: FormattedDateProps['date'];
+    language?: FormattedDateProps['language'];
+    formattedDateProps?: FormattedDateProps;
+}
+interface ChatBubbleMessageProps extends ChatBubbleProps {
+    fromMe: boolean;
+    sameSenderAbove: boolean;
+    title?: string;
+    senderName?: string;
+    senderAvatar?: AvatarProps['src'];
+    statusSent?: StatusSentProps['status'];
+    avatarProps?: AvatarProps;
+    bubbleProps?: React.ComponentProps<'div'>;
+    titleProps?: React.ComponentProps<'span'>;
+    statusSentProps?: StatusSentProps;
+}
+interface ChatBubbleInfoProps extends ChatBubbleProps {
+    info?: string | undefined;
+    iconElement?: React.ReactNode;
+    infoProps?: React.ComponentProps<'span'>;
+}
+declare const ChatBubbleMessage: React.NamedExoticComponent<Omit<ChatBubbleMessageProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ChatBubbleInfo: React.NamedExoticComponent<Omit<ChatBubbleInfoProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ChatBubbleMessage, ChatBubbleInfo, type ChatBubbleMessageProps, type ChatBubbleInfoProps };

package/dist/types/components/connectycube-ui/chat-input.d.ts

@@ -0,0 +1,26 @@
+import { TextareaAutosizeProps } from 'react-textarea-autosize';
+import { LucideProps } from 'lucide-react';
+import { LabelProps } from './label';
+import * as React from 'react';
+interface ChatInputSendProps extends LabelProps {
+    onSend: () => void;
+    iconElement?: React.ReactNode;
+    iconProps?: LucideProps;
+}
+interface ChatInputProps extends TextareaAutosizeProps, Omit<React.ComponentProps<'textarea'>, 'style'> {
+    children?: React.ReactNode;
+    pending?: boolean;
+    draft?: string;
+    onSend?: (value?: string) => void;
+    onDraft?: (value?: string) => void;
+    onTyping?: (typing?: boolean) => void;
+    onHeightGrow?: (data: {
+        height: number;
+        shift: number;
+    }) => void;
+    hideChatInputSend?: boolean;
+    chatInputSendProps?: ChatInputSendProps;
+    containerProps?: React.ComponentProps<'div'>;
+}
+declare const ChatInput: React.ForwardRefExoticComponent<Omit<ChatInputProps, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export { ChatInput, type ChatInputProps };

package/dist/types/components/connectycube-ui/chat-list.d.ts

@@ -0,0 +1,30 @@
+import { VirtualizerProps, VirtualizerHandle } from 'virtua';
+import { FilePickerDropzoneProps } from './file-picker';
+import { QuickActionsProps } from './quick-actions';
+import * as React from 'react';
+interface ChatListProps extends VirtualizerProps {
+    key: string;
+    loading?: boolean;
+    textareaMeasurement: {
+        height: number;
+        shift: number;
+    };
+    offsetToReach?: number;
+    onScrollStartReached?: () => void;
+    onScrollEndReached?: () => void;
+    onListReset?: (prev: string | undefined, next: string | undefined) => void;
+    onListCreate?: () => void;
+    onListGrow?: () => void;
+    enableFilePickerDropzone?: boolean;
+    containerProps?: React.ComponentProps<'div'>;
+    filePickerDropzoneProps?: FilePickerDropzoneProps;
+    quickActionsProps?: QuickActionsProps;
+    quickActionsVisible?: boolean;
+    minItemsCount?: number;
+}
+interface ChatListHandle extends VirtualizerHandle {
+    scrollToBottom: (force?: boolean) => void;
+    setShift: (shift: boolean) => void;
+}
+declare const ChatList: React.ForwardRefExoticComponent<ChatListProps & React.RefAttributes<ChatListHandle>>;
+export { ChatList, type ChatListProps, type ChatListHandle };

package/dist/types/components/connectycube-ui/checkbox.d.ts

@@ -0,0 +1,10 @@
+import { LucideProps } from 'lucide-react';
+import * as React from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+interface CheckboxProps extends CheckboxPrimitive.CheckboxProps {
+    iconElement?: React.ReactNode;
+    iconProps?: LucideProps;
+    indicatorProps?: CheckboxPrimitive.CheckboxIndicatorProps;
+}
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox, type CheckboxProps };

package/dist/types/components/connectycube-ui/dialog-item.d.ts

@@ -0,0 +1,45 @@
+import { AvatarProps } from './avatar';
+import { LucideProps } from 'lucide-react';
+import { FormattedDateProps } from './formatted-date';
+import { StatusSentProps } from './status-sent';
+import { PresenceStatus } from './presence';
+import { BadgeProps } from './badge';
+import * as React from 'react';
+interface DialogItemProps extends React.ComponentProps<'div'> {
+    index?: number;
+    isPrivateDialog?: boolean;
+    selected?: boolean;
+    onSelect?: () => void;
+    name: string;
+    photo?: string;
+    userOnline?: boolean;
+    userPresence?: PresenceStatus;
+    hasGroupIcon?: boolean;
+    lastSentStatus?: StatusSentProps['status'];
+    lastSentDate?: FormattedDateProps['date'];
+    lastSenderName?: string;
+    lastMessage?: string;
+    typingStatusText?: string;
+    draft?: string;
+    draftLabel?: string;
+    unreadCount?: number;
+    language?: string;
+    divider?: 'top' | 'bottom' | 'both' | 'none';
+    avatarProps?: AvatarProps;
+    contentProps?: React.ComponentProps<'div'>;
+    headerProps?: React.ComponentProps<'div'>;
+    headerLeftProps?: React.ComponentProps<'div'>;
+    groupIconProps?: LucideProps;
+    nameProps?: React.ComponentProps<'span'>;
+    headerRightProps?: React.ComponentProps<'div'>;
+    statusSentIconProps?: StatusSentProps;
+    formattedDateProps?: FormattedDateProps;
+    footerProps?: React.ComponentProps<'div'>;
+    lastMessageProps?: React.ComponentProps<'span'>;
+    draftLabelProps?: React.ComponentProps<'span'>;
+    lastSenderNameProps?: React.ComponentProps<'span'>;
+    unreadBadgeProps?: BadgeProps;
+    dividerProps?: React.ComponentProps<'div'>;
+}
+declare const DialogItem: React.NamedExoticComponent<Omit<DialogItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { DialogItem, type DialogItemProps };

package/dist/types/components/connectycube-ui/dialogs-list.d.ts

@@ -0,0 +1,13 @@
+import { VListHandle, VListProps } from 'virtua';
+import * as React from 'react';
+interface DialogsListProps extends VListProps {
+    pending?: boolean;
+    pendingListLength?: number;
+    offsetToReach?: number;
+    placeholderVisible?: boolean;
+    placeholderTitles?: string[];
+    onScrollStartReached?: () => void;
+    onScrollEndReached?: () => void;
+}
+declare const DialogsList: React.ForwardRefExoticComponent<DialogsListProps & React.RefAttributes<VListHandle>>;
+export { DialogsList, type DialogsListProps };

package/dist/types/components/connectycube-ui/dismiss-layer.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+interface DismissLayerProps extends React.ComponentProps<'div'> {
+    active: boolean;
+    onDismiss: () => void;
+    disableClickOutside?: boolean;
+    disableEscKeyPress?: boolean;
+    disabled?: boolean;
+}
+declare const DismissLayer: React.ForwardRefExoticComponent<Omit<DismissLayerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { DismissLayer, type DismissLayerProps };

package/dist/types/components/connectycube-ui/file-picker.d.ts

@@ -0,0 +1,21 @@
+import { LucideProps } from 'lucide-react';
+import { LabelProps } from './label';
+import * as React from 'react';
+interface FilePickerInputProps extends React.ComponentProps<'input'> {
+    onSelectFile?: (files: File[]) => void;
+    onInvalidFile?: () => void;
+    iconElement?: React.ReactNode;
+    labelProps?: LabelProps;
+    iconProps?: LucideProps;
+}
+interface FilePickerDropzoneProps extends FilePickerInputProps {
+    children?: React.ReactNode;
+    placeholder?: string;
+    dropZoneProps?: React.ComponentProps<'div'>;
+    placeholderContainerProps?: React.ComponentProps<'div'>;
+    iconProps?: LucideProps;
+    placeholderProps?: React.ComponentProps<'span'>;
+}
+declare const FilePickerInput: React.ForwardRefExoticComponent<Omit<FilePickerInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const FilePickerDropzone: React.ForwardRefExoticComponent<Omit<FilePickerDropzoneProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { FilePickerInput, FilePickerDropzone, FilePickerInput as Input, FilePickerDropzone as Dropzone, type FilePickerInputProps, type FilePickerDropzoneProps, };

package/dist/types/components/connectycube-ui/formatted-date.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+interface FormattedDateProps extends React.ComponentProps<'span'> {
+    date?: Date | string | number | null | undefined;
+    language?: string;
+    distanceToNow?: boolean;
+}
+declare const FormattedDate: React.NamedExoticComponent<Omit<FormattedDateProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { FormattedDate, type FormattedDateProps };

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

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

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

@@ -0,0 +1,4 @@
+import { LabelProps } from '@radix-ui/react-label';
+import * as React from 'react';
+declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+export { Label, type LabelProps };

package/dist/types/components/connectycube-ui/link-preview.d.ts

@@ -0,0 +1,20 @@
+import { LucideProps } from 'lucide-react';
+import * as React from 'react';
+interface LinkPreviewProps extends React.ComponentProps<'a'> {
+    thin?: boolean;
+    title?: string;
+    description?: string;
+    icon?: React.ComponentProps<'img'>['src'];
+    image?: React.ComponentProps<'img'>['src'];
+    onReady?: () => void;
+    iconFallbackElement?: React.ReactElement;
+    titleContainerProps?: React.ComponentProps<'div'>;
+    iconProps?: React.ComponentProps<'img'>;
+    iconFallbackProps?: LucideProps;
+    titleProps?: React.ComponentProps<'span'>;
+    descriptionProps?: React.ComponentProps<'div'>;
+    imageContainerProps?: React.ComponentProps<'div'>;
+    imageProps?: React.ComponentProps<'img'>;
+}
+declare const LinkPreview: React.NamedExoticComponent<Omit<LinkPreviewProps, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+export { LinkPreview, type LinkPreviewProps };

package/dist/types/components/connectycube-ui/linkify-text.d.ts

@@ -0,0 +1,13 @@
+import { Opts } from 'linkifyjs';
+import * as React from 'react';
+interface LinkifyTextProps extends React.ComponentProps<'p'> {
+    text?: string;
+    pending?: boolean;
+    onReady?: () => void;
+    linkifyProps?: Opts;
+    skeletonContainerProps?: React.ComponentProps<'div'>;
+    skeletonLineProps?: React.ComponentProps<'span'>;
+    skeletonLinesClassNames?: string[];
+}
+declare const LinkifyText: React.NamedExoticComponent<Omit<LinkifyTextProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { LinkifyText, type LinkifyTextProps };

package/dist/types/components/connectycube-ui/placeholder-text.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+interface PlaceholderTextProps extends React.ComponentProps<'div'> {
+    title?: string;
+    titles?: string[];
+    rowProps?: React.ComponentProps<'div'>;
+}
+declare const PlaceholderText: React.ForwardRefExoticComponent<Omit<PlaceholderTextProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { PlaceholderText, type PlaceholderTextProps };

package/dist/types/components/connectycube-ui/presence.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+type PresenceStatus = 'available' | 'busy' | 'away' | 'unknown' | undefined;
+interface PresenceProps extends React.ComponentProps<'div'> {
+    badge?: boolean;
+    status: PresenceStatus;
+    label: string;
+    badgeProps?: PresenceBadgeProps;
+    labelProps?: React.ComponentProps<'span'>;
+}
+interface PresenceBadgeProps extends React.ComponentProps<'svg'> {
+    status?: PresenceStatus;
+}
+declare function PresenceBadge({ status, ...props }: PresenceBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+declare namespace PresenceBadge {
+    var displayName: string;
+}
+declare function Presence({ badge, status, label, badgeProps, labelProps, ...props }: PresenceProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Presence {
+    var displayName: string;
+}
+export { Presence, PresenceBadge, type PresenceStatus, type PresenceProps, type PresenceBadgeProps };

package/dist/types/components/connectycube-ui/quick-actions.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+interface QuickActionsProps extends React.HTMLAttributes<HTMLDivElement> {
+    title?: string;
+    description?: string;
+    actions?: string[];
+    onAction?: (action: string) => void;
+    containerProps?: React.ComponentProps<'div'>;
+    titleProps?: React.ComponentProps<'h2'>;
+    descriptionProps?: React.ComponentProps<'span'>;
+    actionProps?: React.ComponentProps<'div'>;
+}
+declare const QuickActions: React.ForwardRefExoticComponent<QuickActionsProps & React.RefAttributes<HTMLDivElement>>;
+export { QuickActions, type QuickActionsProps };

package/dist/types/components/connectycube-ui/search.d.ts

@@ -0,0 +1,14 @@
+import { InputProps } from './input';
+import { LucideProps } from 'lucide-react';
+import * as React from 'react';
+interface SearchProps extends InputProps {
+    onSearch?: (value: string) => void;
+    onCancel?: () => void;
+    hasSearchIcon?: boolean;
+    hasCancelIcon?: boolean;
+    searchIconProps?: LucideProps;
+    cancelIconProps?: LucideProps;
+    containerProps?: React.ComponentProps<'div'>;
+}
+declare const Search: React.ForwardRefExoticComponent<Omit<SearchProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Search, type SearchProps };

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

@@ -0,0 +1,9 @@
+import { LucideProps } from 'lucide-react';
+import * as React from 'react';
+interface SpinnerProps extends LucideProps {
+    loading?: boolean;
+    type?: 'default' | 'circle';
+    layout?: 'absolute' | 'centered' | 'overlay' | 'flow';
+}
+declare const Spinner: React.FC<SpinnerProps>;
+export { Spinner, type SpinnerProps };

package/dist/types/components/connectycube-ui/status-call.d.ts

@@ -0,0 +1,8 @@
+import { LucideProps } from 'lucide-react';
+import * as React from 'react';
+interface StatusCallProps extends LucideProps {
+    fromMe?: boolean;
+    status?: 'reject' | 'notAnswer' | 'hungUp' | 'cancel' | undefined;
+}
+declare const StatusCall: React.FC<StatusCallProps>;
+export { StatusCall, type StatusCallProps };

package/dist/types/components/connectycube-ui/status-indicator.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+type StatusName = string | 'unknown';
+interface StatusIndicatorProps extends React.ComponentProps<'div'> {
+    status?: StatusName;
+    statusColorConfig?: Record<StatusName, string>;
+    statusProps?: React.ComponentProps<'div'>;
+    tooltipProviderProps?: TooltipPrimitive.TooltipProviderProps;
+    tooltipProps?: TooltipPrimitive.TooltipProps;
+    tooltipTriggerProps?: TooltipPrimitive.TooltipTriggerProps;
+    tooltipPortalProps?: TooltipPrimitive.TooltipPortalProps;
+    tooltipContentProps?: TooltipPrimitive.TooltipContentProps;
+    tooltipArrowProps?: TooltipPrimitive.TooltipArrowProps;
+    tooltip?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare const StatusIndicator: React.ForwardRefExoticComponent<Omit<StatusIndicatorProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { StatusIndicator, type StatusName, type StatusIndicatorProps };

package/dist/types/components/connectycube-ui/status-sent.d.ts

@@ -0,0 +1,7 @@
+import { LucideProps } from 'lucide-react';
+import * as React from 'react';
+interface StatusSentProps extends LucideProps {
+    status?: 'wait' | 'sent' | 'read' | 'lost' | null | undefined;
+}
+declare const StatusSent: React.FC<StatusSentProps>;
+export { StatusSent, type StatusSentProps };

package/dist/types/components/connectycube-ui/stream-view.d.ts

@@ -1,47 +1,30 @@
-import { default as React } from 'react';
-export type StreamViewProps = {
-    id?: string;
+import { LucideProps } from 'lucide-react';
+import * as React from 'react';
+interface StreamViewProps extends React.ComponentProps<'video'> {
     stream?: MediaStream | null;
     mirror?: boolean;
-} & React.VideoHTMLAttributes<HTMLVideoElement>;
-export declare const StreamView: React.ForwardRefExoticComponent<{
-    id?: string;
-    stream?: MediaStream | null;
-    mirror?: boolean;
-} & React.VideoHTMLAttributes<HTMLVideoElement> & React.RefAttributes<HTMLVideoElement>>;
-export declare const LocalStreamView: React.ForwardRefExoticComponent<{
-    id?: string;
-    stream?: MediaStream | null;
-    mirror?: boolean;
-} & React.VideoHTMLAttributes<HTMLVideoElement> & React.RefAttributes<HTMLVideoElement>>;
-export declare const RemoteStreamView: React.ForwardRefExoticComponent<{
-    id?: string;
-    stream?: MediaStream | null;
-    mirror?: boolean;
-} & React.VideoHTMLAttributes<HTMLVideoElement> & React.RefAttributes<HTMLVideoElement>>;
-export type FullscreenStreamViewProps = {
+}
+declare const StreamView: React.ForwardRefExoticComponent<Omit<StreamViewProps, "ref"> & React.RefAttributes<HTMLVideoElement>>;
+declare const LocalStreamView: React.ForwardRefExoticComponent<Omit<StreamViewProps, "ref"> & React.RefAttributes<HTMLVideoElement>>;
+declare const RemoteStreamView: React.ForwardRefExoticComponent<Omit<StreamViewProps, "ref"> & React.RefAttributes<HTMLVideoElement>>;
+interface FullscreenStreamViewProps extends React.ComponentProps<'div'> {
     element: React.ReactElement<StreamViewProps>;
     pipElement?: React.ReactElement<StreamViewProps>;
     navElement?: React.ReactElement<HTMLElement>;
     hideIconElement?: React.ReactElement;
     showIconElement?: React.ReactElement;
-    containerClassName?: string;
-    fullscreenButtonClassName?: string;
-    fullscreenButtonIconClassName?: string;
-    pipContainerClassName?: string;
-    pipButtonClassName?: string;
-    pipButtonIconClassName?: string;
-    containerProps?: React.HTMLAttributes<HTMLDivElement>;
-    fullscreenButtonProps?: React.HTMLAttributes<HTMLButtonElement>;
-    fullscreenButtonIconProps?: React.HTMLAttributes<SVGElement>;
-    pipContainerProps?: React.HTMLAttributes<HTMLDivElement>;
-    pipButtonProps?: React.HTMLAttributes<HTMLButtonElement>;
-    pipButtonIconProps?: React.HTMLAttributes<SVGElement>;
-};
-export type FullscreenStreamViewRef = {
+    containerProps?: React.ComponentProps<'div'>;
+    fullscreenButtonProps?: React.ComponentProps<'button'>;
+    fullscreenButtonIconProps?: LucideProps;
+    pipProps?: React.ComponentProps<'div'>;
+    pipButtonProps?: React.ComponentProps<'button'>;
+    pipButtonIconProps?: LucideProps;
+}
+interface FullscreenStreamViewRef extends React.ComponentRef<'div'> {
     isFullscreen: boolean;
     isPictureInPicture: boolean;
     toggleFullscreen: () => Promise<void>;
     togglePictureInPicture: () => void;
-};
-export declare const FullscreenStreamView: React.ForwardRefExoticComponent<FullscreenStreamViewProps & React.RefAttributes<FullscreenStreamViewRef>>;
+}
+declare const FullscreenStreamView: React.ForwardRefExoticComponent<Omit<FullscreenStreamViewProps, "ref"> & React.RefAttributes<FullscreenStreamViewRef>>;
+export { StreamView, LocalStreamView, RemoteStreamView, FullscreenStreamView, type StreamViewProps, type FullscreenStreamViewProps, type FullscreenStreamViewRef, };

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

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+type SwitchProps = React.ComponentProps<typeof SwitchPrimitive.Root>;
+declare function Switch(props: SwitchProps): import("react/jsx-runtime").JSX.Element;
+export { Switch, type SwitchProps };

package/dist/types/components/connectycube-ui/utils.d.ts

@@ -1,3 +1,4 @@
 import { ClassValue } from 'clsx';
 export declare function cn(...inputs: ClassValue[]): string;
 export declare function getRandomString(length?: number): string;
+export declare function capitalize(str?: string): string;

package/dist/types/components/home/main/ai-dropdown-menu/ai-dropdown-change-tone.d.ts

@@ -1,11 +1,11 @@
 import { default as React } from 'react';
 import { AIDropdownMenuSubKeys } from '../../../../helpers/widget';
-import { LanguageModelV2 } from '@ai-sdk/provider';
+import { LanguageModelV3 } from '@ai-sdk/provider';
 type AIDropdownChangeToneProps = {
     activeKey: AIDropdownMenuSubKeys;
     setActiveKey: (active: AIDropdownMenuSubKeys) => void;
     enabled: boolean;
-    aiModel: LanguageModelV2;
+    aiModel: LanguageModelV3;
     message: string;
     changeMessage: (message: string) => void;
     setProcessing: (processing: boolean) => void;

package/dist/types/components/home/main/ai-dropdown-menu/ai-dropdown-get-summary.d.ts

@@ -1,11 +1,11 @@
 import { default as React } from 'react';
 import { AIDropdownMenuSubKeys } from '../../../../helpers/widget';
-import { LanguageModelV2 } from '@ai-sdk/provider';
+import { LanguageModelV3 } from '@ai-sdk/provider';
 type AIDropdownGetSummaryProps = {
     activeKey: AIDropdownMenuSubKeys;
     setActiveKey: (active: AIDropdownMenuSubKeys) => void;
     enabled: boolean;
-    aiModel: LanguageModelV2;
+    aiModel: LanguageModelV3;
 };
 declare const AIDropdownGetSummary: React.FC<AIDropdownGetSummaryProps>;
 export default AIDropdownGetSummary;

package/dist/types/components/home/main/{chat-input.d.ts → chat-footer.d.ts}

@@ -1,9 +1,12 @@
 import { default as React } from 'react';
 import { Dialogs } from '@connectycube/react';
-export interface ChatInputProps {
+export interface ChatFooterProps {
     onSendMessage: (message: string, dialog?: Dialogs.Dialog) => void;
     onSendAttachment: (files: File[]) => void;
-    setTextareaScrollOffset: React.Dispatch<React.SetStateAction<number>>;
+    onHeightGrow: React.Dispatch<React.SetStateAction<{
+        height: number;
+        shift: number;
+    }>>;
 }
-declare const _default: React.NamedExoticComponent<ChatInputProps>;
+declare const _default: React.NamedExoticComponent<ChatFooterProps>;
 export default _default;