/// <reference types="react" />
import React$1 from 'react';
import { Config, UserDataProvider, VeltDataProvider, VeltEncryptionProvider, VeltAuthProvider, VeltPermissionProvider, Velt, ContextOptions, ReactionMap, CustomAnnotationDropdownData, AutocompleteData, AutoCompleteScrollConfig, AssignToType, CommentSidebarFilterConfig as CommentSidebarFilterConfig$2, CommentSidebarGroupConfig as CommentSidebarGroupConfig$2, CommentSidebarFilters as CommentSidebarFilters$2, SidebarFilterCriteria, SortOrder, SortBy, RecorderLayoutMode, RecordedData, RecorderMode, CommentAnnotation, NotificationSettingsLayout, NotificationPanelMode, AutocompleteItem, User, Options, DocumentMetadata, Document, SetDocumentsRequestOptions, Location as Location$1, SetLocationsRequestOptions, HeartbeatConfig, GetHeartbeatResponse, GetUserPermissionsResponse, CommentElement, UnreadCommentsCount, CommentAddEventData, CommentUpdateEventData, CommentSelectionChangeData, CommentSidebarCustomActionEventData, CommentContextProvider, 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, CrdtElement, CrdtEventTypesMap, ActivityElement, ActivitySubscribeConfig, ActivityRecord, SuggestionElement, SuggestionGetSuggestionsFilter, Suggestion, EnableSuggestionModeConfig, RegisterTargetConfig, CommitSuggestionConfig, SuggestionEventTypesMap } 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;
    permissionProvider?: VeltPermissionProvider;
    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;
    openDialog?: boolean;
}
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;
    visibilityOptions?: 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;
    editPlaceholder?: string;
    editCommentPlaceholder?: string;
    editReplyPlaceholder?: string;
    allowedFileTypes?: string[];
    attachmentNameInMessage?: boolean;
    forceCloseAllOnEsc?: boolean;
    screenshot?: boolean;
    paginatedContactList?: boolean;
    autoCompleteScrollConfig?: AutoCompleteScrollConfig;
    assignToType?: AssignToType;
    formatOptions?: boolean;
    attachmentDownload?: boolean;
    pinDrag?: boolean;
    /**
     * When false, disables anonymous email mentions for comments (global comments container).
     * When true, enables them. Mirrors `anonymousEmail` on `velt-comments`.
     */
    anonymousEmail?: 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;
    openAnnotationInFocusMode?: boolean;
    searchPlaceholder?: string;
    filterOptionLayout?: 'checkbox' | 'dropdown';
    filterCount?: boolean;
    fullExpanded?: boolean;
    systemFiltersOperator?: 'and' | 'or';
    sidebarButtonCountType?: 'default' | 'filter';
    filterGhostCommentsInSidebar?: boolean;
    fullScreen?: boolean;
    readOnly?: boolean;
    dialogSelection?: boolean;
    expandOnSelection?: boolean;
    context?: {
        [key: string]: any;
    };
    defaultMinimalFilter?: SidebarFilterCriteria;
    sortOrder?: SortOrder;
    sortBy?: SortBy;
    forceClose?: boolean;
    commentPlaceholder?: string;
    replyPlaceholder?: string;
    editPlaceholder?: string;
    editCommentPlaceholder?: string;
    editReplyPlaceholder?: string;
    pageModePlaceholder?: string;
}
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;
    contextInPageModeComposer?: boolean;
}
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;
    videoEditorTimelinePreview?: boolean;
}
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;
    videoEditorTimelinePreview?: 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;
    playbackOnPreviewClick?: 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;
    commentCountType?: 'total' | 'unread';
}
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;
    considerAllNotifications?: boolean;
    pageSize?: number;
    settingsLayout?: NotificationSettingsLayout;
    enableSettingsAtOrganizationLevel?: boolean;
}
declare const VeltNotificationsTool: React$1.FC<IVeltNotificationsToolProps>;

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

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

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

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

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;
    pageSize?: number;
    settingsLayout?: NotificationSettingsLayout;
    enableSettingsAtOrganizationLevel?: boolean;
}
declare const VeltNotificationsPanel: React$1.FC<IVeltNotificationsPanelProps>;

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

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

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

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

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

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

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

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

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

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

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

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

interface IVeltNotificationsPanelContentListProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    notifications?: any;
    listItemTemplate?: any;
}
declare const VeltNotificationsPanelContentList: React$1.FC<IVeltNotificationsPanelContentListProps>;

interface IVeltNotificationsPanelContentListItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    notification?: any;
    listItemTemplate?: any;
}
declare const VeltNotificationsPanelContentListItem: React$1.FC<IVeltNotificationsPanelContentListItemProps>;

interface IVeltNotificationsPanelContentListItemAvatarProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    notification?: any;
}
declare const VeltNotificationsPanelContentListItemAvatar: React$1.FC<IVeltNotificationsPanelContentListItemAvatarProps>;

interface IVeltNotificationsPanelContentListItemUnreadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    notification?: any;
    isDefault?: boolean;
}
declare const VeltNotificationsPanelContentListItemUnread: React$1.FC<IVeltNotificationsPanelContentListItemUnreadProps>;

interface IVeltNotificationsPanelContentListItemHeadlineProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    notification?: any;
}
declare const VeltNotificationsPanelContentListItemHeadline: React$1.FC<IVeltNotificationsPanelContentListItemHeadlineProps>;

interface IVeltNotificationsPanelContentListItemBodyProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    notification?: any;
}
declare const VeltNotificationsPanelContentListItemBody: React$1.FC<IVeltNotificationsPanelContentListItemBodyProps>;

interface IVeltNotificationsPanelContentListItemFileNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    notification?: any;
}
declare const VeltNotificationsPanelContentListItemFileName: React$1.FC<IVeltNotificationsPanelContentListItemFileNameProps>;

interface IVeltNotificationsPanelContentListItemTimeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    notification?: any;
}
declare const VeltNotificationsPanelContentListItemTime: React$1.FC<IVeltNotificationsPanelContentListItemTimeProps>;

interface IVeltNotificationsPanelContentAllListProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    listItemTemplate?: any;
}
declare const VeltNotificationsPanelContentAllList: React$1.FC<IVeltNotificationsPanelContentAllListProps>;

interface IVeltNotificationsPanelContentAllListItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    listItemTemplate?: any;
}
declare const VeltNotificationsPanelContentAllListItem: React$1.FC<IVeltNotificationsPanelContentAllListItemProps>;

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

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

interface IVeltNotificationsPanelContentPeopleListProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    listItemTemplate?: any;
}
declare const VeltNotificationsPanelContentPeopleList: React$1.FC<IVeltNotificationsPanelContentPeopleListProps>;

interface IVeltNotificationsPanelContentPeopleListItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    data?: any;
    listItemTemplate?: any;
}
declare const VeltNotificationsPanelContentPeopleListItem: React$1.FC<IVeltNotificationsPanelContentPeopleListItemProps>;

interface IVeltNotificationsPanelContentPeopleListItemAvatarProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    data?: any;
}
declare const VeltNotificationsPanelContentPeopleListItemAvatar: React$1.FC<IVeltNotificationsPanelContentPeopleListItemAvatarProps>;

interface IVeltNotificationsPanelContentPeopleListItemNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    data?: any;
}
declare const VeltNotificationsPanelContentPeopleListItemName: React$1.FC<IVeltNotificationsPanelContentPeopleListItemNameProps>;

interface IVeltNotificationsPanelContentPeopleListItemCountProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    data?: any;
}
declare const VeltNotificationsPanelContentPeopleListItemCount: React$1.FC<IVeltNotificationsPanelContentPeopleListItemCountProps>;

interface IVeltNotificationsPanelContentPeopleListItemContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    data?: any;
}
declare const VeltNotificationsPanelContentPeopleListItemContent: React$1.FC<IVeltNotificationsPanelContentPeopleListItemContentProps>;

interface IVeltNotificationsPanelContentDocumentsListProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    listItemTemplate?: any;
}
declare const VeltNotificationsPanelContentDocumentsList: React$1.FC<IVeltNotificationsPanelContentDocumentsListProps>;

interface IVeltNotificationsPanelContentDocumentsListItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    document?: any;
    index?: number;
    listItemTemplate?: any;
}
declare const VeltNotificationsPanelContentDocumentsListItem: React$1.FC<IVeltNotificationsPanelContentDocumentsListItemProps>;

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

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

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

interface IVeltNotificationsPanelContentDocumentsListItemUnreadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    isDefault?: boolean;
}
declare const VeltNotificationsPanelContentDocumentsListItemUnread: React$1.FC<IVeltNotificationsPanelContentDocumentsListItemUnreadProps>;

interface IVeltNotificationsPanelContentLoadMoreProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    isLoadMoreVisible?: boolean;
    notifications?: any;
}
declare const VeltNotificationsPanelContentLoadMore: React$1.FC<IVeltNotificationsPanelContentLoadMoreProps>;

interface IVeltNotificationsPanelContentAllReadContainerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    isAllRead?: boolean;
}
declare const VeltNotificationsPanelContentAllReadContainer: React$1.FC<IVeltNotificationsPanelContentAllReadContainerProps>;

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

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

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

interface IVeltNotificationsPanelSkeletonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    isLoading?: boolean;
}
declare const VeltNotificationsPanelSkeleton: React$1.FC<IVeltNotificationsPanelSkeletonProps>;

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

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

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

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

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

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

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

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

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

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

interface IVeltNotificationsPanelSettingsAccordionProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordion: React$1.FC<IVeltNotificationsPanelSettingsAccordionProps>;

interface IVeltNotificationsPanelSettingsAccordionTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordionTrigger: React$1.FC<IVeltNotificationsPanelSettingsAccordionTriggerProps>;

interface IVeltNotificationsPanelSettingsAccordionTriggerLabelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordionTriggerLabel: React$1.FC<IVeltNotificationsPanelSettingsAccordionTriggerLabelProps>;

interface IVeltNotificationsPanelSettingsAccordionTriggerIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordionTriggerIcon: React$1.FC<IVeltNotificationsPanelSettingsAccordionTriggerIconProps>;

interface IVeltNotificationsPanelSettingsAccordionTriggerSelectedValueProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordionTriggerSelectedValue: React$1.FC<IVeltNotificationsPanelSettingsAccordionTriggerSelectedValueProps>;

interface IVeltNotificationsPanelSettingsAccordionContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordionContent: React$1.FC<IVeltNotificationsPanelSettingsAccordionContentProps>;

interface IVeltNotificationsPanelSettingsAccordionContentItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    option?: any;
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordionContentItem: React$1.FC<IVeltNotificationsPanelSettingsAccordionContentItemProps>;

interface IVeltNotificationsPanelSettingsAccordionContentItemLabelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    option?: any;
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordionContentItemLabel: React$1.FC<IVeltNotificationsPanelSettingsAccordionContentItemLabelProps>;

interface IVeltNotificationsPanelSettingsAccordionContentItemIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    option?: any;
    accordionConfig?: any;
}
declare const VeltNotificationsPanelSettingsAccordionContentItemIcon: React$1.FC<IVeltNotificationsPanelSettingsAccordionContentItemIconProps>;

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

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

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 IVeltAutocompleteOptionProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    userObject?: any;
    userId?: string;
}
declare const VeltAutocompleteOption: React$1.FC<IVeltAutocompleteOptionProps>;

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

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

interface IVeltAutocompleteOptionDescriptionProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    field?: string;
}
declare const VeltAutocompleteOptionDescription: React$1.FC<IVeltAutocompleteOptionDescriptionProps>;

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

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

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

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

interface IVeltAutocompleteChipProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    type?: 'contact' | 'custom' | 'group' | 'loading';
    email?: string;
    userObject?: any;
    userId?: string;
}
declare const VeltAutocompleteChip: React$1.FC<IVeltAutocompleteChipProps>;

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

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

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

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

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;
    commentPlaceholder?: string;
    replyPlaceholder?: string;
    composerPlaceholder?: string;
    editPlaceholder?: string;
    editCommentPlaceholder?: string;
    editReplyPlaceholder?: string;
    readOnly?: boolean;
    /**
     * Per-section override for anonymous email mentions. When set, overrides the global
     * comment setting for this inline section only.
     */
    anonymousEmail?: boolean;
    /**
     * When enabled, long comment messages are visually truncated to a fixed number of lines
     * with Show more / Show less controls. Off by default.
     */
    messageTruncation?: boolean;
    /**
     * Number of lines to show before truncating a comment message. Defaults to 4.
     * Only takes effect when `messageTruncation` is enabled.
     */
    messageTruncationLines?: number;
}
declare const VeltInlineCommentsSection: React$1.FC<IVeltInlineCommentsSectionProps>;

interface IVeltInlineCommentsSectionCommentCountProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionCommentCount: React$1.FC<IVeltInlineCommentsSectionCommentCountProps>;

interface IVeltInlineCommentsSectionComposerContainerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionComposerContainer: React$1.FC<IVeltInlineCommentsSectionComposerContainerProps>;

interface IVeltInlineCommentsSectionListProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionList: React$1.FC<IVeltInlineCommentsSectionListProps>;

interface IVeltInlineCommentsSectionPanelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionPanel: React$1.FC<IVeltInlineCommentsSectionPanelProps>;

interface IVeltInlineCommentsSectionSkeletonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionSkeleton: React$1.FC<IVeltInlineCommentsSectionSkeletonProps>;

interface IVeltInlineCommentsSectionFilterDropdownProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionFilterDropdown: React$1.FC<IVeltInlineCommentsSectionFilterDropdownProps>;

interface IVeltInlineCommentsSectionFilterDropdownTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionFilterDropdownTrigger: React$1.FC<IVeltInlineCommentsSectionFilterDropdownTriggerProps>;

interface IVeltInlineCommentsSectionFilterDropdownTriggerArrowProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionFilterDropdownTriggerArrow: React$1.FC<IVeltInlineCommentsSectionFilterDropdownTriggerArrowProps>;

interface IVeltInlineCommentsSectionFilterDropdownTriggerNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionFilterDropdownTriggerName: React$1.FC<IVeltInlineCommentsSectionFilterDropdownTriggerNameProps>;

interface IVeltInlineCommentsSectionFilterDropdownContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionFilterDropdownContent: React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentProps>;

interface IVeltInlineCommentsSectionFilterDropdownContentListProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionFilterDropdownContentList: React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentListProps>;

interface IVeltInlineCommentsSectionFilterDropdownContentListItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    filter?: string;
}
declare const VeltInlineCommentsSectionFilterDropdownContentListItem: React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentListItemProps>;

interface IVeltInlineCommentsSectionFilterDropdownContentListItemCheckboxProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    filter?: string;
}
declare const VeltInlineCommentsSectionFilterDropdownContentListItemCheckbox: React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentListItemCheckboxProps>;

interface IVeltInlineCommentsSectionFilterDropdownContentListItemLabelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    filter?: string;
}
declare const VeltInlineCommentsSectionFilterDropdownContentListItemLabel: React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentListItemLabelProps>;

interface IVeltInlineCommentsSectionSortingDropdownProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionSortingDropdown: React$1.FC<IVeltInlineCommentsSectionSortingDropdownProps>;

interface IVeltInlineCommentsSectionSortingDropdownTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionSortingDropdownTrigger: React$1.FC<IVeltInlineCommentsSectionSortingDropdownTriggerProps>;

interface IVeltInlineCommentsSectionSortingDropdownTriggerIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionSortingDropdownTriggerIcon: React$1.FC<IVeltInlineCommentsSectionSortingDropdownTriggerIconProps>;

interface IVeltInlineCommentsSectionSortingDropdownTriggerNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionSortingDropdownTriggerName: React$1.FC<IVeltInlineCommentsSectionSortingDropdownTriggerNameProps>;

interface IVeltInlineCommentsSectionSortingDropdownContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltInlineCommentsSectionSortingDropdownContent: React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentProps>;

interface IVeltInlineCommentsSectionSortingDropdownContentItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    sortOption?: string;
    sortOptionText?: string;
}
declare const VeltInlineCommentsSectionSortingDropdownContentItem: React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentItemProps>;

interface IVeltInlineCommentsSectionSortingDropdownContentItemIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    sortOption?: string;
}
declare const VeltInlineCommentsSectionSortingDropdownContentItemIcon: React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentItemIconProps>;

interface IVeltInlineCommentsSectionSortingDropdownContentItemNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    sortOptionText?: string;
}
declare const VeltInlineCommentsSectionSortingDropdownContentItemName: React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentItemNameProps>;

interface IVeltInlineCommentsSectionSortingDropdownContentItemTickProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    sortOption?: string;
}
declare const VeltInlineCommentsSectionSortingDropdownContentItemTick: React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentItemTickProps>;

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 IVeltCommentPinNumberProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentPinNumber: React$1.FC<IVeltCommentPinNumberProps$1>;

interface IVeltCommentPinIndexProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentPinIndex: React$1.FC<IVeltCommentPinIndexProps$1>;

interface IVeltCommentPinTriangleProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentPinTriangle: React$1.FC<IVeltCommentPinTriangleProps$1>;

interface IVeltCommentPinPrivateCommentIndicatorProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentPinPrivateCommentIndicator: React$1.FC<IVeltCommentPinPrivateCommentIndicatorProps$1>;

interface IVeltCommentPinGhostCommentIndicatorProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentPinGhostCommentIndicator: React$1.FC<IVeltCommentPinGhostCommentIndicatorProps$1>;

interface IVeltCommentPinUnreadCommentIndicatorProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentPinUnreadCommentIndicator: React$1.FC<IVeltCommentPinUnreadCommentIndicatorProps$1>;

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;
    className?: string;
    id?: string;
}
declare const VeltData: React$1.FC<IVeltDataProps>;

interface IVeltIfProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    condition?: string;
    className?: string;
    id?: 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;
    context?: {
        [key: string]: any;
    };
    locationId?: string;
    documentId?: string;
    folderId?: string;
    targetComposerElementId?: string;
    placeholder?: string;
    readOnly?: 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 IVeltCommentsSidebarV2Props extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    pageMode?: boolean;
    focusedThreadMode?: boolean;
    readOnly?: boolean;
    embedMode?: string;
    floatingMode?: boolean;
    position?: string;
    variant?: string;
    forceClose?: boolean;
    onSidebarOpen?: Function;
    onSidebarClose?: Function;
    onCommentClick?: Function;
    onCommentNavigationButtonClick?: Function;
}
declare const VeltCommentsSidebarV2: React$1.FC<IVeltCommentsSidebarV2Props>;

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

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

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

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

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

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

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

interface IVeltCommentsSidebarV2ListItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotation?: any;
    scrollIdle?: boolean;
}
declare const VeltCommentsSidebarV2ListItem: React$1.FC<IVeltCommentsSidebarV2ListItemProps$1>;

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

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

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

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

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

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

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

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

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

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

interface IVeltCommentsSidebarV2FilterDropdownTriggerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    isActive?: boolean;
}
declare const VeltCommentsSidebarV2FilterDropdownTrigger: React$1.FC<IVeltCommentsSidebarV2FilterDropdownTriggerProps$1>;

interface IVeltCommentsSidebarV2FilterDropdownContentProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    groups?: any;
}
declare const VeltCommentsSidebarV2FilterDropdownContent: React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentProps$1>;

interface IVeltCommentsSidebarV2FilterDropdownContentListProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    groups?: any;
}
declare const VeltCommentsSidebarV2FilterDropdownContentList: React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListProps$1>;

interface IVeltCommentsSidebarV2FilterDropdownContentListItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    item?: any;
    group?: any;
}
declare const VeltCommentsSidebarV2FilterDropdownContentListItem: React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListItemProps$1>;

interface IVeltCommentsSidebarV2FilterDropdownContentListItemIndicatorProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    mode?: string;
    selected?: boolean;
}
declare const VeltCommentsSidebarV2FilterDropdownContentListItemIndicator: React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListItemIndicatorProps$1>;

interface IVeltCommentsSidebarV2FilterDropdownContentListItemLabelProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    label?: string;
}
declare const VeltCommentsSidebarV2FilterDropdownContentListItemLabel: React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListItemLabelProps$1>;

interface IVeltCommentsSidebarV2FilterDropdownContentListCategoryProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    group?: any;
    itemTemplate?: any;
}
declare const VeltCommentsSidebarV2FilterDropdownContentListCategory: React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListCategoryProps$1>;

interface IVeltCommentsSidebarV2FilterDropdownContentListCategoryContentProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    group?: any;
    itemTemplate?: any;
}
declare const VeltCommentsSidebarV2FilterDropdownContentListCategoryContent: React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListCategoryContentProps$1>;

interface IVeltCommentDialogProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentPinSelected?: boolean;
    fullExpanded?: boolean;
    shadowDom?: boolean;
    placeholder?: string;
    editPlaceholder?: string;
    editCommentPlaceholder?: string;
    editReplyPlaceholder?: string;
    /**
     * Per-dialog override for anonymous email mentions for this annotation context.
     */
    anonymousEmail?: boolean;
}
declare const VeltCommentDialog: React$1.FC<IVeltCommentDialogProps>;

interface IVeltCommentDialogContextWrapperProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    [key: string]: any;
}
declare const VeltCommentDialogContextWrapper: React$1.FC<IVeltCommentDialogContextWrapperProps>;

interface IVeltCommentDialogThreadCardProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCard: React$1.FC<IVeltCommentDialogThreadCardProps$1>;

interface IVeltCommentDialogThreadCardAvatarProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAvatar: React$1.FC<IVeltCommentDialogThreadCardAvatarProps$1>;

interface IVeltCommentDialogThreadCardDeviceTypeProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardDeviceType: React$1.FC<IVeltCommentDialogThreadCardDeviceTypeProps$1>;

interface IVeltCommentDialogThreadCardDraftProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardDraft: React$1.FC<IVeltCommentDialogThreadCardDraftProps$1>;

interface IVeltCommentDialogThreadCardEditedProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardEdited: React$1.FC<IVeltCommentDialogThreadCardEditedProps$1>;

interface IVeltCommentDialogThreadCardMessageProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardMessage: React$1.FC<IVeltCommentDialogThreadCardMessageProps$1>;

interface IVeltCommentDialogThreadCardMessageShowMoreProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
    expanded?: boolean;
    truncated?: boolean;
    onToggle?: () => void;
}
declare const VeltCommentDialogThreadCardMessageShowMore: React$1.FC<IVeltCommentDialogThreadCardMessageShowMoreProps$1>;

interface IVeltCommentDialogThreadCardMessageShowLessProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
    expanded?: boolean;
    onToggle?: () => void;
}
declare const VeltCommentDialogThreadCardMessageShowLess: React$1.FC<IVeltCommentDialogThreadCardMessageShowLessProps$1>;

interface IVeltCommentDialogThreadCardNameProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardName: React$1.FC<IVeltCommentDialogThreadCardNameProps$1>;

interface IVeltCommentDialogThreadCardReactionToolProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
    noPadding?: boolean | string;
}
declare const VeltCommentDialogThreadCardReactionTool: React$1.FC<IVeltCommentDialogThreadCardReactionToolProps$1>;

interface IVeltCommentDialogThreadCardReactionsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardReactions: React$1.FC<IVeltCommentDialogThreadCardReactionsProps$1>;

interface IVeltCommentDialogThreadCardRecordingsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
    recorderId?: string;
}
declare const VeltCommentDialogThreadCardRecordings: React$1.FC<IVeltCommentDialogThreadCardRecordingsProps$1>;

interface IVeltCommentDialogThreadCardReplyProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardReply: React$1.FC<IVeltCommentDialogThreadCardReplyProps$1>;

interface IVeltCommentDialogThreadCardTimeProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardTime: React$1.FC<IVeltCommentDialogThreadCardTimeProps$1>;

interface IVeltCommentDialogThreadCardUnreadProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardUnread: React$1.FC<IVeltCommentDialogThreadCardUnreadProps$1>;

interface IVeltCommentDialogThreadCardOptionsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardOptions: React$1.FC<IVeltCommentDialogThreadCardOptionsProps$1>;

interface IVeltCommentDialogStatusDropdownProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    disabled?: boolean;
    onChangeStatus?: (event: {
        status: any;
        statusOptionType: string;
    }) => void;
}
declare const VeltCommentDialogStatusDropdown: React$1.FC<IVeltCommentDialogStatusDropdownProps>;

interface IVeltCommentDialogStatusDropdownTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogStatusDropdownTrigger: React$1.FC<IVeltCommentDialogStatusDropdownTriggerProps>;

interface IVeltCommentDialogStatusDropdownTriggerIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogStatusDropdownTriggerIcon: React$1.FC<IVeltCommentDialogStatusDropdownTriggerIconProps>;

interface IVeltCommentDialogStatusDropdownTriggerNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogStatusDropdownTriggerName: React$1.FC<IVeltCommentDialogStatusDropdownTriggerNameProps>;

interface IVeltCommentDialogStatusDropdownTriggerArrowProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogStatusDropdownTriggerArrow: React$1.FC<IVeltCommentDialogStatusDropdownTriggerArrowProps>;

interface IVeltCommentDialogStatusDropdownContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogStatusDropdownContent: React$1.FC<IVeltCommentDialogStatusDropdownContentProps>;

interface IVeltCommentDialogStatusDropdownContentItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogStatusDropdownContentItem: React$1.FC<IVeltCommentDialogStatusDropdownContentItemProps>;

interface IVeltCommentDialogStatusDropdownContentItemIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogStatusDropdownContentItemIcon: React$1.FC<IVeltCommentDialogStatusDropdownContentItemIconProps>;

interface IVeltCommentDialogStatusDropdownContentItemNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogStatusDropdownContentItemName: React$1.FC<IVeltCommentDialogStatusDropdownContentItemNameProps>;

interface IVeltCommentDialogPriorityDropdownProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    disabled?: boolean;
}
declare const VeltCommentDialogPriorityDropdown: React$1.FC<IVeltCommentDialogPriorityDropdownProps>;

interface IVeltCommentDialogPriorityDropdownTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownTrigger: React$1.FC<IVeltCommentDialogPriorityDropdownTriggerProps>;

interface IVeltCommentDialogPriorityDropdownTriggerIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownTriggerIcon: React$1.FC<IVeltCommentDialogPriorityDropdownTriggerIconProps>;

interface IVeltCommentDialogPriorityDropdownTriggerNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownTriggerName: React$1.FC<IVeltCommentDialogPriorityDropdownTriggerNameProps>;

interface IVeltCommentDialogPriorityDropdownTriggerArrowProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownTriggerArrow: React$1.FC<IVeltCommentDialogPriorityDropdownTriggerArrowProps>;

interface IVeltCommentDialogPriorityDropdownContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownContent: React$1.FC<IVeltCommentDialogPriorityDropdownContentProps>;

interface IVeltCommentDialogPriorityDropdownContentItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownContentItem: React$1.FC<IVeltCommentDialogPriorityDropdownContentItemProps>;

interface IVeltCommentDialogPriorityDropdownContentItemIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownContentItemIcon: React$1.FC<IVeltCommentDialogPriorityDropdownContentItemIconProps>;

interface IVeltCommentDialogPriorityDropdownContentItemNameProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownContentItemName: React$1.FC<IVeltCommentDialogPriorityDropdownContentItemNameProps>;

interface IVeltCommentDialogPriorityDropdownContentItemTickProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPriorityDropdownContentItemTick: React$1.FC<IVeltCommentDialogPriorityDropdownContentItemTickProps>;

interface IVeltCommentDialogCustomAnnotationDropdownProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdown: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownTriggerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownTrigger: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownTriggerArrowProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownTriggerArrow: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerArrowProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownTriggerListProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownTriggerList: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerListProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownTriggerListItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownTriggerListItem: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerListItemProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownTriggerPlaceholderProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownTriggerPlaceholder: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerPlaceholderProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownTriggerRemainingCountProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownTriggerRemainingCount: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerRemainingCountProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownContentProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownContent: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownContentProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownContentItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownContentItem: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownContentItemProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownContentItemIconProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownContentItemIcon: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownContentItemIconProps$1>;

interface IVeltCommentDialogCustomAnnotationDropdownContentItemLabelProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCustomAnnotationDropdownContentItemLabel: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownContentItemLabelProps$1>;

interface IVeltCommentDialogOptionsDropdownProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentIndex?: number | string;
    enableAssignment?: boolean;
    allowAssignment?: boolean;
    enableEdit?: boolean;
    allowEdit?: boolean;
    enableNotifications?: boolean;
    allowToggleNotification?: boolean;
    enablePrivateMode?: boolean;
    allowChangeCommentAccessMode?: boolean;
    triggerTemplate?: any;
    contentTemplate?: any;
    onOpenDropdownIndex?: (index: number) => void;
}
declare const VeltCommentDialogOptionsDropdown: React$1.FC<IVeltCommentDialogOptionsDropdownProps>;

interface IVeltCommentDialogOptionsDropdownTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownTrigger: React$1.FC<IVeltCommentDialogOptionsDropdownTriggerProps>;

interface IVeltCommentDialogOptionsDropdownContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContent: React$1.FC<IVeltCommentDialogOptionsDropdownContentProps>;

interface IVeltCommentDialogOptionsDropdownContentAssignProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentAssign: React$1.FC<IVeltCommentDialogOptionsDropdownContentAssignProps>;

interface IVeltCommentDialogOptionsDropdownContentEditProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentEdit: React$1.FC<IVeltCommentDialogOptionsDropdownContentEditProps>;

interface IVeltCommentDialogOptionsDropdownContentDeleteProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentDelete: React$1.FC<IVeltCommentDialogOptionsDropdownContentDeleteProps>;

interface IVeltCommentDialogOptionsDropdownContentDeleteCommentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentDeleteComment: React$1.FC<IVeltCommentDialogOptionsDropdownContentDeleteCommentProps>;

interface IVeltCommentDialogOptionsDropdownContentDeleteThreadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentDeleteThread: React$1.FC<IVeltCommentDialogOptionsDropdownContentDeleteThreadProps>;

interface IVeltCommentDialogOptionsDropdownContentMakePrivateProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentMakePrivate: React$1.FC<IVeltCommentDialogOptionsDropdownContentMakePrivateProps>;

interface IVeltCommentDialogOptionsDropdownContentMakePrivateEnableProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentMakePrivateEnable: React$1.FC<IVeltCommentDialogOptionsDropdownContentMakePrivateEnableProps>;

interface IVeltCommentDialogOptionsDropdownContentMakePrivateDisableProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentMakePrivateDisable: React$1.FC<IVeltCommentDialogOptionsDropdownContentMakePrivateDisableProps>;

interface IVeltCommentDialogOptionsDropdownContentNotificationProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentNotification: React$1.FC<IVeltCommentDialogOptionsDropdownContentNotificationProps>;

interface IVeltCommentDialogOptionsDropdownContentNotificationSubscribeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentNotificationSubscribe: React$1.FC<IVeltCommentDialogOptionsDropdownContentNotificationSubscribeProps>;

interface IVeltCommentDialogOptionsDropdownContentNotificationUnsubscribeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentNotificationUnsubscribe: React$1.FC<IVeltCommentDialogOptionsDropdownContentNotificationUnsubscribeProps>;

interface IVeltCommentDialogOptionsDropdownContentMarkAsReadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    enableMarkAsRead?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentMarkAsRead: React$1.FC<IVeltCommentDialogOptionsDropdownContentMarkAsReadProps>;

interface IVeltCommentDialogOptionsDropdownContentMarkAsReadMarkReadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentMarkAsReadMarkRead: React$1.FC<IVeltCommentDialogOptionsDropdownContentMarkAsReadMarkReadProps>;

interface IVeltCommentDialogOptionsDropdownContentMarkAsReadMarkUnreadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogOptionsDropdownContentMarkAsReadMarkUnread: React$1.FC<IVeltCommentDialogOptionsDropdownContentMarkAsReadMarkUnreadProps>;

interface IVeltCommentDialogVisibilityBannerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBanner: React$1.FC<IVeltCommentDialogVisibilityBannerProps$1>;

interface IVeltCommentDialogVisibilityBannerIconProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerIcon: React$1.FC<IVeltCommentDialogVisibilityBannerIconProps$1>;

interface IVeltCommentDialogVisibilityBannerTextProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerText: React$1.FC<IVeltCommentDialogVisibilityBannerTextProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdown: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownTriggerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownTrigger: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownTriggerLabelProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownTriggerLabel: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerLabelProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownTriggerAvatarList: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownTriggerAvatarListItem: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListItemProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListRemainingCountProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownTriggerAvatarListRemainingCount: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListRemainingCountProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownTriggerIconProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownTriggerIcon: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerIconProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownContentProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownContent: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownContentItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    type?: 'restrictedSelf' | 'restrictedSelectedPeople' | 'organizationPrivate' | 'public';
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownContentItem: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentItemProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownContentItemIconProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownContentItemIcon: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentItemIconProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownContentItemLabelProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownContentItemLabel: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentItemLabelProps$1>;

interface IVeltCommentDialogVisibilityBannerDropdownContentUserPickerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityBannerDropdownContentUserPicker: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentUserPickerProps$1>;

interface IVeltCommentDialogAssignDropdownProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    assignTo?: any | string;
    selectedUserContacts?: any[] | string;
    onSetAssignTo?: (event: {
        assignTo: any;
    }) => void;
}
declare const VeltCommentDialogAssignDropdown: React$1.FC<IVeltCommentDialogAssignDropdownProps>;

interface IVeltCommentDialogAttachmentButtonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    template?: any;
    componentMeta?: {
        componentName: string;
        variant?: string;
        suffix?: string;
    } | string;
    allowedFileTypes?: string[] | string;
    onClicked?: () => void;
    onSelectFiles?: (files: any) => void;
}
declare const VeltCommentDialogAttachmentButton: React$1.FC<IVeltCommentDialogAttachmentButtonProps>;

interface IVeltCommentDialogDeviceTypeIconsProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    deviceType?: string;
}
declare const VeltCommentDialogDeviceTypeIcons: React$1.FC<IVeltCommentDialogDeviceTypeIconsProps>;

interface IVeltCommentDialogOptionsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    variant?: string;
}
declare const VeltCommentDialogOptions: React$1.FC<IVeltCommentDialogOptionsProps$1>;

interface IVeltCommentDialogPriorityProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    variant?: string;
}
declare const VeltCommentDialogPriority: React$1.FC<IVeltCommentDialogPriorityProps$1>;

interface IVeltCommentDialogStatusProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    variant?: string;
}
declare const VeltCommentDialogStatus: React$1.FC<IVeltCommentDialogStatusProps$1>;

interface IVeltCommentDialogVisibilityDropdownProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    disabled?: boolean;
}
declare const VeltCommentDialogVisibilityDropdown: React$1.FC<IVeltCommentDialogVisibilityDropdownProps$1>;

interface IVeltCommentDialogVisibilityDropdownTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityDropdownTrigger: React$1.FC<IVeltCommentDialogVisibilityDropdownTriggerProps>;

interface IVeltCommentDialogVisibilityDropdownTriggerLabelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityDropdownTriggerLabel: React$1.FC<IVeltCommentDialogVisibilityDropdownTriggerLabelProps>;

interface IVeltCommentDialogVisibilityDropdownTriggerIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityDropdownTriggerIcon: React$1.FC<IVeltCommentDialogVisibilityDropdownTriggerIconProps>;

interface IVeltCommentDialogVisibilityDropdownContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityDropdownContent: React$1.FC<IVeltCommentDialogVisibilityDropdownContentProps>;

interface IVeltCommentDialogVisibilityDropdownContentPublicProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityDropdownContentPublic: React$1.FC<IVeltCommentDialogVisibilityDropdownContentPublicProps>;

interface IVeltCommentDialogVisibilityDropdownContentPrivateProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogVisibilityDropdownContentPrivate: React$1.FC<IVeltCommentDialogVisibilityDropdownContentPrivateProps>;

interface IVeltCommentDialogDeleteButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogDeleteButton: React$1.FC<IVeltCommentDialogDeleteButtonProps$1>;

interface IVeltCommentDialogAssigneeBannerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogAssigneeBanner: React$1.FC<IVeltCommentDialogAssigneeBannerProps$1>;

interface IVeltCommentDialogAssigneeBannerUserNameProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogAssigneeBannerUserName: React$1.FC<IVeltCommentDialogAssigneeBannerUserNameProps$1>;

interface IVeltCommentDialogAssigneeBannerUserAvatarProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogAssigneeBannerUserAvatar: React$1.FC<IVeltCommentDialogAssigneeBannerUserAvatarProps$1>;

interface IVeltCommentDialogAssigneeBannerResolveButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogAssigneeBannerResolveButton: React$1.FC<IVeltCommentDialogAssigneeBannerResolveButtonProps$1>;

interface IVeltCommentDialogAssigneeBannerUnresolveButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogAssigneeBannerUnresolveButton: React$1.FC<IVeltCommentDialogAssigneeBannerUnresolveButtonProps$1>;

interface IVeltCommentDialogAllCommentProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogAllComment: React$1.FC<IVeltCommentDialogAllCommentProps$1>;

interface IVeltCommentDialogApproveProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogApprove: React$1.FC<IVeltCommentDialogApproveProps$1>;

interface IVeltCommentDialogAssignMenuProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogAssignMenu: React$1.FC<IVeltCommentDialogAssignMenuProps$1>;

interface IVeltCommentDialogBodyProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogBody: React$1.FC<IVeltCommentDialogBodyProps$1>;

interface IVeltCommentDialogCloseButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCloseButton: React$1.FC<IVeltCommentDialogCloseButtonProps$1>;

interface IVeltCommentDialogCommentCategoryProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCommentCategory: React$1.FC<IVeltCommentDialogCommentCategoryProps$1>;

interface IVeltCommentDialogCommentIndexProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCommentIndex: React$1.FC<IVeltCommentDialogCommentIndexProps$1>;

interface IVeltCommentDialogCommentNumberProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCommentNumber: React$1.FC<IVeltCommentDialogCommentNumberProps$1>;

interface IVeltCommentDialogCommentSuggestionStatusProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCommentSuggestionStatus: React$1.FC<IVeltCommentDialogCommentSuggestionStatusProps$1>;

interface IVeltCommentDialogCopyLinkProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogCopyLink: React$1.FC<IVeltCommentDialogCopyLinkProps$1>;

interface IVeltCommentDialogGhostBannerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogGhostBanner: React$1.FC<IVeltCommentDialogGhostBannerProps$1>;

interface IVeltCommentDialogHeaderProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogHeader: React$1.FC<IVeltCommentDialogHeaderProps$1>;

interface IVeltCommentDialogHideReplyProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogHideReply: React$1.FC<IVeltCommentDialogHideReplyProps$1>;

interface IVeltCommentDialogMetadataProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogMetadata: React$1.FC<IVeltCommentDialogMetadataProps>;

interface IVeltCommentDialogMoreReplyProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogMoreReply: React$1.FC<IVeltCommentDialogMoreReplyProps$1>;

interface IVeltCommentDialogNavigationButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogNavigationButton: React$1.FC<IVeltCommentDialogNavigationButtonProps$1>;

interface IVeltCommentDialogPrivateBannerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPrivateBanner: React$1.FC<IVeltCommentDialogPrivateBannerProps$1>;

interface IVeltCommentDialogPrivateButtonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogPrivateButton: React$1.FC<IVeltCommentDialogPrivateButtonProps>;

interface IVeltCommentDialogResolveButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogResolveButton: React$1.FC<IVeltCommentDialogResolveButtonProps$1>;

interface IVeltCommentDialogSignInProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogSignIn: React$1.FC<IVeltCommentDialogSignInProps$1>;

interface IVeltCommentDialogThreadsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentDialogSelected?: boolean;
}
declare const VeltCommentDialogThreads: React$1.FC<IVeltCommentDialogThreadsProps$1>;

interface IVeltCommentDialogUnresolveButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogUnresolveButton: React$1.FC<IVeltCommentDialogUnresolveButtonProps$1>;

interface IVeltCommentDialogUpgradeProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogUpgrade: React$1.FC<IVeltCommentDialogUpgradeProps$1>;

interface IVeltCommentDialogToggleReplyProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogToggleReply: React$1.FC<IVeltCommentDialogToggleReplyProps$1>;

interface IVeltCommentDialogToggleReplyCountProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogToggleReplyCount: React$1.FC<IVeltCommentDialogToggleReplyCountProps$1>;

interface IVeltCommentDialogToggleReplyIconProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogToggleReplyIcon: React$1.FC<IVeltCommentDialogToggleReplyIconProps$1>;

interface IVeltCommentDialogToggleReplyTextProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogToggleReplyText: React$1.FC<IVeltCommentDialogToggleReplyTextProps$1>;

interface IVeltCommentDialogReplyAvatarsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogReplyAvatars: React$1.FC<IVeltCommentDialogReplyAvatarsProps$1>;

interface IVeltCommentDialogReplyAvatarsListProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogReplyAvatarsList: React$1.FC<IVeltCommentDialogReplyAvatarsListProps$1>;

interface IVeltCommentDialogReplyAvatarsListItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogReplyAvatarsListItem: React$1.FC<IVeltCommentDialogReplyAvatarsListItemProps$1>;

interface IVeltCommentDialogReplyAvatarsRemainingCountProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogReplyAvatarsRemainingCount: React$1.FC<IVeltCommentDialogReplyAvatarsRemainingCountProps$1>;

interface IVeltCommentDialogSuggestionActionProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogSuggestionAction: React$1.FC<IVeltCommentDialogSuggestionActionProps$1>;

interface IVeltCommentDialogSuggestionActionAcceptProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogSuggestionActionAccept: React$1.FC<IVeltCommentDialogSuggestionActionAcceptProps$1>;

interface IVeltCommentDialogSuggestionActionRejectProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogSuggestionActionReject: React$1.FC<IVeltCommentDialogSuggestionActionRejectProps$1>;

interface IVeltCommentDialogComposerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    editMode?: boolean;
    commentObj?: any | string;
    commentIndex?: number | string;
    composerWireframe?: any;
    placeholder?: string;
    commentplaceholder?: string;
    replyplaceholder?: string;
    editplaceholder?: string;
    editcommentplaceholder?: string;
    editreplyplaceholder?: string;
    targetElementId?: string;
    targetComposerElementId?: string;
    context?: {
        [key: string]: any;
    };
}
declare const VeltCommentDialogComposer: React$1.FC<IVeltCommentDialogComposerProps$1>;

interface IVeltCommentDialogComposerActionButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerActionButton: React$1.FC<IVeltCommentDialogComposerActionButtonProps$1>;

interface IVeltCommentDialogComposerAssignUserProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAssignUser: React$1.FC<IVeltCommentDialogComposerAssignUserProps$1>;

interface IVeltCommentDialogComposerAvatarProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAvatar: React$1.FC<IVeltCommentDialogComposerAvatarProps$1>;

interface IVeltCommentDialogComposerInputProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    editMode?: boolean;
    commentObj?: any | string;
    commentIndex?: number | string;
    placeholder?: string;
    commentplaceholder?: string;
    replyplaceholder?: string;
    editplaceholder?: string;
    editcommentplaceholder?: string;
    editreplyplaceholder?: string;
}
declare const VeltCommentDialogComposerInput: React$1.FC<IVeltCommentDialogComposerInputProps$1>;

interface IVeltCommentDialogComposerPrivateBadgeProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerPrivateBadge: React$1.FC<IVeltCommentDialogComposerPrivateBadgeProps$1>;

interface IVeltCommentDialogComposerRecordingsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerRecordings: React$1.FC<IVeltCommentDialogComposerRecordingsProps$1>;

interface IVeltCommentDialogComposerFormatToolbarProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerFormatToolbar: React$1.FC<IVeltCommentDialogComposerFormatToolbarProps$1>;

interface IVeltCommentDialogComposerFormatToolbarButtonProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    type?: 'bold' | 'italic' | 'underline' | 'strikethrough';
}
declare const VeltCommentDialogComposerFormatToolbarButton: React$1.FC<IVeltCommentDialogComposerFormatToolbarButtonProps$1>;

interface IVeltCommentDialogComposerAttachmentsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachments: React$1.FC<IVeltCommentDialogComposerAttachmentsProps$1>;

interface IVeltCommentDialogComposerAttachmentsSelectedProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsSelected: React$1.FC<IVeltCommentDialogComposerAttachmentsSelectedProps$1>;

interface IVeltCommentDialogComposerAttachmentsImageProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsImage: React$1.FC<IVeltCommentDialogComposerAttachmentsImageProps$1>;

interface IVeltCommentDialogComposerAttachmentsImageDeleteProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsImageDelete: React$1.FC<IVeltCommentDialogComposerAttachmentsImageDeleteProps$1>;

interface IVeltCommentDialogComposerAttachmentsImageDownloadProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsImageDownload: React$1.FC<IVeltCommentDialogComposerAttachmentsImageDownloadProps$1>;

interface IVeltCommentDialogComposerAttachmentsImageLoadingProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsImageLoading: React$1.FC<IVeltCommentDialogComposerAttachmentsImageLoadingProps$1>;

interface IVeltCommentDialogComposerAttachmentsImagePreviewProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsImagePreview: React$1.FC<IVeltCommentDialogComposerAttachmentsImagePreviewProps$1>;

interface IVeltCommentDialogComposerAttachmentsOtherProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsOther: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherProps$1>;

interface IVeltCommentDialogComposerAttachmentsOtherDeleteProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsOtherDelete: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherDeleteProps$1>;

interface IVeltCommentDialogComposerAttachmentsOtherDownloadProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsOtherDownload: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherDownloadProps$1>;

interface IVeltCommentDialogComposerAttachmentsOtherIconProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsOtherIcon: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherIconProps$1>;

interface IVeltCommentDialogComposerAttachmentsOtherLoadingProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsOtherLoading: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherLoadingProps$1>;

interface IVeltCommentDialogComposerAttachmentsOtherNameProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsOtherName: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherNameProps$1>;

interface IVeltCommentDialogComposerAttachmentsOtherSizeProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsOtherSize: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherSizeProps$1>;

interface IVeltCommentDialogComposerAttachmentsInvalidProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsInvalid: React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidProps$1>;

interface IVeltCommentDialogComposerAttachmentsInvalidItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsInvalidItem: React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidItemProps$1>;

interface IVeltCommentDialogComposerAttachmentsInvalidItemDeleteProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsInvalidItemDelete: React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidItemDeleteProps$1>;

interface IVeltCommentDialogComposerAttachmentsInvalidItemMessageProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsInvalidItemMessage: React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidItemMessageProps$1>;

interface IVeltCommentDialogComposerAttachmentsInvalidItemPreviewProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogComposerAttachmentsInvalidItemPreview: React$1.FC<IVeltCommentDialogComposerAttachmentsInvalidItemPreviewProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
    attachmentId?: string;
}
declare const VeltCommentDialogThreadCardAttachments: React$1.FC<IVeltCommentDialogThreadCardAttachmentsProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsImageProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    attachment?: any | string;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
    attachmentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsImage: React$1.FC<IVeltCommentDialogThreadCardAttachmentsImageProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsImageDeleteProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsImageDelete: React$1.FC<IVeltCommentDialogThreadCardAttachmentsImageDeleteProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsImageDownloadProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsImageDownload: React$1.FC<IVeltCommentDialogThreadCardAttachmentsImageDownloadProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsImagePreviewProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsImagePreview: React$1.FC<IVeltCommentDialogThreadCardAttachmentsImagePreviewProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsOtherProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    attachment?: any | string;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
    attachmentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsOther: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsOtherDeleteProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsOtherDelete: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherDeleteProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsOtherDownloadProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsOtherDownload: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherDownloadProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsOtherIconProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsOtherIcon: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherIconProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsOtherNameProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsOtherName: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherNameProps$1>;

interface IVeltCommentDialogThreadCardAttachmentsOtherSizeProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
}
declare const VeltCommentDialogThreadCardAttachmentsOtherSize: React$1.FC<IVeltCommentDialogThreadCardAttachmentsOtherSizeProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
    commentObj?: any | string;
    commentId?: number | string;
    commentIndex?: number | string;
    enableSeenByUsers?: boolean | string;
    isDraft?: boolean | string;
    viewCount?: number | string;
}
declare const VeltCommentDialogThreadCardSeenDropdown: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownTriggerProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogThreadCardSeenDropdownTrigger: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownTriggerProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownContentProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogThreadCardSeenDropdownContent: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownContentTitleProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogThreadCardSeenDropdownContentTitle: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentTitleProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownContentItemsProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogThreadCardSeenDropdownContentItems: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemsProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownContentItemProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogThreadCardSeenDropdownContentItem: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownContentItemAvatarProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogThreadCardSeenDropdownContentItemAvatar: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemAvatarProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownContentItemNameProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogThreadCardSeenDropdownContentItemName: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemNameProps$1>;

interface IVeltCommentDialogThreadCardSeenDropdownContentItemTimeProps$1 extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    annotationId?: string;
    defaultCondition?: boolean;
    inlineCommentSectionMode?: boolean;
}
declare const VeltCommentDialogThreadCardSeenDropdownContentItemTime: React$1.FC<IVeltCommentDialogThreadCardSeenDropdownContentItemTimeProps$1>;

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 IVeltCommentDialogVisibilityBannerIconProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityBannerTextProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityBannerDropdownTriggerLabelProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListItemProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListRemainingCountProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarList extends React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListProps> {
    Item: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListItemProps>;
    RemainingCount: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarListRemainingCountProps>;
}

interface IVeltCommentDialogVisibilityBannerDropdownTriggerIconProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityBannerDropdownTriggerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityBannerDropdownTrigger extends React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerProps> {
    Label: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerLabelProps>;
    AvatarList: IVeltCommentDialogVisibilityBannerDropdownTriggerAvatarList;
    Icon: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownTriggerIconProps>;
}

interface IVeltCommentDialogVisibilityBannerDropdownContentItemIconProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityBannerDropdownContentItemLabelProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityBannerDropdownContentItemProps extends IVeltWireframeCommonProps {
    type?: 'restrictedSelf' | 'restrictedSelectedPeople' | 'organizationPrivate' | 'public';
}
interface IVeltCommentDialogVisibilityBannerDropdownContentItem extends React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentItemProps> {
    Icon: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentItemIconProps>;
    Label: React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentItemLabelProps>;
}

interface IVeltCommentDialogVisibilityBannerDropdownContentUserPickerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityBannerDropdownContentUserPicker extends React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentUserPickerProps> {
}

interface IVeltCommentDialogVisibilityBannerDropdownContentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityBannerDropdownContent extends React$1.FC<IVeltCommentDialogVisibilityBannerDropdownContentProps> {
    Item: IVeltCommentDialogVisibilityBannerDropdownContentItem;
    UserPicker: IVeltCommentDialogVisibilityBannerDropdownContentUserPicker;
}

interface IVeltCommentDialogVisibilityBannerDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityBannerDropdown extends React$1.FC<IVeltCommentDialogVisibilityBannerDropdownProps> {
    Trigger: IVeltCommentDialogVisibilityBannerDropdownTrigger;
    Content: IVeltCommentDialogVisibilityBannerDropdownContent;
}

interface IVeltCommentDialogVisibilityBannerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityBanner extends React$1.FC<IVeltCommentDialogVisibilityBannerProps> {
    Icon: React$1.FC<IVeltCommentDialogVisibilityBannerIconProps>;
    Text: React$1.FC<IVeltCommentDialogVisibilityBannerTextProps>;
    Dropdown: IVeltCommentDialogVisibilityBannerDropdown;
}

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' | 'format';
    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 IVeltCommentDialogComposerAttachmentsImageDownloadProps 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>;
    Download: React$1.FC<IVeltCommentDialogComposerAttachmentsImageDownloadProps>;
    Loading: React$1.FC<IVeltCommentDialogComposerAttachmentsImageLoadingProps>;
}

interface IVeltCommentDialogComposerAttachmentsOtherDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherDownloadProps 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>;
    Download: React$1.FC<IVeltCommentDialogComposerAttachmentsOtherDownloadProps>;
    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 IVeltCommentDialogComposerFormatToolbarButtonProps extends IVeltWireframeCommonProps {
    type?: 'bold' | 'italic' | 'underline' | 'strikethrough';
}
interface IVeltCommentDialogComposerFormatToolbarButton extends React$1.FC<IVeltCommentDialogComposerFormatToolbarButtonProps> {
}

interface IVeltCommentDialogComposerFormatToolbarProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogComposerFormatToolbar extends React$1.FC<IVeltCommentDialogComposerFormatToolbarProps> {
    Button: IVeltCommentDialogComposerFormatToolbarButton;
}

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>;
    FormatToolbar: IVeltCommentDialogComposerFormatToolbar;
}

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 IVeltCommentDialogOptionsDropdownContentMarkAsReadWireframeProps extends IVeltWireframeCommonProps {
}

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;
    MarkAsRead: React$1.FC<IVeltCommentDialogOptionsDropdownContentMarkAsReadWireframeProps>;
}
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 IVeltCommentDialogThreadCardMessageShowMoreProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardMessageShowMore extends React$1.FC<IVeltCommentDialogThreadCardMessageShowMoreProps> {
}

interface IVeltCommentDialogThreadCardMessageShowLessProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardMessageShowLess extends React$1.FC<IVeltCommentDialogThreadCardMessageShowLessProps> {
}

interface IVeltCommentDialogThreadCardMessageProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardMessage extends React$1.FC<IVeltCommentDialogThreadCardMessageProps> {
    ShowMore: IVeltCommentDialogThreadCardMessageShowMore;
    ShowLess: IVeltCommentDialogThreadCardMessageShowLess;
}

interface IVeltCommentDialogThreadCardNameProps extends IVeltWireframeCommonProps {
}

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

interface IVeltCommentDialogThreadCardReactionToolProps extends IVeltWireframeCommonProps {
    excludeReactionIds?: string[];
}

interface IVeltCommentDialogThreadCardReactionPinProps extends IVeltWireframeCommonProps {
    reactionId?: string;
}

interface IVeltCommentDialogThreadCardAssignButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardReactionsProps extends IVeltWireframeCommonProps {
    excludeReactionIds?: string[];
}

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: IVeltCommentDialogThreadCardSeenDropdownTrigger;
    Content: IVeltCommentDialogThreadCardSeenDropdownContent;
}

interface IVeltCommentDialogThreadCardEditedProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardEdited extends React$1.FC<IVeltCommentDialogThreadCardEditedProps> {
}

interface IVeltCommentDialogThreadCardReplyProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardReply extends React$1.FC<IVeltCommentDialogThreadCardReplyProps> {
}

interface IVeltCommentDialogThreadCardEditComposerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardEditComposer extends React$1.FC<IVeltCommentDialogThreadCardEditComposerProps> {
}

interface IVeltCommentDialogThreadCardProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCard extends React$1.FC<IVeltCommentDialogThreadCardProps> {
    Avatar: React$1.FC<IVeltCommentDialogThreadCardAvatarProps>;
    DeviceType: React$1.FC<IVeltCommentDialogThreadCardDeviceTypeProps>;
    Attachments: IVeltCommentDialogThreadCardAttachments;
    Message: IVeltCommentDialogThreadCardMessage;
    Name: React$1.FC<IVeltCommentDialogThreadCardNameProps>;
    Options: IVeltCommentDialogThreadCardOptions;
    Reactions: React$1.FC<IVeltCommentDialogThreadCardReactionsProps>;
    ReactionTool: React$1.FC<IVeltCommentDialogThreadCardReactionToolProps>;
    ReactionPin: React$1.FC<IVeltCommentDialogThreadCardReactionPinProps>;
    AssignButton: React$1.FC<IVeltCommentDialogThreadCardAssignButtonProps>;
    Recordings: React$1.FC<IVeltCommentDialogThreadCardRecordingsProps>;
    Time: React$1.FC<IVeltCommentDialogThreadCardTimeProps>;
    Unread: React$1.FC<IVeltCommentDialogThreadCardUnreadProps>;
    Draft: React$1.FC<IVeltCommentDialogThreadCardDraftProps>;
    SeenDropdown: IVeltCommentDialogThreadCardSeenDropdown;
    Edited: IVeltCommentDialogThreadCardEdited;
    Reply: IVeltCommentDialogThreadCardReply;
    EditComposer: IVeltCommentDialogThreadCardEditComposer;
}

interface IVeltCommentDialogThreadsProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogToggleReplyCountProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogToggleReplyCount extends React$1.FC<IVeltCommentDialogToggleReplyCountProps> {
}

interface IVeltCommentDialogToggleReplyTextProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogToggleReplyText extends React$1.FC<IVeltCommentDialogToggleReplyTextProps> {
}

interface IVeltCommentDialogToggleReplyIconProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogToggleReplyIcon extends React$1.FC<IVeltCommentDialogToggleReplyIconProps> {
}

interface IVeltCommentDialogToggleReplyProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogToggleReply extends React$1.FC<IVeltCommentDialogToggleReplyProps> {
    Icon: IVeltCommentDialogToggleReplyIcon;
    Text: IVeltCommentDialogToggleReplyText;
    Count: IVeltCommentDialogToggleReplyCount;
}

interface IVeltCommentDialogUpgradeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCustomAnnotationDropdownContentItemIconProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCustomAnnotationDropdownContentItemLabelProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCustomAnnotationDropdownContentItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogCustomAnnotationDropdownContentItem extends React$1.FC<IVeltCommentDialogCustomAnnotationDropdownContentItemProps> {
    Label: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownContentItemLabelProps>;
    Icon: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownContentItemIconProps>;
}

