import { Subscription } from 'rxjs';
import { AdminType, Contact, EmailType, PhoneNumberType, ReceivedFileCustomisationValue, UserRole, UserType } from './contact.model';
import { RBEvent } from './event.model';
import { CompanyInfo } from '../models/company.model';
export declare enum UserProfileLimits {
    /** maximum number of e-mail addresses for a user */
    MAX_EMAIL_ADDRESSES = 2,
    /** maximum number of phone numbers addresses for a user */
    MAX_PHONE_NUMBERS = 6
}
/**
 * Display format for users' full names (first and last names) data.
 * - "FL": "First name, last name",
 * - "LF": "Last name, first name",
 */
export type DisplayOrder = 'FL' | 'LF';
/**
 * User-specific custom data in the form of an Object with a free keys/values structure
 * Restrictions on a CustomData Object:
 * - max 20 keys,
 * - max key length: 64 characters.
 * - max value length: 4096 characters.
 * It is up to the client to manage the user's customData.
 */
export type UserCustomData = Record<string, string>;
export interface UserAvatar {
    src: string;
}
export interface UsersByEmailsResult {
    contacts: Record<string, Contact>;
    contactsArray: Contact[];
    emails: string[];
}
export declare enum UserExternalPresenceStatus {
    /**
     * User goes to online by leaving any manual state.
     * In case of a call in progress, the user will go to busy state;
     */
    ONLINE = "online",
    /**
     * 'Do not disturb' manual state
     */
    DND = "dnd",
    /**
     * 'Invisible' or 'Appear offline' manual state
     */
    INVISIBLE = "invisible",
    /**
     * 'Away' manual state
     */
    AWAY = "away",
    /**
     * 'Busy' manual state
     */
    BUSY = "busy"
}
export declare enum UserPresenceStatus {
    /**
     * User goes to online by leaving any manual state.
     * In case of a call in progress, the user will go to busy state;
     */
    ONLINE = "online",
    /**
     * 'Do not disturb' manual state
     */
    DND = "dnd",
    /**
     * 'Invisible' or 'Appear offline' manual state
     */
    XA = "xa",
    /**
     * 'Away' manual state
     */
    AWAY = "away"
}
/**
 * This interface represents a user's phone number with its properties, the type of number and data for managing it.
 */
export interface UserPhoneNumber {
    /**
     * The type of the phone number (business, personal, etc.)
     */
    type: PhoneNumberType;
    /**
     * Related phone number. It can be used to make a phone call to this user
     */
    number: string;
    /**
     * Indicates if the phone number is visible by other users.
     * This information is only available and managed for some phone numbers: the business mobile, the personal phone and the personal mobile numbers.
     * For other phone numbers, this information is not relevant and will be ignored, particularly during an update.
     * If this property is not specified, the phone number will be considered to be in shared use.
     */
    shared?: boolean;
    /**
     * Indicates if the phone number can be updated or not.
     * In the absence of this property, the phone number is considered not modifiable.
     * This information is not relevant and will be ignored during an update.
     */
    readOnly?: boolean;
}
/**
 * This interface represents a user's phone number with its properties, the type of number and data for managing it.
 */
export interface UserEmailAddress {
    /** The type of the email (business or personal). */
    type: EmailType;
    /** Related email address. */
    address: string;
}
/**
 * This interface describes the information needed to specify the user's postal address.
 */
export interface PostalAddress {
    /** The number and the name of the street. */
    street: string;
    /** The department. */
    department: string;
    /** The postal code. */
    postalCode: string;
    /** The  city . */
    city: string;
    /** The  state . */
    state: string;
}
/**
 *T his interface provides additional information about a user, such as notes.
 */
export interface UserNotes {
    note1: string;
    note2: string;
}
/**
 * This interface provides media capabilites in a WebRTC Call.
 */
export interface WebCallCapabilities {
    /**
     * Indicates if the audio media can be used at a given moment in a WebRTC Call with a defined remote party.
     */
    audio?: boolean;
    /**
     * Indicates if the video media can be used at a given moment in a WebRTC Call with a defined remote party.
     */
    video?: boolean;
    /**
     * Indicates if the sharing media can be used at a given moment in a WebRTC Call with a defined remote party.
     */
    sharing?: boolean;
}
/**
 * This interface specifies the rights of the connected user in terms of access to certain features such as bubbles, file storage, channels...
 * and permissions to use some functionalities offered by these features.
 * These permissions can be granted or revoked by an administrator.
 * This interface is only available for the connected user.
 */
