import * as React$1 from 'react';
import React__default, { ReactNode, JSX, RefObject, InputHTMLAttributes, ChangeEvent, KeyboardEvent, FocusEvent } from 'react';
import * as _tanstack_react_query from '@tanstack/react-query';
import { QueryClient } from '@tanstack/react-query';
import { AxiosInstance, GenericAbortSignal } from 'axios';
import { Socket } from 'socket.io-client';
import * as zustand from 'zustand';
import * as zustand_middleware from 'zustand/middleware';
export { ErrorResponse, ErrorType } from '@mirantes-micro/errors';

interface ModalProps {
    isOpen: boolean;
    onClose: () => void;
    children: ReactNode;
    showCloseButton?: boolean;
    hideCloseButton?: boolean;
    closeOnClickOutside?: boolean;
    className?: string;
    header?: React__default.ReactNode;
    footer?: React__default.ReactNode;
    disableFullScreen?: boolean;
    isLoading?: boolean;
    size?: "sm" | "md" | "lg" | "xl";
    showOverlay?: boolean;
    asStacked?: boolean;
    asSheet?: boolean;
}
declare const MirantesModal: ({ isOpen, onClose, children, showCloseButton, hideCloseButton, closeOnClickOutside, className, header, footer, disableFullScreen, isLoading, size, showOverlay, asStacked, asSheet, }: ModalProps) => React__default.ReactPortal | null;

type ToastProps = {
    title: string;
    message?: ReactNode;
    icon?: ReactNode;
    duration?: number;
    actionLabel?: string;
    onAction?: () => void;
    cancelLabel?: string;
    onCancel?: () => void;
};
type ActionToastProps = ToastProps & {
    actionLabel: string;
    onAction: () => void;
    cancelLabel?: string;
    onCancel?: () => void;
};
declare function useMirantesToast(): {
    successToast: (props: ToastProps) => string | number;
    errorToast: (props: ToastProps) => string | number;
    infoToast: (props: ToastProps) => string | number;
    warnToast: (props: ToastProps) => string | number;
    actionToast: (props: ActionToastProps) => string | number;
};

declare const NoRecruitmentResponsiveIlustration: ({ className, }: {
    className?: string;
}) => React__default.JSX.Element;

interface IFollowerUser {
    id?: string;
    name?: string;
    avatar?: string;
}
interface IFollowerPage {
    id?: string;
    name?: string;
    logo?: string;
}
interface IFollowers {
    page?: IFollowerPage[];
    user?: IFollowerUser[];
}
interface IPage {
    id?: string;
    name?: string;
    slug?: string;
    logo?: string;
    sector?: string;
    sectorId?: string;
    description?: string;
    aboutUs?: string;
    site?: string;
    organizationSize?: string;
    organizationType?: string;
    pageType?: string;
    isAcademic?: boolean;
    foundedYear?: number;
    address?: {
        city?: string;
        country?: string;
        address?: string;
    };
    phoneNumber?: string;
    followers?: IFollowers;
    followersCount?: number;
}

declare const useApiGetPage: (slug?: string) => {
    page: IPage | null | undefined;
    isGettingPage: boolean;
};

type TLocale$1 = "pt" | "en" | "fr";
interface IMirantesFoundationProviderProps {
    children: ReactNode;
    Notification?: ReactNode;
    queryClient?: QueryClient;
    onOpenCreatePostModal?: () => void;
    commentComponents?: ReactNode | JSX.Element;
    pageTriggerComponents?: ReactNode | JSX.Element;
    createJobButton?: ({ onClick, showLabel, }: {
        onClick?: () => void;
        showLabel?: boolean;
    }) => JSX.Element;
    openCreateJobModal?: () => void;
    values?: {
        pageId?: string;
        isPageFeed?: boolean;
        isCommunityFeed?: boolean;
        community?: {
            id?: string;
            name?: string;
            slug?: string;
            image?: string;
        };
        page?: {
            id?: string;
            slug?: string;
            logo?: string;
            name?: string;
            sector?: string;
        };
        widgetsApi?: string;
        searchApi?: string;
        feedApi?: string;
        authV2ApiUrl?: string;
        environment?: string;
        profileApiUrl?: string;
        analyticsApiUrl?: string;
        billingApiUrl?: string;
        assetsApiUrl?: string;
        multicaixaExpressUrl?: string;
        stripeKey?: string;
        socketApiUrl?: string;
        chatApiUrl?: string;
        chatForPage?: boolean;
        mirantesDomain?: string;
        openCageApiKey?: string;
        ocpSubscriptionKey?: string;
        locale?: TLocale$1;
        Link?: LinkComponent;
        usePathname?: UsePathname;
        user?: User$4;
        isGettingUser?: boolean;
        isGettingStats?: boolean;
        hostUrl?: string;
        isDev?: boolean;
        authedApi?: AxiosInstance;
        uploadFilesApi?: AxiosInstance;
        authApiUrl?: string;
    };
}
interface IMirantesFoundationContext {
    widgetsApi?: string;
    feedApi?: string;
    authV2ApiUrl?: string;
    searchApi?: string;
    profileApiUrl?: string;
    chatApiUrl?: string;
    billingApiUrl?: string;
    analyticsApiUrl?: string;
    assetsApiUrl?: string;
    multicaixaExpressUrl?: string;
    stripeKey?: string;
    chatForPage?: boolean;
    environment?: string;
    socketApiUrl?: string;
    socketRef?: RefObject<Socket | null>;
    mirantesDomain?: string;
    hostUrl?: string;
    locale?: TLocale$1;
    Link?: LinkComponent;
    usePathname?: UsePathname;
    user?: User$4;
    isPageFeed?: boolean;
    isCommunityFeed?: boolean;
    community?: {
        id?: string;
        name?: string;
        slug?: string;
        image?: string;
    };
    pageId?: string;
    page?: {
        id?: string;
        slug?: string;
        logo?: string;
        name?: string;
        sector?: string;
    };
    isGettingUser?: boolean;
    isGettingStats?: boolean;
    Notification?: ReactNode;
    openCageApiKey?: string;
    ocpSubscriptionKey?: string;
    authedApi?: AxiosInstance;
    uploadFilesApi?: AxiosInstance;
    authApiUrl?: string;
    queryClient?: QueryClient;
    onOpenCreatePostModal?: (cb?: () => void) => void;
    openCreateJobModal?: () => void;
    commentComponents?: ReactNode | JSX.Element;
    pageTriggerComponents?: ReactNode | JSX.Element;
    createJobButton?: ({ onClick, showLabel, }: {
        onClick?: () => void;
        showLabel?: boolean;
    }) => JSX.Element;
}
type CommonLinkProps = {
    to?: string;
    href?: string;
    children: ReactNode;
    className?: string;
    replace?: boolean;
    [key: string]: any;
};
type User$4 = {
    id: string;
    name: string;
    email: string;
    phone: string;
    currentCompany?: string;
    isOpenToWork: boolean;
    isActive: boolean;
    avatar: string;
    accessToken: string;
    refreshToken: string;
    role?: string;
    slug: string;
    isInterestsSynced?: boolean;
    headline?: string;
    followersCount?: number;
    followingCount?: number;
    socialStats?: {
        contactsCount?: number;
        followingCount?: number;
        followersCount?: number;
    };
    postsCount?: number;
    profileCompletedPercentage?: number;
};
type LinkComponent = (props: CommonLinkProps) => any;
type UsePathname = () => string;

declare function MirantesFoundationProvider({ children, Notification, queryClient, onOpenCreatePostModal, commentComponents, pageTriggerComponents, openCreateJobModal, createJobButton, values: { chatApiUrl, chatForPage, locale, Link, usePathname, user, isGettingUser, mirantesDomain, environment, feedApi, searchApi, widgetsApi, hostUrl, assetsApiUrl, isDev, profileApiUrl, analyticsApiUrl, isGettingStats, openCageApiKey, pageId, authedApi, authApiUrl, socketApiUrl, uploadFilesApi, page, ocpSubscriptionKey, billingApiUrl, multicaixaExpressUrl, stripeKey, isPageFeed, community, isCommunityFeed, authV2ApiUrl, }, }: IMirantesFoundationProviderProps): React__default.JSX.Element;

declare function useMirantesFoundation(): IMirantesFoundationContext;

/**
 * Creates a persistent state from localStorage
 * @param key - The localStorage key to use
 * @param defaultValue - The default value if no stored value exists
 * @returns The stored value or defaultValue
 */
declare function createPersistentState<T>(key: string, defaultValue: T): T;

/**
 * A hook that persists UI state (views, modals) to localStorage
 * The state is automatically saved when changed and restored on page load
 *
 * @param key - The localStorage key to use for persistence
 * @param defaultValue - The default value if no stored value exists
 * @returns A tuple of [state, setState] similar to useState
 *
 * @example
 * ```tsx
 * // Persist view state
 * const [view, setView] = usePersistentUIState<"home" | "chat">("ui-view", "home");
 *
 * // Persist modal state
 * const [modal, setModal] = usePersistentUIState<string | null>("ui-modal", null);
 * ```
 */
declare function usePersistentUIState<T>(key: string, defaultValue: T): readonly [T, React$1.Dispatch<React$1.SetStateAction<T>>];

interface IUserVisibilitySettings {
    userId?: string;
    profileViewMode?: EProfileViewMode;
    profilePublic?: boolean;
    profilePictureScope?: EPictureVisibility;
    followingVisibility?: EFollowingVisibility;
    notifyMentionsInMedia?: boolean;
}
declare enum EProfileViewMode {
    professional = "PROFESSIONAL_IDENTITY",
    sector = "SECTOR_IDENTIFICATION",
    confidential = "CONFIDENTIAL_MODE"
}
declare enum EPictureVisibility {
    contacts = "CONTACTS",
    network = "NETWORK",
    public = "PUBLIC"
}
declare enum EFollowingVisibility {
    me = "ONLY_ME",
    contacts = "CONTACTS",
    all = "EVERYONE"
}

type Settings = {
    language: {
        interface: string;
        content: string;
    };
    theme: string;
    feed: {
        preference: string;
        allowMentions: boolean;
    };
    profile: IUserVisibilitySettings;
};
declare const getSettingsFromCookie: (cookieName: string) => Settings | null;
declare const clearSettingsCookie: (cookieName: string, options: {
    domain: string;
    isDev: boolean;
}) => void;
declare const useLoadSettings: () => Settings | null;

