import * as React$1 from 'react';
import React__default, { ReactNode, ChangeEvent, KeyboardEvent, FocusEvent } from 'react';
import { QueryClient } from '@tanstack/react-query';
import { AxiosInstance } from 'axios';
import * as zustand from 'zustand';

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

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

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

declare function getInitials(fullName: string): string;

type TLocale = "pt" | "en" | "fr";
interface IMirantesFoundationProviderProps {
    children: ReactNode;
    Notification?: ReactNode;
    queryClient?: QueryClient;
    onOpenCreatePostModal?: () => void;
    values?: {
        pageId?: string;
        page?: {
            id?: string;
            slug?: string;
            logo?: string;
            name?: string;
        };
        widgetsApi?: string;
        searchApi?: string;
        feedApi?: string;
        environment?: string;
        profileApiUrl?: string;
        billingApiUrl?: string;
        multicaixaExpressUrl?: string;
        stripeKey?: string;
        socketApiUrl?: string;
        chatApiUrl?: string;
        chatForPage?: boolean;
        mirantesDomain?: string;
        openCageApiKey?: string;
        ocpSubscriptionKey?: string;
        locale?: TLocale;
        Link?: LinkComponent;
        usePathname?: UsePathname;
        user?: User;
        isGettingUser?: boolean;
        isGettingStats?: boolean;
        hostUrl?: string;
        isDev?: boolean;
        authedApi?: AxiosInstance;
        uploadFilesApi?: AxiosInstance;
        authApiUrl?: string;
    };
}
interface IMirantesFoundationContext {
    widgetsApi?: string;
    feedApi?: string;
    searchApi?: string;
    profileApiUrl?: string;
    chatApiUrl?: string;
    billingApiUrl?: string;
    multicaixaExpressUrl?: string;
    stripeKey?: string;
    chatForPage?: boolean;
    environment?: string;
    socketApiUrl?: string;
    mirantesDomain?: string;
    locale?: TLocale;
    Link?: LinkComponent;
    usePathname?: UsePathname;
    pageId?: string;
    user?: User;
    page?: {
        id?: string;
        slug?: string;
        logo?: string;
        name?: string;
    };
    isGettingUser?: boolean;
    isGettingStats?: boolean;
    Notification?: ReactNode;
    openCageApiKey?: string;
    ocpSubscriptionKey?: string;
    authedApi?: AxiosInstance;
    uploadFilesApi?: AxiosInstance;
    authApiUrl?: string;
    queryClient?: QueryClient;
    onOpenCreatePostModal?: (cb?: () => void) => void;
}
type CommonLinkProps = {
    to?: string;
    href?: string;
    children: ReactNode;
    className?: string;
    replace?: boolean;
    [key: string]: any;
};
type User = {
    id: string;
    name: string;
    email: string;
    phone: string;
    currentCompany?: string;
    isOpenToWork: boolean;
    avatar: string;
    accessToken: string;
    refreshToken: string;
    role?: string;
    slug: string;
    isInterestsSynced?: boolean;
    headline?: string;
    followersCount?: number;
    followingCount?: number;
    postsCount?: number;
    profileCompletedPercentage?: number;
};
type LinkComponent = (props: CommonLinkProps) => any;
type UsePathname = () => string;

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

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

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

declare function useMirantesFoundation(): IMirantesFoundationContext;

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

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

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;

interface DateInputProps {
    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): 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 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 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 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 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;

type BaseInputProps = {
    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;
    disabled?: boolean;
    type?: string;
    name?: string;
    id?: string;
    className?: string;
    children?: React__default.ReactNode;
    wrapperClassName?: string;
    required?: boolean;
    inputClassName?: string;
    requiredInPlaceholder?: boolean;
    min?: number;
    max?: number;
    placeholderColor?: string;
};
declare const BaseInput: React__default.ForwardRefExoticComponent<BaseInputProps & React__default.RefAttributes<HTMLInputElement>>;