interface IVeltCommentDialogCustomAnnotationDropdownContentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogCustomAnnotationDropdownContent extends React$1.FC<IVeltCommentDialogCustomAnnotationDropdownContentProps> {
    Item: IVeltCommentDialogCustomAnnotationDropdownContentItem;
}

interface IVeltCommentDialogCustomAnnotationDropdownTriggerArrowProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCustomAnnotationDropdownTriggerListItemProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCustomAnnotationDropdownTriggerListProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogCustomAnnotationDropdownTriggerList extends React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerListProps> {
    Item: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerListItemProps>;
}

interface IVeltCommentDialogCustomAnnotationDropdownTriggerRemainingCountProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCustomAnnotationDropdownTriggerPlaceholderProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCustomAnnotationDropdownTriggerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogCustomAnnotationDropdownTrigger extends React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerProps> {
    Arrow: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerArrowProps>;
    List: IVeltCommentDialogCustomAnnotationDropdownTriggerList;
    RemainingCount: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerRemainingCountProps>;
    Placeholder: React$1.FC<IVeltCommentDialogCustomAnnotationDropdownTriggerPlaceholderProps>;
}

interface IVeltCommentDialogCustomAnnotationDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogCustomAnnotationDropdown extends React$1.FC<IVeltCommentDialogCustomAnnotationDropdownProps> {
    Content: IVeltCommentDialogCustomAnnotationDropdownContent;
    Trigger: IVeltCommentDialogCustomAnnotationDropdownTrigger;
}

interface IVeltCommentDialogDeleteButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCloseButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogUnresolveButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogNavigationButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogReplyAvatarsListItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogReplyAvatarsListItem extends React$1.FC<IVeltCommentDialogReplyAvatarsListItemProps> {
}

interface IVeltCommentDialogReplyAvatarsListProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogReplyAvatarsList extends React$1.FC<IVeltCommentDialogReplyAvatarsListProps> {
    Item: IVeltCommentDialogReplyAvatarsListItem;
}

interface IVeltCommentDialogReplyAvatarsRemainingCountProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogReplyAvatarsRemainingCount extends React$1.FC<IVeltCommentDialogReplyAvatarsRemainingCountProps> {
}

interface IVeltCommentDialogReplyAvatarsProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogReplyAvatars extends React$1.FC<IVeltCommentDialogReplyAvatarsProps> {
    List: IVeltCommentDialogReplyAvatarsList;
    RemainingCount: IVeltCommentDialogReplyAvatarsRemainingCount;
}

interface IVeltCommentDialogCommentNumberProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogCommentNumber extends React$1.FC<IVeltCommentDialogCommentNumberProps> {
}

interface IVeltCommentDialogHideReplyProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogHideReply extends React$1.FC<IVeltCommentDialogHideReplyProps> {
}

interface IVeltCommentDialogVisibilityDropdownContentPublicWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityDropdownContentPrivateWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityDropdownContentWireframe extends React$1.FC<IVeltCommentDialogVisibilityDropdownContentWireframeProps> {
    Public: React$1.FC<IVeltCommentDialogVisibilityDropdownContentPublicWireframeProps>;
    Private: React$1.FC<IVeltCommentDialogVisibilityDropdownContentPrivateWireframeProps>;
}

interface IVeltCommentDialogVisibilityDropdownTriggerLabelWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityDropdownTriggerIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogVisibilityDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityDropdownTriggerWireframe extends React$1.FC<IVeltCommentDialogVisibilityDropdownTriggerWireframeProps> {
    Label: React$1.FC<IVeltCommentDialogVisibilityDropdownTriggerLabelWireframeProps>;
    Icon: React$1.FC<IVeltCommentDialogVisibilityDropdownTriggerIconWireframeProps>;
}

interface IVeltCommentDialogVisibilityDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogVisibilityDropdown extends React$1.FC<IVeltCommentDialogVisibilityDropdownProps> {
    Content: IVeltCommentDialogVisibilityDropdownContentWireframe;
    Trigger: IVeltCommentDialogVisibilityDropdownTriggerWireframe;
}

interface IVeltCommentDialogWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltCommentDialogWireframe: React$1.FC<IVeltCommentDialogWireframeProps> & {
    AllComment: React$1.FC<IVeltCommentDialogAllCommentProps>;
    Approve: React$1.FC<IVeltCommentDialogApproveProps>;
    AssigneeBanner: IVeltCommentDialogAssigneeBanner;
    VisibilityBanner: IVeltCommentDialogVisibilityBanner;
    AssignMenu: React$1.FC<IVeltCommentDialogAssignMenuProps>;
    Body: React$1.FC<IVeltCommentDialogBodyProps>;
    CommentCategory: React$1.FC<IVeltCommentDialogCommentCategoryProps>;
    CommentIndex: React$1.FC<IVeltCommentDialogCommentIndexProps>;
    CommentNumber: IVeltCommentDialogCommentNumber;
    CommentSuggestionStatus: React$1.FC<IVeltCommentDialogCommentSuggestionStatusProps>;
    Composer: IVeltCommentDialogComposer;
    CopyLink: React$1.FC<IVeltCommentDialogCopyLinkProps>;
    GhostBanner: React$1.FC<IVeltCommentDialogGhostBannerProps>;
    Header: React$1.FC<IVeltCommentDialogHeaderProps>;
    MoreReply: React$1.FC<IVeltCommentDialogMoreReplyProps>;
    Options: IVeltCommentDialogOptions;
    Priority: IVeltCommentDialogPriority;
    PrivateBanner: React$1.FC<IVeltCommentDialogPrivateBannerProps>;
    ResolveButton: React$1.FC<IVeltCommentDialogResolveButtonProps>;
    UnresolveButton: React$1.FC<IVeltCommentDialogUnresolveButtonProps>;
    SignIn: React$1.FC<IVeltCommentDialogSignInProps>;
    Status: IVeltCommentDialogStatus;
    SuggestionAction: IVeltCommentDialogSuggestionAction;
    ThreadCard: IVeltCommentDialogThreadCard;
    Threads: React$1.FC<IVeltCommentDialogThreadsProps>;
    ToggleReply: IVeltCommentDialogToggleReply;
    Upgrade: React$1.FC<IVeltCommentDialogUpgradeProps>;
    CustomAnnotationDropdown: IVeltCommentDialogCustomAnnotationDropdown;
    DeleteButton: React$1.FC<IVeltCommentDialogDeleteButtonProps>;
    CloseButton: React$1.FC<IVeltCommentDialogCloseButtonProps>;
    NavigationButton: React$1.FC<IVeltCommentDialogNavigationButtonProps>;
    ReplyAvatars: IVeltCommentDialogReplyAvatars;
    HideReply: IVeltCommentDialogHideReply;
    VisibilityDropdown: IVeltCommentDialogVisibilityDropdown;
};

interface IVeltCommentsSidebarCloseButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarEmptyPlaceholderProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterItemCheckboxCheckedProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterItemCheckboxUncheckedProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterItemCheckboxProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterItemCheckbox extends React$1.FC<IVeltCommentsSidebarFilterItemCheckboxProps> {
    Checked: React$1.FC<IVeltCommentsSidebarFilterItemCheckboxCheckedProps>;
    Unchecked: React$1.FC<IVeltCommentsSidebarFilterItemCheckboxUncheckedProps>;
}

interface IVeltCommentsSidebarFilterItemCountProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterItemNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterItem extends React$1.FC<IVeltCommentsSidebarFilterItemProps> {
    Checkbox: IVeltCommentsSidebarFilterItemCheckbox;
    Count: React$1.FC<IVeltCommentsSidebarFilterItemCountProps>;
    Name: React$1.FC<IVeltCommentsSidebarFilterItemNameProps>;
}

interface IVeltCommentsSidebarFilterNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterSearchDropdownIconProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterSearchDropdownIcon extends React$1.FC<IVeltCommentsSidebarFilterSearchDropdownIconProps> {
}

interface IVeltCommentsSidebarFilterSearchHiddenCountProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterSearchHiddenCount extends React$1.FC<IVeltCommentsSidebarFilterSearchHiddenCountProps> {
}

interface IVeltCommentsSidebarFilterSearchInputProps extends IVeltWireframeCommonProps {
    placeholder?: string;
}
interface IVeltCommentsSidebarFilterSearchInput extends React$1.FC<IVeltCommentsSidebarFilterSearchInputProps> {
}

interface IVeltCommentsSidebarFilterSearchTagsItemNameProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterSearchTagsItemName extends React$1.FC<IVeltCommentsSidebarFilterSearchTagsItemNameProps> {
}

interface IVeltCommentsSidebarFilterSearchTagsItemCloseProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterSearchTagsItemClose extends React$1.FC<IVeltCommentsSidebarFilterSearchTagsItemCloseProps> {
}

interface IVeltCommentsSidebarFilterSearchTagsItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterSearchTagsItem extends React$1.FC<IVeltCommentsSidebarFilterSearchTagsItemProps> {
    Name: IVeltCommentsSidebarFilterSearchTagsItemName;
    Close: IVeltCommentsSidebarFilterSearchTagsItemClose;
}

interface IVeltCommentsSidebarFilterSearchTagsProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterSearchTags extends React$1.FC<IVeltCommentsSidebarFilterSearchTagsProps> {
    Item: IVeltCommentsSidebarFilterSearchTagsItem;
}

interface IVeltCommentsSidebarFilterSearchProps extends IVeltWireframeCommonProps {
    placeholder?: string;
}
interface IVeltCommentsSidebarFilterSearch extends React$1.FC<IVeltCommentsSidebarFilterSearchProps> {
    DropdownIcon: IVeltCommentsSidebarFilterSearchDropdownIcon;
    Tags: IVeltCommentsSidebarFilterSearchTags;
    HiddenCount: IVeltCommentsSidebarFilterSearchHiddenCount;
    Input: IVeltCommentsSidebarFilterSearchInput;
}

interface IVeltCommentsSidebarFilterCategoryProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterCategory extends React$1.FC<IVeltCommentsSidebarFilterCategoryProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterCloseButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterCommentTypeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterCommentType extends React$1.FC<IVeltCommentsSidebarFilterCommentTypeProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
}

interface IVeltCommentsSidebarFilterDoneButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterGroupByProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterGroupBy extends React$1.FC<IVeltCommentsSidebarFilterGroupByProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
}

interface IVeltCommentsSidebarFilterViewAllProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterLocationProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterLocation extends React$1.FC<IVeltCommentsSidebarFilterLocationProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    ViewAll: React$1.FC<IVeltCommentsSidebarFilterViewAllProps>;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterPeopleProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterPeople extends React$1.FC<IVeltCommentsSidebarFilterPeopleProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterPriorityProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterPriority extends React$1.FC<IVeltCommentsSidebarFilterPriorityProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterTitleProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterVersionsProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterVersions extends React$1.FC<IVeltCommentsSidebarFilterVersionsProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterStatusProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterStatus extends React$1.FC<IVeltCommentsSidebarFilterStatusProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterResetButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFilterAssignedProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterAssigned extends React$1.FC<IVeltCommentsSidebarFilterAssignedProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterTaggedProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterTagged extends React$1.FC<IVeltCommentsSidebarFilterTaggedProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterDocumentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterDocument extends React$1.FC<IVeltCommentsSidebarFilterDocumentProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    ViewAll: React$1.FC<IVeltCommentsSidebarFilterViewAllProps>;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterCustomProps extends IVeltWireframeCommonProps {
    id?: string;
}
interface IVeltCommentsSidebarFilterCustom extends React$1.FC<IVeltCommentsSidebarFilterCustomProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterInvolvedProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilterInvolved extends React$1.FC<IVeltCommentsSidebarFilterInvolvedProps> {
    Name: React$1.FC<IVeltCommentsSidebarFilterNameProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Search: IVeltCommentsSidebarFilterSearch;
}

interface IVeltCommentsSidebarFilterProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFilter extends React$1.FC<IVeltCommentsSidebarFilterProps> {
    Title: React$1.FC<IVeltCommentsSidebarFilterTitleProps>;
    CloseButton: React$1.FC<IVeltCommentsSidebarFilterCloseButtonProps>;
    Location: IVeltCommentsSidebarFilterLocation;
    People: IVeltCommentsSidebarFilterPeople;
    Assigned: IVeltCommentsSidebarFilterAssigned;
    Tagged: IVeltCommentsSidebarFilterTagged;
    Category: IVeltCommentsSidebarFilterCategory;
    CommentType: IVeltCommentsSidebarFilterCommentType;
    Priority: IVeltCommentsSidebarFilterPriority;
    Versions: IVeltCommentsSidebarFilterVersions;
    GroupBy: IVeltCommentsSidebarFilterGroupBy;
    DoneButton: React$1.FC<IVeltCommentsSidebarFilterDoneButtonProps>;
    Item: IVeltCommentsSidebarFilterItem;
    Status: IVeltCommentsSidebarFilterStatus;
    ResetButton: React$1.FC<IVeltCommentsSidebarFilterResetButtonProps>;
    Search: IVeltCommentsSidebarFilterSearch;
    Document: IVeltCommentsSidebarFilterDocument;
    Custom: IVeltCommentsSidebarFilterCustom;
    Involved: IVeltCommentsSidebarFilterInvolved;
}

interface IVeltCommentsSidebarFilterButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarHeaderProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarListItemDialogContainerProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarListItemGroupCountProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarListItemGroupArrowProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarListItemGroupNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarListItemGroupProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarListItemGroup extends React$1.FC<IVeltCommentsSidebarListItemGroupProps> {
    Count: React$1.FC<IVeltCommentsSidebarListItemGroupCountProps>;
    Arrow: React$1.FC<IVeltCommentsSidebarListItemGroupArrowProps>;
    Name: React$1.FC<IVeltCommentsSidebarListItemGroupNameProps>;
}

interface IVeltCommentsSidebarListItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarListItem extends React$1.FC<IVeltCommentsSidebarListItemProps> {
    DialogContainer: React$1.FC<IVeltCommentsSidebarListItemDialogContainerProps>;
    Group: IVeltCommentsSidebarListItemGroup;
}

interface IVeltCommentsSidebarListProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarList extends React$1.FC<IVeltCommentsSidebarListProps> {
    Item: IVeltCommentsSidebarListItem;
}

interface IVeltCommentsSidebarLocationFilterDropdownContentProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarLocationFilterDropdownTriggerLabelProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarLocationFilterDropdownTriggerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarLocationFilterDropdownTrigger extends React$1.FC<IVeltCommentsSidebarLocationFilterDropdownTriggerProps> {
    Label: React$1.FC<IVeltCommentsSidebarLocationFilterDropdownTriggerLabelProps>;
}

interface IVeltCommentsSidebarLocationFilterDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarLocationFilterDropdown extends React$1.FC<IVeltCommentsSidebarLocationFilterDropdownProps> {
    Trigger: IVeltCommentsSidebarLocationFilterDropdownTrigger;
    Content: React$1.FC<IVeltCommentsSidebarLocationFilterDropdownContentProps>;
}

interface IVeltCommentsSidebarDocumentFilterDropdownContentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarDocumentFilterDropdownContent extends React$1.FC<IVeltCommentsSidebarDocumentFilterDropdownContentProps> {
}

interface IVeltCommentsSidebarDocumentFilterDropdownTriggerLabelProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarDocumentFilterDropdownTriggerLabel extends React$1.FC<IVeltCommentsSidebarDocumentFilterDropdownTriggerLabelProps> {
}

interface IVeltCommentsSidebarDocumentFilterDropdownTriggerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarDocumentFilterDropdownTrigger extends React$1.FC<IVeltCommentsSidebarDocumentFilterDropdownTriggerProps> {
    Label: IVeltCommentsSidebarDocumentFilterDropdownTriggerLabel;
}

interface IVeltCommentsSidebarDocumentFilterDropdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarDocumentFilterDropdownWireframe extends React$1.FC<IVeltCommentsSidebarDocumentFilterDropdownWireframeProps> {
    Trigger: IVeltCommentsSidebarDocumentFilterDropdownTrigger;
    Content: IVeltCommentsSidebarDocumentFilterDropdownContent;
}

interface IVeltCommentsSidebarMinimalActionsDropdownContentMarkAllReadWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalActionsDropdownContentMarkAllReadWireframe extends React$1.FC<IVeltCommentsSidebarMinimalActionsDropdownContentMarkAllReadWireframeProps> {
}

interface IVeltCommentsSidebarMinimalActionsDropdownContentMarkAllResolvedWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalActionsDropdownContentMarkAllResolvedWireframe extends React$1.FC<IVeltCommentsSidebarMinimalActionsDropdownContentMarkAllResolvedWireframeProps> {
}

interface IVeltCommentsSidebarMinimalActionsDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalActionsDropdownContentWireframe extends React$1.FC<IVeltCommentsSidebarMinimalActionsDropdownContentWireframeProps> {
    MarkAllRead: IVeltCommentsSidebarMinimalActionsDropdownContentMarkAllReadWireframe;
    MarkAllResolved: IVeltCommentsSidebarMinimalActionsDropdownContentMarkAllResolvedWireframe;
}

interface IVeltCommentsSidebarMinimalActionsDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalActionsDropdownTriggerWireframe extends React$1.FC<IVeltCommentsSidebarMinimalActionsDropdownTriggerWireframeProps> {
}

interface IVeltCommentsSidebarMinimalActionsDropdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalActionsDropdownWireframe extends React$1.FC<IVeltCommentsSidebarMinimalActionsDropdownWireframeProps> {
    Trigger: IVeltCommentsSidebarMinimalActionsDropdownTriggerWireframe;
    Content: IVeltCommentsSidebarMinimalActionsDropdownContentWireframe;
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterAllProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterAll extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentFilterAllProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterReadProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterRead extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentFilterReadProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterResolvedProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterResolved extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentFilterResolvedProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterUnreadProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterUnread extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentFilterUnreadProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterOpenProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterOpen extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentFilterOpenProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterAssignedToMeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterAssignedToMe extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentFilterAssignedToMeProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterResetProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentFilterReset extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentFilterResetProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentSelectedIconProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentSelectedIcon extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentSelectedIconProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentSortDateProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentSortDate extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentSortDateProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentSortUnreadProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContentSortUnread extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentSortUnreadProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownContentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownContent extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownContentProps> {
    FilterAll: IVeltCommentsSidebarMinimalFilterDropdownContentFilterAll;
    FilterUnread: IVeltCommentsSidebarMinimalFilterDropdownContentFilterUnread;
    FilterRead: IVeltCommentsSidebarMinimalFilterDropdownContentFilterRead;
    FilterResolved: IVeltCommentsSidebarMinimalFilterDropdownContentFilterResolved;
    FilterOpen: IVeltCommentsSidebarMinimalFilterDropdownContentFilterOpen;
    FilterAssignedToMe: IVeltCommentsSidebarMinimalFilterDropdownContentFilterAssignedToMe;
    FilterReset: IVeltCommentsSidebarMinimalFilterDropdownContentFilterReset;
    SelectedIcon: IVeltCommentsSidebarMinimalFilterDropdownContentSelectedIcon;
    SortDate: IVeltCommentsSidebarMinimalFilterDropdownContentSortDate;
    SortUnread: IVeltCommentsSidebarMinimalFilterDropdownContentSortUnread;
}

interface IVeltCommentsSidebarMinimalFilterDropdownTriggerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdownTrigger extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownTriggerProps> {
}

interface IVeltCommentsSidebarMinimalFilterDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarMinimalFilterDropdown extends React$1.FC<IVeltCommentsSidebarMinimalFilterDropdownProps> {
    Trigger: IVeltCommentsSidebarMinimalFilterDropdownTrigger;
    Content: IVeltCommentsSidebarMinimalFilterDropdownContent;
}

interface IVeltCommentsSidebarPageModeComposerProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarPanelProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarSearchProps extends IVeltWireframeCommonProps {
    placeholder?: string;
}

interface IVeltCommentsSidebarSkeletonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownContentItemIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownContentItemNameWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownContentItemCheckboxCheckedWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownContentItemCheckboxUncheckedWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownContentItemCheckboxWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarStatusDropdownContentItemCheckboxWireframe extends React$1.FC<IVeltCommentsSidebarStatusDropdownContentItemCheckboxWireframeProps> {
    Checked: React$1.FC<IVeltCommentsSidebarStatusDropdownContentItemCheckboxCheckedWireframeProps>;
    Unchecked: React$1.FC<IVeltCommentsSidebarStatusDropdownContentItemCheckboxUncheckedWireframeProps>;
}

interface IVeltCommentsSidebarStatusDropdownContentItemCountWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownContentItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarStatusDropdownContentItemWireframe extends React$1.FC<IVeltCommentsSidebarStatusDropdownContentItemWireframeProps> {
    Icon: React$1.FC<IVeltCommentsSidebarStatusDropdownContentItemIconWireframeProps>;
    Name: React$1.FC<IVeltCommentsSidebarStatusDropdownContentItemNameWireframeProps>;
    Count: React$1.FC<IVeltCommentsSidebarStatusDropdownContentItemCountWireframeProps>;
    Checkbox: IVeltCommentsSidebarStatusDropdownContentItemCheckboxWireframe;
}

interface IVeltCommentsSidebarStatusDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarStatusDropdownContentWireframe extends React$1.FC<IVeltCommentsSidebarStatusDropdownContentWireframeProps> {
    Item: IVeltCommentsSidebarStatusDropdownContentItemWireframe;
}

interface IVeltCommentsSidebarStatusDropdownTriggerArrowWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownTriggerIndicatorWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownTriggerNameWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarStatusDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarStatusDropdownTriggerWireframe extends React$1.FC<IVeltCommentsSidebarStatusDropdownTriggerWireframeProps> {
    Arrow: React$1.FC<IVeltCommentsSidebarStatusDropdownTriggerArrowWireframeProps>;
    Name: React$1.FC<IVeltCommentsSidebarStatusDropdownTriggerNameWireframeProps>;
    Indicator: React$1.FC<IVeltCommentsSidebarStatusDropdownTriggerIndicatorWireframeProps>;
}

interface IVeltCommentsSidebarStatusProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarStatus extends React$1.FC<IVeltCommentsSidebarStatusProps> {
    Trigger: IVeltCommentsSidebarStatusDropdownTriggerWireframe;
    Content: IVeltCommentsSidebarStatusDropdownContentWireframe;
}

interface IVeltCommentsSidebarResetFilterButtonWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarActionButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentsSidebarFocusedThreadBackButtonProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFocusedThreadBackButton extends React$1.FC<IVeltCommentsSidebarFocusedThreadBackButtonProps> {
}

interface IVeltCommentsSidebarFocusedThreadDialogContainerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFocusedThreadDialogContainer extends React$1.FC<IVeltCommentsSidebarFocusedThreadDialogContainerProps> {
}

interface IVeltCommentsSidebarFocusedThreadProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFocusedThread extends React$1.FC<IVeltCommentsSidebarFocusedThreadProps> {
    BackButton: IVeltCommentsSidebarFocusedThreadBackButton;
    DialogContainer: IVeltCommentsSidebarFocusedThreadDialogContainer;
}

interface IVeltCommentsSidebarFullscreenButtonProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarFullscreenButton extends React$1.FC<IVeltCommentsSidebarFullscreenButtonProps> {
}

interface IVeltCommentsSidebarWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltCommentsSidebarWireframe: React$1.FC<IVeltCommentsSidebarWireframeProps> & {
    CloseButton: React$1.FC<IVeltCommentsSidebarCloseButtonProps>;
    EmptyPlaceholder: React$1.FC<IVeltCommentsSidebarEmptyPlaceholderProps>;
    Filter: IVeltCommentsSidebarFilter;
    Header: React$1.FC<IVeltCommentsSidebarHeaderProps>;
    List: IVeltCommentsSidebarList;
    PageModeComposer: React$1.FC<IVeltCommentsSidebarPageModeComposerProps>;
    Search: React$1.FC<IVeltCommentsSidebarSearchProps>;
    Status: IVeltCommentsSidebarStatus;
    FilterButton: React$1.FC<IVeltCommentsSidebarFilterButtonProps>;
    Skeleton: React$1.FC<IVeltCommentsSidebarSkeletonProps>;
    Panel: React$1.FC<IVeltCommentsSidebarPanelProps>;
    MinimalFilterDropdown: IVeltCommentsSidebarMinimalFilterDropdown;
    LocationFilterDropdown: IVeltCommentsSidebarLocationFilterDropdown;
    DocumentFilterDropdown: IVeltCommentsSidebarDocumentFilterDropdownWireframe;
    MinimalActionsDropdown: IVeltCommentsSidebarMinimalActionsDropdownWireframe;
    ResetFilterButton: React$1.FC<IVeltCommentsSidebarResetFilterButtonWireframeProps>;
    ActionButton: React$1.FC<IVeltCommentsSidebarActionButtonProps>;
    FocusedThread: IVeltCommentsSidebarFocusedThread;
    FullscreenButton: IVeltCommentsSidebarFullscreenButton;
};

interface IVeltCommentsSidebarV2SkeletonProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2Skeleton extends React$1.FC<IVeltCommentsSidebarV2SkeletonProps> {
}

interface IVeltCommentsSidebarV2PanelProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2Panel extends React$1.FC<IVeltCommentsSidebarV2PanelProps> {
}

interface IVeltCommentsSidebarV2HeaderProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2Header extends React$1.FC<IVeltCommentsSidebarV2HeaderProps> {
}

interface IVeltCommentsSidebarV2CloseButtonProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2CloseButton extends React$1.FC<IVeltCommentsSidebarV2CloseButtonProps> {
}

interface IVeltCommentsSidebarV2ResetFilterButtonProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2ResetFilterButton extends React$1.FC<IVeltCommentsSidebarV2ResetFilterButtonProps> {
}

interface IVeltCommentsSidebarV2EmptyPlaceholderProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2EmptyPlaceholder extends React$1.FC<IVeltCommentsSidebarV2EmptyPlaceholderProps> {
    ResetFilterButton: IVeltCommentsSidebarV2ResetFilterButton;
}

interface IVeltCommentsSidebarV2ListItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2ListItem extends React$1.FC<IVeltCommentsSidebarV2ListItemProps> {
}

interface IVeltCommentsSidebarV2ListProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2List extends React$1.FC<IVeltCommentsSidebarV2ListProps> {
    Item: IVeltCommentsSidebarV2ListItem;
}

interface IVeltCommentsSidebarV2PageModeComposerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2PageModeComposer extends React$1.FC<IVeltCommentsSidebarV2PageModeComposerProps> {
}

interface IVeltCommentsSidebarV2FocusedThreadBackButtonProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FocusedThreadBackButton extends React$1.FC<IVeltCommentsSidebarV2FocusedThreadBackButtonProps> {
}

interface IVeltCommentsSidebarV2FocusedThreadDialogContainerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FocusedThreadDialogContainer extends React$1.FC<IVeltCommentsSidebarV2FocusedThreadDialogContainerProps> {
}

interface IVeltCommentsSidebarV2FocusedThreadProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FocusedThread extends React$1.FC<IVeltCommentsSidebarV2FocusedThreadProps> {
    BackButton: IVeltCommentsSidebarV2FocusedThreadBackButton;
    DialogContainer: IVeltCommentsSidebarV2FocusedThreadDialogContainer;
}

interface IVeltCommentsSidebarV2MinimalActionsDropdownTriggerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2MinimalActionsDropdownTrigger extends React$1.FC<IVeltCommentsSidebarV2MinimalActionsDropdownTriggerProps> {
}

interface IVeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllReadProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllRead extends React$1.FC<IVeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllReadProps> {
}

interface IVeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllResolvedProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllResolved extends React$1.FC<IVeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllResolvedProps> {
}

interface IVeltCommentsSidebarV2MinimalActionsDropdownContentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2MinimalActionsDropdownContent extends React$1.FC<IVeltCommentsSidebarV2MinimalActionsDropdownContentProps> {
    MarkAllRead: IVeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllRead;
    MarkAllResolved: IVeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllResolved;
}

interface IVeltCommentsSidebarV2MinimalActionsDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2MinimalActionsDropdown extends React$1.FC<IVeltCommentsSidebarV2MinimalActionsDropdownProps> {
    Trigger: IVeltCommentsSidebarV2MinimalActionsDropdownTrigger;
    Content: IVeltCommentsSidebarV2MinimalActionsDropdownContent;
}

interface IVeltCommentsSidebarV2FilterDropdownTriggerProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdownTrigger extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownTriggerProps> {
}

interface IVeltCommentsSidebarV2FilterDropdownContentListItemIndicatorProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdownContentListItemIndicator extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListItemIndicatorProps> {
}

interface IVeltCommentsSidebarV2FilterDropdownContentListItemLabelProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdownContentListItemLabel extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListItemLabelProps> {
}

interface IVeltCommentsSidebarV2FilterDropdownContentListItemProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdownContentListItem extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListItemProps> {
    Indicator: IVeltCommentsSidebarV2FilterDropdownContentListItemIndicator;
    Label: IVeltCommentsSidebarV2FilterDropdownContentListItemLabel;
}

interface IVeltCommentsSidebarV2FilterDropdownContentListCategoryContentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdownContentListCategoryContent extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListCategoryContentProps> {
}

interface IVeltCommentsSidebarV2FilterDropdownContentListCategoryProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdownContentListCategory extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListCategoryProps> {
    Content: IVeltCommentsSidebarV2FilterDropdownContentListCategoryContent;
}

interface IVeltCommentsSidebarV2FilterDropdownContentListProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdownContentList extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentListProps> {
    Item: IVeltCommentsSidebarV2FilterDropdownContentListItem;
    Category: IVeltCommentsSidebarV2FilterDropdownContentListCategory;
}

interface IVeltCommentsSidebarV2FilterDropdownContentProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdownContent extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownContentProps> {
    List: IVeltCommentsSidebarV2FilterDropdownContentList;
}

interface IVeltCommentsSidebarV2FilterDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarV2FilterDropdown extends React$1.FC<IVeltCommentsSidebarV2FilterDropdownProps> {
    Trigger: IVeltCommentsSidebarV2FilterDropdownTrigger;
    Content: IVeltCommentsSidebarV2FilterDropdownContent;
}

interface IVeltCommentsSidebarV2WireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltCommentsSidebarV2Wireframe: React$1.FC<IVeltCommentsSidebarV2WireframeProps> & {
    Skeleton: IVeltCommentsSidebarV2Skeleton;
    Panel: IVeltCommentsSidebarV2Panel;
    Header: IVeltCommentsSidebarV2Header;
    CloseButton: IVeltCommentsSidebarV2CloseButton;
    EmptyPlaceholder: IVeltCommentsSidebarV2EmptyPlaceholder;
    List: IVeltCommentsSidebarV2List;
    PageModeComposer: IVeltCommentsSidebarV2PageModeComposer;
    FocusedThread: IVeltCommentsSidebarV2FocusedThread;
    MinimalActionsDropdown: IVeltCommentsSidebarV2MinimalActionsDropdown;
    FilterDropdown: IVeltCommentsSidebarV2FilterDropdown;
};

interface IVeltCommentPinGhostCommentIndicatorProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinIndexProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinTriangleProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinUnreadCommentIndicatorProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinPrivateCommentIndicatorProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinNumberProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentPinNumber extends React$1.FC<IVeltCommentPinNumberProps> {
}

interface IVeltCommentPinWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltCommentPinWireframe: React$1.FC<IVeltCommentPinWireframeProps> & {
    GhostCommentIndicator: React$1.FC<IVeltCommentPinGhostCommentIndicatorProps>;
    Index: React$1.FC<IVeltCommentPinIndexProps>;
    Number: IVeltCommentPinNumber;
    PrivateCommentIndicator: React$1.FC<IVeltCommentPinPrivateCommentIndicatorProps>;
    Triangle: React$1.FC<IVeltCommentPinTriangleProps>;
    UnreadCommentIndicator: React$1.FC<IVeltCommentPinUnreadCommentIndicatorProps>;
};

interface IVeltSidebarButtonCommentsCountProps$1 extends IVeltWireframeCommonProps {
}

interface IVeltSidebarButtonIconProps$1 extends IVeltWireframeCommonProps {
}

interface IVeltSidebarButtonUnreadIconProps$1 extends IVeltWireframeCommonProps {
}

interface IVeltSidebarButtonWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltSidebarButtonWireframe: React$1.FC<IVeltSidebarButtonWireframeProps> & {
    CommentsCount: React$1.FC<IVeltSidebarButtonCommentsCountProps$1>;
    Icon: React$1.FC<IVeltSidebarButtonIconProps$1>;
    UnreadIcon: React$1.FC<IVeltSidebarButtonUnreadIconProps$1>;
};

interface IVeltCommentToolWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltCommentToolWireframe: React$1.FC<IVeltCommentToolWireframeProps>;

interface IVeltTextCommentToolWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltTextCommentToolWireframe: React$1.FC<IVeltTextCommentToolWireframeProps>;

interface IVeltTextCommentToolbarCommentAnnotationProps$1 extends IVeltWireframeCommonProps {
}

interface IVeltTextCommentToolbarCopywriterProps$1 extends IVeltWireframeCommonProps {
}

interface IVeltTextCommentToolbarGenericProps$1 extends IVeltWireframeCommonProps {
}

interface IVeltTextCommentToolbarDividerProps$1 extends IVeltWireframeCommonProps {
}

interface IVeltTextCommentToolbarProps$1 extends IVeltWireframeCommonProps {
}
declare const VeltTextCommentToolbar$1: React$1.FC<IVeltTextCommentToolbarProps$1> & {
    CommentAnnotation: React$1.FC<IVeltTextCommentToolbarCommentAnnotationProps$1>;
    Copywriter: React$1.FC<IVeltTextCommentToolbarCopywriterProps$1>;
    Generic: React$1.FC<IVeltTextCommentToolbarGenericProps$1>;
    Divider: React$1.FC<IVeltTextCommentToolbarDividerProps$1>;
};

interface IVeltUserSelectorDropdownAvatarProps extends IVeltWireframeCommonProps {
}

interface IVeltUserSelectorDropdownEmailProps extends IVeltWireframeCommonProps {
}

interface IVeltUserSelectorDropdownErrorIconProps extends IVeltWireframeCommonProps {
}

interface IVeltUserSelectorDropdownNameProps extends IVeltWireframeCommonProps {
}

interface IVeltUserSelectorDropdownProps extends IVeltWireframeCommonProps {
}
declare const VeltUserSelectorDropdown: React$1.FC<IVeltUserSelectorDropdownProps> & {
    Avatar: React$1.FC<IVeltUserSelectorDropdownAvatarProps>;
    Email: React$1.FC<IVeltUserSelectorDropdownEmailProps>;
    ErrorIcon: React$1.FC<IVeltUserSelectorDropdownErrorIconProps>;
    Name: React$1.FC<IVeltUserSelectorDropdownNameProps>;
};

interface IVeltAutocompleteOptionIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltAutocompleteOptionNameWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltAutocompleteOptionDescriptionWireframeProps extends IVeltWireframeCommonProps {
    field?: string;
}

interface IVeltAutocompleteOptionErrorIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltAutocompleteOptionWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltAutocompleteOptionWireframe: React$1.FC<IVeltAutocompleteOptionWireframeProps> & {
    Icon: React$1.FC<IVeltAutocompleteOptionIconWireframeProps>;
    Description: React$1.FC<IVeltAutocompleteOptionDescriptionWireframeProps>;
    ErrorIcon: React$1.FC<IVeltAutocompleteOptionErrorIconWireframeProps>;
    Name: React$1.FC<IVeltAutocompleteOptionNameWireframeProps>;
};

interface IVeltAutocompleteGroupOptionWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltAutocompleteGroupOptionWireframe: React$1.FC<IVeltAutocompleteGroupOptionWireframeProps>;

interface IVeltAutocompleteChipTooltipDescriptionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltAutocompleteChipTooltipDescriptionWireframe extends React$1.FC<IVeltAutocompleteChipTooltipDescriptionWireframeProps> {
}

interface IVeltAutocompleteChipTooltipIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltAutocompleteChipTooltipIconWireframe extends React$1.FC<IVeltAutocompleteChipTooltipIconWireframeProps> {
}

interface IVeltAutocompleteChipTooltipNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltAutocompleteChipTooltipNameWireframe extends React$1.FC<IVeltAutocompleteChipTooltipNameWireframeProps> {
}

interface IVeltAutocompleteChipTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltAutocompleteChipTooltipWireframe extends React$1.FC<IVeltAutocompleteChipTooltipWireframeProps> {
    Description: IVeltAutocompleteChipTooltipDescriptionWireframe;
    Icon: IVeltAutocompleteChipTooltipIconWireframe;
    Name: IVeltAutocompleteChipTooltipNameWireframe;
}
declare const VeltAutocompleteChipTooltipWireframe: IVeltAutocompleteChipTooltipWireframe;

interface IVeltAutocompleteEmptyWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltAutocompleteEmptyWireframe: React$1.FC<IVeltAutocompleteEmptyWireframeProps>;

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

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

interface IVeltCommentBubbleUnreadIconProps$1 extends IVeltWireframeCommonProps {
}

interface IVeltCommentBubbleWireframeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    variant?: string;
}
interface IVeltCommentBubbleWireframe extends React$1.FC<IVeltCommentBubbleWireframeProps> {
    Avatar: React$1.FC<IVeltCommentBubbleAvatarProps$1>;
    CommentsCount: React$1.FC<IVeltCommentBubbleCommentsCountProps$1>;
    UnreadIcon: React$1.FC<IVeltCommentBubbleUnreadIconProps$1>;
}
declare const VeltCommentBubbleWireframe: IVeltCommentBubbleWireframe;

interface IVeltCommentsSidebarStatusDropdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentsSidebarStatusDropdownWireframe extends React$1.FC<IVeltCommentsSidebarStatusDropdownWireframeProps> {
    Trigger: IVeltCommentsSidebarStatusDropdownTriggerWireframe;
    Content: IVeltCommentsSidebarStatusDropdownContentWireframe;
}
declare const VeltCommentsSidebarStatusDropdownWireframe: IVeltCommentsSidebarStatusDropdownWireframe;

interface IVeltReactionToolWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionToolWireframe extends React$1.FC<IVeltReactionToolWireframeProps> {
}
declare const VeltReactionToolWireframe: IVeltReactionToolWireframe;

interface IVeltReactionPinCountWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltReactionPinEmojiWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltReactionPinWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionPinWireframe extends React$1.FC<IVeltReactionPinWireframeProps> {
    Count: React$1.FC<IVeltReactionPinCountWireframeProps>;
    Emoji: React$1.FC<IVeltReactionPinEmojiWireframeProps>;
}
declare const VeltReactionPinWireframe: IVeltReactionPinWireframe;

interface IVeltReactionPinTooltipUserAvatarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionPinTooltipUserAvatarWireframe extends React$1.FC<IVeltReactionPinTooltipUserAvatarWireframeProps> {
}

interface IVeltReactionPinTooltipUserNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionPinTooltipUserNameWireframe extends React$1.FC<IVeltReactionPinTooltipUserNameWireframeProps> {
}

interface IVeltReactionPinTooltipUserWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionPinTooltipUserWireframe extends React$1.FC<IVeltReactionPinTooltipUserWireframeProps> {
    Avatar: IVeltReactionPinTooltipUserAvatarWireframe;
    Name: IVeltReactionPinTooltipUserNameWireframe;
}

interface IVeltReactionPinTooltipUsersWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionPinTooltipUsersWireframe extends React$1.FC<IVeltReactionPinTooltipUsersWireframeProps> {
    User: IVeltReactionPinTooltipUserWireframe;
}

interface IVeltReactionPinTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionPinTooltipWireframe extends React$1.FC<IVeltReactionPinTooltipWireframeProps> {
    Users: IVeltReactionPinTooltipUsersWireframe;
}
declare const VeltReactionPinTooltipWireframe: IVeltReactionPinTooltipWireframe;

interface IVeltReactionsPanelItemEmojiWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionsPanelItemEmojiWireframe extends React$1.FC<IVeltReactionsPanelItemEmojiWireframeProps> {
}

interface IVeltReactionsPanelItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionsPanelItemWireframe extends React$1.FC<IVeltReactionsPanelItemWireframeProps> {
    Emoji: IVeltReactionsPanelItemEmojiWireframe;
}

interface IVeltReactionsPanelItemsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionsPanelItemsWireframe extends React$1.FC<IVeltReactionsPanelItemsWireframeProps> {
    Item: IVeltReactionsPanelItemWireframe;
}

interface IVeltReactionsPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltReactionsPanelWireframe extends React$1.FC<IVeltReactionsPanelWireframeProps> {
    Items: IVeltReactionsPanelItemsWireframe;
}
declare const VeltReactionsPanelWireframe: IVeltReactionsPanelWireframe;

interface IVeltInlineCommentsSectionCommentCountWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltInlineCommentsSectionComposerContainerWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltInlineCommentsSectionListWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltInlineCommentsSectionPanelWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltInlineCommentsSectionSkeletonWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltInlineCommentsSectionSortingDropdownContentItemIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownContentItemIconWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentItemIconWireframeProps> {
}

interface IVeltInlineCommentsSectionSortingDropdownContentItemNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownContentItemNameWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentItemNameWireframeProps> {
}

interface IVeltInlineCommentsSectionSortingDropdownContentItemTickWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownContentItemTickWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentItemTickWireframeProps> {
}

interface IVeltInlineCommentsSectionSortingDropdownContentItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownContentItemWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentItemWireframeProps> {
    Icon: IVeltInlineCommentsSectionSortingDropdownContentItemIconWireframe;
    Name: IVeltInlineCommentsSectionSortingDropdownContentItemNameWireframe;
    Tick: IVeltInlineCommentsSectionSortingDropdownContentItemTickWireframe;
}

interface IVeltInlineCommentsSectionSortingDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownContentWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownContentWireframeProps> {
    Item: IVeltInlineCommentsSectionSortingDropdownContentItemWireframe;
}

interface IVeltInlineCommentsSectionSortingDropdownTriggerIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownTriggerIconWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownTriggerIconWireframeProps> {
}

interface IVeltInlineCommentsSectionSortingDropdownTriggerNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownTriggerNameWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownTriggerNameWireframeProps> {
}

interface IVeltInlineCommentsSectionSortingDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownTriggerWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownTriggerWireframeProps> {
    Icon: IVeltInlineCommentsSectionSortingDropdownTriggerIconWireframe;
    Name: IVeltInlineCommentsSectionSortingDropdownTriggerNameWireframe;
}

interface IVeltInlineCommentsSectionSortingDropdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionSortingDropdownWireframe extends React$1.FC<IVeltInlineCommentsSectionSortingDropdownWireframeProps> {
    Content: IVeltInlineCommentsSectionSortingDropdownContentWireframe;
    Trigger: IVeltInlineCommentsSectionSortingDropdownTriggerWireframe;
}

interface IVeltInlineCommentsSectionFilterDropdownContentListItemLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownContentListItemLabelWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentListItemLabelWireframeProps> {
}

interface IVeltInlineCommentsSectionFilterDropdownContentListItemCheckboxWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownContentListItemCheckboxWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentListItemCheckboxWireframeProps> {
}

interface IVeltInlineCommentsSectionFilterDropdownContentListItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownContentListItemWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentListItemWireframeProps> {
    Label: IVeltInlineCommentsSectionFilterDropdownContentListItemLabelWireframe;
    Checkbox: IVeltInlineCommentsSectionFilterDropdownContentListItemCheckboxWireframe;
}

interface IVeltInlineCommentsSectionFilterDropdownContentListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownContentListWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentListWireframeProps> {
    Item: IVeltInlineCommentsSectionFilterDropdownContentListItemWireframe;
}

interface IVeltInlineCommentsSectionFilterDropdownContentApplyButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownContentApplyButtonWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentApplyButtonWireframeProps> {
}

interface IVeltInlineCommentsSectionFilterDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownContentWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownContentWireframeProps> {
    List: IVeltInlineCommentsSectionFilterDropdownContentListWireframe;
    ApplyButton: IVeltInlineCommentsSectionFilterDropdownContentApplyButtonWireframe;
}

interface IVeltInlineCommentsSectionFilterDropdownTriggerNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownTriggerNameWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownTriggerNameWireframeProps> {
}

interface IVeltInlineCommentsSectionFilterDropdownTriggerArrowWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownTriggerArrowWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownTriggerArrowWireframeProps> {
}

interface IVeltInlineCommentsSectionFilterDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownTriggerWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownTriggerWireframeProps> {
    Arrow: IVeltInlineCommentsSectionFilterDropdownTriggerArrowWireframe;
    Name: IVeltInlineCommentsSectionFilterDropdownTriggerNameWireframe;
}

interface IVeltInlineCommentsSectionFilterDropdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionFilterDropdownWireframe extends React$1.FC<IVeltInlineCommentsSectionFilterDropdownWireframeProps> {
    Content: IVeltInlineCommentsSectionFilterDropdownContentWireframe;
    Trigger: IVeltInlineCommentsSectionFilterDropdownTriggerWireframe;
}

interface IVeltInlineCommentsSectionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineCommentsSectionWireframe extends React$1.FC<IVeltInlineCommentsSectionWireframeProps> {
    CommentCount: React$1.FC<IVeltInlineCommentsSectionCommentCountWireframeProps>;
    ComposerContainer: React$1.FC<IVeltInlineCommentsSectionComposerContainerWireframeProps>;
    List: React$1.FC<IVeltInlineCommentsSectionListWireframeProps>;
    Panel: React$1.FC<IVeltInlineCommentsSectionPanelWireframeProps>;
    Skeleton: React$1.FC<IVeltInlineCommentsSectionSkeletonWireframeProps>;
    SortingDropdown: IVeltInlineCommentsSectionSortingDropdownWireframe;
    FilterDropdown: IVeltInlineCommentsSectionFilterDropdownWireframe;
}
declare const VeltInlineCommentsSectionWireframe: IVeltInlineCommentsSectionWireframe;

interface IVeltNotificationsPanelContentAllListItemContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentAllListItemContentWireframe extends React$1.FC<IVeltNotificationsPanelContentAllListItemContentWireframeProps> {
}

interface IVeltNotificationsPanelContentAllListItemLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentAllListItemLabelWireframe extends React$1.FC<IVeltNotificationsPanelContentAllListItemLabelWireframeProps> {
}

interface IVeltNotificationsPanelContentAllListItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentAllListItemWireframe extends React$1.FC<IVeltNotificationsPanelContentAllListItemWireframeProps> {
    Label: IVeltNotificationsPanelContentAllListItemLabelWireframe;
    Content: IVeltNotificationsPanelContentAllListItemContentWireframe;
}

interface IVeltNotificationsPanelContentAllListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentAllListWireframe extends React$1.FC<IVeltNotificationsPanelContentAllListWireframeProps> {
    Item: IVeltNotificationsPanelContentAllListItemWireframe;
}

interface IVeltNotificationsPanelContentAllWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentAllWireframe extends React$1.FC<IVeltNotificationsPanelContentAllWireframeProps> {
    List: IVeltNotificationsPanelContentAllListWireframe;
}

interface IVeltNotificationsPanelContentDocumentsListItemContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentDocumentsListItemContentWireframe extends React$1.FC<IVeltNotificationsPanelContentDocumentsListItemContentWireframeProps> {
}

interface IVeltNotificationsPanelContentDocumentsListItemCountWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentDocumentsListItemCountWireframe extends React$1.FC<IVeltNotificationsPanelContentDocumentsListItemCountWireframeProps> {
}

interface IVeltNotificationsPanelContentDocumentsListItemNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentDocumentsListItemNameWireframe extends React$1.FC<IVeltNotificationsPanelContentDocumentsListItemNameWireframeProps> {
}

interface IVeltNotificationsPanelContentDocumentsListItemUnreadWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentDocumentsListItemUnreadWireframe extends React$1.FC<IVeltNotificationsPanelContentDocumentsListItemUnreadWireframeProps> {
}

interface IVeltNotificationsPanelContentDocumentsListItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentDocumentsListItemWireframe extends React$1.FC<IVeltNotificationsPanelContentDocumentsListItemWireframeProps> {
    Content: IVeltNotificationsPanelContentDocumentsListItemContentWireframe;
    Name: IVeltNotificationsPanelContentDocumentsListItemNameWireframe;
    Count: IVeltNotificationsPanelContentDocumentsListItemCountWireframe;
    Unread: IVeltNotificationsPanelContentDocumentsListItemUnreadWireframe;
}

interface IVeltNotificationsPanelContentDocumentsListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentDocumentsListWireframe extends React$1.FC<IVeltNotificationsPanelContentDocumentsListWireframeProps> {
    Item: IVeltNotificationsPanelContentDocumentsListItemWireframe;
}

interface IVeltNotificationsPanelContentDocumentsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentDocumentsWireframe extends React$1.FC<IVeltNotificationsPanelContentDocumentsWireframeProps> {
    List: IVeltNotificationsPanelContentDocumentsListWireframe;
}

interface IVeltNotificationsPanelContentForYouWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentForYouWireframe extends React$1.FC<IVeltNotificationsPanelContentForYouWireframeProps> {
}

interface IVeltNotificationsPanelContentPeopleListItemAvatarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentPeopleListItemAvatarWireframe extends React$1.FC<IVeltNotificationsPanelContentPeopleListItemAvatarWireframeProps> {
}

interface IVeltNotificationsPanelContentPeopleListItemContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentPeopleListItemContentWireframe extends React$1.FC<IVeltNotificationsPanelContentPeopleListItemContentWireframeProps> {
}

interface IVeltNotificationsPanelContentPeopleListItemCountWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentPeopleListItemCountWireframe extends React$1.FC<IVeltNotificationsPanelContentPeopleListItemCountWireframeProps> {
}

interface IVeltNotificationsPanelContentPeopleListItemNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentPeopleListItemNameWireframe extends React$1.FC<IVeltNotificationsPanelContentPeopleListItemNameWireframeProps> {
}

interface IVeltNotificationsPanelContentPeopleListItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentPeopleListItemWireframe extends React$1.FC<IVeltNotificationsPanelContentPeopleListItemWireframeProps> {
    Avatar: IVeltNotificationsPanelContentPeopleListItemAvatarWireframe;
    Name: IVeltNotificationsPanelContentPeopleListItemNameWireframe;
    Count: IVeltNotificationsPanelContentPeopleListItemCountWireframe;
    Content: IVeltNotificationsPanelContentPeopleListItemContentWireframe;
}

interface IVeltNotificationsPanelContentPeopleListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentPeopleListWireframe extends React$1.FC<IVeltNotificationsPanelContentPeopleListWireframeProps> {
    Item: IVeltNotificationsPanelContentPeopleListItemWireframe;
}

interface IVeltNotificationsPanelContentPeopleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentPeopleWireframe extends React$1.FC<IVeltNotificationsPanelContentPeopleWireframeProps> {
    List: IVeltNotificationsPanelContentPeopleListWireframe;
}

interface IVeltNotificationsPanelContentLoadMoreWireframeProps extends IVeltWireframeCommonProps {
    variant?: string;
}
interface IVeltNotificationsPanelContentLoadMoreWireframe extends React$1.FC<IVeltNotificationsPanelContentLoadMoreWireframeProps> {
}

interface IVeltNotificationsPanelContentListItemAvatarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentListItemAvatarWireframe extends React$1.FC<IVeltNotificationsPanelContentListItemAvatarWireframeProps> {
}

interface IVeltNotificationsPanelContentListItemBodyWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentListItemBodyWireframe extends React$1.FC<IVeltNotificationsPanelContentListItemBodyWireframeProps> {
}

interface IVeltNotificationsPanelContentListItemFileNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentListItemFileNameWireframe extends React$1.FC<IVeltNotificationsPanelContentListItemFileNameWireframeProps> {
}

interface IVeltNotificationsPanelContentListItemHeadlineWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentListItemHeadlineWireframe extends React$1.FC<IVeltNotificationsPanelContentListItemHeadlineWireframeProps> {
}

interface IVeltNotificationsPanelContentListItemTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentListItemTimeWireframe extends React$1.FC<IVeltNotificationsPanelContentListItemTimeWireframeProps> {
}

interface IVeltNotificationsPanelContentListItemUnreadWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentListItemUnreadWireframe extends React$1.FC<IVeltNotificationsPanelContentListItemUnreadWireframeProps> {
}

interface IVeltNotificationsPanelContentListItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentListItemWireframe extends React$1.FC<IVeltNotificationsPanelContentListItemWireframeProps> {
    Avatar: IVeltNotificationsPanelContentListItemAvatarWireframe;
    Body: IVeltNotificationsPanelContentListItemBodyWireframe;
    FileName: IVeltNotificationsPanelContentListItemFileNameWireframe;
    Headline: IVeltNotificationsPanelContentListItemHeadlineWireframe;
    Time: IVeltNotificationsPanelContentListItemTimeWireframe;
    Unread: IVeltNotificationsPanelContentListItemUnreadWireframe;
}

interface IVeltNotificationsPanelContentListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentListWireframe extends React$1.FC<IVeltNotificationsPanelContentListWireframeProps> {
    Item: IVeltNotificationsPanelContentListItemWireframe;
}

interface IVeltNotificationsPanelContentAllReadContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentAllReadContainerWireframe extends React$1.FC<IVeltNotificationsPanelContentAllReadContainerWireframeProps> {
}

interface IVeltNotificationsPanelContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelContentWireframe extends React$1.FC<IVeltNotificationsPanelContentWireframeProps> {
    All: IVeltNotificationsPanelContentAllWireframe;
    ForYou: IVeltNotificationsPanelContentForYouWireframe;
    Documents: IVeltNotificationsPanelContentDocumentsWireframe;
    People: IVeltNotificationsPanelContentPeopleWireframe;
    LoadMore: IVeltNotificationsPanelContentLoadMoreWireframe;
    List: IVeltNotificationsPanelContentListWireframe;
    AllReadContainer: IVeltNotificationsPanelContentAllReadContainerWireframe;
}

interface IVeltNotificationsPanelHeaderTabDocumentsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelHeaderTabDocumentsWireframe extends React$1.FC<IVeltNotificationsPanelHeaderTabDocumentsWireframeProps> {
}

interface IVeltNotificationsPanelHeaderTabForYouWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelHeaderTabForYouWireframe extends React$1.FC<IVeltNotificationsPanelHeaderTabForYouWireframeProps> {
}

interface IVeltNotificationsPanelHeaderTabPeopleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelHeaderTabPeopleWireframe extends React$1.FC<IVeltNotificationsPanelHeaderTabPeopleWireframeProps> {
}

interface IVeltNotificationsPanelHeaderTabAllWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelHeaderTabAllWireframe extends React$1.FC<IVeltNotificationsPanelHeaderTabAllWireframeProps> {
}

interface IVeltNotificationsPanelHeaderWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelHeaderWireframe extends React$1.FC<IVeltNotificationsPanelHeaderWireframeProps> {
    TabAll: IVeltNotificationsPanelHeaderTabAllWireframe;
    TabDocuments: IVeltNotificationsPanelHeaderTabDocumentsWireframe;
    TabForYou: IVeltNotificationsPanelHeaderTabForYouWireframe;
    TabPeople: IVeltNotificationsPanelHeaderTabPeopleWireframe;
}

interface IVeltNotificationsPanelReadAllButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelReadAllButtonWireframe extends React$1.FC<IVeltNotificationsPanelReadAllButtonWireframeProps> {
}

interface IVeltNotificationsPanelTitleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelTitleWireframe extends React$1.FC<IVeltNotificationsPanelTitleWireframeProps> {
}

interface IVeltNotificationsPanelViewAllButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelViewAllButtonWireframe extends React$1.FC<IVeltNotificationsPanelViewAllButtonWireframeProps> {
}

interface IVeltNotificationsPanelCloseButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelCloseButtonWireframe extends React$1.FC<IVeltNotificationsPanelCloseButtonWireframeProps> {
}

interface IVeltNotificationsPanelSkeletonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSkeletonWireframe extends React$1.FC<IVeltNotificationsPanelSkeletonWireframeProps> {
}

interface IVeltNotificationsPanelSettingsButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsButtonWireframe extends React$1.FC<IVeltNotificationsPanelSettingsButtonWireframeProps> {
}

interface IVeltNotificationsPanelSettingsDescriptionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsDescriptionWireframe extends React$1.FC<IVeltNotificationsPanelSettingsDescriptionWireframeProps> {
}

interface IVeltNotificationsPanelSettingsBackButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsBackButtonWireframe extends React$1.FC<IVeltNotificationsPanelSettingsBackButtonWireframeProps> {
}

interface IVeltNotificationsPanelSettingsFooterWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsFooterWireframe extends React$1.FC<IVeltNotificationsPanelSettingsFooterWireframeProps> {
}

interface IVeltNotificationsPanelSettingsHeaderTitleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsHeaderTitleWireframe extends React$1.FC<IVeltNotificationsPanelSettingsHeaderTitleWireframeProps> {
}

interface IVeltNotificationsPanelSettingsHeaderWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsHeaderWireframe extends React$1.FC<IVeltNotificationsPanelSettingsHeaderWireframeProps> {
    Title: IVeltNotificationsPanelSettingsHeaderTitleWireframe;
}

interface IVeltNotificationsPanelSettingsAccordionTriggerSelectedValueWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionTriggerSelectedValueWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionTriggerSelectedValueWireframeProps> {
}

interface IVeltNotificationsPanelSettingsAccordionTriggerLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionTriggerLabelWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionTriggerLabelWireframeProps> {
}

interface IVeltNotificationsPanelSettingsAccordionTriggerIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionTriggerIconWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionTriggerIconWireframeProps> {
}

interface IVeltNotificationsPanelSettingsAccordionTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionTriggerWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionTriggerWireframeProps> {
    SelectedValue: IVeltNotificationsPanelSettingsAccordionTriggerSelectedValueWireframe;
    Label: IVeltNotificationsPanelSettingsAccordionTriggerLabelWireframe;
    Icon: IVeltNotificationsPanelSettingsAccordionTriggerIconWireframe;
}

interface IVeltNotificationsPanelSettingsAccordionContentItemLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionContentItemLabelWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionContentItemLabelWireframeProps> {
}

interface IVeltNotificationsPanelSettingsAccordionContentItemIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionContentItemIconWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionContentItemIconWireframeProps> {
}

interface IVeltNotificationsPanelSettingsAccordionContentItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionContentItemWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionContentItemWireframeProps> {
    Label: IVeltNotificationsPanelSettingsAccordionContentItemLabelWireframe;
    Icon: IVeltNotificationsPanelSettingsAccordionContentItemIconWireframe;
}

interface IVeltNotificationsPanelSettingsAccordionContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionContentWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionContentWireframeProps> {
    Item: IVeltNotificationsPanelSettingsAccordionContentItemWireframe;
}

interface IVeltNotificationsPanelSettingsAccordionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsAccordionWireframe extends React$1.FC<IVeltNotificationsPanelSettingsAccordionWireframeProps> {
    Trigger: IVeltNotificationsPanelSettingsAccordionTriggerWireframe;
    Content: IVeltNotificationsPanelSettingsAccordionContentWireframe;
}

interface IVeltNotificationsPanelSettingsListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsListWireframe extends React$1.FC<IVeltNotificationsPanelSettingsListWireframeProps> {
    Accordion: IVeltNotificationsPanelSettingsAccordionWireframe;
}

interface IVeltNotificationsPanelSettingsMuteAllDescriptionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsMuteAllDescriptionWireframe extends React$1.FC<IVeltNotificationsPanelSettingsMuteAllDescriptionWireframeProps> {
}

interface IVeltNotificationsPanelSettingsMuteAllTitleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsMuteAllTitleWireframe extends React$1.FC<IVeltNotificationsPanelSettingsMuteAllTitleWireframeProps> {
}

interface IVeltNotificationsPanelSettingsMuteAllToggleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsMuteAllToggleWireframe extends React$1.FC<IVeltNotificationsPanelSettingsMuteAllToggleWireframeProps> {
}

interface IVeltNotificationsPanelSettingsTitleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsTitleWireframe extends React$1.FC<IVeltNotificationsPanelSettingsTitleWireframeProps> {
}

interface IVeltNotificationsPanelSettingsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelSettingsWireframe extends React$1.FC<IVeltNotificationsPanelSettingsWireframeProps> {
    BackButton: IVeltNotificationsPanelSettingsBackButtonWireframe;
    Description: IVeltNotificationsPanelSettingsDescriptionWireframe;
    Footer: IVeltNotificationsPanelSettingsFooterWireframe;
    Header: IVeltNotificationsPanelSettingsHeaderWireframe;
    List: IVeltNotificationsPanelSettingsListWireframe;
    MuteAllDescription: IVeltNotificationsPanelSettingsMuteAllDescriptionWireframe;
    MuteAllTitle: IVeltNotificationsPanelSettingsMuteAllTitleWireframe;
    MuteAllToggle: IVeltNotificationsPanelSettingsMuteAllToggleWireframe;
    Title: IVeltNotificationsPanelSettingsTitleWireframe;
}

interface IVeltNotificationsPanelTitleTextWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelTitleTextWireframe extends React$1.FC<IVeltNotificationsPanelTitleTextWireframeProps> {
}

interface IVeltNotificationsPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelWireframe extends React$1.FC<IVeltNotificationsPanelWireframeProps> {
    Content: IVeltNotificationsPanelContentWireframe;
    Header: IVeltNotificationsPanelHeaderWireframe;
    ReadAllButton: IVeltNotificationsPanelReadAllButtonWireframe;
    Title: IVeltNotificationsPanelTitleWireframe;
    ViewAllButton: IVeltNotificationsPanelViewAllButtonWireframe;
    CloseButton: IVeltNotificationsPanelCloseButtonWireframe;
    Skeleton: IVeltNotificationsPanelSkeletonWireframe;
    SettingsButton: IVeltNotificationsPanelSettingsButtonWireframe;
    Settings: IVeltNotificationsPanelSettingsWireframe;
    TitleText: IVeltNotificationsPanelTitleTextWireframe;
}
declare const VeltNotificationsPanelWireframe: IVeltNotificationsPanelWireframe;

interface IVeltNotificationsToolIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsToolIconWireframe extends React$1.FC<IVeltNotificationsToolIconWireframeProps> {
}

interface IVeltNotificationsToolLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsToolLabelWireframe extends React$1.FC<IVeltNotificationsToolLabelWireframeProps> {
}

interface IVeltNotificationsToolUnreadCountWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsToolUnreadCountWireframe extends React$1.FC<IVeltNotificationsToolUnreadCountWireframeProps> {
}

interface IVeltNotificationsToolUnreadIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsToolUnreadIconWireframe extends React$1.FC<IVeltNotificationsToolUnreadIconWireframeProps> {
}

interface IVeltNotificationsToolWireframeProps extends IVeltWireframeCommonProps {
    variant?: string;
}
interface IVeltNotificationsToolWireframe extends React$1.FC<IVeltNotificationsToolWireframeProps> {
    Label: IVeltNotificationsToolLabelWireframe;
    UnreadIcon: IVeltNotificationsToolUnreadIconWireframe;
    Icon: IVeltNotificationsToolIconWireframe;
    UnreadCount: IVeltNotificationsToolUnreadCountWireframe;
}
declare const VeltNotificationsToolWireframe: IVeltNotificationsToolWireframe;

interface IVeltConfirmDialogTitleWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltConfirmDialogMessageWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltConfirmDialogApproveButtonWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltConfirmDialogRejectButtonWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltConfirmDialogWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltConfirmDialogWireframe extends React$1.FC<IVeltConfirmDialogWireframeProps> {
    Title: React$1.FC<IVeltConfirmDialogTitleWireframeProps>;
    Message: React$1.FC<IVeltConfirmDialogMessageWireframeProps>;
    ApproveButton: React$1.FC<IVeltConfirmDialogApproveButtonWireframeProps>;
    RejectButton: React$1.FC<IVeltConfirmDialogRejectButtonWireframeProps>;
}
declare const VeltConfirmDialogWireframe: IVeltConfirmDialogWireframe;

interface IVeltInlineReactionsSectionListWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltInlineReactionsSectionPanelWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltInlineReactionsSectionToolContainerWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltInlineReactionsSectionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltInlineReactionsSectionWireframe extends React$1.FC<IVeltInlineReactionsSectionWireframeProps> {
    List: React$1.FC<IVeltInlineReactionsSectionListWireframeProps>;
    Panel: React$1.FC<IVeltInlineReactionsSectionPanelWireframeProps>;
    ToolContainer: React$1.FC<IVeltInlineReactionsSectionToolContainerWireframeProps>;
}
declare const VeltInlineReactionsSectionWireframe: IVeltInlineReactionsSectionWireframe;

interface IVeltPersistentCommentModeCloseButtonWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltPersistentCommentModeLabelPrivateWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltPersistentCommentModeLabelPublicWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltPersistentCommentModeLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPersistentCommentModeLabelWireframe extends React$1.FC<IVeltPersistentCommentModeLabelWireframeProps> {
    Private: React$1.FC<IVeltPersistentCommentModeLabelPrivateWireframeProps>;
    Public: React$1.FC<IVeltPersistentCommentModeLabelPublicWireframeProps>;
}

interface IVeltPersistentCommentModeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPersistentCommentModeWireframe extends React$1.FC<IVeltPersistentCommentModeWireframeProps> {
    CloseButton: React$1.FC<IVeltPersistentCommentModeCloseButtonWireframeProps>;
    Label: IVeltPersistentCommentModeLabelWireframe;
}
declare const VeltPersistentCommentModeWireframe: IVeltPersistentCommentModeWireframe;

interface IVeltMultiThreadCommentDialogCloseButtonWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltMultiThreadCommentDialogCommentCountWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltMultiThreadCommentDialogComposerContainerWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltMultiThreadCommentDialogEmptyPlaceholderWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogEmptyPlaceholderWireframe extends React$1.FC<IVeltMultiThreadCommentDialogEmptyPlaceholderWireframeProps> {
}

interface IVeltMultiThreadCommentDialogListWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltMultiThreadCommentDialogMinimalActionsDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalActionsDropdownContentWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalActionsDropdownContentWireframeProps> {
    MarkAllRead: React$1.FC<IVeltWireframeCommonProps>;
    MarkAllResolved: React$1.FC<IVeltWireframeCommonProps>;
}