interface ICreateTelemetryEventInput {
    input?: {
        source?: {
            app?: "mirantes-web" | "mirantes-mobile";
            platform?: "ios" | "android" | "web";
            version?: string;
            environment?: string;
        };
        actor?: {
            user_id?: string;
            anonymous_id?: string;
            session_id?: string;
        };
        context?: {
            route?: string;
            referrer?: string;
            timezone?: string;
            locale?: string;
            country?: string;
            device?: {
                os?: string;
                model?: string;
            };
            browser?: {
                name?: string;
                version?: string;
            };
        };
        events?: ITelemetryEvent[];
    };
}
interface ITelemetryEvent {
    event_id?: string;
    event_type?: "PAGE_VIEW" | "PROFILE_VIEW" | "CLICK_APPLY_JOB" | "SIGNUP_STEP_1" | "SIGNUP_STEP_2" | "SIGNUP_STEP_3" | "PERF_LOAD_TIME";
    occurred_at?: Date;
    metadata?: any;
}
interface ICreateTelemetryEventOutput {
    events?: {
        id?: string;
    }[];
}

declare function useRegisterTracking(): {
    registerEvent: _tanstack_react_query.UseMutateFunction<ICreateTelemetryEventOutput | null, Error, ICreateTelemetryEventInput, unknown>;
};

type OwnerType = "user" | "organization" | "system" | "chat";
interface AssetUploadRequest {
    file: File;
    owner_type: OwnerType;
    owner_id?: string;
    is_public: boolean;
}
interface AssetUploadResponse {
    data: {
        url?: string;
        assetId?: string;
    };
    message: string;
}
interface SignedUrlRequest {
    assetId: string;
    expiry: number;
    version: "small" | "medium" | "large";
}
interface SignedUrlResponse {
    data: {
        expiresAt: string;
        signedUrl: string;
        version: string;
    };
    message: string;
}
type AssetVersionKey = "small" | "medium" | "large";
interface AssetVersion {
    format: string;
    platforms: string[];
    recommended: boolean;
    url: string;
}
interface AssetVersionsResponse {
    mediaID: string;
    platform: string;
    versions: Record<AssetVersionKey, AssetVersion>;
}
interface BulkAssetUploadItemSuccess {
    status: "success";
    message: string;
    data: {
        url: string;
        assetId?: string;
    };
}
interface BulkAssetUploadItemError {
    status: "error";
    message: string;
    data?: null;
}
type BulkAssetUploadItem = BulkAssetUploadItemSuccess | BulkAssetUploadItemError;
interface AssetUploadBulkRequest {
    files: File[];
    owner_type: OwnerType;
    owner_id?: string;
    is_public: boolean;
    signal?: GenericAbortSignal;
}
interface AssetUploadBulkResponse {
    results: BulkAssetUploadItem[];
}

/** POST /assets */
declare function useUploadAsset(): {
    uploadAssets: _tanstack_react_query.UseMutateFunction<AssetUploadResponse | null, Error, AssetUploadRequest, unknown>;
    isUploadingAsset: boolean;
};
/** POST /assets/bulk */
declare function useUploadAssetsBulk(): {
    uploadAssetsBulk: _tanstack_react_query.UseMutateFunction<AssetUploadBulkResponse | null, Error, AssetUploadBulkRequest, unknown>;
    isUploadingBulk: boolean;
};
/** POST /assets/signed-url */
declare function useSignedUrl(): {
    postSignedUrl: _tanstack_react_query.UseMutateFunction<SignedUrlResponse | null, Error, SignedUrlRequest, unknown>;
    isPostingSignedUrl: boolean;
};
/** GET /assets/:id/versions */
declare function useAssetVersions(assetId?: string): {
    assetVersions: AssetVersionsResponse | null | undefined;
    isGettingAssetVersions: boolean;
    error: Error | null;
};
/** Auto-picks best version (large/medium/small) */
declare function useBestAssetVersion(assetId?: string): {
    url: string | null | undefined;
    isGettingUrl: boolean;
    error: Error | null;
};

declare const dispatchLogoutEvent: () => void;

interface LogoutOptions$1 {
    broadcast?: boolean;
    reload?: boolean;
    redirectUrl?: string;
}

interface UseApiLogoutOptions extends LogoutOptions$1 {
    onSuccess?: () => void;
    onError?: (error: unknown) => void;
}
declare function useApiLogout(): {
    handleApiLogout: (options?: UseApiLogoutOptions) => Promise<void>;
};

declare function useLogout(): {
    handleLogout: (options?: LogoutOptions$1) => void;
};

interface AutoComponentProps {
    component?: React__default.ElementType;
    render?: (props: {
        isOpen: boolean;
        onClose: () => void;
    }) => React__default.ReactNode;
    componentProps?: Record<string, any>;
    maxShows?: number;
    initialDelayMs?: number;
    intervalMs?: number;
    mobileOnly?: boolean;
    enabled?: boolean;
    storageKey?: string;
}
declare const AutoComponent: React__default.FC<AutoComponentProps>;

interface AutoDisplayConfig {
    storageKey?: string;
    maxShows?: number;
    initialDelayMs?: number;
    intervalMs?: number;
    mobileOnly?: boolean;
    enabled?: boolean;
    onOpen?: () => void;
    onClose?: () => void;
}
declare const useAutoDisplay: (config?: AutoDisplayConfig) => {
    isOpen: boolean;
    open: () => void;
    close: () => void;
    canShow: boolean;
    reset: () => void;
};

interface LogoutOptions {
    broadcast?: boolean;
    reload?: boolean;
    redirectUrl?: string;
    domain?: string;
    secure?: boolean;
}
declare function clearUserSession(options?: LogoutOptions): void;

declare function ChatView(): React__default.JSX.Element;

declare function useSetChatVisibility(): {
    isChatVisible: boolean;
    isToSendMessageToPage: boolean;
    isPageContext: boolean;
};

type ModalVariant = "expanded" | "minimized" | "center";
interface ModalPosition {
    top?: string;
    bottom?: string;
    left?: string;
    right?: string;
}
interface ModalAnimationConfig {
    duration?: number;
    ease?: string | number[];
    exitDuration?: number;
}
interface BaseModalProps {
    isOpen: boolean;
    onClose: () => void;
    children: React.ReactNode;
}
interface ModalStyleProps {
    className?: string;
    contentClassName?: string;
    overlayClassName?: string;
}
interface ModalBehaviorProps {
    closeOnClickOutside?: boolean;
    closeOnEscape?: boolean;
    hideCloseButton?: boolean;
    preventBodyScroll?: boolean;
    showOverlay?: boolean;
}
interface ModalConfigProps {
    variant?: ModalVariant;
    position?: ModalPosition;
    animationConfig?: ModalAnimationConfig;
    header?: React.ReactNode;
    zIndex?: number;
    offsetTop?: number;
}
interface AnimatedModalProps extends BaseModalProps, ModalStyleProps, ModalBehaviorProps, ModalConfigProps {
}

declare function AnimatedModal({ isOpen, onClose, children, variant, className, contentClassName, overlayClassName, closeOnClickOutside, closeOnEscape, hideCloseButton, showOverlay, position, header, zIndex, offsetTop, preventBodyScroll, }: AnimatedModalProps): React__default.JSX.Element;

interface BaseInputProps extends InputHTMLAttributes<HTMLInputElement> {
    placeholder: string;
    value: string;
    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
    onKeyDown?: (e: KeyboardEvent<HTMLInputElement>) => void;
    onFocus?: (e: FocusEvent<HTMLInputElement>) => void;
    rightIcon?: React__default.ReactNode;
    leftIcon?: React__default.ReactNode;
    label?: string;
    error?: string;
    wrapperClassName?: string;
    inputClassName?: string;
    requiredInPlaceholder?: boolean;
    placeholderColor?: string;
}
declare const BaseInput: React__default.ForwardRefExoticComponent<BaseInputProps & React__default.RefAttributes<HTMLInputElement>>;

type ButtonProps = {
    children: React__default.ReactNode;
    type?: "button" | "submit";
    className?: string;
    onClick?: () => void;
    disabled?: boolean;
    isLoading?: boolean;
};
declare function Button({ children, className, disabled, isLoading, onClick, type, }: ButtonProps): React__default.JSX.Element;

declare function CheckBoxInput({ isChecked, onClick, label, disabled, isRequired, }: {
    isChecked?: boolean;
    isRequired?: boolean;
    onClick?: (e: React__default.MouseEvent<HTMLDivElement> | React__default.KeyboardEvent<HTMLDivElement>) => void;
    label?: string;
    disabled?: boolean;
}): React__default.JSX.Element;

type CustomDrawerProps = {
    children: React__default.ReactNode;
    footer?: React__default.ReactNode;
    title?: React__default.ReactNode;
    onClose: () => void;
    className?: string;
    isOpen?: boolean;
    hideCloseBlock?: boolean;
    direction?: 'bottom' | 'right' | 'left';
    hiddenInMobileArticle?: boolean;
};
declare function CustomDrawer({ children, footer, title, onClose, className, isOpen, hideCloseBlock, direction, hiddenInMobileArticle, }: CustomDrawerProps): React__default.JSX.Element | null;

interface IDropdownProps {
    trigger: React.ReactNode;
    options: IDropdownOption[];
    onSelect: (id: string) => void;
    className?: string;
    itemClassName?: string;
    itemHoverClassName?: string;
    animate?: boolean;
    enableSearch?: boolean;
}
interface IDropdownOption {
    id: string;
    label: string;
    value: string;
    icon?: React.ReactNode;
}

declare function CustomDropdown({ trigger, options, onSelect, className, itemClassName, itemHoverClassName, animate, enableSearch, }: IDropdownProps): React__default.JSX.Element;

type Option = {
    id: string;
    label: string;
    value: string;
};
type CustomSelectInputProps = {
    options: Option[];
    value?: string;
    onChange?: (option: Option | null) => void;
    placeholder?: string;
    className?: string;
    enableSearch?: boolean;
    floattable?: boolean;
    required?: boolean;
    showCheck?: boolean;
    label?: string;
    error?: string;
    disabled?: boolean;
    onSearch?: (query: string) => void;
    isLoading?: boolean;
    reset?: boolean;
};
declare function CustomSelectInput({ options, value, onChange, placeholder, className, enableSearch, floattable, required, showCheck, label, error, disabled, onSearch, isLoading, reset, }: CustomSelectInputProps): React$1.JSX.Element;

interface EmojiPickerButtonProps {
    onEmojiSelect: (emoji: string) => void;
}
declare const EmojiPickerButton: ({ onEmojiSelect, }: EmojiPickerButtonProps) => React__default.JSX.Element;

interface IMirantesButton extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
    label?: string;
    isLoading?: boolean;
    leftElement?: React__default.ReactNode;
    rightElement?: React__default.ReactNode;
    align?: "left" | "center" | "right";
}
declare const MirantesButton: React__default.ForwardRefExoticComponent<IMirantesButton & React__default.RefAttributes<HTMLButtonElement>>;

interface MirantesSheetsProps {
    isOpen: boolean;
    onOpenChange: (open: boolean) => void;
    title?: string;
    iconTitle?: ReactNode;
    iconTitleClassName?: string;
    customHeader?: ReactNode;
    children: ReactNode;
    footer?: ReactNode;
    side?: "top" | "bottom" | "left" | "right";
    className?: string;
    contentClassName?: string;
    hideCloseButton?: boolean;
    zIndex?: number;
}
declare const MirantesSheets: ({ isOpen, onOpenChange, title, customHeader, children, footer, side, className, contentClassName, hideCloseButton, iconTitle, iconTitleClassName, zIndex, }: MirantesSheetsProps) => React__default.JSX.Element;

