@veltdev/react/index.d.ts

Velt is an SDK to add collaborative features to your product within minutes. Example: Comments like Figma, Frame.io, Google docs or sheets, Recording like Loom, Huddles like Slack and much more.

/// <reference types="react" />
import React$1 from 'react';
import { Config, UserDataProvider, VeltDataProvider, VeltEncryptionProvider, VeltAuthProvider, Velt, ContextOptions, ReactionMap, CustomAnnotationDropdownData, AutocompleteData, CommentSidebarFilterConfig as CommentSidebarFilterConfig$2, CommentSidebarGroupConfig as CommentSidebarGroupConfig$2, CommentSidebarFilters as CommentSidebarFilters$2, RecorderLayoutMode, RecordedData, RecorderMode, CommentAnnotation, NotificationPanelMode, AutocompleteItem, User, Options, DocumentMetadata, Document, SetDocumentsRequestOptions, Location as Location$1, SetLocationsRequestOptions, CommentElement, UnreadCommentsCount, CommentAddEventData, CommentUpdateEventData, CommentSelectionChangeData, CommentSidebarCustomActionEventData, AddCommentAnnotationRequest, AddCommentAnnotationEvent, ApproveCommentAnnotationRequest, ApproveCommentAnnotationEvent, RejectCommentAnnotationRequest, RejectCommentAnnotationEvent, SubscribeCommentAnnotationRequest, SubscribeCommentAnnotationEvent, UnsubscribeCommentAnnotationRequest, UnsubscribeCommentAnnotationEvent, DeleteCommentAnnotationRequest, DeleteCommentAnnotationEvent, CommentRequestQuery, GetCommentAnnotationsResponse, GetCommentAnnotationsCountResponse, AssignUserRequest, AssignUserEvent, UpdatePriorityRequest, UpdatePriorityEvent, UpdateStatusRequest, UpdateStatusEvent, UpdateAccessRequest, UpdateAccessEvent, ResolveCommentAnnotationRequest, GetLinkRequest, GetLinkResponse, CopyLinkRequest, CopyLinkEvent, AddCommentRequest, AddCommentEvent, UpdateCommentRequest, UpdateCommentEvent, DeleteCommentRequest, DeleteCommentEvent, GetCommentRequest, AddAttachmentRequest, AddAttachmentResponse, DeleteAttachmentRequest, DeleteAttachmentEvent, GetAttachmentRequest, Attachment, DeleteRecordingRequest, DeleteRecordingEvent, GetRecordingRequest, AddReactionRequest, AddReactionEvent, DeleteReactionRequest, DeleteReactionEvent, ToggleReactionRequest, ToggleReactionEvent, CommentEventTypesMap, CoreEventTypesMap, CursorElement, CursorUser, LiveStateSyncElement, SetLiveStateDataConfig, UserEditorAccess, EditorAccessTimer, ServerConnectionState, LiveStateEventTypesMap, PresenceElement, PresenceUser, PresenceRequestQuery, GetPresenceDataResponse, PresenceEventTypesMap, RecorderElement, RecorderRequestQuery, GetRecordingsResponse, RecorderEventTypesMap, RewriterElement, SelectionElement, LiveSelectionData, TagElement, TagAnnotation, ViewsElement, ViewsByUser, ViewsByDate, NotificationElement, GetNotificationsDataQuery, Notification, NotificationSettingsConfig, NotificationInitialSettingsConfig, NotificationEventTypesMap, AutocompleteElement, AutocompleteChipData, ContactElement, SelectedUserContact, GetContactListResponse } from '@veltdev/types';

interface IVeltProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    apiKey: string;
    config?: Config & {
        proxyDomain?: string;
        version?: string;
        integrity?: boolean;
    };
    user?: any;
    documentId?: string;
    language?: string;
    translations?: {
        [languageCode: string]: {
            [input: string]: string;
        };
    };
    autoTranslation?: boolean;
    userDataProvider?: UserDataProvider;
    dataProviders?: VeltDataProvider;
    encryptionProvider?: VeltEncryptionProvider;
    authProvider?: VeltAuthProvider;
    onClientLoad?: (veltClient?: Velt) => any;
}
declare const SnippylyProvider: React$1.FC<IVeltProps>;

interface IVeltCommentBubbleProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    /**
     * @deprecated Use `targetElementId` instead
     */
    targetCommentElementId?: string;
    targetElementId?: string;
    /**
     * @deprecated Use `avatar` instead
     */
    showAvatar?: boolean;
    avatar?: boolean;
    commentBubbleTargetPinHover?: boolean;
    shadowDom?: boolean;
    variant?: string;
    darkMode?: boolean;
    readOnly?: boolean;
    commentCountType?: 'total' | 'unread';
    context?: {
        [key: string]: any;
    };
    contextOptions?: ContextOptions;
    locationId?: string;
    documentId?: string;
    folderId?: string;
    annotationId?: string;
}
declare const SnippylyCommentBubble: React$1.FC<IVeltCommentBubbleProps>;