interface IVeltMultiThreadCommentDialogMinimalActionsDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalActionsDropdownTriggerWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalActionsDropdownTriggerWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalActionsDropdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalActionsDropdownWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalActionsDropdownWireframeProps> {
    Content: IVeltMultiThreadCommentDialogMinimalActionsDropdownContentWireframe;
    Trigger: IVeltMultiThreadCommentDialogMinimalActionsDropdownTriggerWireframe;
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterAllWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterAllWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterAllWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterReadWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterReadWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterReadWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterResolvedWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterResolvedWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterResolvedWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterUnreadWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterUnreadWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterUnreadWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSelectedIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSelectedIconWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSelectedIconWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortDateWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortDateWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortDateWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortUnreadWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortUnreadWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortUnreadWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentWireframeProps> {
    FilterAll: IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterAllWireframe;
    FilterUnread: IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterUnreadWireframe;
    FilterRead: IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterReadWireframe;
    FilterResolved: IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterResolvedWireframe;
    SelectedIcon: IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSelectedIconWireframe;
    SortDate: IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortDateWireframe;
    SortUnread: IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortUnreadWireframe;
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownTriggerWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownTriggerWireframeProps> {
}

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogMinimalFilterDropdownWireframe extends React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownWireframeProps> {
    Content: IVeltMultiThreadCommentDialogMinimalFilterDropdownContentWireframe;
    Trigger: IVeltMultiThreadCommentDialogMinimalFilterDropdownTriggerWireframe;
}

interface IVeltMultiThreadCommentDialogNewThreadButtonWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltMultiThreadCommentDialogResetFilterButtonWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltMultiThreadCommentDialogWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMultiThreadCommentDialogWireframe extends React$1.FC<IVeltMultiThreadCommentDialogWireframeProps> {
    CommentCount: React$1.FC<IVeltMultiThreadCommentDialogCommentCountWireframeProps>;
    ComposerContainer: React$1.FC<IVeltMultiThreadCommentDialogComposerContainerWireframeProps>;
    List: React$1.FC<IVeltMultiThreadCommentDialogListWireframeProps>;
    CloseButton: React$1.FC<IVeltMultiThreadCommentDialogCloseButtonWireframeProps>;
    MinimalFilterDropdown: IVeltMultiThreadCommentDialogMinimalFilterDropdownWireframe;
    EmptyPlaceholder: IVeltMultiThreadCommentDialogEmptyPlaceholderWireframe;
    NewThreadButton: React$1.FC<IVeltMultiThreadCommentDialogNewThreadButtonWireframeProps>;
    MinimalActionsDropdown: IVeltMultiThreadCommentDialogMinimalActionsDropdownWireframe;
    ResetFilterButton: React$1.FC<IVeltMultiThreadCommentDialogResetFilterButtonWireframeProps>;
}
declare const VeltMultiThreadCommentDialogWireframe: IVeltMultiThreadCommentDialogWireframe;

interface IVeltCommentComposerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentComposerWireframe extends React$1.FC<IVeltCommentComposerWireframeProps> {
}
declare const VeltCommentComposerWireframe: IVeltCommentComposerWireframe;

interface IVeltCommentThreadWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentThreadWireframe extends React$1.FC<IVeltCommentThreadWireframeProps> {
}
declare const VeltCommentThreadWireframe: IVeltCommentThreadWireframe;

interface IVeltMediaSourceSettingsToggleIconOpenWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsToggleIconOpenWireframe extends React$1.FC<IVeltMediaSourceSettingsToggleIconOpenWireframeProps> {
}

interface IVeltMediaSourceSettingsToggleIconCloseWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsToggleIconCloseWireframe extends React$1.FC<IVeltMediaSourceSettingsToggleIconCloseWireframeProps> {
}

interface IVeltMediaSourceSettingsToggleIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsToggleIconWireframe extends React$1.FC<IVeltMediaSourceSettingsToggleIconWireframeProps> {
    Open: IVeltMediaSourceSettingsToggleIconOpenWireframe;
    Close: IVeltMediaSourceSettingsToggleIconCloseWireframe;
}

interface IVeltMediaSourceSettingsSelectedLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsSelectedLabelWireframe extends React$1.FC<IVeltMediaSourceSettingsSelectedLabelWireframeProps> {
}

interface IVeltMediaSourceSettingsOptionsItemLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsOptionsItemLabelWireframe extends React$1.FC<IVeltMediaSourceSettingsOptionsItemLabelWireframeProps> {
}

interface IVeltMediaSourceSettingsOptionsItemIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsOptionsItemIconWireframe extends React$1.FC<IVeltMediaSourceSettingsOptionsItemIconWireframeProps> {
}

interface IVeltMediaSourceSettingsOptionsItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsOptionsItemWireframe extends React$1.FC<IVeltMediaSourceSettingsOptionsItemWireframeProps> {
    Icon: IVeltMediaSourceSettingsOptionsItemIconWireframe;
    Label: IVeltMediaSourceSettingsOptionsItemLabelWireframe;
}

interface IVeltMediaSourceSettingsOptionsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsOptionsWireframe extends React$1.FC<IVeltMediaSourceSettingsOptionsWireframeProps> {
    Item: IVeltMediaSourceSettingsOptionsItemWireframe;
}

interface IVeltMediaSourceSettingsDividerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsDividerWireframe extends React$1.FC<IVeltMediaSourceSettingsDividerWireframeProps> {
}

interface IVeltMediaSourceSettingsAudioWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsAudioWireframe extends React$1.FC<IVeltMediaSourceSettingsAudioWireframeProps> {
    ToggleIcon: IVeltMediaSourceSettingsToggleIconWireframe;
    SelectedLabel: IVeltMediaSourceSettingsSelectedLabelWireframe;
    Options: IVeltMediaSourceSettingsOptionsWireframe;
    Divider: IVeltMediaSourceSettingsDividerWireframe;
}

interface IVeltMediaSourceSettingsVideoWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsVideoWireframe extends React$1.FC<IVeltMediaSourceSettingsVideoWireframeProps> {
    ToggleIcon: IVeltMediaSourceSettingsToggleIconWireframe;
    SelectedLabel: IVeltMediaSourceSettingsSelectedLabelWireframe;
    Options: IVeltMediaSourceSettingsOptionsWireframe;
    Divider: IVeltMediaSourceSettingsDividerWireframe;
}

interface IVeltMediaSourceSettingsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltMediaSourceSettingsWireframe extends React$1.FC<IVeltMediaSourceSettingsWireframeProps> {
    Audio: IVeltMediaSourceSettingsAudioWireframe;
    Video: IVeltMediaSourceSettingsVideoWireframe;
}
declare const VeltMediaSourceSettingsWireframe: IVeltMediaSourceSettingsWireframe;

interface IVeltRecorderAllToolWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderAllToolWireframe extends React$1.FC<IVeltRecorderAllToolWireframeProps> {
}
declare const VeltRecorderAllToolWireframe: IVeltRecorderAllToolWireframe;

interface IVeltRecorderAllToolMenuAudioWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderAllToolMenuAudioWireframe extends React$1.FC<IVeltRecorderAllToolMenuAudioWireframeProps> {
}

interface IVeltRecorderAllToolMenuVideoWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderAllToolMenuVideoWireframe extends React$1.FC<IVeltRecorderAllToolMenuVideoWireframeProps> {
}

interface IVeltRecorderAllToolMenuScreenWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderAllToolMenuScreenWireframe extends React$1.FC<IVeltRecorderAllToolMenuScreenWireframeProps> {
}

interface IVeltRecorderAllToolMenuWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderAllToolMenuWireframe extends React$1.FC<IVeltRecorderAllToolMenuWireframeProps> {
    Video: IVeltRecorderAllToolMenuVideoWireframe;
    Audio: IVeltRecorderAllToolMenuAudioWireframe;
    Screen: IVeltRecorderAllToolMenuScreenWireframe;
}
declare const VeltRecorderAllToolMenuWireframe: IVeltRecorderAllToolMenuWireframe;

interface IVeltRecorderAudioToolWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderAudioToolWireframe extends React$1.FC<IVeltRecorderAudioToolWireframeProps> {
}
declare const VeltRecorderAudioToolWireframe: IVeltRecorderAudioToolWireframe;

interface IVeltRecorderScreenToolWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderScreenToolWireframe extends React$1.FC<IVeltRecorderScreenToolWireframeProps> {
}
declare const VeltRecorderScreenToolWireframe: IVeltRecorderScreenToolWireframe;

interface IVeltRecorderVideoToolWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderVideoToolWireframe extends React$1.FC<IVeltRecorderVideoToolWireframeProps> {
}
declare const VeltRecorderVideoToolWireframe: IVeltRecorderVideoToolWireframe;

interface IVeltRecordingPreviewStepsDialogBottomPanelCloseWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogBottomPanelCloseWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogBottomPanelCloseWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogBottomPanelCountdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogBottomPanelCountdownWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogBottomPanelCountdownWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogBottomPanelIconWireframeProps extends IVeltWireframeCommonProps {
    type?: 'audio' | 'video' | 'screen';
}
interface IVeltRecordingPreviewStepsDialogBottomPanelIconWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogBottomPanelIconWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogBottomPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogBottomPanelWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogBottomPanelWireframeProps> {
    Icon: IVeltRecordingPreviewStepsDialogBottomPanelIconWireframe;
    Close: IVeltRecordingPreviewStepsDialogBottomPanelCloseWireframe;
    Countdown: IVeltRecordingPreviewStepsDialogBottomPanelCountdownWireframe;
}

interface IVeltRecordingPreviewStepsDialogButtonPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogButtonPanelWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogButtonPanelWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogCloseButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogCloseButtonWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogCloseButtonWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogMicButtonOffWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogMicButtonOffWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogMicButtonOffWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogMicButtonOnWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogMicButtonOnWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogMicButtonOnWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogMicButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogMicButtonWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogMicButtonWireframeProps> {
    On: IVeltRecordingPreviewStepsDialogMicButtonOnWireframe;
    Off: IVeltRecordingPreviewStepsDialogMicButtonOffWireframe;
}

interface IVeltRecordingPreviewStepsDialogSettingsPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogSettingsPanelWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogSettingsPanelWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogSettingsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogSettingsWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogSettingsWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogStartRecordingWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogStartRecordingWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogStartRecordingWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogTimerCountdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogTimerCountdownWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogTimerCountdownWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogTimerCancelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogTimerCancelWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogTimerCancelWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogTimerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogTimerWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogTimerWireframeProps> {
    Countdown: IVeltRecordingPreviewStepsDialogTimerCountdownWireframe;
    Cancel: IVeltRecordingPreviewStepsDialogTimerCancelWireframe;
}

interface IVeltRecordingPreviewStepsDialogWaveformWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogWaveformWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogWaveformWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogAudioWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogAudioWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogAudioWireframeProps> {
    BottomPanel: IVeltRecordingPreviewStepsDialogBottomPanelWireframe;
    ButtonPanel: IVeltRecordingPreviewStepsDialogButtonPanelWireframe;
    CloseButton: IVeltRecordingPreviewStepsDialogCloseButtonWireframe;
    MicButton: IVeltRecordingPreviewStepsDialogMicButtonWireframe;
    SettingsPanel: IVeltRecordingPreviewStepsDialogSettingsPanelWireframe;
    Settings: IVeltRecordingPreviewStepsDialogSettingsWireframe;
    StartRecording: IVeltRecordingPreviewStepsDialogStartRecordingWireframe;
    Timer: IVeltRecordingPreviewStepsDialogTimerWireframe;
    Waveform: IVeltRecordingPreviewStepsDialogWaveformWireframe;
}

interface IVeltRecordingPreviewStepsDialogCameraButtonOffWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogCameraButtonOffWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogCameraButtonOffWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogCameraButtonOnWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogCameraButtonOnWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogCameraButtonOnWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogCameraButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogCameraButtonWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogCameraButtonWireframeProps> {
    On: IVeltRecordingPreviewStepsDialogCameraButtonOnWireframe;
    Off: IVeltRecordingPreviewStepsDialogCameraButtonOffWireframe;
}

interface IVeltRecordingPreviewStepsDialogCameraOffMessageWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogCameraOffMessageWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogCameraOffMessageWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogVideoPlayerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogVideoPlayerWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogVideoPlayerWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogScreenPlayerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogScreenPlayerWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogScreenPlayerWireframeProps> {
}

interface IVeltRecordingPreviewStepsDialogVideoWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogVideoWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogVideoWireframeProps> {
    BottomPanel: IVeltRecordingPreviewStepsDialogBottomPanelWireframe;
    ButtonPanel: IVeltRecordingPreviewStepsDialogButtonPanelWireframe;
    CameraButton: IVeltRecordingPreviewStepsDialogCameraButtonWireframe;
    CameraOffMessage: IVeltRecordingPreviewStepsDialogCameraOffMessageWireframe;
    CloseButton: IVeltRecordingPreviewStepsDialogCloseButtonWireframe;
    MicButton: IVeltRecordingPreviewStepsDialogMicButtonWireframe;
    SettingsPanel: IVeltRecordingPreviewStepsDialogSettingsPanelWireframe;
    Settings: IVeltRecordingPreviewStepsDialogSettingsWireframe;
    StartRecording: IVeltRecordingPreviewStepsDialogStartRecordingWireframe;
    Timer: IVeltRecordingPreviewStepsDialogTimerWireframe;
    VideoPlayer: IVeltRecordingPreviewStepsDialogVideoPlayerWireframe;
    ScreenPlayer: IVeltRecordingPreviewStepsDialogScreenPlayerWireframe;
    Waveform: IVeltRecordingPreviewStepsDialogWaveformWireframe;
}

interface IVeltRecordingPreviewStepsDialogWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecordingPreviewStepsDialogWireframe extends React$1.FC<IVeltRecordingPreviewStepsDialogWireframeProps> {
    Video: IVeltRecordingPreviewStepsDialogVideoWireframe;
    Audio: IVeltRecordingPreviewStepsDialogAudioWireframe;
}
declare const VeltRecordingPreviewStepsDialogWireframe: IVeltRecordingPreviewStepsDialogWireframe;

interface IVeltRecorderControlPanelFloatingModeContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelFloatingModeContainerWireframe extends React$1.FC<IVeltRecorderControlPanelFloatingModeContainerWireframeProps> {
}

interface IVeltRecorderControlPanelFloatingModeWaveformWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelFloatingModeWaveformWireframe extends React$1.FC<IVeltRecorderControlPanelFloatingModeWaveformWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarWaveformWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarWaveformWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarWaveformWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarClearWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarClearWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarClearWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarStopWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarStopWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarStopWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarTimeWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarTimeWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarTogglePlayWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarTogglePlayWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarTogglePlayWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarTogglePauseWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarTogglePauseWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarTogglePauseWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarToggleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarToggleWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarToggleWireframeProps> {
    Pause: IVeltRecorderControlPanelActionBarTogglePauseWireframe;
    Play: IVeltRecorderControlPanelActionBarTogglePlayWireframe;
}

interface IVeltRecorderControlPanelActionBarTypeIconWireframeProps extends IVeltWireframeCommonProps {
    type?: 'audio' | 'video' | 'screen';
}
interface IVeltRecorderControlPanelActionBarTypeIconWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarTypeIconWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarPipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarPipWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarPipWireframeProps> {
}

interface IVeltRecorderControlPanelActionBarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarWireframeProps> {
    Clear: IVeltRecorderControlPanelActionBarClearWireframe;
    Stop: IVeltRecorderControlPanelActionBarStopWireframe;
    Time: IVeltRecorderControlPanelActionBarTimeWireframe;
    Toggle: IVeltRecorderControlPanelActionBarToggleWireframe;
    TypeIcon: IVeltRecorderControlPanelActionBarTypeIconWireframe;
    Waveform: IVeltRecorderControlPanelActionBarWaveformWireframe;
    Pip: IVeltRecorderControlPanelActionBarPipWireframe;
}

interface IVeltRecorderControlPanelCollapsedButtonOffWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelCollapsedButtonOffWireframe extends React$1.FC<IVeltRecorderControlPanelCollapsedButtonOffWireframeProps> {
}

interface IVeltRecorderControlPanelCollapsedButtonOnWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelCollapsedButtonOnWireframe extends React$1.FC<IVeltRecorderControlPanelCollapsedButtonOnWireframeProps> {
}

interface IVeltRecorderControlPanelCollapsedButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelCollapsedButtonWireframe extends React$1.FC<IVeltRecorderControlPanelCollapsedButtonWireframeProps> {
    On: IVeltRecorderControlPanelCollapsedButtonOnWireframe;
    Off: IVeltRecorderControlPanelCollapsedButtonOffWireframe;
}

interface IVeltRecorderControlPanelLoadingWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelLoadingWireframe extends React$1.FC<IVeltRecorderControlPanelLoadingWireframeProps> {
}

interface IVeltRecorderControlPanelPausedWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelPausedWireframe extends React$1.FC<IVeltRecorderControlPanelPausedWireframeProps> {
}

interface IVeltRecorderControlPanelVideoWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelVideoWireframe extends React$1.FC<IVeltRecorderControlPanelVideoWireframeProps> {
}

interface IVeltRecorderControlPanelScreenWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelScreenWireframe extends React$1.FC<IVeltRecorderControlPanelScreenWireframeProps> {
}

interface IVeltRecorderControlPanelScreenMiniContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelScreenMiniContainerWireframe extends React$1.FC<IVeltRecorderControlPanelScreenMiniContainerWireframeProps> {
}

interface IVeltRecorderControlPanelFloatingModeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelFloatingModeWireframe extends React$1.FC<IVeltRecorderControlPanelFloatingModeWireframeProps> {
    Container: IVeltRecorderControlPanelFloatingModeContainerWireframe;
    ScreenVideo: IVeltRecorderControlPanelScreenMiniContainerWireframe;
    ScreenMiniContainer: IVeltRecorderControlPanelScreenMiniContainerWireframe;
    Waveform: IVeltRecorderControlPanelFloatingModeWaveformWireframe;
    Video: IVeltRecorderControlPanelVideoWireframe;
    Screen: IVeltRecorderControlPanelScreenWireframe;
    CollapsedButton: IVeltRecorderControlPanelCollapsedButtonWireframe;
    Paused: IVeltRecorderControlPanelPausedWireframe;
    Loading: IVeltRecorderControlPanelLoadingWireframe;
    ActionBar: IVeltRecorderControlPanelActionBarWireframe;
}

interface IVeltRecorderControlPanelThreadModeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelThreadModeWireframe extends React$1.FC<IVeltRecorderControlPanelThreadModeWireframeProps> {
    Video: IVeltRecorderControlPanelVideoWireframe;
    Screen: IVeltRecorderControlPanelScreenWireframe;
    Loading: IVeltRecorderControlPanelLoadingWireframe;
    ActionBar: IVeltRecorderControlPanelActionBarWireframe;
    ScreenMiniContainer: IVeltRecorderControlPanelScreenMiniContainerWireframe;
}

interface IVeltRecorderControlPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelWireframe extends React$1.FC<IVeltRecorderControlPanelWireframeProps> {
    FloatingMode: IVeltRecorderControlPanelFloatingModeWireframe;
    ThreadMode: IVeltRecorderControlPanelThreadModeWireframe;
}
declare const VeltRecorderControlPanelWireframe: IVeltRecorderControlPanelWireframe;

interface IVeltRecorderPlayerAudioTogglePauseWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerAudioTogglePauseWireframe extends React$1.FC<IVeltRecorderPlayerAudioTogglePauseWireframeProps> {
}

interface IVeltRecorderPlayerAudioTogglePlayWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerAudioTogglePlayWireframe extends React$1.FC<IVeltRecorderPlayerAudioTogglePlayWireframeProps> {
}

interface IVeltRecorderPlayerAudioToggleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerAudioToggleWireframe extends React$1.FC<IVeltRecorderPlayerAudioToggleWireframeProps> {
    Play: IVeltRecorderPlayerAudioTogglePlayWireframe;
    Pause: IVeltRecorderPlayerAudioTogglePauseWireframe;
}

interface IVeltRecorderPlayerAudioWaveformWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerAudioWaveformWireframe extends React$1.FC<IVeltRecorderPlayerAudioWaveformWireframeProps> {
}

interface IVeltRecorderPlayerAudioWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerAudioWireframe extends React$1.FC<IVeltRecorderPlayerAudioWireframeProps> {
}

interface IVeltRecorderPlayerCopyLinkWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerCopyLinkWireframe extends React$1.FC<IVeltRecorderPlayerCopyLinkWireframeProps> {
}

interface IVeltRecorderPlayerDeleteWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerDeleteWireframe extends React$1.FC<IVeltRecorderPlayerDeleteWireframeProps> {
}

interface IVeltRecorderPlayerNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerNameWireframe extends React$1.FC<IVeltRecorderPlayerNameWireframeProps> {
}

interface IVeltRecorderPlayerSubtitlesButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerSubtitlesButtonWireframe extends React$1.FC<IVeltRecorderPlayerSubtitlesButtonWireframeProps> {
}

interface IVeltRecorderPlayerSubtitlesWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerSubtitlesWireframe extends React$1.FC<IVeltRecorderPlayerSubtitlesWireframeProps> {
}

interface IVeltRecorderPlayerTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerTimeWireframe extends React$1.FC<IVeltRecorderPlayerTimeWireframeProps> {
}

interface IVeltRecorderPlayerTranscriptionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerTranscriptionWireframe extends React$1.FC<IVeltRecorderPlayerTranscriptionWireframeProps> {
}

interface IVeltRecorderPlayerAvatarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerAvatarWireframe extends React$1.FC<IVeltRecorderPlayerAvatarWireframeProps> {
}

interface IVeltRecorderPlayerAudioContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerAudioContainerWireframe extends React$1.FC<IVeltRecorderPlayerAudioContainerWireframeProps> {
    AudioToggle: IVeltRecorderPlayerAudioToggleWireframe;
    Time: IVeltRecorderPlayerTimeWireframe;
    Audio: IVeltRecorderPlayerAudioWireframe;
    Subtitles: IVeltRecorderPlayerSubtitlesWireframe;
    Name: IVeltRecorderPlayerNameWireframe;
    SubtitlesButton: IVeltRecorderPlayerSubtitlesButtonWireframe;
    Transcription: IVeltRecorderPlayerTranscriptionWireframe;
    CopyLink: IVeltRecorderPlayerCopyLinkWireframe;
    Delete: IVeltRecorderPlayerDeleteWireframe;
    AudioWaveform: IVeltRecorderPlayerAudioWaveformWireframe;
    Avatar: IVeltRecorderPlayerAvatarWireframe;
}

interface IVeltRecorderPlayerFullScreenButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerFullScreenButtonWireframe extends React$1.FC<IVeltRecorderPlayerFullScreenButtonWireframeProps> {
}

interface IVeltRecorderPlayerOverlayWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerOverlayWireframe extends React$1.FC<IVeltRecorderPlayerOverlayWireframeProps> {
}

interface IVeltRecorderPlayerPlayButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerPlayButtonWireframe extends React$1.FC<IVeltRecorderPlayerPlayButtonWireframeProps> {
}

interface IVeltRecorderPlayerTimelineSeekBarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerTimelineSeekBarWireframe extends React$1.FC<IVeltRecorderPlayerTimelineSeekBarWireframeProps> {
}

interface IVeltRecorderPlayerTimelineWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerTimelineWireframe extends React$1.FC<IVeltRecorderPlayerTimelineWireframeProps> {
    SeekBar: IVeltRecorderPlayerTimelineSeekBarWireframe;
}

interface IVeltRecorderPlayerVideoWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerVideoWireframe extends React$1.FC<IVeltRecorderPlayerVideoWireframeProps> {
}

interface IVeltRecorderPlayerEditButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerEditButtonWireframe extends React$1.FC<IVeltRecorderPlayerEditButtonWireframeProps> {
}

interface IVeltRecorderPlayerVideoContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerVideoContainerWireframe extends React$1.FC<IVeltRecorderPlayerVideoContainerWireframeProps> {
    Video: IVeltRecorderPlayerVideoWireframe;
    Timeline: IVeltRecorderPlayerTimelineWireframe;
    PlayButton: IVeltRecorderPlayerPlayButtonWireframe;
    EditButton: IVeltRecorderPlayerEditButtonWireframe;
    FullScreenButton: IVeltRecorderPlayerFullScreenButtonWireframe;
    Overlay: IVeltRecorderPlayerOverlayWireframe;
    Time: IVeltRecorderPlayerTimeWireframe;
    Subtitles: IVeltRecorderPlayerSubtitlesWireframe;
    Name: IVeltRecorderPlayerNameWireframe;
    SubtitlesButton: IVeltRecorderPlayerSubtitlesButtonWireframe;
    Transcription: IVeltRecorderPlayerTranscriptionWireframe;
    CopyLink: IVeltRecorderPlayerCopyLinkWireframe;
    Delete: IVeltRecorderPlayerDeleteWireframe;
    Avatar: IVeltRecorderPlayerAvatarWireframe;
}

interface IVeltRecorderPlayerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerWireframe extends React$1.FC<IVeltRecorderPlayerWireframeProps> {
    AudioContainer: IVeltRecorderPlayerAudioContainerWireframe;
    VideoContainer: IVeltRecorderPlayerVideoContainerWireframe;
}
declare const VeltRecorderPlayerWireframe: IVeltRecorderPlayerWireframe;

interface IVeltRecorderPlayerExpandedControlsDeleteButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsDeleteButtonWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsDeleteButtonWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsProgressBarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsProgressBarWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsProgressBarWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsSettingsButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsSettingsButtonWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsSettingsButtonWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsSubtitleButtonIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsSubtitleButtonIconWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsSubtitleButtonIconWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsSubtitleButtonTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsSubtitleButtonTooltipWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsSubtitleButtonTooltipWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsSubtitleButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsSubtitleButtonWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsSubtitleButtonWireframeProps> {
    Icon: IVeltRecorderPlayerExpandedControlsSubtitleButtonIconWireframe;
    Tooltip: IVeltRecorderPlayerExpandedControlsSubtitleButtonTooltipWireframe;
}

interface IVeltRecorderPlayerExpandedControlsTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsTimeWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsTimeWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsTogglePauseWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsTogglePauseWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsTogglePauseWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsTogglePlayWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsTogglePlayWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsTogglePlayWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsToggleButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsToggleButtonWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsToggleButtonWireframeProps> {
    Play: IVeltRecorderPlayerExpandedControlsTogglePlayWireframe;
    Pause: IVeltRecorderPlayerExpandedControlsTogglePauseWireframe;
}

interface IVeltRecorderPlayerExpandedControlsTranscriptionIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsTranscriptionIconWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsTranscriptionIconWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsTranscriptionTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsTranscriptionTooltipWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsTranscriptionTooltipWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsTranscriptionButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsTranscriptionButtonWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsTranscriptionButtonWireframeProps> {
    Icon: IVeltRecorderPlayerExpandedControlsTranscriptionIconWireframe;
    Tooltip: IVeltRecorderPlayerExpandedControlsTranscriptionTooltipWireframe;
}

interface IVeltRecorderPlayerExpandedControlsVolumeButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsVolumeButtonWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsVolumeButtonWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsCurrentTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsCurrentTimeWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsCurrentTimeWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsTotalTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsTotalTimeWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsTotalTimeWireframeProps> {
}

interface IVeltRecorderPlayerExpandedControlsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedControlsWireframe extends React$1.FC<IVeltRecorderPlayerExpandedControlsWireframeProps> {
    DeleteButton: IVeltRecorderPlayerExpandedControlsDeleteButtonWireframe;
    ProgressBar: IVeltRecorderPlayerExpandedControlsProgressBarWireframe;
    SettingsButton: IVeltRecorderPlayerExpandedControlsSettingsButtonWireframe;
    SubtitleButton: IVeltRecorderPlayerExpandedControlsSubtitleButtonWireframe;
    Time: IVeltRecorderPlayerExpandedControlsTimeWireframe;
    TranscriptionButton: IVeltRecorderPlayerExpandedControlsTranscriptionButtonWireframe;
    ToggleButton: IVeltRecorderPlayerExpandedControlsToggleButtonWireframe;
    VolumeButton: IVeltRecorderPlayerExpandedControlsVolumeButtonWireframe;
    CurrentTime: IVeltRecorderPlayerExpandedControlsCurrentTimeWireframe;
    TotalTime: IVeltRecorderPlayerExpandedControlsTotalTimeWireframe;
}

interface IVeltRecorderPlayerExpandedCopyLinkWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedCopyLinkWireframe extends React$1.FC<IVeltRecorderPlayerExpandedCopyLinkWireframeProps> {
}

interface IVeltRecorderPlayerExpandedDisplayWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedDisplayWireframe extends React$1.FC<IVeltRecorderPlayerExpandedDisplayWireframeProps> {
}

interface IVeltRecorderPlayerExpandedMinimizeButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedMinimizeButtonWireframe extends React$1.FC<IVeltRecorderPlayerExpandedMinimizeButtonWireframeProps> {
}

interface IVeltRecorderPlayerExpandedPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedPanelWireframe extends React$1.FC<IVeltRecorderPlayerExpandedPanelWireframeProps> {
}

interface IVeltRecorderPlayerExpandedSubtitlesWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedSubtitlesWireframe extends React$1.FC<IVeltRecorderPlayerExpandedSubtitlesWireframeProps> {
}

interface IVeltRecorderPlayerExpandedTranscriptionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedTranscriptionWireframe extends React$1.FC<IVeltRecorderPlayerExpandedTranscriptionWireframeProps> {
}

interface IVeltRecorderPlayerExpandedWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerExpandedWireframe extends React$1.FC<IVeltRecorderPlayerExpandedWireframeProps> {
    Controls: IVeltRecorderPlayerExpandedControlsWireframe;
    CopyLink: IVeltRecorderPlayerExpandedCopyLinkWireframe;
    Display: IVeltRecorderPlayerExpandedDisplayWireframe;
    MinimizeButton: IVeltRecorderPlayerExpandedMinimizeButtonWireframe;
    Panel: IVeltRecorderPlayerExpandedPanelWireframe;
    Subtitles: IVeltRecorderPlayerExpandedSubtitlesWireframe;
    Transcription: IVeltRecorderPlayerExpandedTranscriptionWireframe;
}
declare const VeltRecorderPlayerExpandedWireframe: IVeltRecorderPlayerExpandedWireframe;

interface IVeltVideoEditorPlayerTitleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTitleWireframe extends React$1.FC<IVeltVideoEditorPlayerTitleWireframeProps> {
}

interface IVeltVideoEditorPlayerApplyButtonLoadingWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerApplyButtonLoadingWireframe extends React$1.FC<IVeltVideoEditorPlayerApplyButtonLoadingWireframeProps> {
}

interface IVeltVideoEditorPlayerApplyButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerApplyButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerApplyButtonWireframeProps> {
    Loading: IVeltVideoEditorPlayerApplyButtonLoadingWireframe;
}

interface IVeltVideoEditorPlayerCloseButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerCloseButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerCloseButtonWireframeProps> {
}

interface IVeltVideoEditorPlayerPreviewLoadingWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerPreviewLoadingWireframe extends React$1.FC<IVeltVideoEditorPlayerPreviewLoadingWireframeProps> {
}

interface IVeltVideoEditorPlayerPreviewVideoWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerPreviewVideoWireframe extends React$1.FC<IVeltVideoEditorPlayerPreviewVideoWireframeProps> {
}

interface IVeltVideoEditorPlayerPreviewWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerPreviewWireframe extends React$1.FC<IVeltVideoEditorPlayerPreviewWireframeProps> {
    Loading: IVeltVideoEditorPlayerPreviewLoadingWireframe;
    Video: IVeltVideoEditorPlayerPreviewVideoWireframe;
}

interface IVeltVideoEditorPlayerToggleButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerToggleButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerToggleButtonWireframeProps> {
}

interface IVeltVideoEditorPlayerTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimeWireframe extends React$1.FC<IVeltVideoEditorPlayerTimeWireframeProps> {
}

interface IVeltVideoEditorPlayerCurrentTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerCurrentTimeWireframe extends React$1.FC<IVeltVideoEditorPlayerCurrentTimeWireframeProps> {
}

interface IVeltVideoEditorPlayerTotalTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTotalTimeWireframe extends React$1.FC<IVeltVideoEditorPlayerTotalTimeWireframeProps> {
}

interface IVeltVideoEditorPlayerSplitButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerSplitButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerSplitButtonWireframeProps> {
}

interface IVeltVideoEditorPlayerDeleteButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerDeleteButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerDeleteButtonWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelineMarkerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineMarkerWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineMarkerWireframeProps> {
}

interface IVeltVideoEditorPlayerZoomButtonTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerZoomButtonTriggerWireframe extends React$1.FC<IVeltVideoEditorPlayerZoomButtonTriggerWireframeProps> {
}

interface IVeltVideoEditorPlayerZoomButtonOptionsListItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerZoomButtonOptionsListItemWireframe extends React$1.FC<IVeltVideoEditorPlayerZoomButtonOptionsListItemWireframeProps> {
}

interface IVeltVideoEditorPlayerZoomButtonOptionsListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerZoomButtonOptionsListWireframe extends React$1.FC<IVeltVideoEditorPlayerZoomButtonOptionsListWireframeProps> {
    Item: IVeltVideoEditorPlayerZoomButtonOptionsListItemWireframe;
}

interface IVeltVideoEditorPlayerZoomButtonOptionsInputWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerZoomButtonOptionsInputWireframe extends React$1.FC<IVeltVideoEditorPlayerZoomButtonOptionsInputWireframeProps> {
}

interface IVeltVideoEditorPlayerZoomButtonOptionsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerZoomButtonOptionsWireframe extends React$1.FC<IVeltVideoEditorPlayerZoomButtonOptionsWireframeProps> {
    List: IVeltVideoEditorPlayerZoomButtonOptionsListWireframe;
    Input: IVeltVideoEditorPlayerZoomButtonOptionsInputWireframe;
}

interface IVeltVideoEditorPlayerZoomButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerZoomButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerZoomButtonWireframeProps> {
    Trigger: IVeltVideoEditorPlayerZoomButtonTriggerWireframe;
    Options: IVeltVideoEditorPlayerZoomButtonOptionsWireframe;
}

interface IVeltVideoEditorPlayerTimelineScaleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineScaleWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineScaleWireframeProps> {
    ZoomButton: IVeltVideoEditorPlayerZoomButtonWireframe;
}

interface IVeltVideoEditorPlayerTimelineTrimWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineTrimWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineTrimWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelineContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineContainerWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineContainerWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelinePlayheadLineWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelinePlayheadLineWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelinePlayheadLineWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelinePlayheadActionsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelinePlayheadActionsWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelinePlayheadActionsWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelinePlayheadProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelinePlayhead extends React$1.FC<IVeltVideoEditorPlayerTimelinePlayheadProps> {
    Line: IVeltVideoEditorPlayerTimelinePlayheadLineWireframe;
    Actions: IVeltVideoEditorPlayerTimelinePlayheadActionsWireframe;
}

interface IVeltVideoEditorPlayerTimelineOnboardingContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineOnboardingContentWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineOnboardingContentWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelineOnboardingTextTitleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineOnboardingTextTitleWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineOnboardingTextTitleWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelineOnboardingTextDescriptionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineOnboardingTextDescriptionWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineOnboardingTextDescriptionWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelineOnboardingTextWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineOnboardingTextWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineOnboardingTextWireframeProps> {
    Title: IVeltVideoEditorPlayerTimelineOnboardingTextTitleWireframe;
    Description: IVeltVideoEditorPlayerTimelineOnboardingTextDescriptionWireframe;
}

interface IVeltVideoEditorPlayerTimelineOnboardingArrowWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineOnboardingArrowWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineOnboardingArrowWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelineOnboardingWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineOnboardingWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineOnboardingWireframeProps> {
    Content: IVeltVideoEditorPlayerTimelineOnboardingContentWireframe;
    Text: IVeltVideoEditorPlayerTimelineOnboardingTextWireframe;
    Arrow: IVeltVideoEditorPlayerTimelineOnboardingArrowWireframe;
}

interface IVeltVideoEditorPlayerTimelineBackspaceHintWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineBackspaceHintWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineBackspaceHintWireframeProps> {
}

interface IVeltVideoEditorPlayerTimelineWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineWireframeProps> {
    Marker: IVeltVideoEditorPlayerTimelineMarkerWireframe;
    Scale: IVeltVideoEditorPlayerTimelineScaleWireframe;
    Trim: IVeltVideoEditorPlayerTimelineTrimWireframe;
    Container: IVeltVideoEditorPlayerTimelineContainerWireframe;
    Playhead: IVeltVideoEditorPlayerTimelinePlayhead;
    Onboarding: IVeltVideoEditorPlayerTimelineOnboardingWireframe;
    BackspaceHint: IVeltVideoEditorPlayerTimelineBackspaceHintWireframe;
}

interface IVeltVideoEditorPlayerDownloadButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerDownloadButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerDownloadButtonWireframeProps> {
}

interface IVeltVideoEditorPlayerAddZoomButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerAddZoomButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerAddZoomButtonWireframeProps> {
}

interface IVeltVideoEditorPlayerRetakeButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerRetakeButtonWireframe extends React$1.FC<IVeltVideoEditorPlayerRetakeButtonWireframeProps> {
}

interface IVeltVideoEditorPlayerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerWireframe extends React$1.FC<IVeltVideoEditorPlayerWireframeProps> {
    Title: IVeltVideoEditorPlayerTitleWireframe;
    ApplyButton: IVeltVideoEditorPlayerApplyButtonWireframe;
    CloseButton: IVeltVideoEditorPlayerCloseButtonWireframe;
    DownloadButton: IVeltVideoEditorPlayerDownloadButtonWireframe;
    Preview: IVeltVideoEditorPlayerPreviewWireframe;
    ToggleButton: IVeltVideoEditorPlayerToggleButtonWireframe;
    Time: IVeltVideoEditorPlayerTimeWireframe;
    CurrentTime: IVeltVideoEditorPlayerCurrentTimeWireframe;
    TotalTime: IVeltVideoEditorPlayerTotalTimeWireframe;
    SplitButton: IVeltVideoEditorPlayerSplitButtonWireframe;
    DeleteButton: IVeltVideoEditorPlayerDeleteButtonWireframe;
    Timeline: IVeltVideoEditorPlayerTimelineWireframe;
    AddZoomButton: IVeltVideoEditorPlayerAddZoomButtonWireframe;
    RetakeButton: IVeltVideoEditorPlayerRetakeButtonWireframe;
}
declare const VeltVideoEditorPlayerWireframe: IVeltVideoEditorPlayerWireframe;

interface IVeltSubtitlesTextWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSubtitlesTextWireframe extends React$1.FC<IVeltSubtitlesTextWireframeProps> {
}

interface IVeltSubtitlesEmbedModeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSubtitlesEmbedModeWireframe extends React$1.FC<IVeltSubtitlesEmbedModeWireframeProps> {
    Text: IVeltSubtitlesTextWireframe;
}

interface IVeltSubtitlesPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSubtitlesPanelWireframe extends React$1.FC<IVeltSubtitlesPanelWireframeProps> {
}

interface IVeltSubtitlesButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSubtitlesButtonWireframe extends React$1.FC<IVeltSubtitlesButtonWireframeProps> {
}

interface IVeltSubtitlesTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSubtitlesTooltipWireframe extends React$1.FC<IVeltSubtitlesTooltipWireframeProps> {
}

interface IVeltSubtitlesCloseButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSubtitlesCloseButtonWireframe extends React$1.FC<IVeltSubtitlesCloseButtonWireframeProps> {
}

interface IVeltSubtitlesFloatingModeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSubtitlesFloatingModeWireframe extends React$1.FC<IVeltSubtitlesFloatingModeWireframeProps> {
    Button: IVeltSubtitlesButtonWireframe;
    Tooltip: IVeltSubtitlesTooltipWireframe;
    Panel: IVeltSubtitlesPanelWireframe;
    CloseButton: IVeltSubtitlesCloseButtonWireframe;
    Text: IVeltSubtitlesTextWireframe;
}

interface IVeltSubtitlesWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSubtitlesWireframe extends React$1.FC<IVeltSubtitlesWireframeProps> {
    EmbedMode: IVeltSubtitlesEmbedModeWireframe;
    FloatingMode: IVeltSubtitlesFloatingModeWireframe;
}
declare const VeltSubtitlesWireframe: IVeltSubtitlesWireframe;

interface IVeltTranscriptionCloseButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionCloseButtonWireframe extends React$1.FC<IVeltTranscriptionCloseButtonWireframeProps> {
}

interface IVeltTranscriptionContentItemTextWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionContentItemTextWireframe extends React$1.FC<IVeltTranscriptionContentItemTextWireframeProps> {
}

interface IVeltTranscriptionContentItemTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionContentItemTimeWireframe extends React$1.FC<IVeltTranscriptionContentItemTimeWireframeProps> {
}

interface IVeltTranscriptionContentItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionContentItemWireframe extends React$1.FC<IVeltTranscriptionContentItemWireframeProps> {
    Time: IVeltTranscriptionContentItemTimeWireframe;
    Text: IVeltTranscriptionContentItemTextWireframe;
}

interface IVeltTranscriptionContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionContentWireframe extends React$1.FC<IVeltTranscriptionContentWireframeProps> {
    Item: IVeltTranscriptionContentItemWireframe;
}

interface IVeltTranscriptionCopyLinkButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionCopyLinkButtonWireframe extends React$1.FC<IVeltTranscriptionCopyLinkButtonWireframeProps> {
}

interface IVeltTranscriptionCopyLinkTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionCopyLinkTooltipWireframe extends React$1.FC<IVeltTranscriptionCopyLinkTooltipWireframeProps> {
}

interface IVeltTranscriptionCopyLinkWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionCopyLinkWireframe extends React$1.FC<IVeltTranscriptionCopyLinkWireframeProps> {
    Button: IVeltTranscriptionCopyLinkButtonWireframe;
    Tooltip: IVeltTranscriptionCopyLinkTooltipWireframe;
}

interface IVeltTranscriptionSummaryExpandToggleOffWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionSummaryExpandToggleOffWireframe extends React$1.FC<IVeltTranscriptionSummaryExpandToggleOffWireframeProps> {
}

interface IVeltTranscriptionSummaryExpandToggleOnWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionSummaryExpandToggleOnWireframe extends React$1.FC<IVeltTranscriptionSummaryExpandToggleOnWireframeProps> {
}

interface IVeltTranscriptionSummaryExpandToggleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionSummaryExpandToggleWireframe extends React$1.FC<IVeltTranscriptionSummaryExpandToggleWireframeProps> {
    On: IVeltTranscriptionSummaryExpandToggleOnWireframe;
    Off: IVeltTranscriptionSummaryExpandToggleOffWireframe;
}

interface IVeltTranscriptionSummaryTextWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionSummaryTextWireframe extends React$1.FC<IVeltTranscriptionSummaryTextWireframeProps> {
}

interface IVeltTranscriptionSummaryWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionSummaryWireframe extends React$1.FC<IVeltTranscriptionSummaryWireframeProps> {
    ExpandToggle: IVeltTranscriptionSummaryExpandToggleWireframe;
    Text: IVeltTranscriptionSummaryTextWireframe;
}

interface IVeltTranscriptionPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionPanelWireframe extends React$1.FC<IVeltTranscriptionPanelWireframeProps> {
    CloseButton: IVeltTranscriptionCloseButtonWireframe;
    CopyLink: IVeltTranscriptionCopyLinkWireframe;
    Summary: IVeltTranscriptionSummaryWireframe;
    Content: IVeltTranscriptionContentWireframe;
}

interface IVeltTranscriptionEmbedModeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionEmbedModeWireframe extends React$1.FC<IVeltTranscriptionEmbedModeWireframeProps> {
    Panel: IVeltTranscriptionPanelWireframe;
}

interface IVeltTranscriptionPanelContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionPanelContainerWireframe extends React$1.FC<IVeltTranscriptionPanelContainerWireframeProps> {
}

interface IVeltTranscriptionButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionButtonWireframe extends React$1.FC<IVeltTranscriptionButtonWireframeProps> {
}

interface IVeltTranscriptionTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionTooltipWireframe extends React$1.FC<IVeltTranscriptionTooltipWireframeProps> {
}

interface IVeltTranscriptionFloatingModeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionFloatingModeWireframe extends React$1.FC<IVeltTranscriptionFloatingModeWireframeProps> {
    Button: IVeltTranscriptionButtonWireframe;
    Tooltip: IVeltTranscriptionTooltipWireframe;
    PanelContainer: IVeltTranscriptionPanelContainerWireframe;
    Panel: IVeltTranscriptionPanelWireframe;
}

interface IVeltTranscriptionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltTranscriptionWireframe extends React$1.FC<IVeltTranscriptionWireframeProps> {
    EmbedMode: IVeltTranscriptionEmbedModeWireframe;
    FloatingMode: IVeltTranscriptionFloatingModeWireframe;
}
declare const VeltTranscriptionWireframe: IVeltTranscriptionWireframe;

interface IVeltButtonWireframeProps extends IVeltWireframeCommonProps {
    id?: string;
    disabled?: boolean;
    active?: boolean;
    type?: 'button' | 'button-toggle' | 'multi-select' | 'single-select';
    group?: string;
}
declare const VeltButtonWireframe: React$1.FC<IVeltButtonWireframeProps>;

interface IVeltSingleEditorModePanelAcceptRequestWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelAcceptRequestWireframe extends React$1.FC<IVeltSingleEditorModePanelAcceptRequestWireframeProps> {
}

interface IVeltSingleEditorModePanelCancelRequestWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelCancelRequestWireframe extends React$1.FC<IVeltSingleEditorModePanelCancelRequestWireframeProps> {
}

interface IVeltSingleEditorModePanelCountdownWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelCountdownWireframe extends React$1.FC<IVeltSingleEditorModePanelCountdownWireframeProps> {
}

interface IVeltSingleEditorModePanelEditHereWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelEditHereWireframe extends React$1.FC<IVeltSingleEditorModePanelEditHereWireframeProps> {
}

interface IVeltSingleEditorModePanelEditorTextWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelEditorTextWireframe extends React$1.FC<IVeltSingleEditorModePanelEditorTextWireframeProps> {
}

interface IVeltSingleEditorModePanelRejectRequestWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelRejectRequestWireframe extends React$1.FC<IVeltSingleEditorModePanelRejectRequestWireframeProps> {
}

interface IVeltSingleEditorModePanelRequestAccessWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelRequestAccessWireframe extends React$1.FC<IVeltSingleEditorModePanelRequestAccessWireframeProps> {
}

interface IVeltSingleEditorModePanelViewerTextWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelViewerTextWireframe extends React$1.FC<IVeltSingleEditorModePanelViewerTextWireframeProps> {
}

interface IVeltSingleEditorModePanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltSingleEditorModePanelWireframe extends React$1.FC<IVeltSingleEditorModePanelWireframeProps> {
    RequestAccess: IVeltSingleEditorModePanelRequestAccessWireframe;
    RejectRequest: IVeltSingleEditorModePanelRejectRequestWireframe;
    ViewerText: IVeltSingleEditorModePanelViewerTextWireframe;
    EditorText: IVeltSingleEditorModePanelEditorTextWireframe;
    EditHere: IVeltSingleEditorModePanelEditHereWireframe;
    Countdown: IVeltSingleEditorModePanelCountdownWireframe;
    CancelRequest: IVeltSingleEditorModePanelCancelRequestWireframe;
    AcceptRequest: IVeltSingleEditorModePanelAcceptRequestWireframe;
}
declare const VeltSingleEditorModePanelWireframe: IVeltSingleEditorModePanelWireframe;

interface IVeltPresenceAvatarListItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPresenceAvatarListItemWireframe extends React$1.FC<IVeltPresenceAvatarListItemWireframeProps> {
}

interface IVeltPresenceAvatarListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPresenceAvatarListWireframe extends React$1.FC<IVeltPresenceAvatarListWireframeProps> {
    Item: IVeltPresenceAvatarListItemWireframe;
}

interface IVeltPresenceAvatarRemainingCountWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPresenceAvatarRemainingCountWireframe extends React$1.FC<IVeltPresenceAvatarRemainingCountWireframeProps> {
}

interface IVeltPresenceWireframeProps extends IVeltWireframeCommonProps {
    variant?: string;
}
interface IVeltPresenceWireframe extends React$1.FC<IVeltPresenceWireframeProps> {
    AvatarList: IVeltPresenceAvatarListWireframe;
    AvatarRemainingCount: IVeltPresenceAvatarRemainingCountWireframe;
}
declare const VeltPresenceWireframe: IVeltPresenceWireframe;

interface IVeltPresenceTooltipAvatarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPresenceTooltipAvatarWireframe extends React$1.FC<IVeltPresenceTooltipAvatarWireframeProps> {
}

interface IVeltPresenceTooltipUserActiveWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPresenceTooltipUserActiveWireframe extends React$1.FC<IVeltPresenceTooltipUserActiveWireframeProps> {
}

interface IVeltPresenceTooltipUserInactiveWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPresenceTooltipUserInactiveWireframe extends React$1.FC<IVeltPresenceTooltipUserInactiveWireframeProps> {
}

interface IVeltPresenceTooltipUserNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPresenceTooltipUserNameWireframe extends React$1.FC<IVeltPresenceTooltipUserNameWireframeProps> {
}

interface IVeltPresenceTooltipStatusContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltPresenceTooltipStatusContainerWireframe extends React$1.FC<IVeltPresenceTooltipStatusContainerWireframeProps> {
}

interface IVeltPresenceTooltipWireframeProps extends IVeltWireframeCommonProps {
    variant?: string;
}
interface IVeltPresenceTooltipWireframe extends React$1.FC<IVeltPresenceTooltipWireframeProps> {
    Avatar: IVeltPresenceTooltipAvatarWireframe;
    UserActive: IVeltPresenceTooltipUserActiveWireframe;
    UserInactive: IVeltPresenceTooltipUserInactiveWireframe;
    UserName: IVeltPresenceTooltipUserNameWireframe;
    StatusContainer: IVeltPresenceTooltipStatusContainerWireframe;
}
declare const VeltPresenceTooltipWireframe: IVeltPresenceTooltipWireframe;

interface IVeltCursorPointerArrowWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerArrowWireframe extends React$1.FC<IVeltCursorPointerArrowWireframeProps> {
}

interface IVeltCursorPointerAudioHuddleAvatarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerAudioHuddleAvatarWireframe extends React$1.FC<IVeltCursorPointerAudioHuddleAvatarWireframeProps> {
}

interface IVeltCursorPointerAudioHuddleAudioWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerAudioHuddleAudioWireframe extends React$1.FC<IVeltCursorPointerAudioHuddleAudioWireframeProps> {
}

interface IVeltCursorPointerAudioHuddleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerAudioHuddleWireframe extends React$1.FC<IVeltCursorPointerAudioHuddleWireframeProps> {
    Avatar: IVeltCursorPointerAudioHuddleAvatarWireframe;
    Audio: IVeltCursorPointerAudioHuddleAudioWireframe;
}

interface IVeltCursorPointerAvatarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerAvatarWireframe extends React$1.FC<IVeltCursorPointerAvatarWireframeProps> {
}

interface IVeltCursorPointerDefaultNameWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerDefaultNameWireframe extends React$1.FC<IVeltCursorPointerDefaultNameWireframeProps> {
}

interface IVeltCursorPointerDefaultCommentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerDefaultCommentWireframe extends React$1.FC<IVeltCursorPointerDefaultCommentWireframeProps> {
}

interface IVeltCursorPointerDefaultWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerDefaultWireframe extends React$1.FC<IVeltCursorPointerDefaultWireframeProps> {
    Name: IVeltCursorPointerDefaultNameWireframe;
    Comment: IVeltCursorPointerDefaultCommentWireframe;
}

interface IVeltCursorPointerVideoHuddleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerVideoHuddleWireframe extends React$1.FC<IVeltCursorPointerVideoHuddleWireframeProps> {
}

interface IVeltCursorPointerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltCursorPointerWireframe extends React$1.FC<IVeltCursorPointerWireframeProps> {
    Arrow: IVeltCursorPointerArrowWireframe;
    AudioHuddle: IVeltCursorPointerAudioHuddleWireframe;
    Avatar: IVeltCursorPointerAvatarWireframe;
    Default: IVeltCursorPointerDefaultWireframe;
    VideoHuddle: IVeltCursorPointerVideoHuddleWireframe;
}
declare const VeltCursorPointerWireframe: IVeltCursorPointerWireframe;

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

interface IVeltActivityLogHeaderProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogHeader: React$1.FC<IVeltActivityLogHeaderProps>;

interface IVeltActivityLogHeaderTitleProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogHeaderTitle: React$1.FC<IVeltActivityLogHeaderTitleProps>;

interface IVeltActivityLogHeaderCloseButtonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogHeaderCloseButton: React$1.FC<IVeltActivityLogHeaderCloseButtonProps>;

interface IVeltActivityLogHeaderFilterProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogHeaderFilter: React$1.FC<IVeltActivityLogHeaderFilterProps>;

interface IVeltActivityLogHeaderFilterTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogHeaderFilterTrigger: React$1.FC<IVeltActivityLogHeaderFilterTriggerProps>;

interface IVeltActivityLogHeaderFilterTriggerIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogHeaderFilterTriggerIcon: React$1.FC<IVeltActivityLogHeaderFilterTriggerIconProps>;

interface IVeltActivityLogHeaderFilterTriggerLabelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogHeaderFilterTriggerLabel: React$1.FC<IVeltActivityLogHeaderFilterTriggerLabelProps>;

interface IVeltActivityLogHeaderFilterContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogHeaderFilterContent: React$1.FC<IVeltActivityLogHeaderFilterContentProps>;

interface IVeltActivityLogHeaderFilterContentItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    filterOption?: string;
    isActive?: boolean;
}
declare const VeltActivityLogHeaderFilterContentItem: React$1.FC<IVeltActivityLogHeaderFilterContentItemProps>;

interface IVeltActivityLogHeaderFilterContentItemIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    isActive?: boolean;
}
declare const VeltActivityLogHeaderFilterContentItemIcon: React$1.FC<IVeltActivityLogHeaderFilterContentItemIconProps>;