declare function RadioButtonInput({ label, isSelected, onSelect, }: {
    label?: string;
    isSelected?: boolean;
    onSelect?: () => void;
}): React__default.JSX.Element;

interface IResponsiveDrawerProps {
    isOpen: boolean;
    onClose: () => void;
    header?: React$1.ReactNode;
    footer?: React$1.ReactNode;
    children: React$1.ReactNode;
    className?: string;
    side?: "right" | "left" | "bottom";
    swipeable?: boolean;
    swipeThreshold?: number;
}

interface ExtendedDrawerProps extends IResponsiveDrawerProps {
    title?: string;
}
declare function ResponsiveDrawer$1({ isOpen, onClose, title, header, footer, children, className, swipeable, }: ExtendedDrawerProps): React$1.JSX.Element;

type Language = "pt" | "en" | "fr";
interface DateOutput {
    day: string;
    month: string;
    year: string;
    formattedYMD: string | null;
    formattedDMY: string | null;
    isoString: string | null;
}
interface TripleInputDateProps {
    label?: string;
    required?: boolean;
    disabled?: boolean;
    error?: string;
    showDay?: boolean;
    showMonth?: boolean;
    showYear?: boolean;
    lang?: Language;
    value?: Date | string | null;
    minYear?: number;
    maxYear?: number;
    onChange?: (dateData: DateOutput) => void;
    isNewChevronIcon?: boolean;
}
declare const TripleInputDate: ({ label, required, disabled, error, showDay, showMonth, showYear, lang, value, minYear, maxYear, onChange, isNewChevronIcon, }: TripleInputDateProps) => React__default.JSX.Element;

interface AddressSuggestion {
    country?: string;
    city?: string;
    latitude?: number;
    longitude?: number;
    address?: string;
}
interface AddressInputProps {
    value: string;
    onChange: (props?: AddressSuggestion) => void;
    className?: string;
    wrapperClassName?: string;
    inputClassName?: string;
    suggestionsWrapperClassName?: string;
    suggestionItemClassName?: string;
    selectedItemClassName?: string;
    loadingIndicatorClassName?: string;
    clearButtonClassName?: string;
    error?: string;
    errorClassName?: string;
    leftElement?: ReactNode;
    minChars?: number;
    debounceDelay?: number;
    placeholder?: string;
    noResultsText?: string;
    customLoading?: ReactNode;
    floatable?: boolean;
}
declare function AddressAutocompleteInput({ value, onChange, className, wrapperClassName, inputClassName, suggestionsWrapperClassName, suggestionItemClassName, selectedItemClassName, loadingIndicatorClassName, clearButtonClassName, errorClassName, error, leftElement, minChars, debounceDelay, placeholder, noResultsText, customLoading, floatable, }: AddressInputProps): React__default.JSX.Element;

interface IActivateAccountModalProps {
    isOpen: boolean;
    onClose?: () => void;
}

declare function ActivateAccountModal({ isOpen, onClose, }: IActivateAccountModalProps): React__default.JSX.Element;

declare function ChatContacts({ postId, onClose, searchTerm, selectedContacts, setSelectedContacts, }: {
    postId?: string;
    onClose?: () => void;
    searchTerm?: string;
    selectedContacts?: Set<string>;
    setSelectedContacts?: (contacts: Set<string> | ((prev: Set<string>) => Set<string>)) => void;
}): React__default.JSX.Element;

declare function ChatListWrapper({ isChatOpen, isCompactMode }: {
    isChatOpen?: boolean;
    isCompactMode?: boolean;
}): React__default.JSX.Element;

declare function ChatViewDesktopPage(): React__default.JSX.Element;

interface TargetEntity$1 {
    id?: string;
    name?: string;
    avatar?: string;
    logo?: string;
    image?: string;
}
interface IMessageButtonProps$1 {
    user?: TargetEntity$1;
    page?: TargetEntity$1;
    icon?: React__default.ReactNode;
    label?: string;
    className?: string;
    disabled?: boolean;
    onClick?: () => void;
    isSharing?: boolean;
    link?: string;
    onConversationReady?: (conversationId: string) => void;
}
declare function MessageButton({ user, page, icon, label, className, disabled, onClick: customOnClick, isSharing, link, onConversationReady, }: IMessageButtonProps$1): React__default.JSX.Element;

interface TargetEntity {
    id?: string;
    name?: string;
    avatar?: string;
    logo?: string;
    image?: string;
    slug?: string;
}
interface IMessageButtonProps {
    user?: TargetEntity;
    label?: string;
    className?: string;
    disabled?: boolean;
    onClick?: () => void;
    variant?: "default" | "small";
    onConversationReady?: (conversationId: string) => void;
}
declare function MessagesButtonFromPage({ user, label, className, disabled, onClick: customOnClick, variant, }: IMessageButtonProps): React__default.JSX.Element;

declare function useRestorePendingChat(): void;

interface IMessage {
    id?: string;
    conversationId?: string;
    senderId?: string;
    pageId?: string;
    sender?: {
        name?: string;
        slug?: string;
        avatar?: string;
        id?: string;
    };
    attachments?: {
        type?: string;
        url?: string;
    }[];
    body?: string;
    content?: string;
    actions?: string;
    replyMessageId?: string;
    replyMessage?: IMessage;
    createdAt?: Date;
    updatedAt?: Date;
    totalReactions?: number;
    myReaction?: string | null;
    reactions?: {
        reaction?: string;
        count?: number;
    }[];
    isForwarded?: boolean;
    mentions?: {
        mentionedId: string;
    }[];
}

type MessageApp = {
    id: string;
    component: React__default.ReactNode;
};
type TOption = "add-participant" | "select-messages" | "new-group" | "edit-group" | "new-message" | "filter-all" | "filter-unread" | "filter-favorites" | "filter-groups" | "filter-recruitment" | "filter-main" | "filter-archived" | "filter-spam" | "filter-muted" | "filter-pinned" | "options";
type SelectionMode = "all" | "delete-only" | "forward-only";
type TMessageSubject = "service-request" | "service-request-demo" | "support" | "careers" | "other";
type UnreadState = {
    count: number;
    dot: boolean;
};
interface IUser {
    id?: string;
    name?: string;
    avatar?: string;
    isOnline?: boolean;
    email?: string;
    role?: string;
    isGroupOwner?: boolean;
    slug?: string;
    conversationId?: string;
    description?: string;
    isGroup?: boolean;
    isMuted?: boolean;
    participants?: IUser[];
    isGroupAdmin?: boolean;
}
type TMessage = {
    id: string;
    type: "text" | "audio" | "image" | "video" | "file" | "temporary";
    content: string;
    timestamp: number;
    sender: "me" | "other" | {
        name?: string;
        avatar?: string;
        id?: string;
        slug?: string;
    };
    replyMessageId?: string;
    isTemporary?: boolean;
    attachmentType?: "image" | "audio" | "video" | "gif" | "file";
    body?: string;
    createdAt?: string;
    senderId?: string;
    replyMessage?: any;
};
type State = {
    replyMessage?: IMessage | null;
    setReplyMessage?: (message: IMessage | null) => void;
    apps: MessageApp[];
    selectedAppId: string | null;
    setSelectedApp: (id: string) => void;
    chatHeaderOption?: TOption;
    onSelectChatHeaderOption?: (id: TOption) => void;
    subject?: TMessageSubject;
    onSelectMessageSubject?: (id: TMessageSubject) => void;
    searchQuery?: string;
    onSearchQuery?: (value: string) => void;
    searchMessage?: string;
    onSearchMessage?: (value: string) => void;
    selectedChat?: IUser | null;
    onSelectChat?: (user: IUser | null) => void;
    messages: Record<string, TMessage[]>;
    draftMessages: Record<string, string>;
    setDraftMessage: (chatId: string, text: string) => void;
    sendTextMessage: (chatId: string, text: string) => void;
    sendAudioMessage: (chatId: string, blob: Blob) => void;
    addTemporaryMessage: (conversationId: string, content: string, attachmentType?: "image" | "audio" | "video" | "gif" | "file", messageId?: string) => void;
    removeTemporaryMessage: (conversationId: string, messageId: string) => void;
    unreadChats: Record<string, UnreadState>;
    markChatAsRead: (id?: string) => void;
    incrementUnread: (id: string) => void;
    resetUnread: (id?: string) => void;
    clearDot: (id?: string) => void;
    replaceTempConversationId: (tempId: string, realId: string) => void;
    selectedUsers: IUser[];
    addUser: (user: IUser) => void;
    removeUser: (userId: string) => void;
    resetSelectedUsers?: () => void;
    groupToEdit?: {
        id?: string;
        name?: string;
        description?: string;
        participants?: string[];
        image?: string;
    } | null;
    onEditGroup?: (group?: {
        id?: string;
        name?: string;
        description?: string;
        participants?: string[];
        image?: string;
    }) => void;
    resetAll?: () => void;
    selectedMessageIds: string[];
    selectMessage: (id: string) => void;
    clearSelectedMessages: () => void;
    deleteSelectedMessages: () => void;
    selectionMode: SelectionMode;
    setSelectionMode: (mode: SelectionMode) => void;
    mobileSelectedMessageId: string | null;
    setMobileSelectedMessage: (id: string | null) => void;
    forwardMessageIds: string[];
    selectForwardMessage: (id: string) => void;
    clearForwardMessages: () => void;
    forwardTargets: Array<{
        userId?: string;
        conversationId?: string;
    }>;
    selectForwardTarget: (target: {
        userId?: string;
        conversationId?: string;
    }) => void;
    removeForwardTarget: (target: {
        userId?: string;
        conversationId?: string;
    }) => void;
    clearForwardTargets: () => void;
};

declare const useMessageAppStore: zustand.UseBoundStore<zustand.StoreApi<State>>;

declare function PageChatContent(): React__default.JSX.Element;

declare function PageChatContentHeader(): React__default.JSX.Element | null;

declare function PageChatInput(): React__default.JSX.Element;

declare function PageChatList(): React__default.JSX.Element;

declare function PageChatListWrapper(): React__default.JSX.Element;

type PageChatUserSuggestionsProps = {
    onUserClick?: () => void;
};
declare const PageChatUserSuggestions: React__default.ForwardRefExoticComponent<PageChatUserSuggestionsProps & React__default.RefAttributes<HTMLDivElement>>;

declare function PageMessageWrapper({ containerRef: externalContainerRef }: {
    containerRef?: React__default.RefObject<HTMLDivElement | null>;
}): React__default.JSX.Element;

interface CommunityTriggerState {
    isCommunitiesOpen: boolean;
    openCommunity: () => void;
    closeCommunity: () => void;
    toggleCommunity: () => void;
}
declare const useCommunityTriggerStore: zustand.UseBoundStore<zustand.StoreApi<CommunityTriggerState>>;