interface IVeltCommentsProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    streamViewContainerId?: string;
    autoCategorize?: boolean;
    onSignIn?: Function;
    onUpgrade?: Function;
    textMode?: boolean;
    popoverMode?: boolean;
    popoverTriangleComponent?: boolean;
    floatingCommentDialog?: boolean;
    moderatorMode?: boolean;
    streamMode?: boolean;
    signInButton?: boolean;
    upgradeButton?: boolean;
    attachments?: boolean;
    /**
     * Pass `all` to allow all type of recordings.
     * Pass `none` to disable all type of recordings.
     * Pass `string` to allow specific type of recordings.
     * For example: `audio` or `video` or `screen` or any combination like `audio,video`.
     */
    recordings?: string;
    reactions?: boolean;
    deviceInfo?: boolean;
    commentIndex?: boolean;
    dialogOnHover?: boolean;
    dialogOnTargetElementClick?: boolean;
    priority?: boolean;
    status?: boolean;
    resolveButton?: boolean;
    inboxMode?: boolean;
    suggestionMode?: boolean;
    mobileMode?: boolean;
    inlineCommentMode?: boolean;
    privateCommentMode?: boolean;
    minimap?: boolean;
    minimapPosition?: string;
    persistentCommentMode?: boolean;
    ghostComments?: boolean;
    ghostCommentsIndicator?: boolean;
    commentsOnDom?: boolean;
    resolvedCommentsOnDom?: boolean;
    filterCommentsOnDom?: boolean;
    bubbleOnPin?: boolean;
    bubbleOnPinHover?: boolean;
    commentTool?: boolean;
    sidebarButtonOnCommentDialog?: boolean;
    deviceIndicatorOnCommentPins?: boolean;
    scrollToComment?: boolean;
    userMentions?: boolean;
    deleteOnBackspace?: boolean;
    hotkey?: boolean;
    /**
     * @deprecated Use `recordingTranscription` instead.
     */
    recordingSummary?: boolean;
    recordingTranscription?: boolean;
    recordingCountdown?: boolean;
    unreadIndicatorMode?: 'minimal' | 'verbose';
    enterKeyToSubmit?: boolean;
    pinShadowDom?: boolean;
    dialogShadowDom?: boolean;
    shadowDom?: boolean;
    changeDetectionInCommentMode?: boolean;
    areaComment?: boolean;
    pinCursorImage?: string;
    allowedElementIds?: string[];
    allowedElementClassNames?: string[];
    allowedElementQuerySelectors?: string[];
    commentPinHighlighter?: boolean;
    customReactions?: ReactionMap;
    /**
     * @legacy Use `useAddCommentAnnotation` event hook instead.
     */
    onCommentAdd?: Function;
    onCustomPinInject?: Function;
    /**
     * @legacy Use respective update events hooks instead.
     */
    onCommentUpdate?: Function;
    onCommentAccept?: Function;
    onCommentReject?: Function;
    onCopyLink?: Function;
    onSidebarButtonOnCommentDialogClick?: Function;
    onCommentSelectionChange?: Function;
    customStatus?: {
        id: string;
        color: string;
        name: string;
        type: 'default' | 'ongoing' | 'terminal';
        lightColor?: string;
        svg?: string;
        iconUrl?: string;
    }[];
    customPriority?: {
        id: string;
        color: string;
        name: string;
        lightColor?: string;
    }[];
    customCategory?: {
        id: string;
        color: string;
        name: string;
    }[];
    customListDataOnAnnotation?: CustomAnnotationDropdownData;
    customListDataOnComment?: AutocompleteData;
    darkMode?: boolean;
    dialogDarkMode?: boolean;
    pinDarkMode?: boolean;
    textCommentToolDarkMode?: boolean;
    textCommentToolbarDarkMode?: boolean;
    textCommentToolShadowDom?: boolean;
    textCommentToolbarShadowDom?: boolean;
    persistentCommentShadowDom?: boolean;
    composerMode?: 'default' | 'expanded';
    atHereLabel?: string;
    atHereDescription?: string;
    /**
     * @deprecated Use `multiThread` instead.
     */
    multiThreadMode?: boolean;
    multiThread?: boolean;
    /**
     * @deprecated Use `groupMatchedComments` instead.
     */
    groupMultipleMatch?: boolean;
    groupMatchedComments?: boolean;
    deleteReplyConfirmation?: boolean;
    collapsedComments?: boolean;
    shortUserName?: boolean;
    resolveStatusAccessAdminOnly?: boolean;
    svgAsImg?: boolean;
    seenByUsers?: boolean;
    readOnly?: boolean;
    atHereEnabled?: boolean;
    customAutocompleteSearch?: boolean;
    deleteThreadWithFirstComment?: boolean;
    expandMentionGroups?: boolean;
    showMentionGroupsFirst?: boolean;
    showMentionGroupsOnly?: boolean;
    fullExpanded?: boolean;
    commentToNearestAllowedElement?: boolean;
    draftMode?: boolean;
    maxReplyAvatars?: number;
    replyAvatars?: boolean;
    linkCallback?: boolean;
    replyPlaceholder?: string;
    commentPlaceholder?: string;
    allowedFileTypes?: string[];
    attachmentNameInMessage?: boolean;
}
declare const SnippylyComments: React$1.FC<IVeltCommentsProps>;