export interface UserOwnFeatureCapabilities {
    /** The ability for a user to change manually his presence status. */
    presenceUpdateEnabled: boolean;
    /** The ability for a user to set the presence status to 'Invisible'. */
    presenceSetInvisibleEnabled: boolean;
    /**
     * The ability for a user to use instant messages (IM).
     * So, to start a chat, send and receive IMs and notifications in a P2P or bubble conversation.
     */
    IMEnabled: boolean;
    /** The ability for the user to check if an IM message has been read by the peer. */
    IMReadReceiptsEnabled: boolean;
    /** The ability for the user to access the Rainbow file storage to upload/download/copy/share documents. */
    documentStorageEnabled: boolean;
    /** The ability for the user to share document (download and share documents). */
    documentSharingEnabled: boolean;
    /** The ability for the user to transfer a document from one conversation (P2P or bubble) to another. */
    documentTransferEnabled: boolean;
    /** The ability for the user to use the 'Channels' feature, i.e. to create or be a member of channels. */
    channelEnabled: boolean;
    /** The ability for the user to use the 'Bubbles' feature, i.e. to create bubbles or join bubbles (chat and bubble conference). */
    bubbleEnabled: boolean;
    /** The ability for the user to view the speaking time for each participant in a bubble conference. */
    bubbleUseSpeakingTimeStatsEnabled: boolean;
    /** The ability for the user to record a bubble conference. */
    bubbleConferenceRecordingEnabled: boolean;
    /** The ability for the user to use transcription in a bubble conference. */
    transcriptionEnabled: boolean;
    /**
     * The ability for the user to use Web RTC audio conversation (P2P/Bubble conference call).
     * This includes the ability to make WebRTC P2P audio call, start a bubble conference call and to be joined via Web RTC audio call.
     */
    callWebrtcAudioEnabled: boolean;
    /**
     * The ability for the user to use Web RTC video conversation (P2P/Bubble conference call).
     * This includes the ability to make WebRTC P2P video call, to add video in a bubble conference call and to be joined via Web RTC video call.
     */
    callWebrtcVideoEnabled: boolean;
    /** The ability for the user to share his screen. */
    callWebrtcSharingEnabled: boolean;
    /** The ability for the user to record a conversation of a P2P call. */
    callConversationRecordingEnabled: boolean;
    /** The ability for the user to modify his entire profile. */
    profileUpdateEnabled: boolean;
    /** The ability for the user to modify certain data relating to its name (title, firstName, lastName) in its profile. */
    profileTitleNameUpdateEnabled: boolean;
    /** The ability for the user to customize his/her avatar */
    profileAvatarCustomizationEnabled: boolean;
    /** The ability for the user to modify all general settings. */
    settingsUpdateEnabled: boolean;
    /** The ability for the user to use the 'Task' feature, i.e. to create and classify tasks, such as messages or personal notes. */
    taskEnabled: boolean;
    /** The ability for the user to activate the 'Calendar synchronization' feature, i.e. to activate the synchro between rainbow and some calendar provider like Outlook or Gmail. */
    calendarSynchEnabled: boolean;
}
/**
 * This interface specifies the custom status data of user
 */
export interface UserCustomStatus {
    /**
     * Information text. 100 char. max
     */
    status?: string;
    /**
     * Emoji icon. 10 char. max.
     */
    emoji?: string;
    /**
     * The status is valid until this date
     */
    expirationDate?: string;
}
/**
 * This interface specifies the rights of a user in terms of access to certain features
 * and permissions to use some functionalities offered by these features.
 * A capacity may also require the user's company to subscribe to a dedicated offer but may also require configuration
 * by an administrator in order to be allocated to the user.
 * This interface is available for all users.
 */
