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

interface IVeltProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    apiKey: string;
    config?: Config & {
        proxyDomain?: string;
        version?: string;
    };
    user?: any;
    documentId?: string;
    language?: string;
    translations?: {
        [languageCode: string]: {
            [input: string]: string;
        };
    };
    autoTranslation?: boolean;
    userDataProvider?: UserDataProvider;
    dataProviders?: VeltDataProvider;
    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;
    commentCountType?: 'total' | 'unread';
}
declare const SnippylyCommentBubble: React$1.FC<IVeltCommentBubbleProps>;

interface IVeltCommentsProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    streamViewContainerId?: string;
    autoCategorize?: boolean;
    onSignIn?: Function;
    onUpgrade?: Function;
    textMode?: boolean;
    popoverMode?: boolean;
    popoverTriangleComponent?: boolean;
    floatingCommentDialog?: boolean;
    moderatorMode?: boolean;
    streamMode?: boolean;
    signInButton?: boolean;
    upgradeButton?: boolean;
    attachments?: boolean;
    /**
     * Pass `all` to allow all type of recordings.
     * Pass `none` to disable all type of recordings.
     * Pass `string` to allow specific type of recordings.
     * For example: `audio` or `video` or `screen` or any combination like `audio,video`.
     */
    recordings?: string;
    reactions?: boolean;
    deviceInfo?: boolean;
    commentIndex?: boolean;
    dialogOnHover?: boolean;
    dialogOnTargetElementClick?: boolean;
    priority?: boolean;
    status?: boolean;
    resolveButton?: boolean;
    inboxMode?: boolean;
    suggestionMode?: boolean;
    mobileMode?: boolean;
    inlineCommentMode?: boolean;
    privateCommentMode?: boolean;
    minimap?: boolean;
    minimapPosition?: string;
    persistentCommentMode?: boolean;
    ghostComments?: boolean;
    ghostCommentsIndicator?: boolean;
    commentsOnDom?: boolean;
    resolvedCommentsOnDom?: boolean;
    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;
    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;
}
declare const SnippylyComments: React$1.FC<IVeltCommentsProps>;

declare class FilterTypeConfig$2 {
    name?: string;
    enable?: boolean;
    multiSelection?: boolean;
    enableGrouping?: boolean;
    order?: string[];
}
declare class CommentSidebarFilterConfig$2 {
    location?: FilterTypeConfig$2;
    people?: FilterTypeConfig$2;
    tagged?: FilterTypeConfig$2;
    assigned?: FilterTypeConfig$2;
    priority?: FilterTypeConfig$2;
    category?: FilterTypeConfig$2;
    commentType?: FilterTypeConfig$2;
    status?: FilterTypeConfig$2;
}
declare class CommentSidebarGroupConfig$2 {
    enable?: boolean;
    name?: string;
}
declare class CommentSidebarFilters$2 {
    location?: Location[];
    people?: {
        userId?: string;
        email?: string;
    }[];
    tagged?: {
        userId?: string;
        email?: string;
    }[];
    assigned?: {
        userId?: string;
        email?: string;
    }[];
    priority?: string[];
    status?: string[];
    category?: string[];
}
interface IVeltCommentsSidebarProps {
    embedMode?: boolean;
    floatingMode?: boolean;
    /**
     * @deprecated Use `urlNavigation` instead
     */
    enableUrlNavigation?: boolean;
    urlNavigation?: boolean;
    queryParamsComments?: boolean;
    pageMode?: boolean;
    currentLocationSuffix?: boolean;
    variant?: string;
    pageModeComposerVariant?: string;
    dialogVariant?: string;
    shadowDom?: boolean;
    sortData?: 'asc' | 'desc' | 'none';
    filterConfig?: CommentSidebarFilterConfig$2;
    groupConfig?: CommentSidebarGroupConfig$2;
    filters?: CommentSidebarFilters$2;
    excludeLocationIds?: string[];
    /**
     * @deprecated Use `onSidebarOpen` instead
     */
    openSidebar?: Function;
    onSidebarOpen?: Function;
    /**
     * @deprecated Use `onCommentClick` instead
     */
    onSidebarCommentClick?: Function;
    onCommentClick?: Function;
    onSidebarClose?: Function;
    onCommentNavigationButtonClick?: Function;
    darkMode?: boolean;
    position?: "right" | "left";
    filterPanelLayout?: 'menu' | 'bottomSheet';
    customActions?: boolean;
    focusedThreadDialogVariant?: string;
    focusedThreadMode?: boolean;
    searchPlaceholder?: string;
    filterOptionLayout?: 'checkbox' | 'dropdown';
    filterCount?: boolean;
    fullExpanded?: boolean;
}
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;
    variant?: string;
    shadowDom?: 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;
}
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;
    documentParams?: any;
    location?: any;
    /**
     * @deprecated Use `onPresenceUserChange` instead
     */
    onUsersChanged?: Function;
    onPresenceUserChange?: Function;
    flockMode?: boolean;
    /**
     * @deprecated Use `defaultFlockNavigation` instead
     */
    disableFlockNavigation?: boolean;
    defaultFlockNavigation?: boolean;
    self?: 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?: Function;
    recordingCountdown?: boolean;
    recordingTranscription?: boolean;
    videoEditor?: 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;
}
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;
}
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;
}
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';
    onCommentClick?: Function;
    onSidebarOpen?: Function;
}
declare const SnippylySidebarButton: React$1.FC<IVeltSidebarButtonProps>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

interface IVeltCommentDialogAllCommentProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogApproveProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssignMenuProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerResolveButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerUserAvatarProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerUserNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogAssigneeBannerUnresolveButtonProps extends IVeltWireframeCommonProps {
}

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

interface IVeltCommentDialogBodyProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCommentCategoryProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCommentIndexProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogCommentSuggestionStatusProps extends IVeltWireframeCommonProps {
}

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

interface IVeltCommentDialogComposerAssignUserProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsInvalidItemPreviewProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsInvalidItemMessageProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsInvalidItemDeleteProps extends IVeltWireframeCommonProps {
}

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

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

interface IVeltCommentDialogComposerAttachmentsImagePreviewProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsImageDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsImageLoadingProps extends IVeltWireframeCommonProps {
}

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

interface IVeltCommentDialogComposerAttachmentsOtherDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherIconProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherLoadingProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAttachmentsOtherSizeProps extends IVeltWireframeCommonProps {
}

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

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

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

interface IVeltCommentDialogComposerInputProps extends IVeltWireframeCommonProps {
    placeholder?: string;
}

interface IVeltCommentDialogComposerRecordingsProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerPrivateBadgeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogComposerAvatarProps extends IVeltWireframeCommonProps {
}

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

interface IVeltCommentDialogCopyLinkProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogGhostBannerProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogHeaderProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogMoreReplyProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogOptionsDropdownContentAssignWireframeProps extends IVeltWireframeCommonProps {
}

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

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

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

interface IVeltCommentDialogOptionsDropdownContentEditWireframeProps extends IVeltWireframeCommonProps {
}

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

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

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

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

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

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

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

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

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

interface IVeltCommentDialogPriorityDropdownContentItemIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownContentItemNameWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownContentItemTickWireframeProps extends IVeltWireframeCommonProps {
}

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

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

interface IVeltCommentDialogPriorityDropdownTriggerArrowWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownTriggerIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogPriorityDropdownTriggerNameWireframeProps extends IVeltWireframeCommonProps {
}

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

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

interface IVeltCommentDialogPrivateBannerProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogResolveButtonProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogSignInProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownContentItemIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownContentItemNameWireframeProps extends IVeltWireframeCommonProps {
}

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

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

interface IVeltCommentDialogStatusDropdownTriggerArrowWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownTriggerIconWireframeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogStatusDropdownTriggerNameWireframeProps extends IVeltWireframeCommonProps {
}

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

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

interface IVeltCommentDialogSuggestionActionAcceptProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogSuggestionActionRejectProps extends IVeltWireframeCommonProps {
}

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

interface IVeltCommentDialogThreadCardAttachmentsImagePreviewProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsImageDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsImageDownloadProps extends IVeltWireframeCommonProps {
}

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

interface IVeltCommentDialogThreadCardAttachmentsOtherDeleteProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherDownloadProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherIconProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherNameProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardAttachmentsOtherSizeProps extends IVeltWireframeCommonProps {
}

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

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