interface IVeltActivityLogHeaderFilterContentItemLabelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    filterOption?: string;
}
declare const VeltActivityLogHeaderFilterContentItemLabel: React$1.FC<IVeltActivityLogHeaderFilterContentItemLabelProps>;

interface IVeltActivityLogEmptyProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogEmpty: React$1.FC<IVeltActivityLogEmptyProps>;

interface IVeltActivityLogLoadingProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogLoading: React$1.FC<IVeltActivityLogLoadingProps>;

interface IVeltActivityLogListProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltActivityLogList: React$1.FC<IVeltActivityLogListProps>;

interface IVeltActivityLogListDateGroupProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    dateGroup?: string;
}
declare const VeltActivityLogListDateGroup: React$1.FC<IVeltActivityLogListDateGroupProps>;

interface IVeltActivityLogListDateGroupLabelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    dateGroup?: string;
}
declare const VeltActivityLogListDateGroupLabel: React$1.FC<IVeltActivityLogListDateGroupLabelProps>;

interface IVeltActivityLogListShowMoreProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    dateGroup?: string;
}
declare const VeltActivityLogListShowMore: React$1.FC<IVeltActivityLogListShowMoreProps>;

interface IVeltActivityLogListItemProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItem: React$1.FC<IVeltActivityLogListItemProps>;

interface IVeltActivityLogListItemAvatarProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItemAvatar: React$1.FC<IVeltActivityLogListItemAvatarProps>;

interface IVeltActivityLogListItemIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItemIcon: React$1.FC<IVeltActivityLogListItemIconProps>;

interface IVeltActivityLogListItemTimeProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItemTime: React$1.FC<IVeltActivityLogListItemTimeProps>;

interface IVeltActivityLogListItemContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItemContent: React$1.FC<IVeltActivityLogListItemContentProps>;

interface IVeltActivityLogListItemContentUserProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItemContentUser: React$1.FC<IVeltActivityLogListItemContentUserProps>;

interface IVeltActivityLogListItemContentActionProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItemContentAction: React$1.FC<IVeltActivityLogListItemContentActionProps>;

interface IVeltActivityLogListItemContentTargetProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItemContentTarget: React$1.FC<IVeltActivityLogListItemContentTargetProps>;

interface IVeltActivityLogListItemContentDetailProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
    activityRecord?: string;
}
declare const VeltActivityLogListItemContentDetail: React$1.FC<IVeltActivityLogListItemContentDetailProps>;

interface IVeltActivityLogHeaderTitleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderTitleWireframe extends React$1.FC<IVeltActivityLogHeaderTitleWireframeProps> {
}

interface IVeltActivityLogHeaderFilterTriggerIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderFilterTriggerIconWireframe extends React$1.FC<IVeltActivityLogHeaderFilterTriggerIconWireframeProps> {
}

interface IVeltActivityLogHeaderFilterTriggerLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderFilterTriggerLabelWireframe extends React$1.FC<IVeltActivityLogHeaderFilterTriggerLabelWireframeProps> {
}

interface IVeltActivityLogHeaderFilterTriggerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderFilterTriggerWireframe extends React$1.FC<IVeltActivityLogHeaderFilterTriggerWireframeProps> {
    Icon: IVeltActivityLogHeaderFilterTriggerIconWireframe;
    Label: IVeltActivityLogHeaderFilterTriggerLabelWireframe;
}

interface IVeltActivityLogHeaderFilterContentItemIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderFilterContentItemIconWireframe extends React$1.FC<IVeltActivityLogHeaderFilterContentItemIconWireframeProps> {
}

interface IVeltActivityLogHeaderFilterContentItemLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderFilterContentItemLabelWireframe extends React$1.FC<IVeltActivityLogHeaderFilterContentItemLabelWireframeProps> {
}

interface IVeltActivityLogHeaderFilterContentItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderFilterContentItemWireframe extends React$1.FC<IVeltActivityLogHeaderFilterContentItemWireframeProps> {
    Icon: IVeltActivityLogHeaderFilterContentItemIconWireframe;
    Label: IVeltActivityLogHeaderFilterContentItemLabelWireframe;
}

interface IVeltActivityLogHeaderFilterContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderFilterContentWireframe extends React$1.FC<IVeltActivityLogHeaderFilterContentWireframeProps> {
    Item: IVeltActivityLogHeaderFilterContentItemWireframe;
}

interface IVeltActivityLogHeaderFilterWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderFilterWireframe extends React$1.FC<IVeltActivityLogHeaderFilterWireframeProps> {
    Trigger: IVeltActivityLogHeaderFilterTriggerWireframe;
    Content: IVeltActivityLogHeaderFilterContentWireframe;
}

interface IVeltActivityLogHeaderCloseButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderCloseButtonWireframe extends React$1.FC<IVeltActivityLogHeaderCloseButtonWireframeProps> {
}

interface IVeltActivityLogHeaderWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogHeaderWireframe extends React$1.FC<IVeltActivityLogHeaderWireframeProps> {
    Title: IVeltActivityLogHeaderTitleWireframe;
    Filter: IVeltActivityLogHeaderFilterWireframe;
    CloseButton: IVeltActivityLogHeaderCloseButtonWireframe;
}

interface IVeltActivityLogListDateGroupLabelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListDateGroupLabelWireframe extends React$1.FC<IVeltActivityLogListDateGroupLabelWireframeProps> {
}

interface IVeltActivityLogListDateGroupWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListDateGroupWireframe extends React$1.FC<IVeltActivityLogListDateGroupWireframeProps> {
    Label: IVeltActivityLogListDateGroupLabelWireframe;
}

interface IVeltActivityLogListItemIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemIconWireframe extends React$1.FC<IVeltActivityLogListItemIconWireframeProps> {
}

interface IVeltActivityLogListItemAvatarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemAvatarWireframe extends React$1.FC<IVeltActivityLogListItemAvatarWireframeProps> {
}

interface IVeltActivityLogListItemContentUserWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemContentUserWireframe extends React$1.FC<IVeltActivityLogListItemContentUserWireframeProps> {
}

interface IVeltActivityLogListItemContentActionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemContentActionWireframe extends React$1.FC<IVeltActivityLogListItemContentActionWireframeProps> {
}

interface IVeltActivityLogListItemContentTargetWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemContentTargetWireframe extends React$1.FC<IVeltActivityLogListItemContentTargetWireframeProps> {
}

interface IVeltActivityLogListItemContentDetailWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemContentDetailWireframe extends React$1.FC<IVeltActivityLogListItemContentDetailWireframeProps> {
}

interface IVeltActivityLogListItemContentWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemContentWireframe extends React$1.FC<IVeltActivityLogListItemContentWireframeProps> {
    User: IVeltActivityLogListItemContentUserWireframe;
    Action: IVeltActivityLogListItemContentActionWireframe;
    Target: IVeltActivityLogListItemContentTargetWireframe;
    Detail: IVeltActivityLogListItemContentDetailWireframe;
}

interface IVeltActivityLogListItemTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemTimeWireframe extends React$1.FC<IVeltActivityLogListItemTimeWireframeProps> {
}

interface IVeltActivityLogListItemWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListItemWireframe extends React$1.FC<IVeltActivityLogListItemWireframeProps> {
    Icon: IVeltActivityLogListItemIconWireframe;
    Avatar: IVeltActivityLogListItemAvatarWireframe;
    Content: IVeltActivityLogListItemContentWireframe;
    Time: IVeltActivityLogListItemTimeWireframe;
}

interface IVeltActivityLogListShowMoreWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListShowMoreWireframe extends React$1.FC<IVeltActivityLogListShowMoreWireframeProps> {
}

interface IVeltActivityLogListWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogListWireframe extends React$1.FC<IVeltActivityLogListWireframeProps> {
    DateGroup: IVeltActivityLogListDateGroupWireframe;
    Item: IVeltActivityLogListItemWireframe;
    ShowMore: IVeltActivityLogListShowMoreWireframe;
}

interface IVeltActivityLogLoadingWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogLoadingWireframe extends React$1.FC<IVeltActivityLogLoadingWireframeProps> {
}

interface IVeltActivityLogEmptyWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogEmptyWireframe extends React$1.FC<IVeltActivityLogEmptyWireframeProps> {
}

interface IVeltActivityLogWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltActivityLogWireframe extends React$1.FC<IVeltActivityLogWireframeProps> {
    Header: IVeltActivityLogHeaderWireframe;
    List: IVeltActivityLogListWireframe;
    Loading: IVeltActivityLogLoadingWireframe;
    Empty: IVeltActivityLogEmptyWireframe;
}
declare const VeltActivityLogWireframe: IVeltActivityLogWireframe;

interface IVeltCommentBubbleAvatarProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentBubbleAvatar: React$1.FC<IVeltCommentBubbleAvatarProps>;

interface IVeltCommentBubbleCommentsCountProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentBubbleCommentsCount: React$1.FC<IVeltCommentBubbleCommentsCountProps>;

interface IVeltCommentBubbleUnreadIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltCommentBubbleUnreadIcon: React$1.FC<IVeltCommentBubbleUnreadIconProps>;

interface IVeltSidebarButtonIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltSidebarButtonIcon: React$1.FC<IVeltSidebarButtonIconProps>;

interface IVeltSidebarButtonCommentsCountProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltSidebarButtonCommentsCount: React$1.FC<IVeltSidebarButtonCommentsCountProps>;

interface IVeltSidebarButtonUnreadIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltSidebarButtonUnreadIcon: React$1.FC<IVeltSidebarButtonUnreadIconProps>;

interface IVeltTextCommentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltTextComment: React$1.FC<IVeltTextCommentProps>;

interface IVeltTextCommentToolProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltTextCommentTool: React$1.FC<IVeltTextCommentToolProps>;

interface IVeltTextCommentToolbarProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltTextCommentToolbar: React$1.FC<IVeltTextCommentToolbarProps>;

interface IVeltTextCommentToolbarCommentAnnotationProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltTextCommentToolbarCommentAnnotation: React$1.FC<IVeltTextCommentToolbarCommentAnnotationProps>;

interface IVeltTextCommentToolbarDividerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltTextCommentToolbarDivider: React$1.FC<IVeltTextCommentToolbarDividerProps>;

interface IVeltTextCommentToolbarCopywriterProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltTextCommentToolbarCopywriter: React$1.FC<IVeltTextCommentToolbarCopywriterProps>;

interface IVeltTextCommentToolbarGenericProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltTextCommentToolbarGeneric: React$1.FC<IVeltTextCommentToolbarGenericProps>;

interface IVeltMultiThreadCommentDialogListProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogList: React$1.FC<IVeltMultiThreadCommentDialogListProps>;

interface IVeltMultiThreadCommentDialogPanelProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogPanel: React$1.FC<IVeltMultiThreadCommentDialogPanelProps>;

interface IVeltMultiThreadCommentDialogComposerContainerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogComposerContainer: React$1.FC<IVeltMultiThreadCommentDialogComposerContainerProps>;

interface IVeltMultiThreadCommentDialogCommentCountProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogCommentCount: React$1.FC<IVeltMultiThreadCommentDialogCommentCountProps>;

interface IVeltMultiThreadCommentDialogEmptyPlaceholderProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogEmptyPlaceholder: React$1.FC<IVeltMultiThreadCommentDialogEmptyPlaceholderProps>;

interface IVeltMultiThreadCommentDialogCloseButtonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogCloseButton: React$1.FC<IVeltMultiThreadCommentDialogCloseButtonProps>;

interface IVeltMultiThreadCommentDialogNewThreadButtonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogNewThreadButton: React$1.FC<IVeltMultiThreadCommentDialogNewThreadButtonProps>;

interface IVeltMultiThreadCommentDialogResetFilterButtonProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogResetFilterButton: React$1.FC<IVeltMultiThreadCommentDialogResetFilterButtonProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdown: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownTrigger: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownTriggerProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownContent: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterAllProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterAll: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterAllProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterReadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterRead: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterReadProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterResolvedProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterResolved: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterResolvedProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterUnreadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterUnread: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterUnreadProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSelectedIconProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownContentSelectedIcon: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSelectedIconProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortDateProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownContentSortDate: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortDateProps>;

interface IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortUnreadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalFilterDropdownContentSortUnread: React$1.FC<IVeltMultiThreadCommentDialogMinimalFilterDropdownContentSortUnreadProps>;

interface IVeltMultiThreadCommentDialogMinimalActionsDropdownProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalActionsDropdown: React$1.FC<IVeltMultiThreadCommentDialogMinimalActionsDropdownProps>;

interface IVeltMultiThreadCommentDialogMinimalActionsDropdownTriggerProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalActionsDropdownTrigger: React$1.FC<IVeltMultiThreadCommentDialogMinimalActionsDropdownTriggerProps>;

interface IVeltMultiThreadCommentDialogMinimalActionsDropdownContentProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalActionsDropdownContent: React$1.FC<IVeltMultiThreadCommentDialogMinimalActionsDropdownContentProps>;

interface IVeltMultiThreadCommentDialogMinimalActionsDropdownContentMarkAllReadProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalActionsDropdownContentMarkAllRead: React$1.FC<IVeltMultiThreadCommentDialogMinimalActionsDropdownContentMarkAllReadProps>;

interface IVeltMultiThreadCommentDialogMinimalActionsDropdownContentMarkAllResolvedProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    defaultCondition?: boolean;
}
declare const VeltMultiThreadCommentDialogMinimalActionsDropdownContentMarkAllResolved: React$1.FC<IVeltMultiThreadCommentDialogMinimalActionsDropdownContentMarkAllResolvedProps>;

declare function useVeltClient(): {
    client: Velt | null;
};

declare function useClient(): any;
declare function useIdentify(user: User, userOptions?: Options): void;
declare function useSetDocument(documentId: string, documentMetadata?: DocumentMetadata): void;
declare function useSetDocumentId(documentId: string): void;
declare function useSetDocuments(): {
    setDocuments: (documents: Document[], options?: SetDocumentsRequestOptions) => void;
};
declare function useSetRootDocument(): {
    setRootDocument: (document: Document) => void;
};
declare function useUnsetDocumentId(): void;
declare function useUnsetDocuments(): void;
declare function useSetLocation(location: Location$1, appendLocation?: boolean): void;
declare function useSetLocations(): {
    setLocations: (locations: Location$1[], options?: SetLocationsRequestOptions) => void;
};
declare function useSetRootLocation(): {
    setRootLocation: (location: Location$1) => void;
};
declare function useVeltInitState(): boolean | undefined;
declare function useUiState<T extends object = object>(): {
    uiState: T | undefined;
    setUiState: (data: T) => void;
};
declare function useHeartbeat(heartbeatConfig?: HeartbeatConfig): GetHeartbeatResponse;
declare function useCurrentUser(): User | null | undefined;
declare function useCurrentUserPermissions(): GetUserPermissionsResponse | null | undefined;

declare function useCommentUtils(): CommentElement | undefined;
declare function useCommentAnnotations(documentId?: string, location?: Location$1): CommentAnnotation[] | null | undefined;
declare function useUnreadCommentCountByAnnotationId(annotationId: string): UnreadCommentsCount;
declare function useUnreadCommentAnnotationCountOnCurrentDocument(): UnreadCommentsCount;
declare function useUnreadCommentCountOnCurrentDocument(): UnreadCommentsCount;
declare function useUnreadCommentCountByLocationId(locationId: string): UnreadCommentsCount;
declare function useUnreadCommentAnnotationCountByLocationId(locationId: string): UnreadCommentsCount;
declare function useCommentModeState(): boolean | undefined;
/**
 * @legacy Use `useCommentEventCallback('addCommentAnnotation')` event hook instead.
 */
declare function useCommentAddHandler(): CommentAddEventData | undefined;
/**
 * @legacy Use `useCommentEventCallback` event hook instead.
 */
declare function useCommentUpdateHandler(): CommentUpdateEventData | undefined;
declare function useCommentDialogSidebarClickHandler(): any;
declare function useCommentSelectionChangeHandler(): CommentSelectionChangeData | undefined;
declare function useCommentCopyLinkHandler(): {
    link: string;
} | undefined;
declare function useCommentAnnotationById(config: {
    annotationId: string;
    documentId?: string;
}): CommentAnnotation | null | undefined;
declare function useCommentSidebarActionButtonClick(): CommentSidebarCustomActionEventData | null;
declare function useCommentSidebarInit(): CommentSidebarCustomActionEventData | null;
declare function useCommentSidebarData(): CommentSidebarCustomActionEventData | null;
declare function useSetContextProvider(): {
    setContextProvider: (provider: CommentContextProvider) => void;
};

declare function useAddCommentAnnotation(): {
    addCommentAnnotation: (request: AddCommentAnnotationRequest) => Promise<AddCommentAnnotationEvent | null>;
};
declare function useApproveCommentAnnotation(): {
    approveCommentAnnotation: (request: ApproveCommentAnnotationRequest) => Promise<ApproveCommentAnnotationEvent | null>;
};
declare function useRejectCommentAnnotation(): {
    rejectCommentAnnotation: (request: RejectCommentAnnotationRequest) => Promise<RejectCommentAnnotationEvent | null>;
};
declare function useSubscribeCommentAnnotation(): {
    subscribeCommentAnnotation: (request: SubscribeCommentAnnotationRequest) => Promise<SubscribeCommentAnnotationEvent | null>;
};
declare function useUnsubscribeCommentAnnotation(): {
    unsubscribeCommentAnnotation: (request: UnsubscribeCommentAnnotationRequest) => Promise<UnsubscribeCommentAnnotationEvent | null>;
};
declare function useDeleteCommentAnnotation(): {
    deleteCommentAnnotation: (request: DeleteCommentAnnotationRequest) => Promise<DeleteCommentAnnotationEvent | null>;
};
declare function useGetCommentAnnotations(query?: CommentRequestQuery): GetCommentAnnotationsResponse;
declare function useCommentAnnotationsCount(query?: CommentRequestQuery): GetCommentAnnotationsCountResponse;
declare function useAssignUser(): {
    assignUser: (request: AssignUserRequest) => Promise<AssignUserEvent | null>;
};
declare function useUpdatePriority(): {
    updatePriority: (request: UpdatePriorityRequest) => Promise<UpdatePriorityEvent | null>;
};
declare function useUpdateStatus(): {
    updateStatus: (request: UpdateStatusRequest) => Promise<UpdateStatusEvent | null>;
};
declare function useUpdateAccess(): {
    updateAccess: (request: UpdateAccessRequest) => Promise<UpdateAccessEvent | null>;
};
declare function useResolveCommentAnnotation(): {
    resolveCommentAnnotation: (request: ResolveCommentAnnotationRequest) => Promise<ResolveCommentAnnotationRequest | null>;
};
declare function useGetLink(): {
    getLink: (request: GetLinkRequest) => Promise<GetLinkResponse | null>;
};
declare function useCopyLink(): {
    copyLink: (request: CopyLinkRequest) => Promise<CopyLinkEvent | null>;
};
declare function useAddComment(): {
    addComment: (request: AddCommentRequest) => Promise<AddCommentEvent | null>;
};
declare function useUpdateComment(): {
    updateComment: (request: UpdateCommentRequest) => Promise<UpdateCommentEvent | null>;
};
declare function useDeleteComment(): {
    deleteComment: (request: DeleteCommentRequest) => Promise<DeleteCommentEvent | null>;
};
declare function useGetComment(): {
    getComment: (request: GetCommentRequest) => Promise<Comment[]>;
};
declare function useAddAttachment(): {
    addAttachment: (request: AddAttachmentRequest) => Promise<AddAttachmentResponse[] | null>;
};
declare function useDeleteAttachment(): {
    deleteAttachment: (request: DeleteAttachmentRequest) => Promise<DeleteAttachmentEvent | null>;
};
declare function useGetAttachment(): {
    getAttachment: (request: GetAttachmentRequest) => Promise<Attachment[] | null>;
};
declare function useDeleteRecording(): {
    deleteRecording: (request: DeleteRecordingRequest) => Promise<DeleteRecordingEvent | null>;
};
declare function useGetRecording(): {
    getRecording: (request: GetRecordingRequest) => Promise<RecordedData[] | null>;
};
declare function useAddReaction(): {
    addReaction: (request: AddReactionRequest) => Promise<AddReactionEvent | null>;
};
declare function useDeleteReaction(): {
    deleteReaction: (request: DeleteReactionRequest) => Promise<DeleteReactionEvent | null>;
};
declare function useToggleReaction(): {
    toggleReaction: (request: ToggleReactionRequest) => Promise<ToggleReactionEvent | null>;
};
/**
 * @deprecated Use useCommentEventCallback hook instead.
 */
declare function useCommentActionCallback<T extends keyof CommentEventTypesMap>(action: T): CommentEventTypesMap[T];
declare function useCommentEventCallback<T extends keyof CommentEventTypesMap>(action: T): CommentEventTypesMap[T];

declare function useVeltEventCallback<T extends keyof CoreEventTypesMap>(action: T): CoreEventTypesMap[T];

declare function useCursorUtils(): CursorElement | undefined;
declare function useCursorUsers(): CursorUser[] | null;

declare function useHuddleUtils(): any | undefined;

declare class LiveStateDataConfig {
    listenToNewChangesOnly?: boolean;
}
declare function useLiveStateSyncUtils(): LiveStateSyncElement | undefined;
declare function useLiveStateData<T = unknown>(liveStateDataId?: string, liveStateDataConfig?: LiveStateDataConfig): T | undefined;
declare function useSetLiveStateData<T = unknown>(liveStateDataId: string, liveStateData: T, config?: SetLiveStateDataConfig): void;
declare function useUserEditorState(): UserEditorAccess | null | undefined;
declare function useEditor(): User | null;
declare function useEditorAccessTimer(): EditorAccessTimer;
declare function useEditorAccessRequestHandler(): {
    requestStatus: string;
    requestedBy: User;
} | null;
declare function useServerConnectionStateChangeHandler(): ServerConnectionState | undefined;
declare function useLiveState<T>(liveStateDataId: string, initialValue?: any, options?: {
    syncDuration?: number;
    resetLiveState?: boolean;
    listenToNewChangesOnly?: boolean;
}): [T, (value: T) => void, ServerConnectionState | undefined];

declare function useLiveStateSyncEventCallback<T extends keyof LiveStateEventTypesMap>(action: T): LiveStateEventTypesMap[T];

declare function usePresenceUtils(): PresenceElement | undefined;
/**
 * @deprecated Use `usePresenceData` hook instead.
 */
declare function usePresenceUsers(): PresenceUser[] | null;
declare function usePresenceData(query?: PresenceRequestQuery): GetPresenceDataResponse;

declare function usePresenceEventCallback<T extends keyof PresenceEventTypesMap>(action: T): PresenceEventTypesMap[T];

declare function useRecorderUtils(): RecorderElement | undefined;
/**
* @deprecated Use `useRecorderEventCallback('recordingDone')` hook instead
*/
declare function useRecorderAddHandler(): RecordedData | null | undefined;
/**
* @deprecated Use `recorderUtils.getRecordingData()` method instead
*/
declare function useRecordingDataByRecorderId(recorderId: string): RecordedData | null;
declare function useRecordings(query?: RecorderRequestQuery): GetRecordingsResponse[];

declare function useRecorderEventCallback<T extends keyof RecorderEventTypesMap>(action: T): RecorderEventTypesMap[T];

declare function useAIRewriterUtils(): RewriterElement | undefined;

declare function useLiveSelectionUtils(): SelectionElement | undefined;
declare function useLiveSelectionDataHandler(): LiveSelectionData | null;

declare function useTagUtils(): TagElement | undefined;
declare function useTagAnnotations(documentId?: string, location?: Location$1): TagAnnotation[] | null;

declare function useViewsUtils(): ViewsElement | undefined;
declare function useUniqueViewsByUser(clientLocationId?: string): ViewsByUser | null;
declare function useUniqueViewsByDate(clientLocationId?: string): ViewsByDate | null;

declare function useNotificationUtils(): NotificationElement | undefined;
declare function useNotificationsData(query?: GetNotificationsDataQuery): Notification[] | null;
declare function useUnreadNotificationsCount(): {
    forYou: number | null;
    all: number | null;
};
declare function useNotificationSettings(): {
    setSettings: (settings: NotificationSettingsConfig) => void;
    setSettingsInitialConfig: (settingsInitialConfig: NotificationInitialSettingsConfig[]) => void;
    settings: NotificationSettingsConfig | null;
};