interface IVeltCommentsSidebarProps {
    embedMode?: boolean;
    floatingMode?: boolean;
    /**
     * @deprecated Use `urlNavigation` instead
     */
    enableUrlNavigation?: boolean;
    urlNavigation?: boolean;
    queryParamsComments?: boolean;
    pageMode?: boolean;
    currentLocationSuffix?: boolean;
    variant?: string;
    pageModeComposerVariant?: string;
    dialogVariant?: string;
    shadowDom?: boolean;
    sortData?: 'asc' | 'desc' | 'none';
    filterConfig?: CommentSidebarFilterConfig$2;
    groupConfig?: CommentSidebarGroupConfig$2;
    filters?: CommentSidebarFilters$2;
    excludeLocationIds?: string[];
    /**
     * @deprecated Use `onSidebarOpen` instead
     */
    openSidebar?: Function;
    onSidebarOpen?: Function;
    /**
     * @deprecated Use `onCommentClick` instead
     */
    onSidebarCommentClick?: Function;
    onCommentClick?: Function;
    onSidebarClose?: Function;
    onCommentNavigationButtonClick?: Function;
    darkMode?: boolean;
    position?: "right" | "left";
    filterPanelLayout?: 'menu' | 'bottomSheet';
    customActions?: boolean;
    focusedThreadDialogVariant?: string;
    focusedThreadMode?: boolean;
    searchPlaceholder?: string;
    filterOptionLayout?: 'checkbox' | 'dropdown';
    filterCount?: boolean;
    fullExpanded?: boolean;
    systemFiltersOperator?: 'and' | 'or';
    sidebarButtonCountType?: 'default' | 'filter';
    filterGhostCommentsInSidebar?: boolean;
    fullScreen?: boolean;
}
declare const SnippylyCommentsSidebar: React$1.FC<IVeltCommentsSidebarProps>;

interface IVeltCommentToolProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    /**
     * @deprecated Use `targetElementId` instead
     */
    targetCommentElementId?: string;
    targetElementId?: string;
    onCommentModeChange?: Function;
    sourceId?: string;
    darkMode?: boolean;
    disabled?: boolean;
    variant?: string;
    shadowDom?: boolean;
    context?: {
        [key: string]: any;
    };
    contextOptions?: ContextOptions;
    locationId?: string;
    documentId?: string;
    folderId?: string;
}
declare const SnippylyCommentTool: React$1.FC<IVeltCommentToolProps>;

interface IVeltCursorProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    avatarMode?: boolean;
    inactivityTime?: number;
    allowedElementIds?: string;
    /**
     * @deprecated Use `onCursorUserChange` instead
     */
    onCursorUsersChanged?: Function;
    onCursorUserChange?: Function;
}
declare const SnippylyCursor: React$1.FC<IVeltCursorProps>;

interface IVeltHuddleProps {
    chat?: boolean;
    flockModeOnAvatarClick?: boolean;
    serverFallback?: boolean;
}
declare const SnippylyHuddle: React$1.FC<IVeltHuddleProps>;

interface IVeltHuddleToolProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    type?: string;
    darkMode?: boolean;
}
declare const SnippylyHuddleTool: React$1.FC<IVeltHuddleToolProps>;

interface IVeltPresenceProps {
    maxUsers?: number;
    inactivityTime?: number;
    offlineInactivityTime?: number;
    documentParams?: any;
    location?: any;
    locationId?: string;
    /**
     * @deprecated Use `onPresenceUserChange` instead
     */
    onUsersChanged?: Function;
    onPresenceUserChange?: Function;
    flockMode?: boolean;
    /**
     * @deprecated Use `defaultFlockNavigation` instead
     */
    disableFlockNavigation?: boolean;
    defaultFlockNavigation?: boolean;
    self?: boolean;
    shadowDom?: boolean;
    onNavigate?: (pageInfo: {
        path: string;
        url: string;
        baseUrl: string;
    }) => void;
    onPresenceUserClick?: (presenceUser: any) => any;
}
declare const SnippylyPresence: React$1.FC<IVeltPresenceProps>;

interface IVeltRecorderControlPanelProps {
    mode?: RecorderLayoutMode;
    panelId?: string;
    onRecordedData?: (data: RecordedData) => void;
    recordingCountdown?: boolean;
    recordingTranscription?: boolean;
    videoEditor?: boolean;
    settingsEmbedded?: boolean;
    autoOpenVideoEditor?: boolean;
    playVideoInFullScreen?: boolean;
    retakeOnVideoEditor?: boolean;
    pictureInPicture?: boolean;
    maxLength?: number;
}
declare const SnippylyRecorderControlPanel: React$1.FC<IVeltRecorderControlPanelProps>;

interface IVeltRecorderNotesProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    shadowDom?: boolean;
    videoEditor?: boolean;
    recordingCountdown?: boolean;
    recordingTranscription?: boolean;
    playVideoInFullScreen?: boolean;
}
declare const SnippylyRecorderNotes: React$1.FC<IVeltRecorderNotesProps>;

interface IVeltRecorderPlayerProps {
    recorderId?: string;
    onDelete?: Function;
    /**
     * @deprecated Use `summary` instead.
     */
    showSummary?: boolean;
    summary?: boolean;
    shadowDom?: boolean;
    videoEditor?: boolean;
    playVideoInFullScreen?: boolean;
    retakeOnVideoEditor?: boolean;
}
declare const SnippylyRecorderPlayer: React$1.FC<IVeltRecorderPlayerProps>;

interface IVeltRecorderToolProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    type?: RecorderMode;
    panelId?: string;
    buttonLabel?: string;
    darkMode?: boolean;
    shadowDom?: boolean;
    recordingCountdown?: boolean;
    variant?: string;
    retakeOnVideoEditor?: boolean;
    pictureInPicture?: boolean;
    maxLength?: number;
}
declare const SnippylyRecorderTool: React$1.FC<IVeltRecorderToolProps>;