export interface UserPeerFeatureCapabilities {
    /**
     * The ability for a user to received alert notification sent as an emergency message.
     * Note: This information is not available for the connected user.
     */
    IMReceiveAlertNotificationEnabled: boolean;
    /** The ability for a user to receive files with possibly restricted source. */
    documentReceivedFilePermission: ReceivedFileCustomisationValue;
}
export interface ConnectedUserProfile {
    /**
     * User title
     */
    title?: string;
    /**
     * User first name
     */
    firstName?: string;
    /**
     * User last name
     */
    lastName?: string;
    /**
     * User nickname
     */
    nickName?: string;
    /**
     * User avatar object
     */
    avatar?: string;
    /**
     * User job title
     */
    jobTitle?: string;
    /**
     * User country (ISO 3166-1 alpha3 format)
     */
    country?: string;
    /**
     * Language format is composed of localeset using format ISO 639-1, with optionally the regional variation using ISO 3166‑1 alpha-2 (separated by hyphen).
     * Locale part is in lowercase, regional part is in uppercase. Examples: en, en-US, fr, fr-FR, fr-CA, es-ES, es-MX, ...
     */
    language?: string;
    /**
     * The list of phone numbers (personal and business) asssociated to the user.
     * When modifying a profile, the phone number management process is as follows:
     * For each provided type of number:
     * - A previously undefined phone number will be added.
     * - A phone number that has been changed will be updated.
     * - A phone number that has not been provided but existed previously will be deleted.
     * This does not applies to phone numbers defined by by the user's company administrator (The Business internal phone number for example)
     * and for phone number for which the 'readOnly' property is set to 'true'.
     * To delete all telephone numbers (except those that cannot be modified), simply set this property to an empty array ('[] ' value).
     * Before any modification, you can validate a phone number format using API 'isPhoneNumberValid(...)'.
     */
    phoneNumbers?: UserPhoneNumber[];
    /**
     * The list of email addresses (personal and business) asssociated to the user.
     * When modifying a profile, the email addresses management process is as follows:
     * For each provided type of email address:
     * - A previously undefined email address will be added.
     * - An email address that has been changed will be updated.
     * - An email address that has not been provided but existed previously will be deleted.
     * To delete all email addresses, simply set this property to an empty array ('[] ' value).
     * Before any modification, you can validate a e-mail address format using API 'isEmailAddressValid(...)'.
     */
    emailAddresses?: UserEmailAddress[];
}
export interface ConnectedUserDisplaySettings {
    /**
     * Display format for all users' full names (first and last names).
     * Note that modifying this parameter has an impact on the 'displayName' user property, which will be updated accordingly.
     */
    displayOrder?: DisplayOrder;
}
/**
 * Optional Hybrid(oxe only) trunk data obtained from server as user's settings data
 * A list of oxe trunks allow user to select a specific trunk to be used for oxe outgoing calls.
 * From user point of view, this trunk selection mainly impact the associated CLI sent to called.
 */
export interface ConnectedUserOxeTrunk {
    /**
     * trunk prefix (used on server side)
     * Allow server to make a call with the trunk
     */
    prefix: string;
    /**
     * description of the trunk (this info/label will be presented to the user in the telephonic settings)
     * in order to identify/select a preferred oxe trunk to be used.
     * The CLI used during outgoing oxe call will depend on this trunk selection.
     */
    description: string;
    /**
     * the trunk index (from server data) used to identify an oxe trunk from the list of trunks
     * This index will be also used to store a preferred trunk to be selected by user
     * and saved in oxePreferredTrunk field also shared with server
     */
    index: number;
}
/**
 * @eventProperty
 * `User` specific events
 * Can listen to it via `user.subscribe()` API
 */