type User$3 = {
    id: string;
    name: string;
    slug: string;
    email: string;
    avatar: string;
    isOpenToWork: boolean;
    isFollowed: boolean;
    isContact: boolean;
    headline?: string;
};

type Contact = {
    id: string;
    followerId: string;
    followedId: string;
    isFollowing: boolean;
    createdAt: string;
    updatedAt: string;
    follower: User$3;
    followed: User$3;
};
type ContactsResponse = {
    contact: {
        meta: {
            currentPage: number;
            perPage: number;
            lastPage: number;
            total: number;
        };
        data: Contact[];
    };
};
type GetFollowersOptions = {
    page: number;
    perPage: number;
    sort: string;
    sortDir: string;
    filter?: {
        name?: string | null;
        slug?: string | null;
    };
    slug?: string;
};
declare const useApiGetContacts: (options: Omit<GetFollowersOptions, "page">, slug?: string, tabEnabled?: boolean) => {
    contacts: Contact[];
    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<ContactsResponse, unknown>, Error>>;
    hasNextPage: boolean;
    isFetchingNextPage: boolean;
    isGettingContacts: boolean;
    meta: {
        currentPage: number;
        perPage: number;
        lastPage: number;
        total: number;
    } | undefined;
};

declare function ContactsModal({ onClose, slug, }: {
    onClose: () => void;
    slug?: string;
}): React__default.JSX.Element;

interface CountryDisplayProps {
    code: string;
    locale: "pt" | "fr" | "en";
    className?: string;
}
declare function CountryDisplay({ code, locale, className, }: CountryDisplayProps): React__default.JSX.Element | null;
declare namespace CountryDisplay {
    var displayName: string;
}

interface ICountryInputProps {
    locale?: "pt" | "fr" | "en";
    value?: string;
    onChange?: (value: {
        locale: string;
        name: string;
    }) => void;
    className?: string;
    defaultCode?: string;
    forNationality?: boolean;
}

interface CountryInputProps extends Omit<ICountryInputProps, "locale" | "onChange"> {
    className?: string;
    buttonClassName?: string;
    inputClassName?: string;
    value?: string;
    onChange?: (payload: {
        code: string;
        name: string;
    }) => void;
    error?: string;
    floatable?: boolean;
}
declare function CountryInput({ className, buttonClassName, inputClassName, defaultCode, onChange, value, error, floatable, }: CountryInputProps): React__default.JSX.Element;
declare namespace CountryInput {
    var displayName: string;
}

interface DateInputProps$1 {
    value?: Date | string | null;
    onChange?: (date: Date | null) => void;
    minDate?: Date;
    maxDate?: Date;
    required?: boolean;
    showDateIcon?: boolean;
    disabled?: boolean;
    readOnly?: boolean;
    className?: string;
    placeholder?: string;
    inputClassName?: string;
    label?: string;
    "data-testid"?: string;
    error?: string;
    formattedAsMonthYear?: boolean;
}
declare function CustomDateInput({ value, error: errorMessage, onChange, minDate, maxDate, required, showDateIcon, disabled, readOnly, className, placeholder, inputClassName, label, "data-testid": testId, formattedAsMonthYear, }: DateInputProps$1): React__default.JSX.Element;

interface DateInputProps {
    label: string;
    onChange: (date: Date) => void;
    value: Date;
    required?: boolean;
    className?: string;
    error?: string;
    disabled?: boolean;
    calendarClassName?: string;
    triggerClassName?: string;
    mode?: "date" | "time" | "both" | "calendar";
    setHasError?: (value: boolean) => void;
}
declare function DateInput({ label, onChange, value, required, className, triggerClassName, error: externalError, disabled, calendarClassName, mode, setHasError, }: DateInputProps): React$1.JSX.Element;

interface AutoDownloadBannerProps {
    /** Número máximo de vezes que o banner pode ser mostrado (padrão: 5) */
    maxShows?: number;
    /** Delay inicial em milissegundos antes de mostrar o banner pela primeira vez (padrão: 30 segundos) */
    initialDelayMs?: number;
    /** Se deve mostrar apenas em dispositivos móveis (padrão: true) */
    mobileOnly?: boolean;
    /** Se o banner automático está ativo (padrão: true) */
    enabled?: boolean;
}
declare const AutoDownloadBanner: React__default.FC<AutoDownloadBannerProps>;

declare const DownloadModalTrigger: () => React__default.JSX.Element;

declare const DownloadMobileVersionBanner: () => React__default.JSX.Element;

interface BannerConfig {
    /** Número máximo de vezes que o banner pode ser mostrado (padrão: 5) */
    maxShows?: number;
    /** Delay inicial em milissegundos antes de mostrar o banner pela primeira vez (padrão: 5 segundos) */
    initialDelayMs?: number;
    /** Se deve mostrar apenas em dispositivos móveis (padrão: true) */
    mobileOnly?: boolean;
}
declare const usePeriodicDownloadBanner: (config?: BannerConfig) => {
    shouldShow: boolean;
    showBanner: () => void;
    resetBannerData: () => void;
    getBannerStats: () => {
        lastShown: Date | null;
        showsCount: number;
        remainingShows: number;
        canShow: boolean;
        shownInCurrentSession: boolean;
    };
    canShow: boolean;
    isMobile: boolean;
};

interface ModalState$1 {
    isDownloadModalOpen: boolean;
    openDownloadModal: () => void;
    closeDownloadModal: () => void;
    toggleDownloadModal: () => void;
}
declare const useModalStore: zustand.UseBoundStore<zustand.StoreApi<ModalState$1>>;

interface ArticleContentProps {
    isOpen: boolean;
    onClose: () => void;
}
declare const ArticleContent: ({ isOpen, onClose }: ArticleContentProps) => React__default.JSX.Element;

type User$2 = {
    id?: string;
    name?: string;
    slug?: string;
    about?: string;
    email?: string;
    phone?: string;
    isOpenToWork?: boolean;
    gender?: string;
    banner?: string;
    isContact?: boolean;
    isFollowed?: boolean;
    isFollowedBy?: boolean;
    birthDate?: string;
    nationality?: string;
    headline?: string;
    country?: string;
    city?: string;
    street?: string;
    countryCode?: string;
    profession?: string;
    addresses?: {
        country?: string;
        city?: string;
        address?: string;
    }[];
    address?: {
        country?: string;
        city?: string;
        address?: string;
    };
    avatar?: string;
    avatarDisplay?: string;
    provider?: string;
    role?: string;
    status?: string;
    createdAt?: string;
    updatedAt?: string;
    isPublic?: boolean;
    currentCompany?: string;
    person?: IPerson$2;
    link?: string;
    links?: string[];
};
interface IPerson$2 {
    gender?: string;
    birthDate?: Date;
    nationality?: string;
    maritalStatus?: string;
    salaryExpectation?: string;
    countryCode?: string;
}

type PostAttachmentProps$2 = {
    title?: string;
    description?: string;
    imageUrl?: string;
    url?: string;
    type: string;
};
type PostAuthor = {
    id?: string;
    name?: string;
    avatar?: string | null;
    slug?: string;
    headline?: string | null;
    rating?: number;
    isFollowing?: boolean;
};
type Post$2 = {
    user: User$2;
    /** Timeline / feed-with-go APIs expose publisher as `author` instead of `user`. */
    author?: PostAuthor;
    clientId?: string;
    postType: "NORMAL" | "REEL" | "ARTICLE";
    id: string;
    createdAt: string;
    scheduledAt?: string;
    bio?: string;
    content: string;
    totalShares?: number;
    totalReactions?: number;
    currentUserReaction?: string | undefined;
    totalComments?: number;
    attachment?: PostAttachmentProps$2;
    isFollowed?: boolean;
    isContact?: boolean;
    isArticle?: boolean;
    isDraft?: boolean;
    expiresAt?: string | null;
    link?: {
        title: string;
        description: string;
        imageUrl: string;
        url: string;
    };
    images: PostAssetProps$2[];
    videos: PostAssetProps$2[];
    reactions?: PostReactionsProps$2[];
    comments?: CommentProps$2[];
    sharedPostId?: string;
    page?: {
        id?: string;
        name?: string;
        slug?: string;
        sector?: string;
        banner?: string;
        logo?: string;
        site?: string;
    };
    media?: unknown;
    linkPreview?: unknown;
    visibility?: string;
    sharedPost?: Post$2;
    title?: string;
    stats?: {
        reactionCount?: number;
        commentCount?: number;
        shareCount?: number;
    };
    sharedContext?: unknown;
    mention?: {
        id: string;
        mentionedId: string;
        mentioned: User$2;
    }[];
    community?: {
        id: string;
        visibility?: string;
        slug: string;
        banner?: string;
        createdAt?: string;
        description?: string;
        image?: string;
        location?: string;
        name: string;
        owner?: {
            id: string;
            name: string;
            slug: string;
            email?: string;
        };
        ownerId?: string;
        members?: {
            userId: string;
            user: {
                id: string;
                name: string;
                slug: string;
            };
        }[];
    };
    userId?: string;
    sharedInCommunity?: {
        id: string;
        slug: string;
        visibility: string;
        name: string;
        banner?: string;
        image?: string;
        location?: string;
        ownerId: string;
        owner: {
            id: string;
            slug: string;
            name: string;
        };
    };
    communityId?: string;
};
type PostAssetProps$2 = {
    id: string;
    url: string;
    type?: "image" | "video" | "pdf";
    createdAt?: string;
};
type PostReactionsProps$2 = {
    id: string;
    userId: string;
    postId: string;
    reaction: "LIKE" | "LOVE" | "HAHA" | "WOW" | "SAD" | "ANGRY" | "AGREE" | "EUREKA" | "NO_COMMENT" | "SUPPORT" | "DISAGREE" | "DISLIKE";
    createdAt?: string;
    updatedAt?: string;
    user?: User$2;
};
type CommentReactionsProps$2 = {
    id: string;
    userId: string;
    commentId: string;
    reaction: "LIKE" | "LOVE" | "HAHA" | "WOW" | "SAD" | "ANGRY" | "AGREE" | "DISAGREE" | "EUREKA" | "NO_COMMENT" | "SUPPORT" | "DISLIKE";
    createdAt: string;
    updatedAt: string;
    user?: User$2;
};
type CommentProps$2 = {
    id: string;
    userId: string;
    postId: string;
    answerId: string;
    content: string;
    imageUrl: string;
    createdAt: string;
    updatedAt: string;
    user: User$2;
    reactions: CommentReactionsProps$2[];
    totalReactions?: number;
    answers: CommentProps$2[];
    totalAnswers: number;
    page?: {
        id: string;
        name: string;
        slug: string;
        sector: string;
    };
};

interface IUserDraft {
    id: string;
    content: string;
    title: string;
    isArticle: boolean;
    isDraft: boolean;
    user: {
        name: string;
        slug: string;
    };
}