declare class FilterTypeConfig$1 {
    name?: string;
    enable?: boolean;
    multiSelection?: boolean;
    enableGrouping?: boolean;
    order?: string[];
}
declare class CommentSidebarFilterConfig$1 {
    location?: FilterTypeConfig$1;
    people?: FilterTypeConfig$1;
    priority?: FilterTypeConfig$1;
    category?: FilterTypeConfig$1;
    commentType?: FilterTypeConfig$1;
    status?: FilterTypeConfig$1;
}
declare class CommentSidebarGroupConfig$1 {
    enable?: boolean;
    name?: string;
}
declare class CommentSidebarFilters$1 {
    location?: Location[];
    people?: {
        userId?: string;
        email?: string;
    }[];
    priority?: string[];
    status?: string[];
    category?: string[];
}
interface IVeltSidebarButtonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    tooltipText?: string;
    darkMode?: boolean;
    shadowDom?: boolean;
    floatingMode?: boolean;
    pageMode?: boolean;
    sortData?: 'asc' | 'desc' | 'none';
    urlNavigation?: boolean;
    currentLocationSuffix?: boolean;
    filterConfig?: CommentSidebarFilterConfig$1;
    groupConfig?: CommentSidebarGroupConfig$1;
    filters?: CommentSidebarFilters$1;
    excludeLocationIds?: string[];
    dialogVariant?: string;
    pageModeComposerVariant?: string;
    sidebarShadowDom?: boolean;
    sidebarVariant?: string;
    position?: "right" | "left";
    filterPanelLayout?: 'menu' | 'bottomSheet';
    sidebarButtonCountType?: 'default' | 'filter';
    filterGhostCommentsInSidebar?: boolean;
    onCommentClick?: Function;
    onSidebarOpen?: Function;
}
declare const SnippylySidebarButton: React$1.FC<IVeltSidebarButtonProps>;

declare class FilterTypeConfig {
    name?: string;
    enable?: boolean;
    multiSelection?: boolean;
    enableGrouping?: boolean;
    order?: string[];
}
declare class CommentSidebarFilterConfig {
    location?: FilterTypeConfig;
    people?: FilterTypeConfig;
    priority?: FilterTypeConfig;
    category?: FilterTypeConfig;
    commentType?: FilterTypeConfig;
    status?: FilterTypeConfig;
}
declare class CommentSidebarGroupConfig {
    enable?: boolean;
    name?: string;
}
declare class CommentSidebarFilters {
    location?: Location[];
    people?: {
        userId?: string;
        email?: string;
    }[];
    priority?: string[];
    status?: string[];
    category?: string[];
}
interface IVeltCommentsSidebarButtonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    tooltipText?: string;
    darkMode?: boolean;
    shadowDom?: boolean;
    floatingMode?: boolean;
    pageMode?: boolean;
    sortData?: 'asc' | 'desc' | 'none';
    urlNavigation?: boolean;
    currentLocationSuffix?: boolean;
    filterConfig?: CommentSidebarFilterConfig;
    groupConfig?: CommentSidebarGroupConfig;
    filters?: CommentSidebarFilters;
    excludeLocationIds?: string[];
    dialogVariant?: string;
    pageModeComposerVariant?: string;
    sidebarShadowDom?: boolean;
    sidebarVariant?: string;
    position?: "right" | "left";
    filterPanelLayout?: 'menu' | 'bottomSheet';
    onCommentClick?: Function;
    onSidebarOpen?: Function;
}
declare const VeltCommentsSidebarButton: React$1.FC<IVeltCommentsSidebarButtonProps>;

interface IVeltTagsProps {
    pinHighlighterClass?: string;
}
declare const SnippylyTags: React$1.FC<IVeltTagsProps>;

interface IVeltTagToolProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    targetTagElementId?: string;
}
declare const SnippylyTagTool: React$1.FC<IVeltTagToolProps>;

declare const SnippylyArrows: React$1.FC<any>;

interface IVeltArrowToolProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    darkMode?: boolean;
}
declare const SnippylyArrowTool: React$1.FC<IVeltArrowToolProps>;

interface IVeltUserInviteToolProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    type?: string;
    source?: string;
    title?: string;
    placeholder?: string;
    inviteUrl?: string;
    accessControlDropdown?: boolean;
    documentUserAccessList?: boolean;
    darkMode?: boolean;
}
declare const SnippylyUserInviteTool: React$1.FC<IVeltUserInviteToolProps>;

interface IVeltUserRequestToolProps {
    /**
     * Allowed values: 'feedback', 'reportBug', 'contactUs'
     *
     * Default value: 'feedback'
     */
    type?: string;
}
declare const SnippylyUserRequestTool: React$1.FC<IVeltUserRequestToolProps>;

interface IVeltCommentPlayerTimelineProps {
    totalMediaLength?: number;
    offset?: number;
    shadowDom?: boolean;
    videoPlayerId?: string;
    onCommentClick?: Function;
    onReactionClick?: Function;
}
declare const VeltCommentPlayerTimeline: React$1.FC<IVeltCommentPlayerTimelineProps>;

interface IVeltVideoPlayerProps {
    src: string;
    darkMode?: boolean;
    sync?: boolean;
    commentTool?: boolean;
    shadowDom?: boolean;
}
declare const VeltVideoPlayer: React$1.FC<IVeltVideoPlayerProps>;

interface IVeltViewAnalyticsProps {
    type?: 'document' | 'location';
    locationId?: string;
}
declare const VeltViewAnalytics: React$1.FC<IVeltViewAnalyticsProps>;

interface IVeltCommentThreadProps {
    annotationId?: string;
    annotation?: CommentAnnotation;
    onCommentClick?: Function;
    darkMode?: boolean;
    variant?: string;
    dialogVariant?: string;
    shadowDom?: boolean;
    fullExpanded?: boolean;
}
declare const VeltCommentThread: React$1.FC<IVeltCommentThreadProps>;