export declare enum UserEvents {
    /**
     * @eventProperty
     * This RBEvent is send when the user presence status is updated
     */
    ON_PRESENCE_CHANGE = "ON_PRESENCE_CHANGE",
    /**
     * @eventProperty
     * This RBEvent is send when the user identity is updated (firstName, lastName, title, nickName or jobTitle)
     */
    ON_IDENTITY_CHANGE = "ON_IDENTITY_CHANGE",
    /**
     * @eventProperty
     * This RBEvent is send when the user avatar is updated
     */
    ON_AVATAR_CHANGE = "ON_AVATAR_CHANGE",//CHECK
    /**
     * @eventProperty
     * This RBEvent is send when the user custom status is updated
     */
    ON_CUSTOM_STATUS_CHANGE = "ON_CUSTOM_STATUS_CHANGE",
    /**
     * @eventProperty
     * This RBEvent is send when the user oxe preferred trunk is updated
     */
    ON_OXEPREFERREDTRUNK_CHANGE = "ON_OXEPREFERREDTRUNK_CHANGE"
}
export interface ConnectedUser extends User {
    /**
     * Specifies the type of administration for a logged-in user with an Administrator role.
     * @readonly
     */
    adminType: AdminType;
    /**
     * The different roles assigned to the connected user
     * @readonly
     */
    roles: UserRole[];
    /**
     * User-specific custom data in the form of an Object with a free keys/values structure
     * @readonly
     */
    customData?: Record<string, string>;
    /**
     * Display format for all users' full names (first and last names)
     * @readonly
     */
    displayOrder: DisplayOrder;
    /**
     * User capabilities
     * This corresponds to permissions granted by an administrator to a user to access features.
     * A capacity may also require the user's company to subscribe to a dedicated offer.
     * @readonly
     */
    ownFeatureCapabilities: UserOwnFeatureCapabilities;
    /**
     * Voicemail number (if the user has one).
     * This feature is only available if the user is behind a PBX, i.e. a Rainbow Hub or Rainbow Hybrid (OXO or OXE) telephone system.
     * In addition, a mailbox must be defined for this user.
     * @readonly
     */
    voicemailNumber: string;
    /**
     * This feature enhances user experience by allowing for more expressive and relevant statuses, improving communication clarity.
     * It also enables users to indicate their availability more precisely, fostering smoother interactions across the platform.
     * @readonly
     */
    customStatus: UserCustomStatus;
    /**
     * Only for OXE telephonic situation, a list of telephonic trunks. This optional structure contains all the trunk's info needed to make OXE call, using a selected
     * trunk that determines the used CLI for the outgoing calls. Those data are mainly provided by the server as a user's settings data set.
     * User has the possibility (if available) to select a specific CLI to be used by selecting the associated trunk.
     * This selected trunk will be then store in the "hereafter" field oxePreferredTrunk
     * @readonly
     */
    oxeTrunks?: ConnectedUserOxeTrunk[];
    /**
     * Only for OXE situation, this optional field contains the index of current selected trunk to be used for oxe outgoing call.
     * This index refers to one of the indexes contained within the structure oxeTrunkPrefixes (above)
     * This trunk selection determines the associated CLI presented to called for outgoing oxe call.
     * @readonly
     */
    oxePreferredTrunk?: number;
    /**
    * Set the current user presence status.
    * The user must have the 'presenceUpdateEnabled' capability (available through 'ownFeatureCapabilities' property) to be able to change manually this status.
    * The status list can be get at all time via getAvailablePresenceStatusList() API.
    * @param status - The presence status that the user wants to set.
    */
    setPresenceStatus(status: UserPresenceStatus | string): Promise<void>;
    /**
     * Set the current user custom status.
     * @param status - The custom status that the user wants to set
     *
     */
    setCustomStatus(status: UserCustomStatus): Promise<void>;
    /**
     * Set the current user custom status.
     * This will add a new "external" ressource to the connected user with that given custom status; Only 1 custom status can be set per user;
     * @param status - The custom status that the user wants to set
     * @param customMessage - The custom message that the user wants to set
     *
     */
    setCustomExternalPresence(status: UserExternalPresenceStatus | string, customMessage?: string): Promise<void>;
    /**
     * Remove the current user custom status.
     * This will remove the "external" ressource set before with setCustomExternalPresence API;
     *
     */
    removeCustomExternalPresence(): Promise<void>;
    /**
     * Return a list of status that the user can currently set via 'setPresenceStatus(...)' API.
     * Possible values are 'online', 'away', 'xa', 'dnd'.
     * + online: User goes to online (or can 'exit') any manual state. In case of a call in progress, the user will go to busy state.
     * + away: A manual Away state.
     * + xa: 'invisible' or 'appear offline' manual state.
     * + dnd:  Do not disturb manual state
     * @returns Returns an array of all available values to be used if the user wants to change his presence
    */
    getAvailablePresenceStatusList(): Promise<string[]>;
    /**
     * Set the user's password
     * @param oldPassword - the old password
     * @param newPassword - the new password
     * @param async - if TRUE, the resolve of this API will be done once the change is taken into account also on XMPP side; Default value is FALSE
     */
    setPassword(oldPassword: string, newPassword: string, async: boolean): Promise<User>;
    /**
     * Sets user profile data related to identity, mainly names, avatar, phone numbers and email addresses.
     * The user must have the 'profileUpdateEnabled' capability (available through 'ownFeatureCapabilities' property) to be able to modify his profile.
     * @param userProfile - the connected user'profile to update
     */
    setProfile(userProfile: ConnectedUserProfile): Promise<User>;
    /**
     * Sets user settings related to the display management such as the order in which first and last names are displayed.
     * @param userSettings - the connected user'settings to update
     */
    setDisplaySettings(userSettings: ConnectedUserDisplaySettings): Promise<void>;
    /**
     * Set user-specific custom data.
     * It is up to the connected user to define and manage their custom data.
     * Any new custom data that is provided will overwrite the existing data.
     * @param customData - the user's custom data.
     */
    setCustomData(customData: UserCustomData): Promise<User>;
    /**
     * Users have a default avatar generated from the initials of their first and/or last names.
     * Ex: User John Do, will have the default avatar : JD.
     * But this avatar can be overloaded by an image chosen by the user.
     * @param base64AvatarImg - Base64 image to be uploaded
     */
    setCustomAvatar(base64AvatarImg: string): Promise<User>;
    /**
     * Remove the current user custom avatar (reset to default avatar)
     */
    removeCustomAvatar(): Promise<User>;
    /**
     * Checks that an email address is valid.
     * @param emailAddress - The email address to verify.
     */
    isEmailAddressValid(emailAddress: string): boolean;
    /**
     * Checks that a phone number is valid.
     * @param phoneNumber - The phone number to verify.
     */
    isPhoneNumberValid(phoneNumber: string): boolean;
    /**
     * Delete current user account.
     * This method deletes the connectedUser account and all its associated data.
     * Depending on the configuration of the company hosting the connectedUser, this method may not work.
     */
    deleteAccount(): Promise<void>;
    /**
     * Get the capabilities representing the medias that could be used for a WebRTC Call with the specified remote Rainbow user.
     * The returned capabilities are a SNAPSHOT taken at the time of this API call and are valid (so guaranteed) only for the time of this call.
     * @param remoteParty - The Rainbow user you want to make a WebRTC call to
     */
    getMakeWebCallCapabilities(remoteParty: User): WebCallCapabilities;
    /**
     * Monitor which medias can be used for a WebRTC call with the specified remote Rainbow user.
     * This monitoring is done through a subscription which allows to receive real-time updates on the capabilities representing these medias.
     * A callback is required to retrieve and managed the current values of these capabilities that will be returned "as parameter" of this callback.
     * An error callback can also be optionally specified to handle thrown errors.
     * It is important to note that, once this monitoring is no longer required, it must be stopped using the 'unsubscribe' method on this subscription.
     * @param remoteParty - The Rainbow user you want to make a WebRTC call to
     * @param callbackResult - Callback to manage capabilities sent in real time
     * @param callbackError - Callback to manage errors
     */
    monitorWebCallCapabilities(remoteParty: User, callbackResult: (arg0: WebCallCapabilities) => any, callbackError?: (error: any) => any): Subscription;
    /**
     * The function will return true if the user is currently engaged in any kind of webrtc call / conference
     * This will not return true if the user has PBX calls in office mode, but only when
     * the call or the conference are done on this current device;
     */
    isCurrentlyInCall(): boolean;
}
/**
 * This interface is used to represent a Rainbow user<br/>
 * A User is defined by a set of public information (name, firstname, avatar...) and a set of private information that are only shared with contacts that are in the user's network or in the same company (email, phone numbers...)
 */