interface IVeltCommentDialogThreadCardAvatarProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardDeviceTypeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardDraftProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardMessageProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardNameProps extends IVeltWireframeCommonProps {
}

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

interface IVeltCommentDialogThreadCardReactionToolProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardReactionsProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardRecordingsProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardTimeProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentDialogThreadCardUnreadProps extends IVeltWireframeCommonProps {
}

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

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

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

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

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

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

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

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

interface IVeltCommentDialogThreadCardSeenDropdownProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCardSeenDropdown extends React$1.FC<IVeltCommentDialogThreadCardSeenDropdownProps> {
    Trigger: IVeltCommentDialogThreadCardSeenDropdownTrigger;
    Content: IVeltCommentDialogThreadCardSeenDropdownContent;
}

interface IVeltCommentDialogThreadCardProps extends IVeltWireframeCommonProps {
}
interface IVeltCommentDialogThreadCard extends React$1.FC<IVeltCommentDialogThreadCardProps> {
    Avatar: React$1.FC<IVeltCommentDialogThreadCardAvatarProps>;
    DeviceType: React$1.FC<IVeltCommentDialogThreadCardDeviceTypeProps>;
    Attachments: IVeltCommentDialogThreadCardAttachments;
    Message: React$1.FC<IVeltCommentDialogThreadCardMessageProps>;
    Name: React$1.FC<IVeltCommentDialogThreadCardNameProps>;
    Options: IVeltCommentDialogThreadCardOptions;
    Reactions: React$1.FC<IVeltCommentDialogThreadCardReactionsProps>;
    ReactionTool: React$1.FC<IVeltCommentDialogThreadCardReactionToolProps>;
    Recordings: React$1.FC<IVeltCommentDialogThreadCardRecordingsProps>;
    Time: React$1.FC<IVeltCommentDialogThreadCardTimeProps>;
    Unread: React$1.FC<IVeltCommentDialogThreadCardUnreadProps>;
    Draft: React$1.FC<IVeltCommentDialogThreadCardDraftProps>;
    SeenDropdown: IVeltCommentDialogThreadCardSeenDropdown;
}

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 IVeltCommentDialogWireframeProps extends IVeltWireframeCommonProps {
}
declare const VeltCommentDialogWireframe: React$1.FC<IVeltCommentDialogWireframeProps> & {
    AllComment: React$1.FC<IVeltCommentDialogAllCommentProps>;
    Approve: React$1.FC<IVeltCommentDialogApproveProps>;
    AssigneeBanner: IVeltCommentDialogAssigneeBanner;
    AssignMenu: React$1.FC<IVeltCommentDialogAssignMenuProps>;
    Body: React$1.FC<IVeltCommentDialogBodyProps>;
    CommentCategory: React$1.FC<IVeltCommentDialogCommentCategoryProps>;
    CommentIndex: React$1.FC<IVeltCommentDialogCommentIndexProps>;
    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>;
};

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 {
}
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 {
}
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 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;
}

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 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 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;
    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 {
}

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 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;
    MinimalActionsDropdown: IVeltCommentsSidebarMinimalActionsDropdownWireframe;
    ResetFilterButton: React$1.FC<IVeltCommentsSidebarResetFilterButtonWireframeProps>;
    ActionButton: React$1.FC<IVeltCommentsSidebarActionButtonProps>;
    FocusedThread: IVeltCommentsSidebarFocusedThread;
};

interface IVeltCommentPinGhostCommentIndicatorProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinIndexProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinTriangleProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinUnreadCommentIndicatorProps extends IVeltWireframeCommonProps {
}

interface IVeltCommentPinPrivateCommentIndicatorProps extends IVeltWireframeCommonProps {
}

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

interface IVeltSidebarButtonCommentsCountProps extends IVeltWireframeCommonProps {
}

interface IVeltSidebarButtonIconProps extends IVeltWireframeCommonProps {
}

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

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

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

interface IVeltTextCommentToolbarCommentAnnotationProps extends IVeltWireframeCommonProps {
}

interface IVeltTextCommentToolbarCopywriterProps extends IVeltWireframeCommonProps {
}

interface IVeltTextCommentToolbarGenericProps extends IVeltWireframeCommonProps {
}