declare class NotificationTabConfigItem$1 {
    name?: string;
    enable?: boolean;
}
declare class NotificationTabConfig$1 {
    forYou?: NotificationTabConfigItem$1;
    documents?: NotificationTabConfigItem$1;
    all?: NotificationTabConfigItem$1;
    people?: NotificationTabConfigItem$1;
}
interface IVeltNotificationsToolProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    darkMode?: boolean;
    onNotificationClick?: Function;
    shadowDom?: boolean;
    panelShadowDom?: boolean;
    variant?: string;
    tabConfig?: NotificationTabConfig$1;
    panelOpenMode?: 'popover' | 'sidebar';
    panelVariant?: string;
    maxDays?: number;
    readNotificationsOnForYouTab?: boolean;
    settings?: boolean;
    selfNotifications?: boolean;
}
declare const VeltNotificationsTool: React$1.FC<IVeltNotificationsToolProps>;

declare class NotificationTabConfigItem {
    name?: string;
    enable?: boolean;
}
declare class NotificationTabConfig {
    forYou?: NotificationTabConfigItem;
    documents?: NotificationTabConfigItem;
    all?: NotificationTabConfigItem;
    people?: NotificationTabConfigItem;
}
interface IVeltNotificationsPanelProps {
    darkMode?: boolean;
    onNotificationClick?: Function;
    shadowDom?: boolean;
    variant?: string;
    tabConfig?: NotificationTabConfig;
    readNotificationsOnForYouTab?: boolean;
    panelOpenMode?: NotificationPanelMode;
    settings?: boolean;
    selfNotifications?: boolean;
}
declare const VeltNotificationsPanel: React$1.FC<IVeltNotificationsPanelProps>;

interface IVeltNotificationsHistoryPanelProps {
    embedMode?: boolean;
    onNotificationClick?: Function;
    darkMode?: boolean;
}
declare const VeltNotificationsHistoryPanel: React$1.FC<IVeltNotificationsHistoryPanelProps>;

interface IVeltNivoChartCommentsProps {
    id: string;
    chartComputedData?: any;
    dialogMetadataTemplate?: string[];
}
declare const VeltNivoChartComments: React$1.FC<IVeltNivoChartCommentsProps>;

interface IVeltHighChartCommentsProps {
    id: string;
    chartComputedData: any;
    dialogMetadataTemplate?: string[];
    Highcharts?: any;
}
declare const VeltHighChartComments: React$1.FC<IVeltHighChartCommentsProps>;

interface IVeltChartCommentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    commentMetadata?: {
        [key: string]: any;
    };
    dialogMetadataTemplate?: string[];
    ghostComment?: boolean;
}
declare const VeltChartComment: React$1.FC<IVeltChartCommentProps>;

interface IVeltAutocompleteProps {
    hotkey: string;
    listData: AutocompleteItem[];
}
declare const VeltAutocomplete: React$1.FC<IVeltAutocompleteProps>;

interface IVeltInlineCommentsSectionProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    config?: {
        id: string;
        name?: string;
    };
    /**
     * @deprecated Use `targetElementId` instead.
     */
    targetInlineCommentElementId?: string;
    /**
     * @deprecated Use `targetElementId` instead.
     */
    targetCommentElementId?: string;
    targetElementId?: string;
    darkMode?: boolean;
    variant?: string;
    dialogVariant?: string;
    composerVariant?: string;
    shadowDom?: boolean;
    multiThread?: boolean;
    /**
     * @deprecated Use `sortBy` and `sortOrder` instead.
     */
    sortData?: 'asc' | 'desc' | 'none';
    composerPosition?: 'top' | 'bottom';
    sortBy?: 'createdAt' | 'lastUpdated';
    sortOrder?: 'asc' | 'desc';
    fullExpanded?: boolean;
    context?: {
        [key: string]: any;
    };
    contextOptions?: ContextOptions;
    locationId?: string;
    documentId?: string;
    folderId?: string;
}
declare const VeltInlineCommentsSection: React$1.FC<IVeltInlineCommentsSectionProps>;

interface IVeltCommentPinProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    multiThreadAnnotationId?: string;
    variant?: string;
    context?: {
        [key: string]: any;
    };
    contextOptions?: ContextOptions;
    locationId?: string;
    documentId?: string;
    folderId?: string;
}
declare const VeltCommentPin: React$1.FC<IVeltCommentPinProps>;

interface IVeltCommentTextProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    multiThreadAnnotationId?: string;
}
declare const VeltCommentText: React$1.FC<IVeltCommentTextProps>;

interface IVeltCanvasCommentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    canvasId: string;
    position: any;
}
declare const VeltCanvasComment: React$1.FC<IVeltCanvasCommentProps>;

interface IVeltDataProps {
    path?: string;
    field?: string;
}
declare const VeltData: React$1.FC<IVeltDataProps>;

interface IVeltIfProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    condition?: string;
}
declare const VeltIf: React$1.FC<IVeltIfProps>;

interface IVeltCommentsMinimapProps {
    position?: string;
    targetScrollableElementId?: string;
}
declare const VeltCommentsMinimap: React$1.FC<IVeltCommentsMinimapProps>;

interface IVeltReactionToolProps {
    videoPlayerId?: string;
    onReactionToolClick?: Function;
}
declare const VeltReactionTool: React$1.FC<IVeltReactionToolProps>;

interface IVeltInlineReactionsSectionProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    targetReactionElementId?: string;
    darkMode?: boolean;
    variant?: string;
    shadowDom?: boolean;
    customReactions?: ReactionMap;
}
declare const VeltInlineReactionsSection: React$1.FC<IVeltInlineReactionsSectionProps>;