export interface User {
    /**
     * Permits to emit UserEvents events
     * Can be listened via user.subscribe() API
     * @param name - the name of the event
     * @param data - the data to be send (an object
     */
    sendEvent(name: UserEvents, data?: any): void;
    /**
     * Subscribe to updates on the current contact (all events are of RBEvent type \{name: string, data:any \});
     * @param handler - The call-back function that will be subscribed to the RxJS subject
     * @param eventNames - A list of event names that the user wants to receive when subscribing (used a filter)
     */
    subscribe(handler: (event: RBEvent<UserEvents>) => any, eventNames?: UserEvents[]): Subscription;
    /**
     * User unique identifier
     * @readonly
     * @internal
     */
    id: string;
    /**
     * User unique database identifier
     * @readonly
     * @internal
     */
    dbId: string;
    /**
     * User unique xmpp identifier
     * @readonly
     * @internal
     */
    jid: string;
    /**
     * User unique xmpp identifier and ressource
     * @readonly
     * @internal
     */
    fullJid: string;
    /**
     * The User main email adress which can also be used for login.
     * @readonly
     */
    loginEmail?: string;
    /**
     * The user displayName (depending of lastname/firstname order settings)
     * @readonly
     */
    displayName?: string;
    /**
     * The user firstname
     * @readonly
     */
    firstname?: string;
    /**
     * The user lastname
     * @readonly
     */
    lastname?: string;
    /**
     * The user nickname
     * @readonly
     */
    nickname?: string;
    /**
     * The user title
     * @readonly
     */
    title?: string;
    /**
     * The user job title
     * @readonly
     */
    jobTitle?: string;
    /**
     * Information about the company associated with the user.
     * This is either the company to which the user belongs, or a company specified manually in a contact card.
     * @readonly
     */
    companyInfo: CompanyInfo;
    /**
     * The user favorite language name
     * @readonly
     */
    language?: string;
    /**
     * The user favorite Country
     * @readonly
     */
    country?: string;
    /**
     * The addditional notes about the user.
     * Notes are only available for a personal directory contact and a business directory contact.
     * @readonly
     */
    notes: UserNotes;
    /**
     * The postal address of the user.
     *Postal address information is only available for a personal directory contact and a business directory contact.
     * @readonly
     */
    postalAddress: PostalAddress;
    /**
     * The user timezone name
     * @readonly
     */
    timezone?: string;
    /**
     * The user avatar object
     * @readonly
     */
    avatar?: UserAvatar;
    /**
     * The user avatar last modification date
     * @readonly
     */
    lastAvatarUpdateDate?: Date;
    /**
     * The user presence status
     * @readonly
     */
    status: 'online' | 'away' | 'offline' | 'unknown' | string;
    /**
     * The user presence status message
     * @readonly
     */
    statusInfo?: string;
    /**
     * The list of e-mail addresses (personal and business) asssociated to the user
     * @readonly
     */
    emails?: UserEmailAddress[];
    /**
     * The list of phone numbers (personal and business) asssociated to the user
     * @readonly
     */
    phoneNumbers?: UserPhoneNumber[];
    /**
     * Specifies the type of user to give a more precise idea of what's behind it.
     * @readonly
     */
    userType: UserType;
    /**
     * User capabilities
     * This corresponds to permissions granted to a user to access functions and perform operations.
     * A capacity may also require the user's company to subscribe to a dedicated offer.
     * @readonly
     */
    peerFeatureCapabilities: UserPeerFeatureCapabilities;
    /**
     * The guest user's company name
     * @readonly
     */
    companyNameOfGuest?: string;
    /**
     * Indicates whether the user is a guest
     * @readonly
     */
    guest: boolean;
    /**
     * Indicates whether the user is in the Rainbow default company
     * @readonly
     */
    isInDefaultCompany: boolean;
    /**
     * Indicates whether the user is considered initialized, i.e. whether he has entered his first and last name
     * when logging in for the first time.
     * @readonly
     */
    initialized: boolean;
    /**
     * Indicates whether the user has been deleted
     * @readonly
     */
    terminated: boolean;
    /**
     * The user's site id
     */
    siteId: string;
    /**
     * Syntactic sugar to check if a user is the connectedUser
     */
    isConnectedUser(): boolean;
    /**
     * Check if a user is a directory contact.
     * By contact we mean a contact present in one of the following directories:
     *  - The Rainbow Business directory
     *  - The Rainbow Personal directory
     *  - The PBX Phonebook
     *  - The Microsoft Azure Active directory
     *  - The Outlook contacts (Client Desktop only)
     * Note that the availability of these directories depends on the configuration options on the administrator side and
     * the profile feature of the connected user.
     */
    isDirectoryContact(): boolean;
    /**
     * Checks if a user matches a given user type.
     * @param userType - The type of user to be compared with the current user
     */
    isUserTypeOf(userType: UserType): boolean;
    /**
     * Checks if the user has a specific role.
     * @param userRole - The role to check against the user's assigned roles
     */
    hasRole(userRole: UserRole): boolean;
    /**
     * Indicates wether the user is a telephony user or not.
     * A telephony user is a user with an business phone number allocated on a PBX, i.e. a Rainbow Hub or Rainbow Hybrid (OXO or OXE) telephone system.
     */
    isTelephonyUser(): boolean;
    /**
     * Indicates wether the user is a Rainbow Hub user or not.
     * A Rainbow Hub user is a user with a Voice licence and an extension number allocated on a Rainbow Hub telephone system.
     */
    isRainbowHubUser(): boolean;
    /**
     * Indicates wether the user is an Rainbow Hybrid user or not.
     * An Rainbow Hybrid user is a user with an extension number allocated on a Hybrid PBX (OXE/OXO/Third party)
     */
    isRainbowHybridUser(): boolean;
    /**
     * Debug Method to return a simplified JSON representation of the User object.
     * @internal
     */
    toJSON(): any;
    /**
     * Matches a user against search criteria using a smart fuzzy matching algorithm.
     *
     * This method performs an intelligent search by:
     * - Normalizing both the user name and search criteria (removing accents, converting to lowercase)
     * - Supporting multi-word searches where each word can match the beginning of any name part
     * - Ensuring all search terms are found (AND logic between multiple words)
     * - Matching only at the start of name parts (prefix matching)
     *
     * @param criteria - The search pattern (can contain multiple words separated by spaces)
     * @returns `true` if all words in the criteria match the beginning of name parts, `false` otherwise
     *
     * @example
     * // For a user "Jean-Pierre Dupont"
     * user.matchesSearchCriteria("jean du")     // true (matches "Jean" and "Dupont")
     * user.matchesSearchCriteria("jp du")       // true (matches "Jean-Pierre" and "Dupont")
     * user.matchesSearchCriteria("pierre dup")  // true (matches "Pierre" and "Dupont")
     * user.matchesSearchCriteria("dupont j")    // true (matches "Dupont" and "Jean")
     * user.matchesSearchCriteria("ont jean")    // false ("ont" doesn't match start of any name part)
     *
     * @remarks
     * - Accents are normalized: "José" matches "jose"
     * - Case insensitive: "JEAN" matches "jean"
     * - Each query word must match at the start of a name part
     */
    matchesSearchCriteria(criteria: string): boolean;
}
/**
 * @internal
 */