type Profile$2 = {
    id: string;
    name: string;
    avatar: string;
    role?: string;
    isPage?: boolean;
};
type ArticleViewMode = "create" | "view";
type ArticleStep = "create" | "preview" | "published";
type ArticleMedia = {
    id: string;
    url: string;
    type: "image" | "video";
    file?: File;
};

type ArticleState = {
    title: string;
    content: string;
    post: Post$2 | null;
    selectedProfile: Profile$2 | null;
    media: ArticleMedia[];
    uploadedMedia: string[];
    isUploading: boolean;
    selectedHashtags: string[];
    viewMode: ArticleViewMode;
    currentStep: ArticleStep;
    isModalOpen: boolean;
    isSaved: boolean;
    isDraft: boolean;
    isPublishing: boolean;
    isSavingDraft: boolean;
    lastSavedAt: Date | null;
    currentDraftId: string | null;
    setTitle: (title: string) => void;
    setContent: (content: string) => void;
    setPost: (post: Post$2 | null) => void;
    setSelectedProfile: (profile: Profile$2 | null) => void;
    addMedia: (media: ArticleMedia) => void;
    removeMedia: (id: string) => void;
    setIsUploading: (isUploading: boolean) => void;
    toggleHashtag: (hashtagId: string) => void;
    setSelectedHashtags: (hashtags: string[]) => void;
    loadDraft: (draft: IUserDraft) => void;
    clearDraft: () => void;
    setCurrentDraftId: (id: string | null) => void;
    setViewMode: (mode: ArticleViewMode) => void;
    setCurrentStep: (step: ArticleStep) => void;
    openModal: () => void;
    closeModal: () => void;
    setIsSaved: (isSaved: boolean) => void;
    setIsPublishing: (isPublishing: boolean) => void;
    setIsSavingDraft: (isSavingDraft: boolean) => void;
    markAsSaved: () => void;
    resetArticle: () => void;
};
declare const useArticleStore: zustand.UseBoundStore<zustand.StoreApi<ArticleState>>;

declare const useArticleNavigation: () => {
    viewMode: ArticleViewMode;
    currentStep: ArticleStep;
    isModalOpen: boolean;
    goToCreate: () => void;
    goToPreview: () => void;
    goToPublished: () => void;
    openModal: () => void;
    closeModal: () => void;
    resetAndClose: () => void;
};

interface ArticleViewerProps {
    content: string;
}
declare function ArticleViewer({ content }: ArticleViewerProps): React__default.JSX.Element;

declare const PostCardArticle: ({ src, title, content, isCompact, classImage, fontSize }: {
    src?: string;
    title?: string;
    content?: string;
    classImage?: string;
    fontSize?: string;
    isCompact?: boolean;
}) => React__default.JSX.Element;

type ModalState = {
    isOpen: boolean;
    modalId: string | null;
    openModal: () => void;
    closeModal: () => void;
    toggleModal: () => void;
};
declare const useModalArticleStore: zustand.UseBoundStore<zustand.StoreApi<ModalState>>;

declare function CreatePostCard(): React__default.JSX.Element;

type Profile$1 = {
    id: string;
    name: string;
    avatar: string;
    role?: string;
    isPage?: boolean;
};

type ModalStep = 'main' | 'select-profile' | 'schedule' | 'scheduled-posts' | 'post-actions-menu' | 'edit-scheduled-post';
interface CreatePostContentProps {
    readonly currentStep: ModalStep;
    readonly selectedProfile: Profile$1 | null;
    readonly scheduledDate: Date | null;
    readonly selectedPostForAction: string | null;
    readonly isSubmitting: boolean;
    readonly isLoading: boolean;
    readonly onProfileSelect: (profile: Profile$1) => void;
    readonly onGoToProfileSelection: () => void;
    readonly onGoToSchedule: () => void;
    readonly onScheduleSelect: (date: Date) => void;
    readonly onBackToMain: () => void;
    readonly onScheduleMore: () => void;
    readonly onPostActions: (postId: string) => void;
    readonly onEditScheduledPost: (postId: string) => void;
    readonly onDeleteScheduledPost: (postId?: string) => void;
    readonly onEditPostSubmit: (postId: string, updatedDate?: Date | null, shouldUpdateScheduledAt?: boolean) => void;
    readonly onSubmit: (type: 'REEL' | 'NORMAL') => void;
    readonly onClose?: () => void;
    readonly shouldLoadScheduledPosts?: boolean;
    readonly onPostDeleted?: () => void;
    readonly onPostUpdated?: () => void;
    readonly showScheduleOption?: boolean;
}
declare function CreatePostContent(props: CreatePostContentProps): React__default.JSX.Element;

type CreatePostFormProps = {
    readonly onSubmit: (data: {
        content: string;
        media: string[];
    }) => void;
    readonly onScheduleClick?: () => void;
    readonly scheduledDate?: Date | null;
    readonly showScheduleOption?: boolean;
    readonly onViewScheduledPosts?: () => void;
};
declare function CreatePostForm({ onSubmit, onScheduleClick, scheduledDate, showScheduleOption, onViewScheduledPosts, }: CreatePostFormProps): React__default.JSX.Element;

interface IMention {
    id: string;
    mentionedId: string;
    mentionType: string;
    mentionedCommunity?: {
        slug: string;
        name: string;
        id: string;
        image: string;
    };
    mentionedPage?: {
        name: string;
        slug: string;
        logo: string;
        id: string;
    };
    mentionedUser?: {
        id: string;
        name: string;
        slug: string;
        avatar: string;
    };
}

interface CreatePostFormState {
    content: string;
    isUploading: boolean;
    hashtags?: string[];
    setHashtags: (value?: string[]) => void;
    mentions?: IMention[];
    setMentions: (mentions?: IMention[]) => void;
    mentionedUsers?: User$4[];
    setMentionedUsers: (users?: User$4[]) => void;
    uploadedMedia: string[];
    selectedFiles: File[];
    currentAssets: {
        id: string;
        url: string;
    }[];
    assetsToDelete: {
        id: string;
        url: string;
    }[];
    setCurrentAssets: (assets: {
        id: string;
        url: string;
    }[]) => void;
    setContent: (content: string) => void;
    handleMediaUpload: (files: FileList | null, ignore?: boolean) => void;
    removeMedia: (index: number) => void;
    replaceMedia: (index: number, file: File) => void;
    resetForm: () => void;
    resetFormContent: () => void;
    isValid: boolean;
    isCreatingThePost: boolean;
    setIsCreatingThePost: (isCreatingThePost: boolean) => void;
    uploadProgress: number;
    setUploadProgress: (progress: number) => void;
    isProcessingPost: boolean;
    setIsProcessingPost: (isProcessing: boolean) => void;
    progressText: string;
    setProgressText: (text: string) => void;
}
declare const useCreatePostFormStore: zustand.UseBoundStore<zustand.StoreApi<CreatePostFormState>>;

interface CreatePostModalProps {
    inline?: boolean;
}
declare function CreatePostModal({ inline }: CreatePostModalProps): React__default.JSX.Element;

type Profile = {
    id: string;
    name: string;
    avatar: string;
    role?: string;
};
type CreatePostModalFiltersProps = {
    readonly selectedProfile?: Profile | null;
    readonly onProfileSelectClick: () => void;
};
declare function CreatePostModalFilters({ selectedProfile, onProfileSelectClick, }: CreatePostModalFiltersProps): React__default.JSX.Element;

interface CreatePostReelFormProps {
    onSubmit: (data: {
        content: string;
        media: string[];
    }) => void;
}
declare function CreatePostReelForm({ onSubmit }: CreatePostReelFormProps): React__default.JSX.Element;

type CreatePostScheduleStepProps = {
    readonly onBack: () => void;
    readonly onScheduleSelect: (scheduledDate: Date) => void;
    readonly onClose?: () => void;
    readonly initialDate?: Date;
    readonly onViewScheduledPosts?: () => void;
};
declare function CreatePostScheduleStep({ onBack, onScheduleSelect, onClose, initialDate, onViewScheduledPosts, }: CreatePostScheduleStepProps): React__default.JSX.Element;

type CreatePostToolbarProps = {
    readonly onMediaSelect?: (files: FileList | null) => void;
    readonly isForReels?: boolean;
    readonly onScheduleClick?: () => void;
    readonly onMentionClick?: () => void;
    readonly showScheduleOption?: boolean;
    readonly hasMedia?: boolean;
    readonly onEmojiSelect?: (emoji: string) => void;
    readonly onViewScheduledPosts?: () => void;
    readonly onSubmit?: (type: 'REEL' | 'NORMAL') => void;
    readonly postType?: string;
};
declare function CreatePostToolbar({ onMediaSelect, isForReels, onScheduleClick, onMentionClick, hasMedia, onEmojiSelect, onViewScheduledPosts, onSubmit, postType, }: CreatePostToolbarProps): React__default.JSX.Element;

type User$1 = {
    id?: string;
    name?: string;
    slug?: string;
    about?: string;
    email?: string;
    phone?: string;
    isOpenToWork?: boolean;
    gender?: string;
    banner?: string;
    isContact?: boolean;
    isFollowed?: boolean;
    isFollowedBy?: boolean;
    birthDate?: string;
    nationality?: string;
    headline?: string;
    country?: string;
    city?: string;
    street?: string;
    countryCode?: string;
    profession?: string;
    addresses?: {
        country?: string;
        city?: string;
        address?: string;
    }[];
    address?: {
        country?: string;
        city?: string;
        address?: string;
    };
    avatar?: string;
    avatarDisplay?: string;
    provider?: string;
    role?: string;
    status?: string;
    createdAt?: string;
    updatedAt?: string;
    isPublic?: boolean;
    currentCompany?: string;
    person?: IPerson$1;
    link?: string;
    links?: string[];
};
interface IPerson$1 {
    gender?: string;
    birthDate?: Date;
    nationality?: string;
    maritalStatus?: string;
    salaryExpectation?: string;
    countryCode?: string;
}