interface IVeltTextCommentToolbarDividerProps extends IVeltWireframeCommonProps {
}

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

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 IVeltCommentBubbleAvatarProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
}

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

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>;
    CommentsCount: React$1.FC<IVeltCommentBubbleCommentsCountProps>;
}
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 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;
}
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 IVeltNotificationsPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltNotificationsPanelWireframe extends React$1.FC<IVeltNotificationsPanelWireframeProps> {
    Content: IVeltNotificationsPanelContentWireframe;
    Header: IVeltNotificationsPanelHeaderWireframe;
    ReadAllButton: IVeltNotificationsPanelReadAllButtonWireframe;
    Title: IVeltNotificationsPanelTitleWireframe;
    ViewAllButton: IVeltNotificationsPanelViewAllButtonWireframe;
    CloseButton: IVeltNotificationsPanelCloseButtonWireframe;
    Skeleton: IVeltNotificationsPanelSkeletonWireframe;
}
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 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;
    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 IVeltRecorderControlPanelFloatingModeScreenVideoWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelFloatingModeScreenVideoWireframe extends React$1.FC<IVeltRecorderControlPanelFloatingModeScreenVideoWireframeProps> {
}

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 IVeltRecorderControlPanelActionBarToggleWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelActionBarToggleWireframe extends React$1.FC<IVeltRecorderControlPanelActionBarToggleWireframeProps> {
    Pause: IVeltRecorderControlPanelActionBarTogglePlayWireframe;
    Play: IVeltRecorderControlPanelActionBarTogglePlayWireframe;
}

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

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

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 IVeltRecorderControlPanelFloatingModeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderControlPanelFloatingModeWireframe extends React$1.FC<IVeltRecorderControlPanelFloatingModeWireframeProps> {
    Container: IVeltRecorderControlPanelFloatingModeContainerWireframe;
    ScreenVideo: IVeltRecorderControlPanelFloatingModeScreenVideoWireframe;
    Waveform: IVeltRecorderControlPanelFloatingModeWaveformWireframe;
    Video: IVeltRecorderControlPanelVideoWireframe;
    CollapsedButton: IVeltRecorderControlPanelCollapsedButtonWireframe;
    Paused: IVeltRecorderControlPanelPausedWireframe;
    Loading: IVeltRecorderControlPanelLoadingWireframe;
    ActionBar: IVeltRecorderControlPanelActionBarWireframe;
}

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

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 IVeltRecorderPlayerVideoContainerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltRecorderPlayerVideoContainerWireframe extends React$1.FC<IVeltRecorderPlayerVideoContainerWireframeProps> {
    Video: IVeltRecorderPlayerVideoWireframe;
    Timeline: IVeltRecorderPlayerTimelineWireframe;
    PlayButton: IVeltRecorderPlayerPlayButtonWireframe;
    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 IVeltVideoPlayerControlsDeleteButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsDeleteButtonWireframe extends React$1.FC<IVeltVideoPlayerControlsDeleteButtonWireframeProps> {
}

interface IVeltVideoPlayerControlsProgressBarWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsProgressBarWireframe extends React$1.FC<IVeltVideoPlayerControlsProgressBarWireframeProps> {
}

interface IVeltVideoPlayerControlsSettingsButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsSettingsButtonWireframe extends React$1.FC<IVeltVideoPlayerControlsSettingsButtonWireframeProps> {
}

interface IVeltVideoPlayerControlsSubtitleButtonIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsSubtitleButtonIconWireframe extends React$1.FC<IVeltVideoPlayerControlsSubtitleButtonIconWireframeProps> {
}

interface IVeltVideoPlayerControlsSubtitleButtonTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsSubtitleButtonTooltipWireframe extends React$1.FC<IVeltVideoPlayerControlsSubtitleButtonTooltipWireframeProps> {
}

interface IVeltVideoPlayerControlsSubtitleButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsSubtitleButtonWireframe extends React$1.FC<IVeltVideoPlayerControlsSubtitleButtonWireframeProps> {
    Icon: IVeltVideoPlayerControlsSubtitleButtonIconWireframe;
    Tooltip: IVeltVideoPlayerControlsSubtitleButtonTooltipWireframe;
}

interface IVeltVideoPlayerControlsTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsTimeWireframe extends React$1.FC<IVeltVideoPlayerControlsTimeWireframeProps> {
}

interface IVeltVideoPlayerControlsTogglePauseWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsTogglePauseWireframe extends React$1.FC<IVeltVideoPlayerControlsTogglePauseWireframeProps> {
}

interface IVeltVideoPlayerControlsTogglePlayWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsTogglePlayWireframe extends React$1.FC<IVeltVideoPlayerControlsTogglePlayWireframeProps> {
}

interface IVeltVideoPlayerControlsToggleButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsToggleButtonWireframe extends React$1.FC<IVeltVideoPlayerControlsToggleButtonWireframeProps> {
    Play: IVeltVideoPlayerControlsTogglePlayWireframe;
    Pause: IVeltVideoPlayerControlsTogglePauseWireframe;
}

interface IVeltVideoPlayerControlsTranscriptionIconWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsTranscriptionIconWireframe extends React$1.FC<IVeltVideoPlayerControlsTranscriptionIconWireframeProps> {
}

interface IVeltVideoPlayerControlsTranscriptionTooltipWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsTranscriptionTooltipWireframe extends React$1.FC<IVeltVideoPlayerControlsTranscriptionTooltipWireframeProps> {
}

interface IVeltVideoPlayerControlsTranscriptionButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsTranscriptionButtonWireframe extends React$1.FC<IVeltVideoPlayerControlsTranscriptionButtonWireframeProps> {
    Icon: IVeltVideoPlayerControlsTranscriptionIconWireframe;
    Tooltip: IVeltVideoPlayerControlsTranscriptionTooltipWireframe;
}

interface IVeltVideoPlayerControlsVolumeButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsVolumeButtonWireframe extends React$1.FC<IVeltVideoPlayerControlsVolumeButtonWireframeProps> {
}

interface IVeltVideoPlayerControlsCurrentTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsCurrentTimeWireframe extends React$1.FC<IVeltVideoPlayerControlsCurrentTimeWireframeProps> {
}

interface IVeltVideoPlayerControlsTotalTimeWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsTotalTimeWireframe extends React$1.FC<IVeltVideoPlayerControlsTotalTimeWireframeProps> {
}

interface IVeltVideoPlayerControlsWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerControlsWireframe extends React$1.FC<IVeltVideoPlayerControlsWireframeProps> {
    DeleteButton: IVeltVideoPlayerControlsDeleteButtonWireframe;
    ProgressBar: IVeltVideoPlayerControlsProgressBarWireframe;
    SettingsButton: IVeltVideoPlayerControlsSettingsButtonWireframe;
    SubtitleButton: IVeltVideoPlayerControlsSubtitleButtonWireframe;
    Time: IVeltVideoPlayerControlsTimeWireframe;
    TranscriptionButton: IVeltVideoPlayerControlsTranscriptionButtonWireframe;
    ToggleButton: IVeltVideoPlayerControlsToggleButtonWireframe;
    VolumeButton: IVeltVideoPlayerControlsVolumeButtonWireframe;
    CurrentTime: IVeltVideoPlayerControlsCurrentTimeWireframe;
    TotalTime: IVeltVideoPlayerControlsTotalTimeWireframe;
}

interface IVeltVideoPlayerCopyLinkWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerCopyLinkWireframe extends React$1.FC<IVeltVideoPlayerCopyLinkWireframeProps> {
}

interface IVeltVideoPlayerDisplayWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerDisplayWireframe extends React$1.FC<IVeltVideoPlayerDisplayWireframeProps> {
}

interface IVeltVideoPlayerMinimizeButtonWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerMinimizeButtonWireframe extends React$1.FC<IVeltVideoPlayerMinimizeButtonWireframeProps> {
}

interface IVeltVideoPlayerPanelWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerPanelWireframe extends React$1.FC<IVeltVideoPlayerPanelWireframeProps> {
}

interface IVeltVideoPlayerSubtitlesWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerSubtitlesWireframe extends React$1.FC<IVeltVideoPlayerSubtitlesWireframeProps> {
}

interface IVeltVideoPlayerTranscriptionWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerTranscriptionWireframe extends React$1.FC<IVeltVideoPlayerTranscriptionWireframeProps> {
}

interface IVeltVideoPlayerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoPlayerWireframe extends React$1.FC<IVeltVideoPlayerWireframeProps> {
    Controls: IVeltVideoPlayerControlsWireframe;
    CopyLink: IVeltVideoPlayerCopyLinkWireframe;
    Display: IVeltVideoPlayerDisplayWireframe;
    MinimizeButton: IVeltVideoPlayerMinimizeButtonWireframe;
    Panel: IVeltVideoPlayerPanelWireframe;
    Subtitles: IVeltVideoPlayerSubtitlesWireframe;
    Transcription: IVeltVideoPlayerTranscriptionWireframe;
}
declare const VeltVideoPlayerWireframe: IVeltVideoPlayerWireframe;

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 IVeltVideoEditorPlayerTimelineWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerTimelineWireframe extends React$1.FC<IVeltVideoEditorPlayerTimelineWireframeProps> {
}

interface IVeltVideoEditorPlayerWireframeProps extends IVeltWireframeCommonProps {
}
interface IVeltVideoEditorPlayerWireframe extends React$1.FC<IVeltVideoEditorPlayerWireframeProps> {
    Title: IVeltVideoEditorPlayerTitleWireframe;
    ApplyButton: IVeltVideoEditorPlayerApplyButtonWireframe;
    CloseButton: IVeltVideoEditorPlayerCloseButtonWireframe;
    Preview: IVeltVideoEditorPlayerPreviewWireframe;
    ToggleButton: IVeltVideoEditorPlayerToggleButtonWireframe;
    Time: IVeltVideoEditorPlayerTimeWireframe;
    CurrentTime: IVeltVideoEditorPlayerCurrentTimeWireframe;
    TotalTime: IVeltVideoEditorPlayerTotalTimeWireframe;
    SplitButton: IVeltVideoEditorPlayerSplitButtonWireframe;
    DeleteButton: IVeltVideoEditorPlayerDeleteButtonWireframe;
    Timeline: IVeltVideoEditorPlayerTimelineWireframe;
}
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>;

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 useUnsetDocumentId(): void;
declare function useUnsetDocuments(): void;
declare function useSetLocation(location: Location$1, appendLocation?: boolean): void;
declare function useVeltInitState(): boolean | 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 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(liveStateDataId?: string, liveStateDataConfig?: LiveStateDataConfig): any;
declare function useSetLiveStateData(liveStateDataId: string, liveStateData: any): void;
declare function useUserEditorState(): UserEditorAccess | null;
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 usePresenceUtils(): PresenceElement | undefined;
declare function usePresenceUsers(): PresenceUser[] | null;

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(): Notification[] | null;
declare function useUnreadNotificationsCount(): {
    forYou: number | null;
    all: number | null;
};

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 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;
};