export declare class ConnectedUserRB extends Contact implements ConnectedUser {
    private logger;
    private errorHelperService;
    /**
     * Checks that the type of phone numbers provided in the user profile is unique
     * @param phoneNumbers - Phone numbers
     */
    private hasNoDuplicatesPhoneNumberType;
    private processPhoneNumbers;
    /**
     * Checks that the type of email addresses provided in the user profile is unique
     * @param emailAdresses - Email addresses
     */
    private hasNoDuplicatesEmailType;
    private processEmailAddresses;
    setPresenceStatus(status: UserPresenceStatus | string): Promise<void>;
    setCustomExternalPresence(status: UserExternalPresenceStatus, customMessage?: string): Promise<void>;
    removeCustomExternalPresence(): Promise<void>;
    getAvailablePresenceStatusList(): Promise<string[]>;
    initialize(userData: ConnectedUserProfile): Promise<User>;
    setPassword(oldPassword: string, newPassword: string, async: boolean): Promise<User>;
    setProfile(userData: ConnectedUserProfile): Promise<User>;
    setCustomAvatar(base64AvatarImg: string): Promise<User>;
    removeCustomAvatar(): Promise<User>;
    setCustomData(customData: UserCustomData): Promise<User>;
    setCustomStatus(status: UserCustomStatus): Promise<void>;
    setDisplaySettings(userData: ConnectedUserDisplaySettings): Promise<void>;
    isEmailAddressValid(emailAddress: string): boolean;
    isPhoneNumberValid(phoneNumber: string): boolean;
    deleteAccount(): Promise<void>;
    getMakeWebCallCapabilities(remoteParty: User): WebCallCapabilities;
    monitorWebCallCapabilities(remoteParty: User, callbackResult: (arg0: WebCallCapabilities) => any, callbackError?: (error: any) => any): Subscription;
    isCurrentlyInCall(): boolean;
}
//# sourceMappingURL=user.model.d.ts.map