interface IVeltCommentComposerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    darkMode?: boolean;
    variant?: string;
    dialogVariant?: string;
    shadowDom?: boolean;
}
declare const VeltCommentComposer: React$1.FC<IVeltCommentComposerProps>;

interface IVeltSingleEditorModePanelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    shadowDom?: boolean;
    variant?: string;
    darkMode?: boolean;
}
declare const VeltSingleEditorModePanel: React$1.FC<IVeltSingleEditorModePanelProps>;

interface IVeltVideoEditorProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    darkMode?: boolean;
    variant?: string;
    blob?: Blob;
    url?: string;
    annotationId?: string;
    recorderId?: string;
}
declare const VeltVideoEditor: React$1.FC<IVeltVideoEditorProps>;

interface IVeltWireframeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
}
declare const VeltWireframe: React$1.FC<IVeltWireframeProps>;

interface IVeltWireframeCommonProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
    veltIf?: string;
    veltClass?: string;
    variant?: string;
}

interface IVeltCommentDialogAllCommentProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogApproveProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssignMenuProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerResolveButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerUserAvatarProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerUserNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerUnresolveButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogAssigneeBanner extends React$1.FC<IVeltCommentDialogAssigneeBannerProps> {
    ResolveButton: React$1.FC<IVeltCommentDialogAssigneeBannerResolveButtonProps>;
    UserAvatar: React$1.FC<IVeltCommentDialogAssigneeBannerUserAvatarProps>;
    UserName: React$1.FC<IVeltCommentDialogAssigneeBannerUserNameProps>;
    UnresolveButton: React$1.FC<IVeltCommentDialogAssigneeBannerUnresolveButtonProps>;
}

interface IVeltCommentDialogBodyProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCommentCategoryProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCommentIndexProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCommentSuggestionStatusProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerActionButtonProps extends IVeltWireframeCommonProps {
    type?: 'userMentions' | 'autocomplete' | 'file' | 'audio' | 'video' | 'screen' | 'submit' | 'attachments';
    hotkey?: string;
}

interface IVeltCommentDialogComposerAssignUserProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsInvalidItemPreviewProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsInvalidItemMessageProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsInvalidItemDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsInvalidItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogComposerAttachmentsInvalidItem extends React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidItemProps> {
    Preview: React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidItemPreviewProps>;
    Message: React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidItemMessageProps>;
    Delete: React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidItemDeleteProps>;
}

interface IVeltCommentDialogComposerAttachmentsInvalidProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogComposerAttachmentsInvalid extends React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidProps> {
    Item: IVeltCommentDialogComposerAttachmentsInvalidItem;
}

interface IVeltCommentDialogComposerAttachmentsImagePreviewProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsImageDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsImageLoadingProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsImageProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogComposerAttachmentsImage extends React$1.FC<IVeltCommentDialogComposerAttachmentsImageProps> {
    Preview: React$1.FC<IVeltCommentDialogComposerAttachmentsImagePreviewProps>;
    Delete: React$1.FC<IVeltCommentDialogComposerAttachmentsImageDeleteProps>;
    Loading: React$1.FC<IVeltCommentDialogComposerAttachmentsImageLoadingProps>;
}

interface IVeltCommentDialogComposerAttachmentsOtherDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherIconProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherLoadingProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherSizeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogComposerAttachmentsOther extends React$1.FC<IVeltCommentDialogComposerAttachmentsOtherProps> {
    Icon: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherIconProps>;
    Delete: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherDeleteProps>;
    Loading: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherLoadingProps>;
    Name: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherNameProps>;
    Size: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherSizeProps>;
}

interface IVeltCommentDialogComposerAttachmentsSelectedProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogComposerAttachmentsSelected extends React$1.FC<IVeltCommentDialogComposerAttachmentsSelectedProps> {
    Image: IVeltCommentDialogComposerAttachmentsImage;
    Other: IVeltCommentDialogComposerAttachmentsOther;
}

interface IVeltCommentDialogComposerAttachmentsProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogComposerAttachments extends React$1.FC<IVeltCommentDialogComposerAttachmentsProps> {
    Invalid: IVeltCommentDialogComposerAttachmentsInvalid;
    Selected: IVeltCommentDialogComposerAttachmentsSelected;
}

interface IVeltCommentDialogComposerInputProps extends IVeltWireframeCommonProps {
    placeholder?: string;
    commentplaceholder?: string;
    replyplaceholder?: string;
}

interface IVeltCommentDialogComposerRecordingsProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerPrivateBadgeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAvatarProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogComposer extends React$1.FC<IVeltCommentDialogComposerProps> {
    ActionButton: React$1.FC<IVeltCommentDialogComposerActionButtonProps>;
    AssignUser: React$1.FC<IVeltCommentDialogComposerAssignUserProps>;
    Attachments: IVeltCommentDialogComposerAttachments;
    Input: React$1.FC<IVeltCommentDialogComposerInputProps>;
    Recordings: React$1.FC<IVeltCommentDialogComposerRecordingsProps>;
    PrivateBadge: React$1.FC<IVeltCommentDialogComposerPrivateBadgeProps>;
    Avatar: React$1.FC<IVeltCommentDialogComposerAvatarProps>;
}

interface IVeltCommentDialogCopyLinkProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogGhostBannerProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogHeaderProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogMoreReplyProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogOptionsDropdownContentAssignWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogOptionsDropdownContentDeleteCommentWireframeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    variant?: string;
}

interface IVeltCommentDialogOptionsDropdownContentDeleteThreadWireframeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    variant?: string;
}