export { SnippylyArrowTool as VeltArrowTool, SnippylyArrows as VeltArrows, VeltAutocomplete, VeltAutocompleteChipTooltipWireframe, VeltAutocompleteGroupOptionWireframe, VeltAutocompleteOptionWireframe, VeltButtonWireframe, VeltCanvasComment, VeltChartComment, SnippylyCommentBubble as VeltCommentBubble, VeltCommentBubbleWireframe, VeltCommentComposer, VeltCommentComposerWireframe, VeltCommentDialogOptionsDropdownContentWireframe, VeltCommentDialogOptionsDropdownTriggerWireframe, VeltCommentDialogPriorityDropdownContentWireframe, VeltCommentDialogPriorityDropdownTriggerWireframe, VeltCommentDialogStatusDropdownContentWireframe, VeltCommentDialogStatusDropdownTriggerWireframe, VeltCommentDialogWireframe, VeltCommentPin, VeltCommentPinWireframe, VeltCommentPlayerTimeline, VeltCommentText, VeltCommentThread, VeltCommentThreadWireframe, SnippylyCommentTool as VeltCommentTool, VeltCommentToolWireframe, SnippylyComments as VeltComments, VeltCommentsMinimap, SnippylyCommentsSidebar as VeltCommentsSidebar, VeltCommentsSidebarButton, VeltCommentsSidebarStatusDropdownWireframe, VeltCommentsSidebarWireframe, VeltConfirmDialogWireframe, SnippylyCursor as VeltCursor, VeltData, VeltHighChartComments, SnippylyHuddle as VeltHuddle, SnippylyHuddleTool as VeltHuddleTool, VeltIf, VeltInlineCommentsSection, VeltInlineCommentsSectionWireframe, VeltInlineReactionsSection, VeltInlineReactionsSectionWireframe, VeltMediaSourceSettingsWireframe, VeltMultiThreadCommentDialogWireframe, VeltNivoChartComments, VeltNotificationsHistoryPanel, VeltNotificationsPanel, VeltNotificationsPanelWireframe, VeltNotificationsTool, VeltNotificationsToolWireframe, VeltPersistentCommentModeWireframe, SnippylyPresence as VeltPresence, SnippylyProvider as VeltProvider, VeltReactionPinTooltipWireframe, VeltReactionPinWireframe, VeltReactionTool, VeltReactionToolWireframe, VeltReactionsPanelWireframe, VeltRecorderAllToolMenuWireframe, VeltRecorderAllToolWireframe, VeltRecorderAudioToolWireframe, SnippylyRecorderControlPanel as VeltRecorderControlPanel, VeltRecorderControlPanelWireframe, SnippylyRecorderNotes as VeltRecorderNotes, SnippylyRecorderPlayer as VeltRecorderPlayer, VeltRecorderPlayerWireframe, VeltRecorderScreenToolWireframe, SnippylyRecorderTool as VeltRecorderTool, VeltRecorderVideoToolWireframe, VeltRecordingPreviewStepsDialogWireframe, SnippylySidebarButton as VeltSidebarButton, VeltSidebarButtonWireframe, VeltSubtitlesWireframe, SnippylyTagTool as VeltTagTool, SnippylyTags as VeltTags, VeltTextCommentToolWireframe, VeltTextCommentToolbar as VeltTextCommentToolbarWireframe, VeltTranscriptionWireframe, SnippylyUserInviteTool as VeltUserInviteTool, SnippylyUserRequestTool as VeltUserRequestTool, VeltUserSelectorDropdown as VeltUserSelectorDropdownWireframe, VeltVideoEditorPlayerWireframe, VeltVideoPlayer, VeltVideoPlayerWireframe, VeltViewAnalytics, VeltWireframe, createLiveStateMiddleware, useAIRewriterUtils, useAddAttachment, useAddComment, useAddCommentAnnotation, useAddReaction, useApproveCommentAnnotation, useAssignUser, useAutocompleteChipClick, useAutocompleteUtils, useClient, useCommentActionCallback, useCommentAddHandler, useCommentAnnotationById, useCommentAnnotations, useCommentAnnotationsCount, useCommentCopyLinkHandler, useCommentDialogSidebarClickHandler, useCommentEventCallback, useCommentModeState, useCommentSelectionChangeHandler, useCommentSidebarActionButtonClick, useCommentSidebarData, useCommentSidebarInit, useCommentUpdateHandler, useCommentUtils, useContactList, useContactSelected, useContactUtils, useCopyLink, useCursorUsers, useCursorUtils, useDeleteAttachment, useDeleteComment, useDeleteCommentAnnotation, useDeleteReaction, useDeleteRecording, useEditor, useEditorAccessRequestHandler, useEditorAccessTimer, useGetAttachment, useGetComment, useGetCommentAnnotations, useGetLink, useGetRecording, useHuddleUtils, useIdentify, useLiveSelectionDataHandler, useLiveSelectionUtils, useLiveState, useLiveStateData, useLiveStateSyncUtils, useNotificationUtils, useNotificationsData, usePresenceUsers, usePresenceUtils, useRecorderAddHandler, useRecorderEventCallback, useRecorderUtils, useRecordingDataByRecorderId, useRecordings, useRejectCommentAnnotation, useResolveCommentAnnotation, useServerConnectionStateChangeHandler, useSetDocument, useSetDocumentId, useSetDocuments, useSetLiveStateData, useSetLocation, useSubscribeCommentAnnotation, useTagAnnotations, useTagUtils, useToggleReaction, useUniqueViewsByDate, useUniqueViewsByUser, useUnreadCommentAnnotationCountByLocationId, useUnreadCommentAnnotationCountOnCurrentDocument, useUnreadCommentCountByAnnotationId, useUnreadCommentCountByLocationId, useUnreadCommentCountOnCurrentDocument, useUnreadNotificationsCount, useUnsetDocumentId, useUnsetDocuments, useUnsubscribeCommentAnnotation, useUpdateAccess, useUpdateComment, useUpdatePriority, useUpdateStatus, useUserEditorState, useVeltClient, useVeltEventCallback, useVeltInitState, useViewsUtils };