declare function useNotificationEventCallback<T extends keyof NotificationEventTypesMap>(action: T): NotificationEventTypesMap[T];

declare function useAutocompleteUtils(): AutocompleteElement | undefined;
declare function useAutocompleteChipClick(): AutocompleteChipData | undefined;

declare function useContactUtils(): ContactElement | undefined;
declare function useContactSelected(): SelectedUserContact | undefined;
declare function useContactList(): GetContactListResponse | null;

declare function useCrdtUtils(): CrdtElement | undefined;

declare function useCrdtEventCallback<T extends keyof CrdtEventTypesMap>(action: T): CrdtEventTypesMap[T];

declare function useActivityUtils(): ActivityElement | undefined;
declare function useAllActivities(config?: ActivitySubscribeConfig): ActivityRecord<unknown, unknown>[] | null;

declare function useSuggestionUtils(): SuggestionElement | undefined;
declare function useSuggestionModeState(): boolean | undefined;
declare function useSuggestions(filter?: SuggestionGetSuggestionsFilter): Suggestion[] | undefined;
declare function usePendingSuggestion<T = unknown>(targetId: string): Suggestion<T> | null | undefined;

declare function useEnableSuggestionMode(): {
    enableSuggestionMode: (config?: EnableSuggestionModeConfig) => void;
};
declare function useDisableSuggestionMode(): {
    disableSuggestionMode: () => void;
};
declare function useRegisterTarget(): {
    registerTarget: <T = unknown>(config: RegisterTargetConfig<T>) => void;
};
declare function useUnregisterTarget(): {
    unregisterTarget: (targetId: string) => void;
};
declare function useStartSuggestion(): {
    startSuggestion: (targetId: string) => void;
};
declare function useCommitSuggestion(): {
    commitSuggestion: <T = unknown>(config: CommitSuggestionConfig<T>) => Promise<{
        id: string;
    }>;
};
declare function useSuggestionEventCallback<T extends keyof SuggestionEventTypesMap>(action: T): SuggestionEventTypesMap[T];

declare type LiveStateMiddlewareConfig = {
    allowedActionTypes?: Set<string>;
    disabledActionTypes?: Set<string>;
    allowAction?: (action: any) => boolean;
    liveStateDataId?: string;
};
declare const createLiveStateMiddleware: (config?: LiveStateMiddlewareConfig) => {
    middleware: (store: any) => (next: any) => (action: any) => any;
    updateLiveStateDataId: (newId?: string) => void;
    updateAllowedActionTypes: (newAllowedActionTypes?: Set<string>) => void;
    updateDisabledActionTypes: (newDisabledActionTypes?: Set<string>) => void;
    updateAllowAction: (newAllowAction?: ((action: any) => boolean) | undefined) => void;
};

export { VeltActivityLog, VeltActivityLogEmpty, VeltActivityLogHeader, VeltActivityLogHeaderCloseButton, VeltActivityLogHeaderFilter, VeltActivityLogHeaderFilterContent, VeltActivityLogHeaderFilterContentItem, VeltActivityLogHeaderFilterContentItemIcon, VeltActivityLogHeaderFilterContentItemLabel, VeltActivityLogHeaderFilterTrigger, VeltActivityLogHeaderFilterTriggerIcon, VeltActivityLogHeaderFilterTriggerLabel, VeltActivityLogHeaderTitle, VeltActivityLogList, VeltActivityLogListDateGroup, VeltActivityLogListDateGroupLabel, VeltActivityLogListItem, VeltActivityLogListItemAvatar, VeltActivityLogListItemContent, VeltActivityLogListItemContentAction, VeltActivityLogListItemContentDetail, VeltActivityLogListItemContentTarget, VeltActivityLogListItemContentUser, VeltActivityLogListItemIcon, VeltActivityLogListItemTime, VeltActivityLogListShowMore, VeltActivityLogLoading, VeltActivityLogWireframe, SnippylyArrowTool as VeltArrowTool, SnippylyArrows as VeltArrows, VeltAutocomplete, VeltAutocompleteChip, VeltAutocompleteChipTooltip, VeltAutocompleteChipTooltipDescription, VeltAutocompleteChipTooltipIcon, VeltAutocompleteChipTooltipName, VeltAutocompleteChipTooltipWireframe, VeltAutocompleteEmpty, VeltAutocompleteEmptyWireframe, VeltAutocompleteGroupOption, VeltAutocompleteGroupOptionWireframe, VeltAutocompleteOption, VeltAutocompleteOptionDescription, VeltAutocompleteOptionErrorIcon, VeltAutocompleteOptionIcon, VeltAutocompleteOptionName, VeltAutocompleteOptionWireframe, VeltAutocompleteTool, VeltButtonWireframe, VeltCanvasComment, VeltChartComment, SnippylyCommentBubble as VeltCommentBubble, VeltCommentBubbleAvatar, VeltCommentBubbleCommentsCount, VeltCommentBubbleUnreadIcon, VeltCommentBubbleWireframe, VeltCommentComposer, VeltCommentComposerWireframe, VeltCommentDialog, VeltCommentDialogAllComment, VeltCommentDialogApprove, VeltCommentDialogAssignDropdown, VeltCommentDialogAssignMenu, VeltCommentDialogAssigneeBanner, VeltCommentDialogAssigneeBannerResolveButton, VeltCommentDialogAssigneeBannerUnresolveButton, VeltCommentDialogAssigneeBannerUserAvatar, VeltCommentDialogAssigneeBannerUserName, VeltCommentDialogAttachmentButton, VeltCommentDialogBody, VeltCommentDialogCloseButton, VeltCommentDialogCommentCategory, VeltCommentDialogCommentIndex, VeltCommentDialogCommentNumber, VeltCommentDialogCommentSuggestionStatus, VeltCommentDialogComposer, VeltCommentDialogComposerActionButton, VeltCommentDialogComposerAssignUser, VeltCommentDialogComposerAttachments, VeltCommentDialogComposerAttachmentsImage, VeltCommentDialogComposerAttachmentsImageDelete, VeltCommentDialogComposerAttachmentsImageDownload, VeltCommentDialogComposerAttachmentsImageLoading, VeltCommentDialogComposerAttachmentsImagePreview, VeltCommentDialogComposerAttachmentsInvalid, VeltCommentDialogComposerAttachmentsInvalidItem, VeltCommentDialogComposerAttachmentsInvalidItemDelete, VeltCommentDialogComposerAttachmentsInvalidItemMessage, VeltCommentDialogComposerAttachmentsInvalidItemPreview, VeltCommentDialogComposerAttachmentsOther, VeltCommentDialogComposerAttachmentsOtherDelete, VeltCommentDialogComposerAttachmentsOtherDownload, VeltCommentDialogComposerAttachmentsOtherIcon, VeltCommentDialogComposerAttachmentsOtherLoading, VeltCommentDialogComposerAttachmentsOtherName, VeltCommentDialogComposerAttachmentsOtherSize, VeltCommentDialogComposerAttachmentsSelected, VeltCommentDialogComposerAvatar, VeltCommentDialogComposerFormatToolbar, VeltCommentDialogComposerFormatToolbarButton, VeltCommentDialogComposerInput, VeltCommentDialogComposerPrivateBadge, VeltCommentDialogComposerRecordings, VeltCommentDialogContextWrapper, VeltCommentDialogCopyLink, VeltCommentDialogCustomAnnotationDropdown, VeltCommentDialogCustomAnnotationDropdownContent, VeltCommentDialogCustomAnnotationDropdownContentItem, VeltCommentDialogCustomAnnotationDropdownContentItemIcon, VeltCommentDialogCustomAnnotationDropdownContentItemLabel, VeltCommentDialogCustomAnnotationDropdownTrigger, VeltCommentDialogCustomAnnotationDropdownTriggerArrow, VeltCommentDialogCustomAnnotationDropdownTriggerList, VeltCommentDialogCustomAnnotationDropdownTriggerListItem, VeltCommentDialogCustomAnnotationDropdownTriggerPlaceholder, VeltCommentDialogCustomAnnotationDropdownTriggerRemainingCount, VeltCommentDialogDeleteButton, VeltCommentDialogDeviceTypeIcons, VeltCommentDialogGhostBanner, VeltCommentDialogHeader, VeltCommentDialogHideReply, VeltCommentDialogMetadata, VeltCommentDialogMoreReply, VeltCommentDialogNavigationButton, VeltCommentDialogOptions, VeltCommentDialogOptionsDropdown, VeltCommentDialogOptionsDropdownContent, VeltCommentDialogOptionsDropdownContentAssign, VeltCommentDialogOptionsDropdownContentDelete, VeltCommentDialogOptionsDropdownContentDeleteComment, VeltCommentDialogOptionsDropdownContentDeleteThread, VeltCommentDialogOptionsDropdownContentEdit, VeltCommentDialogOptionsDropdownContentMakePrivate, VeltCommentDialogOptionsDropdownContentMakePrivateDisable, VeltCommentDialogOptionsDropdownContentMakePrivateEnable, VeltCommentDialogOptionsDropdownContentMarkAsRead, VeltCommentDialogOptionsDropdownContentMarkAsReadMarkRead, VeltCommentDialogOptionsDropdownContentMarkAsReadMarkUnread, VeltCommentDialogOptionsDropdownContentNotification, VeltCommentDialogOptionsDropdownContentNotificationSubscribe, VeltCommentDialogOptionsDropdownContentNotificationUnsubscribe, VeltCommentDialogOptionsDropdownContentWireframe, VeltCommentDialogOptionsDropdownTrigger, VeltCommentDialogOptionsDropdownTriggerWireframe, VeltCommentDialogPriority, VeltCommentDialogPriorityDropdown, VeltCommentDialogPriorityDropdownContent, VeltCommentDialogPriorityDropdownContentItem, VeltCommentDialogPriorityDropdownContentItemIcon, VeltCommentDialogPriorityDropdownContentItemName, VeltCommentDialogPriorityDropdownContentItemTick, VeltCommentDialogPriorityDropdownContentWireframe, VeltCommentDialogPriorityDropdownTrigger, VeltCommentDialogPriorityDropdownTriggerArrow, VeltCommentDialogPriorityDropdownTriggerIcon, VeltCommentDialogPriorityDropdownTriggerName, VeltCommentDialogPriorityDropdownTriggerWireframe, VeltCommentDialogPrivateBanner, VeltCommentDialogPrivateButton, VeltCommentDialogReplyAvatars, VeltCommentDialogReplyAvatarsList, VeltCommentDialogReplyAvatarsListItem, VeltCommentDialogReplyAvatarsRemainingCount, VeltCommentDialogResolveButton, VeltCommentDialogSignIn, VeltCommentDialogStatus, VeltCommentDialogStatusDropdown, VeltCommentDialogStatusDropdownContent, VeltCommentDialogStatusDropdownContentItem, VeltCommentDialogStatusDropdownContentItemIcon, VeltCommentDialogStatusDropdownContentItemName, VeltCommentDialogStatusDropdownContentWireframe, VeltCommentDialogStatusDropdownTrigger, VeltCommentDialogStatusDropdownTriggerArrow, VeltCommentDialogStatusDropdownTriggerIcon, VeltCommentDialogStatusDropdownTriggerName, VeltCommentDialogStatusDropdownTriggerWireframe, VeltCommentDialogSuggestionAction, VeltCommentDialogSuggestionActionAccept, VeltCommentDialogSuggestionActionReject, VeltCommentDialogThreadCard, VeltCommentDialogThreadCardAttachments, VeltCommentDialogThreadCardAttachmentsImage, VeltCommentDialogThreadCardAttachmentsImageDelete, VeltCommentDialogThreadCardAttachmentsImageDownload, VeltCommentDialogThreadCardAttachmentsImagePreview, VeltCommentDialogThreadCardAttachmentsOther, VeltCommentDialogThreadCardAttachmentsOtherDelete, VeltCommentDialogThreadCardAttachmentsOtherDownload, VeltCommentDialogThreadCardAttachmentsOtherIcon, VeltCommentDialogThreadCardAttachmentsOtherName, VeltCommentDialogThreadCardAttachmentsOtherSize, VeltCommentDialogThreadCardAvatar, VeltCommentDialogThreadCardDeviceType, VeltCommentDialogThreadCardDraft, VeltCommentDialogThreadCardEdited, VeltCommentDialogThreadCardMessage, VeltCommentDialogThreadCardMessageShowLess, VeltCommentDialogThreadCardMessageShowMore, VeltCommentDialogThreadCardName, VeltCommentDialogThreadCardOptions, VeltCommentDialogThreadCardReactionTool, VeltCommentDialogThreadCardReactions, VeltCommentDialogThreadCardRecordings, VeltCommentDialogThreadCardReply, VeltCommentDialogThreadCardSeenDropdown, VeltCommentDialogThreadCardSeenDropdownContent, VeltCommentDialogThreadCardSeenDropdownContentItem, VeltCommentDialogThreadCardSeenDropdownContentItemAvatar, VeltCommentDialogThreadCardSeenDropdownContentItemName, VeltCommentDialogThreadCardSeenDropdownContentItemTime, VeltCommentDialogThreadCardSeenDropdownContentItems, VeltCommentDialogThreadCardSeenDropdownContentTitle, VeltCommentDialogThreadCardSeenDropdownTrigger, VeltCommentDialogThreadCardTime, VeltCommentDialogThreadCardUnread, VeltCommentDialogThreads, VeltCommentDialogToggleReply, VeltCommentDialogToggleReplyCount, VeltCommentDialogToggleReplyIcon, VeltCommentDialogToggleReplyText, VeltCommentDialogUnresolveButton, VeltCommentDialogUpgrade, VeltCommentDialogVisibilityBanner, VeltCommentDialogVisibilityBannerDropdown, VeltCommentDialogVisibilityBannerDropdownContent, VeltCommentDialogVisibilityBannerDropdownContentItem, VeltCommentDialogVisibilityBannerDropdownContentItemIcon, VeltCommentDialogVisibilityBannerDropdownContentItemLabel, VeltCommentDialogVisibilityBannerDropdownContentUserPicker, VeltCommentDialogVisibilityBannerDropdownTrigger, VeltCommentDialogVisibilityBannerDropdownTriggerAvatarList, VeltCommentDialogVisibilityBannerDropdownTriggerAvatarListItem, VeltCommentDialogVisibilityBannerDropdownTriggerAvatarListRemainingCount, VeltCommentDialogVisibilityBannerDropdownTriggerIcon, VeltCommentDialogVisibilityBannerDropdownTriggerLabel, VeltCommentDialogVisibilityBannerIcon, VeltCommentDialogVisibilityBannerText, VeltCommentDialogVisibilityDropdown, VeltCommentDialogVisibilityDropdownContent, VeltCommentDialogVisibilityDropdownContentPrivate, VeltCommentDialogVisibilityDropdownContentPublic, VeltCommentDialogVisibilityDropdownTrigger, VeltCommentDialogVisibilityDropdownTriggerIcon, VeltCommentDialogVisibilityDropdownTriggerLabel, VeltCommentDialogWireframe, VeltCommentPin, VeltCommentPinGhostCommentIndicator, VeltCommentPinIndex, VeltCommentPinNumber, VeltCommentPinPrivateCommentIndicator, VeltCommentPinTriangle, VeltCommentPinUnreadCommentIndicator, VeltCommentPinWireframe, VeltCommentPlayerTimeline, VeltCommentText, VeltCommentThread, VeltCommentThreadWireframe, SnippylyCommentTool as VeltCommentTool, VeltCommentToolWireframe, SnippylyComments as VeltComments, VeltCommentsMinimap, SnippylyCommentsSidebar as VeltCommentsSidebar, VeltCommentsSidebarButton, VeltCommentsSidebarStatusDropdownWireframe, VeltCommentsSidebarV2, VeltCommentsSidebarV2CloseButton, VeltCommentsSidebarV2EmptyPlaceholder, VeltCommentsSidebarV2FilterDropdown, VeltCommentsSidebarV2FilterDropdownContent, VeltCommentsSidebarV2FilterDropdownContentList, VeltCommentsSidebarV2FilterDropdownContentListCategory, VeltCommentsSidebarV2FilterDropdownContentListCategoryContent, VeltCommentsSidebarV2FilterDropdownContentListItem, VeltCommentsSidebarV2FilterDropdownContentListItemIndicator, VeltCommentsSidebarV2FilterDropdownContentListItemLabel, VeltCommentsSidebarV2FilterDropdownTrigger, VeltCommentsSidebarV2FocusedThread, VeltCommentsSidebarV2FocusedThreadBackButton, VeltCommentsSidebarV2FocusedThreadDialogContainer, VeltCommentsSidebarV2Header, VeltCommentsSidebarV2List, VeltCommentsSidebarV2ListItem, VeltCommentsSidebarV2MinimalActionsDropdown, VeltCommentsSidebarV2MinimalActionsDropdownContent, VeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllRead, VeltCommentsSidebarV2MinimalActionsDropdownContentMarkAllResolved, VeltCommentsSidebarV2MinimalActionsDropdownTrigger, VeltCommentsSidebarV2PageModeComposer, VeltCommentsSidebarV2Panel, VeltCommentsSidebarV2ResetFilterButton, VeltCommentsSidebarV2Skeleton, VeltCommentsSidebarV2Wireframe, VeltCommentsSidebarWireframe, VeltConfirmDialogWireframe, SnippylyCursor as VeltCursor, VeltCursorPointerWireframe, VeltData, VeltHighChartComments, SnippylyHuddle as VeltHuddle, SnippylyHuddleTool as VeltHuddleTool, VeltIf, VeltInlineCommentsSection, VeltInlineCommentsSectionCommentCount, VeltInlineCommentsSectionComposerContainer, VeltInlineCommentsSectionFilterDropdown, VeltInlineCommentsSectionFilterDropdownContent, VeltInlineCommentsSectionFilterDropdownContentList, VeltInlineCommentsSectionFilterDropdownContentListItem, VeltInlineCommentsSectionFilterDropdownContentListItemCheckbox, VeltInlineCommentsSectionFilterDropdownContentListItemLabel, VeltInlineCommentsSectionFilterDropdownTrigger, VeltInlineCommentsSectionFilterDropdownTriggerArrow, VeltInlineCommentsSectionFilterDropdownTriggerName, VeltInlineCommentsSectionList, VeltInlineCommentsSectionPanel, VeltInlineCommentsSectionSkeleton, VeltInlineCommentsSectionSortingDropdown, VeltInlineCommentsSectionSortingDropdownContent, VeltInlineCommentsSectionSortingDropdownContentItem, VeltInlineCommentsSectionSortingDropdownContentItemIcon, VeltInlineCommentsSectionSortingDropdownContentItemName, VeltInlineCommentsSectionSortingDropdownContentItemTick, VeltInlineCommentsSectionSortingDropdownTrigger, VeltInlineCommentsSectionSortingDropdownTriggerIcon, VeltInlineCommentsSectionSortingDropdownTriggerName, VeltInlineCommentsSectionWireframe, VeltInlineReactionsSection, VeltInlineReactionsSectionWireframe, VeltMediaSourceSettingsWireframe, VeltMultiThreadCommentDialogCloseButton, VeltMultiThreadCommentDialogCommentCount, VeltMultiThreadCommentDialogComposerContainer, VeltMultiThreadCommentDialogEmptyPlaceholder, VeltMultiThreadCommentDialogList, VeltMultiThreadCommentDialogMinimalActionsDropdown, VeltMultiThreadCommentDialogMinimalActionsDropdownContent, VeltMultiThreadCommentDialogMinimalActionsDropdownContentMarkAllRead, VeltMultiThreadCommentDialogMinimalActionsDropdownContentMarkAllResolved, VeltMultiThreadCommentDialogMinimalActionsDropdownTrigger, VeltMultiThreadCommentDialogMinimalFilterDropdown, VeltMultiThreadCommentDialogMinimalFilterDropdownContent, VeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterAll, VeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterRead, VeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterResolved, VeltMultiThreadCommentDialogMinimalFilterDropdownContentFilterUnread, VeltMultiThreadCommentDialogMinimalFilterDropdownContentSelectedIcon, VeltMultiThreadCommentDialogMinimalFilterDropdownContentSortDate, VeltMultiThreadCommentDialogMinimalFilterDropdownContentSortUnread, VeltMultiThreadCommentDialogMinimalFilterDropdownTrigger, VeltMultiThreadCommentDialogNewThreadButton, VeltMultiThreadCommentDialogPanel, VeltMultiThreadCommentDialogResetFilterButton, VeltMultiThreadCommentDialogWireframe, VeltNivoChartComments, VeltNotificationsHistoryPanel, VeltNotificationsPanel, VeltNotificationsPanelCloseButton, VeltNotificationsPanelContent, VeltNotificationsPanelContentAll, VeltNotificationsPanelContentAllList, VeltNotificationsPanelContentAllListItem, VeltNotificationsPanelContentAllListItemContent, VeltNotificationsPanelContentAllListItemLabel, VeltNotificationsPanelContentAllReadContainer, VeltNotificationsPanelContentDocuments, VeltNotificationsPanelContentDocumentsList, VeltNotificationsPanelContentDocumentsListItem, VeltNotificationsPanelContentDocumentsListItemContent, VeltNotificationsPanelContentDocumentsListItemCount, VeltNotificationsPanelContentDocumentsListItemName, VeltNotificationsPanelContentDocumentsListItemUnread, VeltNotificationsPanelContentForYou, VeltNotificationsPanelContentList, VeltNotificationsPanelContentListItem, VeltNotificationsPanelContentListItemAvatar, VeltNotificationsPanelContentListItemBody, VeltNotificationsPanelContentListItemFileName, VeltNotificationsPanelContentListItemHeadline, VeltNotificationsPanelContentListItemTime, VeltNotificationsPanelContentListItemUnread, VeltNotificationsPanelContentLoadMore, VeltNotificationsPanelContentPeople, VeltNotificationsPanelContentPeopleList, VeltNotificationsPanelContentPeopleListItem, VeltNotificationsPanelContentPeopleListItemAvatar, VeltNotificationsPanelContentPeopleListItemContent, VeltNotificationsPanelContentPeopleListItemCount, VeltNotificationsPanelContentPeopleListItemName, VeltNotificationsPanelHeader, VeltNotificationsPanelHeaderTabAll, VeltNotificationsPanelHeaderTabDocuments, VeltNotificationsPanelHeaderTabForYou, VeltNotificationsPanelHeaderTabPeople, VeltNotificationsPanelReadAllButton, VeltNotificationsPanelSettings, VeltNotificationsPanelSettingsAccordion, VeltNotificationsPanelSettingsAccordionContent, VeltNotificationsPanelSettingsAccordionContentItem, VeltNotificationsPanelSettingsAccordionContentItemIcon, VeltNotificationsPanelSettingsAccordionContentItemLabel, VeltNotificationsPanelSettingsAccordionTrigger, VeltNotificationsPanelSettingsAccordionTriggerIcon, VeltNotificationsPanelSettingsAccordionTriggerLabel, VeltNotificationsPanelSettingsAccordionTriggerSelectedValue, VeltNotificationsPanelSettingsBackButton, VeltNotificationsPanelSettingsButton, VeltNotificationsPanelSettingsDescription, VeltNotificationsPanelSettingsFooter, VeltNotificationsPanelSettingsHeader, VeltNotificationsPanelSettingsHeaderTitle, VeltNotificationsPanelSettingsList, VeltNotificationsPanelSettingsMuteAllDescription, VeltNotificationsPanelSettingsMuteAllTitle, VeltNotificationsPanelSettingsMuteAllToggle, VeltNotificationsPanelSettingsTitle, VeltNotificationsPanelSkeleton, VeltNotificationsPanelTitle, VeltNotificationsPanelTitleText, VeltNotificationsPanelViewAllButton, VeltNotificationsPanelWireframe, VeltNotificationsTool, VeltNotificationsToolIcon, VeltNotificationsToolLabel, VeltNotificationsToolUnreadCount, VeltNotificationsToolUnreadIcon, VeltNotificationsToolWireframe, VeltPersistentCommentModeWireframe, SnippylyPresence as VeltPresence, VeltPresenceTooltipWireframe, VeltPresenceWireframe, SnippylyProvider as VeltProvider, VeltReactionPinTooltipWireframe, VeltReactionPinWireframe, VeltReactionTool, VeltReactionToolWireframe, VeltReactionsPanelWireframe, VeltRecorderAllToolMenuWireframe, VeltRecorderAllToolWireframe, VeltRecorderAudioToolWireframe, SnippylyRecorderControlPanel as VeltRecorderControlPanel, VeltRecorderControlPanelWireframe, SnippylyRecorderNotes as VeltRecorderNotes, SnippylyRecorderPlayer as VeltRecorderPlayer, VeltRecorderPlayerExpandedWireframe, VeltRecorderPlayerWireframe, VeltRecorderScreenToolWireframe, SnippylyRecorderTool as VeltRecorderTool, VeltRecorderVideoToolWireframe, VeltRecordingPreviewStepsDialogWireframe, SnippylySidebarButton as VeltSidebarButton, VeltSidebarButtonCommentsCount, VeltSidebarButtonIcon, VeltSidebarButtonUnreadIcon, VeltSidebarButtonWireframe, VeltSingleEditorModePanel, VeltSingleEditorModePanelWireframe, VeltSubtitlesWireframe, SnippylyTagTool as VeltTagTool, SnippylyTags as VeltTags, VeltTextComment, VeltTextCommentTool, VeltTextCommentToolWireframe, VeltTextCommentToolbar, VeltTextCommentToolbarCommentAnnotation, VeltTextCommentToolbarCopywriter, VeltTextCommentToolbarDivider, VeltTextCommentToolbarGeneric, VeltTextCommentToolbar$1 as VeltTextCommentToolbarWireframe, VeltTranscriptionWireframe, SnippylyUserInviteTool as VeltUserInviteTool, SnippylyUserRequestTool as VeltUserRequestTool, VeltUserSelectorDropdown as VeltUserSelectorDropdownWireframe, VeltVideoEditor, VeltVideoEditorPlayerWireframe, VeltVideoPlayer, VeltViewAnalytics, VeltWireframe, createLiveStateMiddleware, useAIRewriterUtils, useActivityUtils, useAddAttachment, useAddComment, useAddCommentAnnotation, useAddReaction, useAllActivities, useApproveCommentAnnotation, useAssignUser, useAutocompleteChipClick, useAutocompleteUtils, useClient, useCommentActionCallback, useCommentAddHandler, useCommentAnnotationById, useCommentAnnotations, useCommentAnnotationsCount, useCommentCopyLinkHandler, useCommentDialogSidebarClickHandler, useCommentEventCallback, useCommentModeState, useCommentSelectionChangeHandler, useCommentSidebarActionButtonClick, useCommentSidebarData, useCommentSidebarInit, useCommentUpdateHandler, useCommentUtils, useCommitSuggestion, useContactList, useContactSelected, useContactUtils, useCopyLink, useCrdtEventCallback, useCrdtUtils, useCurrentUser, useCurrentUserPermissions, useCursorUsers, useCursorUtils, useDeleteAttachment, useDeleteComment, useDeleteCommentAnnotation, useDeleteReaction, useDeleteRecording, useDisableSuggestionMode, useEditor, useEditorAccessRequestHandler, useEditorAccessTimer, useEnableSuggestionMode, useGetAttachment, useGetComment, useGetCommentAnnotations, useGetLink, useGetRecording, useHeartbeat, useHuddleUtils, useIdentify, useLiveSelectionDataHandler, useLiveSelectionUtils, useLiveState, useLiveStateData, useLiveStateSyncEventCallback, useLiveStateSyncUtils, useNotificationEventCallback, useNotificationSettings, useNotificationUtils, useNotificationsData, usePendingSuggestion, usePresenceData, usePresenceEventCallback, usePresenceUsers, usePresenceUtils, useRecorderAddHandler, useRecorderEventCallback, useRecorderUtils, useRecordingDataByRecorderId, useRecordings, useRegisterTarget, useRejectCommentAnnotation, useResolveCommentAnnotation, useServerConnectionStateChangeHandler, useSetContextProvider, useSetDocument, useSetDocumentId, useSetDocuments, useSetLiveStateData, useSetLocation, useSetLocations, useSetRootDocument, useSetRootLocation, useStartSuggestion, useSubscribeCommentAnnotation, useSuggestionEventCallback, useSuggestionModeState, useSuggestionUtils, useSuggestions, useTagAnnotations, useTagUtils, useToggleReaction, useUiState, useUniqueViewsByDate, useUniqueViewsByUser, useUnreadCommentAnnotationCountByLocationId, useUnreadCommentAnnotationCountOnCurrentDocument, useUnreadCommentCountByAnnotationId, useUnreadCommentCountByLocationId, useUnreadCommentCountOnCurrentDocument, useUnreadNotificationsCount, useUnregisterTarget, useUnsetDocumentId, useUnsetDocuments, useUnsubscribeCommentAnnotation, useUpdateAccess, useUpdateComment, useUpdatePriority, useUpdateStatus, useUserEditorState, useVeltClient, useVeltEventCallback, useVeltInitState, useViewsUtils };