@veltdev/react/index.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

interface IVeltAutocompleteOptionProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    userObject?: any;
    userId?: string;
}
declare const VeltAutocompleteOption: React$1.FC<IVeltAutocompleteOptionProps>;

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

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

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

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

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

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

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

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

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

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

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

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

interface IVeltInlineCommentsSectionProps extends React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLElement>, HTMLElement> {
    config?: {
        id: string;
        name?: string;
    };
    /**
     * @deprecated Use `targetElementId` instead.
     */
    targetInlineCommentElementId?: string;
    /**
     * @deprecated Use `targetElementId` instead.
     */
    targetCommentElementId?: string;
    targetElementId?: string;
    darkMode?: boolean;
    variant?: string;
    dialogVariant?: string;
    composerVariant?: string;
    shadowDom?: boolean;
    multiThread?: boolean;
    /**
     * @deprecated Use `sortBy` and `sortOrder` instead.
     */
    sortData?: 'asc' | 'desc' | 'none';
    composerPosition?: 'top' | 'bottom';
    sortBy?: 'createdAt' | 'lastUpdated';
    sortOrder?: 'asc' | 'desc';
    fullExpanded?: boolean;
    context?: {
        [key: string]: any;
    };
    contextOptions?: ContextOptions;
    locationId?: string;
    documentId?: string;
    folderId?: string;
    commentPlaceholder?: string;
    replyPlaceholder?: string;
    composerPlaceholder?: string;
    editPlaceholder?: string;
    editCommentPlaceholder?: string;
    editReplyPlaceholder?: string;
    readOnly?: boolean;
    /**
     * Per-section override for anonymous email mentions. When set, overrides the global
     * comment setting for this inline section only.
     */
    anonymousEmail?: boolean;
    /**
     * When enabled, long comment messages are visually truncated to a fixed number of lines
     * with Show more / Show less controls. Off by default.
     */
    messageTruncation?: boolean;
    /**
     * Number of lines to show before truncating a comment message. Defaults to 4.
     * Only takes effect when `messageTruncation` is enabled.
     */
    messageTruncationLines?: number;
}
declare const VeltInlineCommentsSection: React$1.FC<IVeltInlineCommentsSectionProps>;

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

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

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

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

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