type PostAttachmentProps$1 = {
    title?: string;
    description?: string;
    imageUrl?: string;
    url?: string;
    type: string;
};
type Post$1 = {
    user: User$1;
    postType: "NORMAL" | "REEL" | "ARTICLE";
    id: string;
    createdAt: string;
    scheduledAt?: string;
    bio: string;
    content: string;
    totalShares: number;
    totalReactions?: number;
    totalComments?: number;
    attachment?: PostAttachmentProps$1;
    isFollowed?: boolean;
    isContact?: boolean;
    isArticle?: boolean;
    isDraft?: boolean;
    expiresAt?: string | null;
    link: {
        title: string;
        description: string;
        imageUrl: string;
        url: string;
    };
    images: PostAssetProps$1[];
    videos: PostAssetProps$1[];
    reactions: PostReactionsProps$1[];
    comments: CommentProps$1[];
    sharedPostId: string;
    pageId?: string;
    page?: {
        id?: string;
        name?: string;
        slug?: string;
        sector?: string;
        banner?: string;
        logo?: string;
        site?: string;
    };
    media?: unknown;
    linkPreview?: unknown;
    visibility?: string;
    sharedPost: Post$1;
    currentUserReaction?: string;
    title?: string;
    stats?: {
        reactionCount?: number;
        commentCount?: number;
        shareCount?: number;
    };
    sharedContext?: unknown;
    mention?: IMention[];
    community?: {
        id: string;
        visibility: string;
        slug: string;
        banner?: string;
        createdAt?: string;
        description?: string;
        image?: string;
        location?: string;
        name: string;
        owner: {
            id: string;
            name: string;
            slug: string;
            email?: string;
        };
        ownerId: string;
        members?: {
            userId: string;
            user: {
                id: string;
                name: string;
                slug: string;
            };
        }[];
    };
    userId?: string;
    sharedInCommunity?: {
        id: string;
        slug: string;
        visibility: string;
        name: string;
        banner?: string;
        image?: string;
        location?: string;
        ownerId: string;
        owner: {
            id: string;
            slug: string;
            name: string;
        };
    };
    communityId?: string;
};
type PostAssetProps$1 = {
    id: string;
    url: string;
    type?: "image" | "video" | "pdf";
    createdAt?: string;
};
type PostReactionsProps$1 = {
    id: string;
    userId: string;
    postId: string;
    reaction: "LIKE" | "LOVE" | "HAHA" | "WOW" | "SAD" | "ANGRY" | "AGREE" | "DISAGREE" | "NO_COMMENT" | "EUREKA" | "SUPPORT";
    createdAt: string;
    updatedAt: string;
    user: User$1;
};
type CommentReactionsProps$1 = {
    id: string;
    userId: string;
    commentId: string;
    reaction: "LIKE" | "LOVE" | "HAHA" | "WOW" | "SAD" | "ANGRY" | "AGREE" | "DISAGREE" | "EUREKA" | "NO_COMMENT" | "SUPPORT" | "DISLIKE";
    createdAt: string;
    updatedAt: string;
    user?: User$1;
};
type CommentProps$1 = {
    id: string;
    userId: string;
    postId: string;
    answerId: string;
    content: string;
    imageUrl: string;
    createdAt: string;
    updatedAt: string;
    user: User$1;
    reactions: CommentReactionsProps$1[];
    totalReactions?: number;
    answers: CommentProps$1[];
    totalAnswers: number;
    page?: {
        id: string;
        name: string;
        slug: string;
        sector: string;
    };
};

type PostType = "text" | "media" | "job" | "reel" | "schedule" | null;
type InitialStep = "main" | "schedule" | "scheduled-posts" | null;
interface CreatePostState {
    isOpen: boolean;
    post: Post$1 | undefined;
    setPost: (post: Post$1 | undefined) => void;
    postType: PostType;
    initialStep: InitialStep;
    openModal: (type?: PostType, step?: InitialStep) => void;
    closeModal: (preserveFormState?: boolean) => void;
    operation: "create" | "update";
    setOperation: (operation: "create" | "update") => void;
    setInitialStep: (step: InitialStep) => void;
}
declare const useCreatePostStore: zustand.UseBoundStore<zustand.StoreApi<CreatePostState>>;

type TMentionType = "user" | "page" | "community";
type TMentionItem = {
    id?: string;
    name?: string;
    slug?: string;
    logo?: string;
    image?: string;
    avatar?: string;
    headline?: string;
    type?: TMentionType;
};

type MentionableItem$1 = {
    id?: string;
    name?: string;
    slug?: string;
    image?: string;
    type?: 'user' | 'page' | 'community';
    originalData?: TMentionItem;
};

declare function injectMentionUIDs(text: string, mentionedItems: MentionableItem$1[]): string;

type MentionableItem = {
    id?: string;
    name?: string;
    slug?: string;
    image?: string;
    type?: "user" | "page" | "community";
    originalData?: TMentionItem;
};

interface MentionableTextareaRef {
    insertMention: () => void;
    focus: () => void;
    getEditor: () => HTMLDivElement | null;
}
type MentionableTextareaProps = {
    value: string;
    onChange: (value: string) => void;
    placeholder?: string;
    className?: string;
    disabled?: boolean;
    onMentionsChange?: (mentions: IMention[]) => void;
    onKeyDown?: React__default.KeyboardEventHandler<HTMLDivElement>;
    minHeight?: number;
    maxHeight?: number;
    initialMentions?: MentionableItem[];
};
declare const MentionableTextarea: React__default.ForwardRefExoticComponent<MentionableTextareaProps & React__default.RefAttributes<MentionableTextareaRef>>;

type User = {
    id?: string;
    name?: string;
    slug?: string;
    about?: string;
    email?: string;
    phone?: string;
    isOpenToWork?: boolean;
    gender?: string;
    banner?: string;
    isContact?: boolean;
    isFollowed?: boolean;
    isFollowedBy?: boolean;
    birthDate?: string;
    nationality?: string;
    headline?: string;
    country?: string;
    city?: string;
    street?: string;
    countryCode?: string;
    profession?: string;
    addresses?: {
        country?: string;
        city?: string;
        address?: string;
    }[];
    address?: {
        country?: string;
        city?: string;
        address?: string;
    };
    avatar?: string;
    avatarDisplay?: string;
    provider?: string;
    role?: string;
    status?: string;
    createdAt?: string;
    updatedAt?: string;
    isPublic?: boolean;
    currentCompany?: string;
    person?: IPerson;
    link?: string;
    links?: string[];
};
interface IPerson {
    gender?: string;
    birthDate?: Date;
    nationality?: string;
    maritalStatus?: string;
    salaryExpectation?: string;
    countryCode?: string;
}
type PostAttachmentProps = {
    title?: string;
    description?: string;
    imageUrl?: string;
    url?: string;
    slug?: string;
    type: string;
};
type Post = {
    user: User;
    postType: "NORMAL" | "REEL";
    id: string;
    slug: string;
    createdAt: string;
    scheduledAt?: string;
    bio: string;
    content: string;
    totalShares: number;
    totalReactions?: number;
    totalComments?: number;
    attachment?: PostAttachmentProps;
    isFollowed?: boolean;
    isContact?: boolean;
    isArticle?: boolean;
    expiresAt?: string | null;
    link: {
        title: string;
        description: string;
        imageUrl: string;
        url: string;
        slug: string;
    };
    images: PostAssetProps[];
    videos: PostAssetProps[];
    reactions: PostReactionsProps[];
    comments: CommentProps[];
    sharedPostId: string;
    page?: {
        id?: string;
        name?: string;
        slug?: string;
        sector?: string;
        banner?: string;
        logo?: string;
        site?: string;
    };
    media?: unknown;
    linkPreview?: unknown;
    visibility?: string;
    sharedPost: Post;
    title?: string;
    stats?: {
        reactionCount?: number;
        commentCount?: number;
        shareCount?: number;
    };
    sharedContext?: unknown;
    mention?: {
        id: string;
        mentionedId: string;
        mentioned: User;
    }[];
    community?: {
        id: string;
        visibility: string;
        slug: string;
        banner?: string;
        createdAt?: string;
        description?: string;
        image?: string;
        location?: string;
        name: string;
        owner: {
            id: string;
            name: string;
            slug: string;
            email?: string;
        };
        ownerId: string;
        members?: {
            userId: string;
            user: {
                id: string;
                name: string;
                slug: string;
            };
        }[];
    };
    userId?: string;
    sharedInCommunity?: {
        id: string;
        slug: string;
        visibility: string;
        name: string;
        banner?: string;
        image?: string;
        location?: string;
        ownerId: string;
        owner: {
            id: string;
            slug: string;
            name: string;
        };
    };
    communityId?: string;
};
type PostAssetProps = {
    id: string;
    url: string;
    type?: "image" | "video" | "pdf";
    createdAt?: string;
};
type PostReactionsProps = {
    id: string;
    userId: string;
    postId: string;
    reaction: "LIKE" | "LOVE" | "HAHA" | "WOW" | "SAD" | "ANGRY";
    createdAt: string;
    updatedAt: string;
    user: User;
};
type CommentReactionsProps = {
    id: string;
    userId: string;
    commentId: string;
    reaction: "LIKE" | "LOVE" | "HAHA" | "AGREE" | "DISLIKE" | "EUREKA" | "NO_COMMENT" | "SUPPORT";
    createdAt: string;
    updatedAt: string;
    user?: User;
};
type CommentProps = {
    id: string;
    userId: string;
    postId: string;
    answerId: string;
    content: string;
    imageUrl: string;
    createdAt: string;
    updatedAt: string;
    user: User;
    reactions: CommentReactionsProps[];
    totalReactions?: number;
    answers: CommentProps[];
    totalAnswers: number;
    page?: {
        id: string;
        name: string;
        slug: string;
        sector: string;
    };
};

interface RepostFlowTriggerProps {
    post: Post;
    className?: string;
}
declare function RepostFlowTrigger({ post, className }: RepostFlowTriggerProps): React__default.JSX.Element;

interface ShareFlowTriggerProps {
    post: Post;
    className?: string;
}
declare function ShareFlowTrigger({ post, className }: ShareFlowTriggerProps): React__default.JSX.Element;

interface SavedItemsStoreProps {
    isOpen: boolean;
    openModal: () => void;
    closeModal: () => void;
    toggleModal: () => void;
}
declare const useSavedItemsStore: zustand.UseBoundStore<zustand.StoreApi<SavedItemsStoreProps>>;

declare function GradientModal({ onClose, children, isOpen, className, contentClassName, showGradient, }: {
    onClose: () => void;
    children: React__default.ReactNode;
    isOpen: boolean;
    className?: string;
    contentClassName?: string;
    showGradient?: boolean;
}): React__default.JSX.Element;

type OportunityType = "jobs" | "candidancies" | null;
interface OportunitiesState {
    openType: OportunityType;
    setOpenType: (type: OportunityType) => void;
    reset: () => void;
}
declare const useOportunitiesStore: zustand.UseBoundStore<zustand.StoreApi<OportunitiesState>>;

interface ICreateCompanyModalProps {
    isOpen: boolean;
    onClose: () => void;
}

declare function CreateCompany({ isOpen, onClose }: ICreateCompanyModalProps): React__default.JSX.Element;

declare function PagesFeedTrigger({ onClick }: {
    onClick?: (e: React__default.MouseEvent) => void;
}): React__default.JSX.Element;

interface NavbarProps {
    activeOverride?: "home" | "jobs" | "marketplace";
}

declare function Header({ className, activeOverride }: {
    className?: string;
    activeOverride?: NavbarProps["activeOverride"];
}): React__default.JSX.Element;

interface CandidaciesTriggerState {
    isCandidaciesOpen: boolean;
    openCandidacies: () => void;
    closeCandidacies: () => void;
    toggleCandidacies: () => void;
}
declare const useCandidaciesTriggerStore: zustand.UseBoundStore<zustand.StoreApi<CandidaciesTriggerState>>;