declare function CheckBoxInput({ isChecked, onClick, label, disabled, }: {
    isChecked?: 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;
    onClose: () => void;
    className?: string;
    isOpen?: boolean;
    hideCloseBlock?: boolean;
};
declare function CustomDrawer({ children, footer, onClose, className, isOpen, hideCloseBlock, }: CustomDrawerProps): React__default.JSX.Element;

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

type Option = {
    id: string;
    label: string;
    value: string;
};
type CustomSelectInputProps = {
    options: Option[];
    value?: string;
    onChange?: (option: Option) => 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;
};
declare function CustomSelectInput({ options, value, onChange, placeholder, className, enableSearch, floattable, required, showCheck, label, error, disabled, onSearch, isLoading, }: CustomSelectInputProps): React$1.JSX.Element;

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;

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

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

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

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

declare function ChatView(): 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;
}
declare function MessageButton({ user, page, icon, label, className, disabled, onClick: customOnClick, isSharing, link, }: IMessageButtonProps$1): React__default.JSX.Element;

interface JobTriggerState {
    isJobOpen: boolean;
    openJob: () => void;
    closeJob: () => void;
    toggleJob: () => void;
}
declare const useJobTriggerStore: zustand.UseBoundStore<zustand.StoreApi<JobTriggerState>>;

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

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

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 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({ isOpen, onClose, title, header, footer, children, className, swipeable, }: ExtendedDrawerProps): React$1.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>>;

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

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

declare const DownloadModalTrigger: () => React__default.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>;

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

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

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

interface IRatingsCardProps {
    isCurrentPageOrProfile?: boolean;
    userId?: string;
    pageId?: string;
    forAPage?: boolean;
    currentUserId?: string;
}

declare function RatingsCard({ isCurrentPageOrProfile, pageId, userId, variant, forAPage, currentUserId, className, }: IRatingsCardProps & {
    variant?: "maximized" | "minimized";
    className?: string;
}): 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;

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;

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

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

type AddRatingProps = {
    enableTitle?: boolean;
    variantStars?: "large" | "medium" | "small";
    starSize?: {
        width: number;
        height: number;
    };
    forAPage?: boolean;
    receiverPageId?: string;
    receiverUserId?: string;
    className?: string;
};
declare function AddRating({ enableTitle, variantStars, starSize, // <-- RECEBIDO AQUI
forAPage, receiverPageId, receiverUserId, className, }: AddRatingProps): 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;

declare const NoRecruitmentResponsiveIlustration: ({ className, }: {
    className?: string;
}) => 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";
}
declare function MessagesButtonFromPage({ user, label, className, disabled, onClick: customOnClick, variant, }: IMessageButtonProps): React__default.JSX.Element;

export { AddRating, AddressAutocompleteInput, AnimatedModal, AutoDownloadBanner, AvatarRatingBadge, BaseInput, Button, ChatContacts, ChatView, ChatViewDesktopPage, CheckBoxInput, ContactsModal, CountryDisplay, CountryInput, CustomDateInput, CustomDrawer, CustomDropdown, CustomSelectInput, DateInput, DownloadMobileVersionBanner, DownloadModalTrigger, GradientModal, Header, MessageButton, MessagesButtonFromPage, MirantesButton, MirantesFoundationProvider, NoRecruitmentResponsiveIlustration, PageFloatFooter, PagesFeedTrigger, RadioButtonInput, RatingsCard, RattingSuggestionCard, ResponsiveDrawer, SalaryInputWithButton, Calendar as ScheduleCalendar, ShareProfile, ShareProfileButton, ShareProfileModal, Spinner, WorkspacePanel, clearSettingsCookie, closeLogoutChannel, getInitials, getSettingsFromCookie, joinUrlWithPathAndQuery, onLogout, stringToObj, useApiGetPage, useCandidaciesTriggerStore, useCommunityTriggerStore, useJobTriggerStore, useLoadSettings, useMirantesFoundation, useModalStore, useOportunitiesStore, usePeriodicDownloadBanner, useSetChatVisibility };