interface IVeltCommentDialogOptionsDropdownContentDeleteWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogOptionsDropdownContentDeleteWireframe extends React$1.FC<IVeltCommentDialogOptionsDropdownContentDeleteWireframeProps> {
    Comment: React$1.FC<IVeltCommentDialogOptionsDropdownContentDeleteCommentWireframeProps>;
    Thread: React$1.FC<IVeltCommentDialogOptionsDropdownContentDeleteThreadWireframeProps>;
}

interface IVeltCommentDialogOptionsDropdownContentEditWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogOptionsDropdownContentMakePrivateDisableWireframeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    variant?: string;
}

interface IVeltCommentDialogOptionsDropdownContentMakePrivateEnableWireframeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    variant?: string;
}

interface IVeltCommentDialogOptionsDropdownContentMakePrivateWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogOptionsDropdownContentMakePrivateWireframe extends React$1.FC<IVeltCommentDialogOptionsDropdownContentMakePrivateWireframeProps> {
    Enable: React$1.FC<IVeltCommentDialogOptionsDropdownContentMakePrivateEnableWireframeProps>;
    Disable: React$1.FC<IVeltCommentDialogOptionsDropdownContentMakePrivateDisableWireframeProps>;
}

interface IVeltCommentDialogOptionsDropdownContentNotificationSubscribeWireframeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
}

interface IVeltCommentDialogOptionsDropdownContentNotificationUnsubscribeWireframeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
}

interface IVeltCommentDialogOptionsDropdownContentNotificationWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogOptionsDropdownContentNotificationWireframe extends React$1.FC<IVeltCommentDialogOptionsDropdownContentNotificationWireframeProps> {
    Subscribe: React$1.FC<IVeltCommentDialogOptionsDropdownContentNotificationSubscribeWireframeProps>;
    Unsubscribe: React$1.FC<IVeltCommentDialogOptionsDropdownContentNotificationUnsubscribeWireframeProps>;
}

interface IVeltCommentDialogOptionsDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogOptionsDropdownContentWireframe extends React$1.FC<IVeltCommentDialogOptionsDropdownContentWireframeProps> {
    Assign: React$1.FC<IVeltCommentDialogOptionsDropdownContentAssignWireframeProps>;
    MakePrivate: IVeltCommentDialogOptionsDropdownContentMakePrivateWireframe;
    Delete: IVeltCommentDialogOptionsDropdownContentDeleteWireframe;
    Edit: React$1.FC<IVeltCommentDialogOptionsDropdownContentEditWireframeProps>;
    Notification: IVeltCommentDialogOptionsDropdownContentNotificationWireframe;
}
declare const VeltCommentDialogOptionsDropdownContentWireframe: IVeltCommentDialogOptionsDropdownContentWireframe;

interface IVeltCommentDialogOptionsDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogOptionsDropdownTriggerWireframe extends React$1.FC<IVeltCommentDialogOptionsDropdownTriggerWireframeProps> {
}
declare const VeltCommentDialogOptionsDropdownTriggerWireframe: IVeltCommentDialogOptionsDropdownTriggerWireframe;

interface IVeltCommentDialogOptionsProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogOptions extends React$1.FC<IVeltCommentDialogOptionsProps> {
    Content: IVeltCommentDialogOptionsDropdownContentWireframe;
    Trigger: IVeltCommentDialogOptionsDropdownTriggerWireframe;
}

interface IVeltCommentDialogPriorityDropdownContentItemIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownContentItemNameWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownContentItemTickWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownContentItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogPriorityDropdownContentItemWireframe extends React$1.FC<IVeltCommentDialogPriorityDropdownContentItemWireframeProps> {
    Icon: React$1.FC<IVeltCommentDialogPriorityDropdownContentItemIconWireframeProps>;
    Name: React$1.FC<IVeltCommentDialogPriorityDropdownContentItemNameWireframeProps>;
    Tick: React$1.FC<IVeltCommentDialogPriorityDropdownContentItemTickWireframeProps>;
}

interface IVeltCommentDialogPriorityDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogPriorityDropdownContentWireframe extends React$1.FC<IVeltCommentDialogPriorityDropdownContentWireframeProps> {
    Item: IVeltCommentDialogPriorityDropdownContentItemWireframe;
}
declare const VeltCommentDialogPriorityDropdownContentWireframe: IVeltCommentDialogPriorityDropdownContentWireframe;

interface IVeltCommentDialogPriorityDropdownTriggerArrowWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownTriggerIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownTriggerNameWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogPriorityDropdownTriggerWireframe extends React$1.FC<IVeltCommentDialogPriorityDropdownTriggerWireframeProps> {
    Arrow: React$1.FC<IVeltCommentDialogPriorityDropdownTriggerArrowWireframeProps>;
    Name: React$1.FC<IVeltCommentDialogPriorityDropdownTriggerNameWireframeProps>;
    Icon: React$1.FC<IVeltCommentDialogPriorityDropdownTriggerIconWireframeProps>;
}
declare const VeltCommentDialogPriorityDropdownTriggerWireframe: IVeltCommentDialogPriorityDropdownTriggerWireframe;

interface IVeltCommentDialogPriorityProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogPriority extends React$1.FC<IVeltCommentDialogPriorityProps> {
    Content: IVeltCommentDialogPriorityDropdownContentWireframe;
    Trigger: IVeltCommentDialogPriorityDropdownTriggerWireframe;
}

interface IVeltCommentDialogPrivateBannerProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogResolveButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogSignInProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownContentItemIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownContentItemNameWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownContentItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogStatusDropdownContentItemWireframe extends React$1.FC<IVeltCommentDialogStatusDropdownContentItemWireframeProps> {
    Icon: React$1.FC<IVeltCommentDialogStatusDropdownContentItemIconWireframeProps>;
    Name: React$1.FC<IVeltCommentDialogStatusDropdownContentItemNameWireframeProps>;
}

interface IVeltCommentDialogStatusDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogStatusDropdownContentWireframe extends React$1.FC<IVeltCommentDialogStatusDropdownContentWireframeProps> {
    Item: IVeltCommentDialogStatusDropdownContentItemWireframe;
}
declare const VeltCommentDialogStatusDropdownContentWireframe: IVeltCommentDialogStatusDropdownContentWireframe;

interface IVeltCommentDialogStatusDropdownTriggerArrowWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownTriggerIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownTriggerNameWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogStatusDropdownTriggerWireframe extends React$1.FC<IVeltCommentDialogStatusDropdownTriggerWireframeProps> {
    Arrow: React$1.FC<IVeltCommentDialogStatusDropdownTriggerArrowWireframeProps>;
    Name: React$1.FC<IVeltCommentDialogStatusDropdownTriggerNameWireframeProps>;
    Icon: React$1.FC<IVeltCommentDialogStatusDropdownTriggerIconWireframeProps>;
}
declare const VeltCommentDialogStatusDropdownTriggerWireframe: IVeltCommentDialogStatusDropdownTriggerWireframe;

interface IVeltCommentDialogStatusProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogStatus extends React$1.FC<IVeltCommentDialogStatusProps> {
    Content: IVeltCommentDialogStatusDropdownContentWireframe;
    Trigger: IVeltCommentDialogStatusDropdownTriggerWireframe;
}

interface IVeltCommentDialogSuggestionActionAcceptProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogSuggestionActionRejectProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogSuggestionActionProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogSuggestionAction extends React$1.FC<IVeltCommentDialogSuggestionActionProps> {
    Accept: React$1.FC<IVeltCommentDialogSuggestionActionAcceptProps>;
    Reject: React$1.FC<IVeltCommentDialogSuggestionActionRejectProps>;
}

interface IVeltCommentDialogThreadCardAttachmentsImagePreviewProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsImageDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsImageDownloadProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsImageProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardAttachmentsImage extends React$1.FC<IVeltCommentDialogThreadCardAttachmentsImageProps> {
    Preview: React$1.FC<IVeltCommentDialogThreadCardAttachmentsImagePreviewProps>;
    Delete: React$1.FC<IVeltCommentDialogThreadCardAttachmentsImageDeleteProps>;
    Download: React$1.FC<IVeltCommentDialogThreadCardAttachmentsImageDownloadProps>;
}

interface IVeltCommentDialogThreadCardAttachmentsOtherDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherDownloadProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherIconProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherSizeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardAttachmentsOther extends React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherProps> {
    Icon: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherIconProps>;
    Delete: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherDeleteProps>;
    Download: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherDownloadProps>;
    Name: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherNameProps>;
    Size: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherSizeProps>;
}

interface IVeltCommentDialogThreadCardAttachmentsProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardAttachments extends React$1.FC<IVeltCommentDialogThreadCardAttachmentsProps> {
    Other: IVeltCommentDialogThreadCardAttachmentsOther;
    Image: IVeltCommentDialogThreadCardAttachmentsImage;
}

interface IVeltCommentDialogThreadCardAvatarProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardDeviceTypeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardDraftProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardMessageProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardOptionsProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardOptions extends React$1.FC<IVeltCommentDialogThreadCardOptionsProps> {
    Content: IVeltCommentDialogOptionsDropdownContentWireframe;
    Trigger: IVeltCommentDialogOptionsDropdownTriggerWireframe;
}

interface IVeltCommentDialogThreadCardReactionToolProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardReactionsProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardRecordingsProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardTimeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardUnreadProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardSeenDropdownContentTitleProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdownContentTitle extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentTitleProps> {
}

interface IVeltCommentDialogThreadCardSeenDropdownContentItemAvatarProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdownContentItemAvatar extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemAvatarProps> {
}

interface IVeltCommentDialogThreadCardSeenDropdownContentItemNameProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdownContentItemName extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemNameProps> {
}

interface IVeltCommentDialogThreadCardSeenDropdownContentItemTimeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdownContentItemTime extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemTimeProps> {
}

interface IVeltCommentDialogThreadCardSeenDropdownContentItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdownContentItem extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemProps> {
    Avatar: IVeltCommentDialogThreadCardSeenDropdownContentItemAvatar;
    Name: IVeltCommentDialogThreadCardSeenDropdownContentItemName;
    Time: IVeltCommentDialogThreadCardSeenDropdownContentItemTime;
}

interface IVeltCommentDialogThreadCardSeenDropdownContentItemsProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdownContentItems extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemsProps> {
    Item: IVeltCommentDialogThreadCardSeenDropdownContentItem;
}

interface IVeltCommentDialogThreadCardSeenDropdownContentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdownContent extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentProps> {
    Title: IVeltCommentDialogThreadCardSeenDropdownContentTitle;
    Items: IVeltCommentDialogThreadCardSeenDropdownContentItems;
}

interface IVeltCommentDialogThreadCardSeenDropdownTriggerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdownTrigger extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownTriggerProps> {
}

interface IVeltCommentDialogThreadCardSeenDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdown extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownProps> {
    Trigger: IVeltCommentDialog