interface JobTriggerState {
    isJobOpen: boolean;
    openJob: () => void;
    closeJob: () => void;
    toggleJob: () => void;
}
declare const useJobTriggerStore: zustand.UseBoundStore<Omit<zustand.StoreApi<JobTriggerState>, "setState" | "persist"> & {
    setState(partial: JobTriggerState | Partial<JobTriggerState> | ((state: JobTriggerState) => JobTriggerState | Partial<JobTriggerState>), replace?: false | undefined): unknown;
    setState(state: JobTriggerState | ((state: JobTriggerState) => JobTriggerState), replace: true): unknown;
    persist: {
        setOptions: (options: Partial<zustand_middleware.PersistOptions<JobTriggerState, unknown, unknown>>) => void;
        clearStorage: () => void;
        rehydrate: () => Promise<void> | void;
        hasHydrated: () => boolean;
        onHydrate: (fn: (state: JobTriggerState) => void) => () => void;
        onFinishHydration: (fn: (state: JobTriggerState) => void) => () => void;
        getOptions: () => Partial<zustand_middleware.PersistOptions<JobTriggerState, unknown, unknown>>;
    };
}>;

type TLocale = "pt" | "en" | "fr";
type ToastVariant = "error" | "warning" | "info";
interface IMirantesErrorHandlerConfig {
    onRedirect?: (path: string) => void;
    onLogout?: () => void;
    onRetry?: () => void;
    onCriticalError?: (title: string, message: string) => void;
    locale?: TLocale;
}

interface MirantesErrorBoundaryProps {
    children: React__default.ReactNode;
    locale?: TLocale;
    fallback?: React__default.ReactNode | ((error: Error, reset: () => void) => React__default.ReactNode);
    onError?: (error: Error, info: React__default.ErrorInfo) => void;
}
interface MirantesErrorBoundaryState {
    hasError: boolean;
    error: Error | null;
}
declare class MirantesErrorBoundary extends React__default.Component<MirantesErrorBoundaryProps, MirantesErrorBoundaryState> {
    constructor(props: MirantesErrorBoundaryProps);
    static getDerivedStateFromError(error: Error): MirantesErrorBoundaryState;
    componentDidCatch(error: Error, info: React__default.ErrorInfo): void;
    handleReset(): void;
    render(): string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | React__default.JSX.Element | null | undefined;
}

declare function setErrorConfig(newConfig: IMirantesErrorHandlerConfig): void;
declare function getErrorConfig(): IMirantesErrorHandlerConfig | null;
declare function clearErrorConfig(): void;

declare function handleError(error: unknown, toastFunctions?: {
    errorToast: (props: {
        title: string;
        message?: string;
        actionLabel?: string;
        onAction?: () => void;
    }) => void;
    warningToast: (props: {
        title: string;
        message?: string;
    }) => void;
    infoToast: (props: {
        title: string;
        message?: string;
    }) => void;
}): void;
declare function handleAxiosError(error: any, toastFunctions?: any): void;
declare function handleGraphQLError(error: any, toastFunctions?: any): void;

declare function useErrorHandler(): {
    handleError: (error: unknown) => void;
    handleAxiosError: (error: any) => void;
    handleGraphQLError: (error: any) => void;
};
declare function useAxiosErrorInterceptor(axiosInstance?: AxiosInstance): void;

interface MirantesChatButtonProps {
    forMobile?: boolean;
    chatForPage?: boolean;
}
declare function MirantesChatButton({ forMobile, chatForPage, }: MirantesChatButtonProps): React__default.JSX.Element;

declare function useOpenChat(): {
    isChatVisible: boolean;
    isToSendMessageToPage: boolean;
    toggleChat: () => void;
    openChat: (sendMessageToPage?: boolean) => void;
    closeChat: () => void;
};

interface IndexProps {
    chatForPage?: boolean;
    isCompactMode?: boolean;
}
declare const Index: ({ chatForPage, isCompactMode }: IndexProps) => React__default.JSX.Element;

declare const MirantesPDFViewer: ({ url, className, }: {
    url?: string;
    className?: string;
}) => React__default.JSX.Element;

interface CalendarProps {
    locale?: "pt" | "fr" | "en";
    onMarkAsUnavailable?: () => void;
    isModalOpen?: boolean;
    onClose?: () => void;
    calendarCardClassName?: string;
}
declare function Calendar({ onMarkAsUnavailable, isModalOpen, onClose, calendarCardClassName, }: CalendarProps): React__default.JSX.Element;

interface PageFloatFooterProps {
    /**
     * Callback chamado quando o botão de adicionar é clicado.
     * Se fornecido, será usado em vez do comportamento padrão.
     */
    onAddClick?: () => void;
}
declare function PageFloatFooter({ onAddClick }: PageFloatFooterProps): React__default.JSX.Element;

interface ControlButtonsProps {
    onPrevious: () => void;
    onNext: () => void;
    canGoPrevious: boolean;
    canGoNext: boolean;
}
declare const ControlButtons: ({ onPrevious, onNext, canGoPrevious, canGoNext }: ControlButtonsProps) => React__default.JSX.Element;

interface PdfFooterProps {
    currentPage: number;
    numPages: number;
    pdfUrl: string;
    isHovered: boolean;
    onToggleFullscreen?: () => void;
    variant?: 'default' | 'fullscreen';
    zoom?: number;
    onZoomIn?: () => void;
    onZoomOut?: () => void;
}
declare const PdfFooter: ({ currentPage, numPages, pdfUrl, isHovered, onToggleFullscreen, variant, zoom, onZoomIn, onZoomOut }: PdfFooterProps) => React__default.JSX.Element;

interface PdfFullscreenViewProps {
    pdfUrl: string;
    pdfUrlWithPage: string;
    currentPage: number;
    numPages: number;
    pdfName: string;
    zoom: number;
    onClose: () => void;
    onDownload: () => void;
    onOpenAccessibility: () => void;
    onZoomIn: () => void;
    onZoomOut: () => void;
    onPreviousPage: () => void;
    onNextPage: () => void;
    canGoPrevious: boolean;
    canGoNext: boolean;
}
declare const PdfFullscreenView: ({ pdfUrl, pdfUrlWithPage, currentPage, numPages, pdfName, zoom, onClose, onDownload, onOpenAccessibility, onZoomIn, onZoomOut, onPreviousPage, onNextPage, canGoPrevious, canGoNext, }: PdfFullscreenViewProps) => React__default.ReactPortal | null;

interface PdfReaderProps {
    pdfUrl?: string;
    totalPages?: number;
    pdfName?: string;
    className?: string;
    onMaximizeClicked?: () => void;
}
declare const PdfReader: ({ pdfUrl, totalPages: initialTotalPages, pdfName: initialPdfName, className, onMaximizeClicked }: PdfReaderProps) => React__default.JSX.Element;

interface PdfReaderHeaderProps {
    pdfName: string;
    currentPage: number;
    numPages: number;
    isHovered: boolean;
    variant?: 'default' | 'fullscreen';
    onOpenAccessibility?: () => void;
    onDownload?: () => void;
    onClose?: () => void;
}
declare const PdfReaderHeader: ({ pdfName, currentPage, numPages, isHovered, variant, onOpenAccessibility, onDownload, onClose }: PdfReaderHeaderProps) => React__default.JSX.Element;

interface ProgressBarProps {
    currentPage: number;
    totalPages: number;
}
declare const ProgressBar: ({ currentPage, totalPages }: ProgressBarProps) => React__default.JSX.Element;

declare function OpenClipsButton(): React__default.JSX.Element;

declare function PostTriggerModal(props: any): React__default.JSX.Element | null;

declare function PostBackgroundManager({ displayMode, }: {
    displayMode?: "inline" | "floating";
}): React__default.JSX.Element;

type TActions = "media" | "clips" | "saved-items" | "articles" | "mention" | "create-a-job" | "schedule-a-post";

declare function PostTrigger({ community, type: initialType, restrictProfileSelection, optimisticUpdateType, hiddenOptions, onClickAction, processModeDisplay, typeRender, }: {
    processModeDisplay?: "floating" | "inline";
    typeRender?: {
        render?: "input" | "button";
        buttonClassName?: string;
        buttonText?: string;
    };
    type?: "page" | "user" | "community";
    restrictProfileSelection?: boolean;
    optimisticUpdateType: "profile" | "pages" | "community" | "feed" | "feed-with-go";
    hiddenOptions?: TActions[];
    onClickAction: (action: "clips" | "saved-items" | "articles") => void;
    community?: {
        id?: string;
        name?: string;
        logo?: string;
        sector?: string;
    };
}): React__default.JSX.Element;

declare const useApiCheckRater: ({ userId, pageId, communityId, forAPage, inView, }: {
    userId?: string;
    pageId?: string;
    communityId?: string;
    forAPage?: boolean;
    inView?: boolean;
}) => {
    hasRated: boolean;
    isCheckingRater: boolean;
    error: Error | null;
};

type AddRatingProps = {
    enableTitle?: boolean;
    variantStars?: "large" | "small" | "medium";
    starSize?: {
        width: number;
        height: number;
    };
    forAPage?: boolean;
    receiverPageId?: string;
    receiverUserId?: string;
    receiverCommunityId?: string;
    className?: string;
    isCommunity?: boolean;
    variant?: "default" | "feed" | "only-one-card";
    userSlug?: string;
    pageSlug?: string;
    communitySlug?: string;
    align?: "left" | "center" | "right";
};
declare function AddRating({ enableTitle, variantStars, starSize, forAPage, receiverPageId, receiverUserId, receiverCommunityId, className, isCommunity, variant, userSlug, pageSlug, communitySlug, align, }: AddRatingProps): React__default.JSX.Element;

type AvatarRatingBadgeProps = {
    name?: string;
    src?: string;
    rating: number;
    asPage?: boolean;
    isCommunity?: boolean;
    className?: string;
    slug?: string;
};
declare function AvatarRatingBadge({ name, asPage, src, rating, isCommunity, className, slug, }: AvatarRatingBadgeProps): React__default.JSX.Element;

declare function RatingReviewsList({ variant, forPage, receiverPageId, receiverUserId, receiverCommunityId, inlinePreview, onOpenAllRatings, externalError, }: {
    variant?: "maximized" | "minimized";
    forPage?: boolean;
    receiverUserId?: string;
    receiverPageId?: string;
    receiverCommunityId?: string;
    inlinePreview?: boolean;
    onOpenAllRatings?: () => void;
    externalError?: unknown;
}): React__default.JSX.Element | null;

interface IRatingsCardProps {
    isCurrentPageOrProfile?: boolean;
    userId?: string;
    pageId?: string;
    communityId?: string;
    forAPage?: boolean;
    currentUserId?: string;
    pageSlug?: string;
    userSlug?: string;
    communitySlug?: string;
}
type TRatingUserCard = {
    user: {
        name: string;
        profession: string;
        avatar?: string;
        isOwner?: boolean;
        slug?: string;
    };
    anonymous?: boolean;
    rating: number;
    userRating: number;
    comment: string;
    createdAt: string | Date;
};

declare function RatingUserCard({ user, rating, userRating, comment, createdAt, anonymous, }: TRatingUserCard): React__default.JSX.Element;

interface RattingSuggestionCardProps {
    asPage?: boolean;
    page?: {
        slug?: string;
        id?: string;
        sector?: string;
        logo?: string;
        rating?: number;
        totalRatings?: number;
    };
    user?: {
        avatar?: string;
        name?: string;
        id?: string;
        headline?: string;
        slug?: string;
        rating?: number;
        totalRatings?: number;
    };
    renderFollowButton?: ReactNode;
    averageRatingScore?: number;
}
declare function RattingSuggestionCard({ asPage, page, user, renderFollowButton, averageRatingScore, }: RattingSuggestionCardProps): React__default.JSX.Element;

declare function RatingsSummary({ variant, asPage, receiverUserId, receiverPageId, receiverCommunityId }: {
    variant?: "maximized" | "minimized";
    asPage?: boolean;
    receiverUserId?: string;
    receiverPageId?: string;
    receiverCommunityId?: string;
}): React__default.JSX.Element;

interface ShareProfileDivProps extends RattingSuggestionCardProps {
    className?: string;
}
declare function ShareProfile({ asPage, page, user, className, }: ShareProfileDivProps): React__default.JSX.Element;

interface ShareProfileButtonProps {
    onClick: () => void;
}
declare function ShareProfileButton({ onClick }: ShareProfileButtonProps): React__default.JSX.Element;

interface ShareProfileModalProps extends RattingSuggestionCardProps {
    isOpen: boolean;
    onClose: () => void;
}
declare function ShareProfileModal({ asPage, page, user, isOpen, onClose, }: ShareProfileModalProps): React__default.JSX.Element;

declare function RatingsCard({ isCurrentPageOrProfile, pageId, userId, communityId, variant, forAPage, currentUserId, className, userSlug, pageSlug, communitySlug, }: IRatingsCardProps & {
    variant?: "maximized" | "minimized";
    className?: string;
    userSlug?: string;
    pageSlug?: string;
    communitySlug?: string;
}): React__default.JSX.Element;

type TReaction = "AGREE" | "SUPPORT" | "EUREKA" | "NO_COMMENT" | "DISAGREE";
type TReactionsFor = "feed" | "comments" | "profile" | "pages" | "communities";
type TReactionPostSnapshot = {
    id?: string;
    totalReactions?: number;
    currentUserReaction?: string | null;
    myReaction?: string | null;
    reactions?: Array<{
        reaction?: string;
        userId?: string;
    }>;
    metrics?: {
        reactions?: Array<{
            type?: string;
            count?: number;
        }>;
    };
};
type TReactionsButtonProps = {
    className?: string;
    currentReaction?: TReaction | null;
    totalReactions?: number;
    topReactions?: TReaction[];
    /** When set (e.g. feed post), totals and top badges are derived from this object and stay in sync after optimistic updates. */
    post?: TReactionPostSnapshot;
    reactionsFor?: TReactionsFor;
    isGettingReactions?: boolean;
    postId?: string;
    commentId?: string;
    /** Profile feed cache (`postsByUser`) when `reactionsFor` is `"profile"`. */
    profileUserId?: string;
    /** Page posts cache (`post-page`) when `reactionsFor` is `"pages"`. */
    pageId?: string;
};

declare function ReactionButton({ reactionsFor, currentReaction, isGettingReactions, topReactions, totalReactions, post, postId, commentId, profileUserId, pageId, className, }: TReactionsButtonProps): React__default.JSX.Element;

declare function getPostReactionSummary(post: TReactionPostSnapshot, options?: {
    fallbackTop?: TReaction[];
    fallbackTotal?: number;
    userId?: string;
}): {
    totalReactions: number;
    topReactions: TReaction[];
    currentReaction: TReaction | null;
};
declare function applyOptimisticReactionToSnapshot(snapshot: TReactionPostSnapshot, postId: string, reaction: TReaction, userId: string, userInfo: {
    id: string;
    name: string;
    email: string;
    avatar: string;
    slug: string;
    headline: string;
}): TReactionPostSnapshot;

type ReactionType = {
    emoji: ReactNode;
    id: string;
    label: string;
};

type ReactionMetric = {
    type?: string;
    count?: number;
};
type ReactPostButtonProps = {
    post: Post$2;
    hideLabel?: boolean;
    className?: string;
    orientation?: "vertical" | "horizontal";
    compact?: boolean;
    currentReaction?: string | null;
    totalReactions?: number;
    reactions?: Post$2["reactions"];
    optimisticReactions?: PostReactionsProps$2[];
    topReactions?: ReactionType[];
    metrics?: {
        reactions?: ReactionMetric[];
    } | ReactionMetric[];
};
declare function ReactPostButton({ post, hideLabel, className, orientation, compact, currentReaction: currentReactionOverride, totalReactions: totalReactionsOverride, reactions: reactionsOverride, optimisticReactions: optimisticReactionsOverride, topReactions: topReactionsOverride, metrics, }: ReactPostButtonProps): JSX.Element;

type DrawerSide = 'bottom' | 'right';
interface ResponsiveDrawerProps {
    isOpen: boolean;
    onClose: () => void;
    children: React__default.ReactNode;
    className?: string;
    fullWidth?: boolean;
    title?: string;
    header?: React__default.ReactNode;
    footer?: React__default.ReactNode;
    side?: DrawerSide;
}
declare const ResponsiveDrawer: React__default.FC<ResponsiveDrawerProps>;

declare function Spinner({ className }: {
    className?: string;
}): React__default.JSX.Element;

interface SalaryInputWithButtonProps {
    label?: string;
    value?: {
        amount: string;
        currency: string;
    };
    onChange?: (val: {
        amount: string;
        currency: string;
    }) => void;
    onGenerate?: () => void;
    placeholder?: string;
    disabled?: boolean;
    className?: string;
    buttonLabel?: string;
}
declare function SalaryInputWithButton({ label, value, onChange, onGenerate, placeholder, disabled, className, buttonLabel, }: SalaryInputWithButtonProps): React__default.JSX.Element;

interface SharePostModalProps {
    isOpen: boolean;
    onClose: () => void;
    post: Post;
    isProfileLink?: boolean;
    variant?: "share" | "repost";
    postCardComponent?: React__default.ReactNode | JSX.Element;
}
declare const SharePostModal: ({ isOpen, onClose, post, variant, isProfileLink, postCardComponent, }: SharePostModalProps) => JSX.Element;

declare function getInitials(fullName: string): string;

declare function joinUrlWithPathAndQuery(baseUrl: string, path: string, query?: Record<string, string>): string;

declare function broadcastLogout(): void;
declare function onLogout(callback: () => void): void;
declare function closeLogoutChannel(): void;

declare function stringToObj<T>(inputString: string, separator: string): T | undefined;

type MobileWorkspaceBarProps = {
    onCreatePost?: () => void;
    onCreateReel?: () => void;
    onCreateJob?: () => void;
    onJobsClick?: () => void;
};
declare function MobileWorkspaceBar({ onCreateJob, }: MobileWorkspaceBarProps): React__default.JSX.Element;

declare function WorkspacePanel(): React__default.JSX.Element;

export { ActivateAccountModal, AddRating, AddressAutocompleteInput, AnimatedModal, ArticleContent, ArticleViewer, AutoComponent, AutoDownloadBanner, AvatarRatingBadge, BaseInput, Button, ChatContacts, ChatListWrapper, ChatView, ChatViewDesktopPage, CheckBoxInput, closeLogoutChannel as CloseLogoutChannel, ContactsModal, ControlButtons, CountryDisplay, CountryInput, CreateCompany, CreatePostCard, CreatePostContent, CreatePostForm, CreatePostModal, CreatePostModalFilters, CreatePostReelForm, CreatePostScheduleStep, CreatePostToolbar, CustomDateInput, CustomDrawer, CustomDropdown, MirantesModal as CustomMirantesModal, CustomSelectInput, DateInput, DownloadMobileVersionBanner, DownloadModalTrigger, EmojiPickerButton, GradientModal, Header, type IMirantesErrorHandlerConfig, MentionableTextarea, MessageButton, MessagesButtonFromPage, MirantesButton, Index as MirantesChatApp, MirantesChatButton, MirantesErrorBoundary, MirantesFoundationProvider, MirantesPDFViewer, ResponsiveDrawer as MirantesResponsiveDrawer, MirantesSheets, MobileWorkspaceBar, NoRecruitmentResponsiveIlustration, onLogout as Onlogout, OpenClipsButton, PageChatContent, PageChatContentHeader, PageChatInput, PageChatList, PageChatListWrapper, PageChatUserSuggestions, PageFloatFooter, PageMessageWrapper, PagesFeedTrigger, PdfFooter, PdfFullscreenView, PdfReader, PdfReaderHeader, PostBackgroundManager, PostCardArticle, PostTrigger, PostTriggerModal, ProgressBar, RadioButtonInput, RatingReviewsList, RatingUserCard, RatingsCard, RatingsSummary, RattingSuggestionCard, ReactPostButton, ReactionButton, RepostFlowTrigger, ResponsiveDrawer$1 as ResponsiveDrawer, SalaryInputWithButton, Calendar as ScheduleCalendar, ShareFlowTrigger, SharePostModal, ShareProfile, ShareProfileButton, ShareProfileModal, Spinner, type TReactionPostSnapshot, type ToastVariant, TripleInputDate, PostBackgroundManager as UploadProgressManager, WorkspacePanel, applyOptimisticReactionToSnapshot, broadcastLogout, clearErrorConfig, clearSettingsCookie, clearUserSession, closeLogoutChannel, createPersistentState, dispatchLogoutEvent, getErrorConfig, getInitials, getPostReactionSummary, getSettingsFromCookie, handleAxiosError, handleError, handleGraphQLError, injectMentionUIDs, joinUrlWithPathAndQuery, onLogout, setErrorConfig, stringToObj, useApiCheckRater, useApiGetContacts, useApiGetPage, useApiLogout, useArticleNavigation, useArticleStore, useAssetVersions, useAutoDisplay, useAxiosErrorInterceptor, useBestAssetVersion, useCandidaciesTriggerStore, useCommunityTriggerStore, useCreatePostFormStore, useCreatePostStore, useErrorHandler, useJobTriggerStore, useLoadSettings, useLogout, useMessageAppStore, useMirantesFoundation, useMirantesToast, useModalArticleStore, useModalStore, useOpenChat, useOportunitiesStore, usePeriodicDownloadBanner, usePersistentUIState, useRegisterTracking, useRestorePendingChat, useSavedItemsStore, useSetChatVisibility, useSignedUrl, useUploadAsset, useUploadAssetsBulk };
