Source: https://rox.chat/kb/pt/mobile/sdk/ios-sdk-handbook.html

> A revisão corresponde à versão atual do Mobile SDK 3 para iOS.

# Guia de referência do Rox.Chat Mobile SDK para aplicativos iOS

A revisão corresponde à versão atual do **Mobile SDK 3** para **iOS**.

!!! Note "N.B."
    As respostas às perguntas mais comuns são fornecidas em [este artigo](https://rox.chat/kb/pt/mobile/sdk/recommendations-of-usage.html).

## Classe `Roxchat` { #roxchat }

Um conjunto de métodos estáticos que são usados na criação de um objeto de sessão e para lidar com notificações push do serviço **Rox.Chat**

### Método da classe `newSessionBuilder()` { #new-session-builder }

Método necessário para obter um objeto [`SessionBuilder`](#session-builder), que, por sua vez, é necessário para criar uma instância da classe [`RoxchatSession`](#roxchat-session)

### Método de classe `parse(remoteNotification:visitorId:)` { #parse-remote-notification }

Um método usado para converter um objeto que representa uma notificação por push para um aplicativo iOS em um objeto da classe [`RoxchatRemoteNotification`](#roxchat-remote-notification).

O parâmetro `remoteNotification` é um dicionário do tipo `[AnyHashable: Any]` (o mesmo tipo de dicionário é passado para o método `application(_:didReceiveRemoteNotification:)` no parâmetro `userInfo` na classe `AppDelegate` do aplicativo iOS). Você deve passar o valor do parâmetro `userInfo`, o método acima mencionado da classe `AppDelegate` em uma forma não modificada para o parâmetro.

Retorna um objeto da classe [`RoxchatRemoteNotification`](#roxchat-remote-notification) ou `nil` se o valor do parâmetro `remoteNotification` não corresponder ao formato da notificação push recebida do serviço **Rox.Chat** ou se a notificação não contiver carga útil.

Como uma verificação preliminar se o parâmetro `remoteNotification` é uma notificação push recebida do serviço **Rox.Chat**, o método [`isRoxchat(remoteNotification:)`](#is-roxchat-remote-notification) pode ser chamado.

### Método de classe `isRoxchat(remoteNotification:)` { #is-roxchat-remote-notification }

Um método para descobrir se o objeto que representa uma notificação por push no aplicativo iOS é uma notificação por push recebida do serviço **Rox.Chat**.

O parâmetro `remoteNotification` é um dicionário do tipo `[AnyHashable: Any]` (o mesmo tipo de dicionário é passado para o método `application(_:didReceiveRemoteNotification:)` no parâmetro `userInfo` na classe `AppDelegate` do aplicativo iOS). Você deve passar o valor do parâmetro `userInfo`, o método mencionado acima da classe `AppDelegate` em uma forma não modificada para o parâmetro.

Retorna um valor booleano: `true` - se o valor do parâmetro `remoteNotification` for uma notificação push recebida do serviço **Rox.Chat**, `false` - se não for.

---

## Tipo enumerado `RemoteNotificationSystem` { #remote-notification-system }

Sistemas de notificação push que podem ser passados como parâmetro para o método de instância [`SessionBuilder`](#session-builder)[`set(remoteNotificationSystem:)`](#set-remote-notification-system).

### Case `APNS`

Corresponde ao **Apple Push Notification System**.

### Case `NONE` { #none }

Corresponde à situação em que o aplicativo não precisa receber notificações push do serviço **Rox.Chat**.

---

## Classe `SessionBuilder` { #session-builder }

Uma classe cuja instância é usada para obter uma instância da classe [`RoxchatSession`](#roxchat-session). Uma instância da classe é obtida usando o método [`newSessionBuilder()`](#new-session-builder) da classe [`Roxchat`](#roxchat).

### Método da classe `set(notFatalErrorHandler:)`

Um método para definir um objeto que obedece ao protocolo [NotFatalErrorHandler`](#not-fatal-error-handler), que será responsável pelo tratamento de erros de criação de instâncias de sessão que podem ser gerados pelo serviço **Rox.Chat**.

O parâmetro `notFatalErrorHandler` é qualquer classe que implemente a interface [`NotFatalErrorHandler`](#not-fatal-error-handler).

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o objeto `NotFatalErrorHandler` instalado. Para obter uma instância da classe [`RoxchatSession`](#roxchat-session), a chamada do método é opcional.

### Método da classe `set(accountName:)` { #set-account-name}

O método é necessário para definir o nome da conta no sistema **Rox.Chat** ao criar uma sessão.

O parâmetro `accountName` é o nome da conta do cliente no sistema **Rox.Chat**. Normalmente é uma URL do servidor (por exemplo, `https://demo.roxchat.ru`), mas também pode ser um nome de conta em uma palavra (por exemplo, `demo`), se o servidor estiver no domínio `roxchat.ru`. O tipo de parâmetro é `String`.

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o nome da conta definido.

Para obter uma instância de [`RoxchatSession`](#roxchat-session), a chamada do método é obrigatória.

### Método de classe `set(location:)` { #set-location }

O método é necessário para definir o local inicialmente usado ao criar uma sessão.

O parâmetro `location` é o local dentro do serviço **Rox.Chat** que será usado durante o bate-papo. O tipo do parâmetro é `String`. Provavelmente, você pode usar os valores `mobile` e/ou `default` imediatamente. Para criar e usar locais adicionais, entre em contato com a equipe de suporte do serviço **Rox.Chat**.

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o nome do conjunto de locais usado.

Para obter uma instância de [`RoxchatSession`](#roxchat-session), a chamada do método é obrigatória.

### Método de classe `set(appVersion:)`

O método é usado para definir a versão do aplicativo cliente se eles precisarem ser distinguidos no contexto do serviço **Rox.Chat**.

O parâmetro `appVersion` é a versão do aplicativo cliente ou `nil`. O tipo de parâmetro é uma `String` opcional.

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com a versão do aplicativo cliente instalada se o parâmetro `appVersion` não for `nil`, e uma instância não modificada da classe [`SessionBuilder`](#session-builder) `se o parâmetro appVersion for nil`.

É opcional chamar o método para obter uma instância da classe [`RoxchatSession`](#roxchat-session).

### Método de classe `set(visitorFieldsJSONString:)` { #set-visitor-fields-json-string-json-string }

O método é usado para autorizar o visitante internamente.

Sem chamar esse método ao criar um objeto de sessão, o usuário será anônimo, com uma ID gerada aleatoriamente. Essa ID é armazenada nas configurações do aplicativo e, se essas configurações forem perdidas (por exemplo, ao reinstalar o aplicativo), todos os dados (histórico de mensagens) serão perdidos.

Todos os dados de um usuário autorizado são salvos e estarão disponíveis ao autorizar a partir de qualquer dispositivo.

Parâmetro `jsonString` - campos de dados de autorização do usuário no formato `JSON`, tipo - `String`. Informações detalhadas sobre esses campos (incluindo quais são obrigatórios e como eles devem ser formados) podem ser encontradas em [este artigo](https://rox.chat/kb/pt/dev/identification/id-2-0.html).

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com as credenciais de autorização do visitante definidas.

É opcional chamar esse método para obter uma instância da classe [`RoxchatSession`](#roxchat-session).

Esse método não pode ser chamado ao mesmo tempo que o método [`set(providedAuthorizationTokenStateListener:providedAuthorizationToken:)`](#set-provided-authorization-token-state-listener-provided-authorization-token).

### Método de classe `set(visitorFieldsJSONData jsonData:)` { #set-visitor-fields-json-data-json-data }

Um método completamente semelhante ao método [`set(visitorFieldsJSONString:)`](#set-visitor-fields-json-string-json-string), exceto pelo parâmetro: o parâmetro `jsonData` é do tipo `Data` (fornecido no formato `JSON`). Qual dos dois métodos usar é irrelevante.

### Class Método `set(providedAuthorizationTokenStateListener:providedAuthorizationToken:)` { #set-provided-authorization-token-state-listener-provided-authorization-token }

Quando um aplicativo cliente fornece seu próprio mecanismo de autorização de visitante, isso pode ser implementado passando um token especial em vez de campos de visitante.

Esse método passa um objeto de protocolo [`ProvidedAuthorizationTokenStateListener`](#provided-authorization-token-state-listener) e um token. Não é necessário passar o token: se você omitir o segundo parâmetro, o token será gerado pela biblioteca.

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o objeto [`ProvidedAuthorizationTokenStateListener`](#provided-authorization-token-state-listener) e o token do sistema cliente de autorização do visitante instalado.

É opcional chamar esse método para obter uma instância da classe [`RoxchatSession`](#roxchat-session).

Esse método não pode ser chamado simultaneamente com os métodos [`set(visitorFieldsJSONString:)`](#set-visitor-fields-json-string-json-string) ou [`set(visitorFieldsJSONData:)`](#set-visitor-fields-json-data-json-data).

### Método de classe `set(pageTitle:)`

Um método para definir o título do chat do lado do operador ao criar uma instância de sessão. Se o método não tiver sido chamado quando a instância da sessão foi criada, o título assumirá o valor padrão de `iOS Client`.

O parâmetro `pageTitle` é o título do chat do lado do operador. O tipo de parâmetro é `String`.

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o título do chat do lado do operador definido.

É opcional chamar esse método para obter uma instância da classe [`RoxchatSession`](#roxchat-session).

### Método de classe `set(fatalErrorHandler:)`

Um método para definir um objeto que obedece ao protocolo [`FatalErrorHandler`](#fatal-error-handler), que será responsável pelo tratamento de erros de instância de sessão que podem ser chamados pelo serviço **Rox.Chat**.

O parâmetro `fatalErrorHandler` é opcional; qualquer classe que obedeça ao protocolo [`FatalErrorHandler`](#fatal-error-handler), ou `nil` se os métodos do protocolo [`FatalErrorHandler`](#fatal-error-handler) não forem usados no aplicativo.

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o objeto [`FatalErrorHandler`](#fatal-error-handler) instalado.

É opcional chamar o método para obter uma instância da classe [`RoxchatSession`](#roxchat-session).

### Método de classe `set(remoteNotificationSystem:)` { #set-remote-notification-system }

Um método para especificar, ao criar uma sessão, se o aplicativo receberá notificações por push do serviço **Rox.Chat** e, em caso afirmativo, qual sistema de notificação por push o aplicativo usará para fazer isso. (Consulte o tipo enumerado [`RemoteNotificationSystem`](#remote-notification-system) na classe [`Roxchat`](#roxchat).

O parâmetro `remoteNotificationSystem` é o valor correspondente do tipo [`RemoteNotificationSystem`](#remote-notification-system) da classe [`Roxchat`](#roxchat).

Requer uma instância obtida anteriormente da classe [`SessionBuilder`](#session-builder). Se esse método for chamado e o valor do parâmetro remoteNotificationSystem for diferente de [`NONE`](#none), será obrigatório chamar o método [`set(deviceToken:)`](#set-device-token) ao criar uma instância da sessão.

Para obter uma instância da classe [`RoxchatSession`](#roxchat-session), a chamada do método [`set(deviceToken:)`](#roxchat-session) é opcional. Se o método não tiver sido chamado durante a criação de uma sessão, o serviço **Rox.Chat** não enviará notificações push para o aplicativo (de forma semelhante ao valor do parâmetro `remoteNotificationSystem` [`NONE`](#none)).

### Método de classe `set(deviceToken:)` { #set-deivce-token }

Um método que pode ser usado para especificar um token de dispositivo para que o aplicativo receba notificações push do serviço **Rox.Chat** ao criar uma sessão.

O parâmetro `deviceToken` é o token de dispositivo usado para receber notificações push no aplicativo. Type - `String` opcional em formato hexadecimal, sem caracteres de serviço e espaços.

Um exemplo de conversão do valor do token do dispositivo para a forma desejada a partir do valor no formato `Data` obtido pelo método `application(_:,didRegisterForRemoteNotificationsWithDeviceToken:)` da classe `AppDelegate` de um aplicativo:

```
let deviceToken = deviceToken.map { String(format: “%02.2hhx”, $0) }.joined()
```

Retorna a mesma instância da classe [``SessionBuilder``](#session-builder), mas com o valor do token do dispositivo definido.

Para que um aplicativo receba notificações push do serviço **Rox.Chat**, a chamada desse método não é suficiente: também é necessária uma chamada para o método [`set(remoteNotificationSystem:)`](#set-remote-notification-system).

Para obter uma instância da classe [`RoxchatSession`](#roxchat-session), não é necessário chamar esse método.

### Método de classe `set(isLocalHistoryStoragingEnabled:)`

Por padrão, a sessão armazena o histórico de mensagens no dispositivo (no repositório SQLite associado ao aplicativo). Se essa funcionalidade precisar ser desativada para qualquer finalidade, esse método será usado com o valor do parâmetro `isLocalHistoryStoragingEnabled` `false`.

O parâmetro `isLocalHistoryStoragingEnabled` é uma variável booleana que indica se o histórico de mensagens deve ser armazenado localmente (valor `true`) ou não (valor `false`).

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o valor da opção correspondente definido manualmente.

É opcional chamar o método para obter uma instância da classe [`RoxchatSession`](#roxchat-session). Não chamar o método é o mesmo que chamá-lo com o valor do parâmetro `isLocalHistoryStoragingEnabled` `true`.

### Método de classe `set(isVisitorDataClearingEnabled:)`

Método usado para remover todos os dados de usuário existentes durante a criação da instância da sessão.

O parâmetro `isVisitorDataClearingEnabled` é uma variável booleana que indica a necessidade de limpar os dados do usuário (valor `true`) ou sua (necessidade) ausência (valor `false`).

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o valor da opção correspondente definido manualmente.

É opcional chamar o método para obter uma instância da classe [`RoxchatSession`](#roxchat-session). A ausência de chamada do método é semelhante à sua chamada com o valor do parâmetro `isVisitorDataClearingEnabled false`.

Para obter uma instância da classe [`RoxchatSession`](#roxchat-session), a chamada do método é opcional

### Método de classe `set(roxchatLogger:verbosityLevel:availableLogTypes:)` { #set-roxchat-logger }

O método pelo qual o objeto [`RoxchatLogger`](#roxchat-logger) é passado.

O parâmetro `verbosityLevel` é o valor de [`RoxchatLoggerVerbosityLevel`](#roxchat-logger-verbosity-level) (pode ser omitido).

O parâmetro `availableLogTypes` é o valor de [`RoxchatLogType`](#roxchat-log-type) (pode ser omitido).

### Método de classe `build()` { #build }

Um método que é chamado na conclusão dos métodos acima para obter uma instância de [`RoxchatSession`](#roxchat-session).

Retorna um objeto [`RoxchatSession`](#roxchat-session) com os parâmetros definidos usando o restante dos métodos de instância da classe.

Pode gerar erros como [`SessionBuilderError`](#session-builder-error).

Requer a chamada dos métodos [`set(accountName:)`](#set-account-name) e [`set(location:)`](#set-location) (em qualquer ordem). Quaisquer outros métodos (em qualquer ordem e combinação) da instância da classe [`SessionBuilder`](#session-builder) também podem ser chamados previamente.

### Método da classe `set(multivisitorSection:)`

O método é usado para obter notificações para diferentes visitantes no mesmo dispositivo.

O parâmetro `multivisitorSection` é uma `String`.

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o valor da opção correspondente definido manualmente.

### Método de classe `set(roxchatAlert:)`

O método é usado para mostrar avisos de erro padrão.

O parâmetro `roxchatALert` é um aviso, o tipo é [`RoxchatAlert`](#roxchat-alert).

Retorna a mesma instância da classe [`SessionBuilder`](#session-builder), mas com o valor da opção correspondente definida lá.

### Método da classe `set(mobileChatInstance:)`

O método é usado para definir uma nova sessão dentro do aplicativo móvel.

O parâmetro `mobileChatInstance` é `String`.

O valor padrão é `default`.

Se você não definir esse parâmetro e tentar criar uma nova sessão dentro do aplicativo móvel, obterá a mesma sessão.

Retorna a mesma instância da classe `SessionBuilder`, mas com o valor da opção correspondente definido manualmente.

---

## Tipo enumerado `RoxchatLogType` { #roxchat-log-type }

Tipos de registro possíveis. Usado no método [`set(roxchatLogger:verbosityLevel:availableLogTypes:)`](#set-roxchat-logger).

### Case `networkRequest`

Registros relacionados a solicitações de rede.

### Case `messageHistory`

Registros relacionados ao histórico de mensagens.

### Case `manualCall`

Registros relacionados a chamadas de métodos manuais.

### Case `undefined`

Tipo indefinido.

---

## Tipo enumerado `FileState`

Usado para definir o estado de um arquivo.

### Case `error`

Ocorre quando ocorre um erro ao carregar um arquivo.

### Case `ready`

Ocorre quando um arquivo foi carregado.

### Case `upload`

Ocorre quando um arquivo está sendo carregado.

### Caso `externalChecks`

O arquivo é verificado pelo servidor.

---

## Tipo enumerado `EditMessageError` { #edit-message-error }

Possíveis erros que podem ser passados para o parâmetro `error` ao chamar o método [`EditMessageCompletionHandler.onFailure(messageID:error:)`](#edit-message-completion-handler-on-failure).

### Case `UNKNOWN`

Erro desconhecido.

### Case `NOT_ALLOWED`

A capacidade de editar mensagens está desativada no servidor.

### Case `MESSAGE_EMPTY`

A mensagem que está sendo editada está vazia.

### Case `MESSAGE_NOT_OWNED`

O visitante só pode editar suas próprias mensagens. O identificador especificado pertence a outra mensagem.

### Case `MAX_LENGTH_EXCEEDED`

O servidor poderá rejeitar a solicitação se o tamanho da mensagem exceder o limite. O tamanho máximo da mensagem é configurável no servidor.

### Case `WRONG_MESSAGE_KIND`

O visitante só pode editar mensagens de texto.

---

## Tipo enumerado `RoxchatLoggerVerbosityLevel` { #roxchat-logger-verbosity-level }

Especifica o grau de informatividade das entradas passadas para o objeto [`RoxchatLogger`](#roxchat-logger).

### Case `VERBOSE`

Todas as informações disponíveis serão passadas para o objeto [`RoxchatLogger`](#roxchat-logger) com o nível máximo de informatividade:

  * parâmetros de configuração da conexão de rede;

  * URLs, métodos HTTP e parâmetros de solicitação de rede;

  * Códigos HTTP, dados recebidos e erros de respostas a solicitações de rede;

  * Consultas SQL e erros que ocorrem com essas consultas;

  * Informações completas que podem ser úteis na depuração e notas adicionais.

### Case `DEBUG`

Todas as informações necessárias para depuração serão passadas para o objeto [`RoxchatLogger`](#roxchat-logger) com o nível de informação necessário:

* parâmetros de configuração da conexão de rede;

* URLs, métodos HTTP e parâmetros de solicitação de rede;

* Códigos HTTP, dados recebidos e erros de respostas a solicitações de rede;

* Consultas SQL e erros que ocorrem com essas consultas;

* Informações completas que podem ser úteis para depuração moderadamente informativa.

### Case `INFO`

O objeto [`RoxchatLogger`](#roxchat-logger) receberá informações de segundo plano, bem como todos os avisos e erros:

* URLs, métodos HTTP e parâmetros de solicitação de rede;

* Códigos HTTP, dados recebidos e erros de resposta da solicitação de rede;

* Consultas SQL e erros gerados por essas consultas.

### Case `WARNING`

Somente avisos e erros serão enviados para o objeto [`RoxchatLogger`](#roxchat-logger):

* Códigos HTTP, dados recebidos e erros de resposta de solicitação de rede;

* Consultas SQL e erros que ocorrem com essas consultas.

### Case `ERROR`

Somente os erros serão passados para o objeto [`RoxchatLogger`](#roxchat-logger):

  * Códigos HTTP e erros de respostas a solicitações de rede que falharam.

---

## Tipo enumerado `SessionBuilderError` { #session-builder-error }

Os valores do tipo correspondem a possíveis erros que podem ocorrer ao chamar o método [`build()`](#build) da classe [`SessionBuilder`](#session-builder).

### Case `NIL_ACCOUNT_NAME`

Ocorre quando nenhum valor de nome de conta (ou esse valor é `nil`) foi passado quando a sessão foi criada.

### Caso `NIL_LOCATION`

Ocorre quando nenhum valor de nome de local (ou esse valor é `nil`) foi passado quando a sessão foi criada.

### Caso `INVALID_AUTHENTICATION_PARAMETERS`

Ocorre quando foi feita uma tentativa de usar os métodos padrão (consulte os métodos [`set(visitorFieldsJSONString:)`](#set-visitor-fields-json-string-json-string) e [`set(visitorFieldsJSONData:)`](#set-visitor-fields-json-data-json-data)) e personalizado (consulte os métodos [`set(providedAuthenticATION_PARAMETERS`)) ao mesmo tempo ao criar uma sessão. O método [`set(providedAuthorizationTokenStateListener:providedAuthorizationToken:)`](#set-provided-authorization-token-state-listener-provided-authorization-token)] do sistema de autorização de visitantes.

### Caso `INVALIDE_HEX`

Ocorre quando uma string inválida no formato `HEX` é passada.

### Caso `INVALID_REMOTE_NOTIFICATION_CONFIGURATION`

Ocorre quando uma configuração inválida do serviço push ocorreu durante a criação da sessão (o serviço a ser usado ao receber notificações push do serviço **Rox.Chat** que não seja [`NONE`](#none) foi definido (consulte o método [`set(remoteNOTIFICATION_CONFIGURATION_CONFIGURATION_CONFIGURATION_CONFIGURATION_CONFIGURATION_CONFIGURATION_CONFIGURATION`)]. método [`set(remoteNotificationSystem:)`](#set-remote-notification-system) da classe [`SessionBuilder`](#session-builder), mas nenhum valor de token de dispositivo (ou o valor `nil`) foi passado - veja o método [`set(deviceToken:)`](#set-device-token) da classe [`SessionBuilder`](#session-builder)).

### Case `UNKNOWN`

Erro desconhecido.

---

## Tipo enumerado `ButtonState` { #button-state }

Usado para definir o estado de um botão.

### Case `showing`

O botão está sendo exibido.

### Case `showingSelected`

O botão está selecionado.

### Case `hidden`

O botão está oculto.

---

## Tipo enumerado `ButtonType` { #button-type }

Usado para definir o tipo de um botão.

### Case `URL`

O botão contém um link que levará o visitante quando o botão for clicado.

### Case `insert`

O botão contém um texto que será enviado em nome do visitante quando o botão for clicado.

---

## Protocolo `Configuração` { #configuration }

O protocolo é uma abstração que representa as informações de configuração dos botões do teclado do chatbot.

### Método `isActive()`

Um método que pode ser usado para obter informações sobre se um botão está ativo ou não.

Retorna `true` se estiver ativo e `false` se não estiver. O tipo é `Bool`.

### Método `getButtonType()`

Um método que pode ser usado para obter informações sobre o tipo de botão.

Retorna o tipo do botão. O tipo é [`ButtonType`](#button-type).

### Método `getData()`

Um método que pode ser usado para obter informações sobre o botão.

Retorna informações sobre o botão. O tipo é `String`.

### Método `getState()`

Um método que pode ser usado para obter informações sobre o estado do botão.

Retorna informações sobre o estado do botão. Tipo - [`ButtonState`](#button-state).

---

## Protocolo `FileInfo` { #file-info }

Contém informações sobre anexos.

### Método `getContentType()`

Um método que pode ser usado para obter o tipo `MIME` de um anexo.

Retorna o tipo `MIME` do anexo em forma de texto ou `nil`. O tipo é uma `String` opcional.

### Método `getFileName()`

Um método que pode ser usado para obter o nome do arquivo de anexo.

Retorna o nome do arquivo de anexo em formato de texto ou `nil`. O tipo é `String`.

### Método `getImageInfo()` { #get-image-info }

Um método que pode ser usado para obter informações sobre uma imagem, se o anexo for uma.

Retorna um objeto [`ImageInfo`](#image-info) ou `nil` se o anexo não for uma imagem.

### Método `getSize()`

Um método que pode ser usado para obter o tamanho do arquivo de anexo.

Retorna o tamanho do arquivo de anexo em bytes ou `nil`. O tipo é opcional `Int64`.

### Método `getURL()`

Um método que pode ser usado para obter um link para fazer download do arquivo anexo. O link é válido apenas para a sessão atual.

Retorna a URL do arquivo de anexo ou `nil`.

### Método `getGuid()`

Um método que pode ser usado para obter o `guid` do arquivo de anexo.
Retorna o valor em forma de texto. O tipo é `String`.

---

## Protocolo `Keyboard` { #keyboard }

O protocolo é uma abstração que fornece os elementos do teclado de um chatbot.

### Método `getButtons()`

Um método que pode ser usado para obter uma lista de botões para um elemento de teclado.

Retorna uma lista de botões. O tipo é [`KeyboardButton`](#keyboard-button).

### Método `getState()` { #keyboard-get-state }

Um método que pode ser usado para obter o estado do teclado.

Retorna o estado do teclado. O tipo é [`KeyboardState`](#keyboard-state).

### Método `getKeyboardResponse()`

Um método que pode ser usado para obter o botão selecionado pelo usuário.

Retorna o botão selecionado pelo usuário. O tipo é opcional [`KeyboardResponse`](#keyboard-response).

---

## Protocolo `KeyboardButton` { #keyboard-button }

O protocolo é uma abstração que representa informações sobre os botões do teclado do chatbot.

### Método `getId()`

Um método que pode ser usado para obter a ID exclusiva de um botão no teclado do chatbot.

Retorna a ID em forma de texto. O tipo é `String`. A ID do botão pode conter apenas letras latinas, dígitos, hífen e caracteres de sublinhado e não deve ter mais de 24 caracteres. O ID do botão gerado no lado do **Rox.Chat** tem o formato `UUID4` e o ID gerado externamente (incluindo bots de terceiros) só é verificado quanto à conformidade com os critérios acima.

### Método `getText()`

Método que pode ser usado para obter o texto de um botão no teclado do chatbot.

Retorna o nome do botão em forma de texto. O tipo é `String`.

### Método `getConfiguration()`

Um método que pode ser usado para obter a configuração de um botão no teclado do chatbot. O tipo é opcional [`Configuration`](#configuration).

---

## Protocolo `KeyboardRequest` { #keyboard-request }

O protocolo é uma abstração que representa informações sobre o botão selecionado no teclado do chatbot.

### Método `getButton()`

Um método que pode ser usado para recuperar o botão selecionado de um elemento do teclado.

Retorna um objeto [`KeyboardButton`](#keyboard-button).

### Método `getMessageId()`

Método que pode ser usado para obter a ID da mensagem na qual o botão foi selecionado.

Retorna o nome do ID da mensagem em formato de texto. O tipo é `String`.

---

## Protocolo `KeyboardResponse` { #keyboard-response }

O protocolo é uma abstração que representa informações sobre o botão selecionado no teclado do chatbot.

### Método `getButtonId()`

Um método que pode ser usado para obter a ID exclusiva do botão selecionado no teclado do chatbot.

Retorna a ID em forma de texto. O tipo é `String`.

### Método `getMessageId()`

Método que pode ser usado para obter o ID da mensagem na qual o botão foi selecionado.

Retorna o nome do ID da mensagem em formato de texto. O tipo é `String`.

---

## Protocolo `NotFatalErrorHandler` { #not-fatal-error-handler }

Um protocolo que fornece métodos para tratar erros não críticos que podem ocorrer no serviço **Rox.Chat**.

### Método `on(error:)` { #not-fatal-error-handler-on-error }

Chamado quando ocorre um erro não crítico do serviço **Rox.Chat**.

O parâmetro `error` é um erro do serviço **Rox.Chat**. O tipo é [`RoxchatNotFatalError`](#roxchat-not-fatal-error).

!!! Warning “Warning!”
    Esse método não é chamado na thread principal!

### Método `connectionStateChanged(connected:)`

Chamado quando ocorre o erro de conexão do serviço **Rox.Chat**.

!!! Warning “Warning!”
    Esse método não é chamado na thread principal!

---

## Protocolo `Quote` { #quote }

O protocolo é uma abstração que representa informações sobre uma mensagem citada.

### Método `getAuthorId()`

Use esse método para obter o ID do autor da mensagem citada.

Retorna o ID da mensagem. O tipo é um `String` opcional.

### Método `getMessageAttachment()`

Use esse método para obter um anexo se ele for um arquivo enviado por um visitante ou operador (`FILE_FROM_OPERATOR` ou `FILE_FROM_VISITOR`).

Retorna informações sobre o anexo. O tipo é opcional [`FileInfo`](#file-info).

### Método `getMessageTimestamp()`

Use esse método para obter a hora em que a mensagem foi enviada.

Retorna o número de milissegundos decorridos desde o início da época até o momento em que a mensagem é processada pelo servidor. O tipo é o opcional ``Date``.

### Método `getMessageId()`

Use esse método para obter o ID exclusivo da mensagem citada.

Ele retorna o ID da mensagem. O tipo é opcional `String`.

### Método `getMessageText()`

Use esse método para obter o texto da mensagem.

Retorna o texto da mensagem. O tipo é opcional `String`.

### Método `getMessageType()`

Use esse método para obter o tipo da mensagem citada.

Retorna um valor opcional do tipo enumerado [`MessageType`](#message-type).

### Método `getSenderName()`

Use esse método para obter o nome do remetente de uma mensagem.

Retorna o nome do remetente da mensagem. O tipo é o opcional `String`.

### Método `getState()`

Use esse método para obter o status da cotação.

Retorna um valor do tipo enumerado [`QuoteState`](#quote-state).

---

## Tipo enumerado `QuoteState` { #quote-state }

Usado para determinar o estado de uma mensagem citada.

### Case `PENDING`

Ocorre quando a cotação está sendo carregada.

### Case `FILLED`

Ocorre quando a citação é carregada.

### Caso `NOT_FOUND`

Ocorre quando a mensagem citada não é encontrada no servidor.

---

## Tipo enumerado `NotFatalErrorType` { #not-fatal-error-type }

Corresponde aos valores de possíveis erros fatais que podem ocorrer no serviço **Rox.Chat** (consulte o método [`getErrorType()`](#roxchat-not-fatal-error-get-error-type) da interface [`RoxchatNotFatalError`](#roxchat-not-fatal-error)).

### Case `NO_NETWORK_CONNECTION`

Esse erro indica que não há conexão de rede.

### Caso `SERVER_IS_NOT_AVAILABLE`

Esse erro ocorre quando o servidor não está disponível.

---

## Tipo enumerado `KeyboardResponseError` { #keyboard-response-error }

Possíveis erros que podem ser passados para o parâmetro `error` ao chamar o método `KeyboardResponseCompletionHandler.onFailure(error:)`.

### Case `UNKNOWN`

Erro desconhecido.

### Case `NO_CHAT`

Um botão do teclado do chatbot foi enviado para o chat errado.

### Case `BUTTON_ID_NOT_SET`

O ID do botão não está definido.

### Caso `REQUEST_MESSAGE_ID_NOT_SET`

O identificador da mensagem de solicitação não está definido.

### Caso `CAN_NOT_CREATE_RESPONSE`

Não é possível criar uma resposta.

---

## Tipo enumerado `KeyboardRequest`

Usado para determinar o estado de uma mensagem citada.

### Caso `PENDING`

Ocorre quando a mensagem citada é carregada.

### Case `FILLED`

Ocorre quando a citação é carregada.

### Caso `NOT_FOUND`

Ocorre quando a mensagem citada não é encontrada no servidor.

---

## Tipo enumerado `KeyboardState` { #keyboard-state }

Usado para determinar o estado da mensagem citada (consulte o método [`getState()`](#keyboard-get-state) da interface [`Keyboard`](#keyboard)).

### Case `PENDING`

Ocorre quando o teclado está ativo e as teclas podem ser pressionadas.

### Caso `CANCELLED`

Ocorre quando o teclado está inativo e as teclas não podem ser pressionadas.

### Caso `COMPLETED`

Ocorre quando o teclado está inativo e uma das teclas está selecionada.

---

## Protocolo `EditMessageCompletionHandler` { #edit-message-completion-handler }

Um objeto que implementa esse protocolo pode ser passado para o parâmetro `completionHandler` do método [`edit(message:text:completionHandler:)`](#message-stream-edit-message-text-completion-handler) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess(messageID:)`

Chamado quando a chamada ao método [`edit(message:text:completionHandler:)`](#message-stream-edit-message-text-completion-handler) do protocolo [`MessageStream`](#message-stream) é bem-sucedida.

O parâmetro `messageID` é o ID da mensagem correspondente. O tipo é `String`.

### Método `onFailure(messageID:error:)` { #edit-message-completion-handler-on-failure }

Chamado quando o método [`edit(message:text:completionHandler:)`](#message-stream-edit-message-text-completion-handler) do protocolo [`MessageStream`](#message-stream) falha.

O parâmetro `messageID` é o ID da mensagem correspondente. O tipo é `String`.

O parâmetro `error` - o erro que impediu a edição bem-sucedida da mensagem. Tipo - [`EditMessageError`](#edit-message-error).

---

## Protocol `ProvidedAuthorizationTokenStateListener` { #provided-authorization-token-state-listener }

Se o cliente fornecer seu próprio mecanismo de autorização de visitante, isso poderá ser implementado passando um token especial que é usado no lugar dos campos de visitante (consulte os métodos [`set(visitorFieldsJSONString:)`](#set-visitor-fields-json-string-json-string) e [`set(visitorFieldsJSONData:)`](#set-visitor-fields-json-data-json-data)). No momento em que esse token é gerado (ou recebe um valor passado), o método `update(providedAuthorizationToken:)` é chamado. Isso significa que o serviço do cliente deve passar esse token para o serviço **Rox.Chat**.

Esse mecanismo não é uma implementação autossuficiente. O serviço do cliente deve suportar e implementar métodos para passar o token e os dados do visitante para o serviço **Rox.Chat**.

## Método `update(providedAuthorizationToken:)`

O método é chamado em dois casos:

  1. O token do mecanismo de autorização do cliente é fornecido ou gerado e precisa ser enviado ao serviço **Rox.Chat** pelo cliente.

  2. É recebida informação do serviço **Rox.Chat** de que o token usado é desconhecido para ele. Isso pode acontecer, por exemplo, se o token não tiver sido enviado ao serviço **Rox.Chat** pelo serviço do cliente ou não tiver sido recebido pelo serviço **Rox.Chat**. Nesse caso, o serviço **Rox.Chat** precisa fornecer o token e os dados do visitante correspondentes a ele.

---

## Protocolo `RoxchatSession` { #roxchat-session }

Um protocolo que permite a manipulação da sessão atual. Uma instância da classe [`RoxchatSession`](#roxchat-session) é obtida usando os métodos da classe [`SessionBuilder`](#session-builder).

### Método `resume()` { #resume }

Quando uma instância da classe [`RoxchatSession`](#roxchat-session) é criada, sua sessão correspondente está em um estado suspenso. Esse método é necessário para iniciar a atividade de rede da sessão.

Ele pode gerar erros como [`AccessError`](#access-error).

Necessário para que o serviço funcione plenamente no contexto do aplicativo.

Vários métodos [`MessageListener`](#message-listener), [`ChatStateListener`](#chat-state-listener), [`CurrentOperatorChangeListener`](#current-operator-change-listener) e [`LocationSettingsChangeListener`](#location-settings-change-listener) podem ser chamados como resultado da resposta do servidor.

### Método `pause()` { #pause }

Um método usado para suspender a atividade de rede de uma sessão. Se a sessão já estiver em um estado suspenso, o método não executará nenhuma ação.

Pode gerar erros do tipo [`AccessError`](#access-error).

A sessão não deve estar em um estado desativado para que o método seja chamado.

### Método `destroy()` { #destroy }

Um método que é usado para desativar a sessão e a instância da classe. Quando esse método é chamado, nenhum método relacionado à sessão pode ser usado.

Pode gerar erros como [`AccessError`](#access-error).

### Método `getStream()` { #get-stream }

O método a ser chamado para recuperar a sessão de instância [`MessageStream`](#message-stream) correspondente.

Para o uso completo dos métodos do protocolo [`MessageStream`](#message-stream), a sessão não deve ser suspensa ou desativada (consulte os métodos [`resume()`](#resume), [`pause()`](#pause) e [`destroy()`](#destroy)).

### Método `set(deviceToken:)` { #set-device-token }

O método é usado para definir o token do dispositivo para receber notificações por push.

O parâmetro `deviceToken` é o token de dispositivo usado para receber notificações push no aplicativo. Type - `String` opcional em formato hexadecimal, sem caracteres de serviço e espaços.

Um exemplo de conversão do valor do token do dispositivo para a forma desejada a partir do valor no formato `Data` obtido pelo método `application(_:didRegisterForRemoteNotificationsWithDeviceToken:)` da classe `AppDelegate` de um aplicativo:

```
let deviceToken = deviceToken.map { String(format: “%02.2hhx”, $0) }.joined()
```

Pode gerar erros como [`AccessError`](#access-error).

A sessão não deve estar em um estado suspenso ou desativado para chamar o método (consulte os métodos [`resume()`](#resume), [`pause()`](#pause) e [`destroy()`](#destroy)).

### Método `destroyWithClearVisitorData()`

Um método usado para desativar a sessão e a instância da classe com as informações do usuário removidas. Quando esse método é chamado, nenhum método relacionado à sessão pode ser usado.

Pode gerar erros como [`AccessError`](#access-error).

---

## Protocolo `MessageData` { #message-data }

Contém um arquivo anexado à mensagem.

### Método `getAttachment()` { #get-attachment }
Use esse método para obter um anexo se ele for um arquivo enviado por um visitante ou operador (`MessageType` `FILE_FROM_OPERATOR` ou `FILE_FROM_VISITOR`).

Retorna uma instância da classe [`MessageAttachment`](#message-attachment) ou `nil` se o arquivo estiver em processo de envio.

---

## Protocol `MessageStream` { #message-stream }

A instância da classe pela qual os métodos de protocolo são chamados existe apenas uma vez em uma sessão e é obtida usando o método [`getStream()`](#get-stream) de uma instância da classe [`RoxchatSession`](#roxchat-session). Os métodos de protocolo são usados diretamente para interagir com o serviço **Rox.Chat** (como enviar e receber mensagens). Para usar os métodos de protocolo, é necessário que a sessão não esteja em estado suspenso ou desativado (consulte os métodos [`resume()`](#resume), [`pause()`](#pause) e [`destroy()`](#destroy) da classe [`RoxchatSession`](#roxchat-session)).

### Método `startChat(customFields:)`

O método inicia um chat com os campos personalizados especificados. Em termos do serviço **Rox.Chat**, ele altera o estado atual do chat, representado pelo tipo `ChatState`, para `QUEUE`.

Ele pode gerar erros do tipo [`AccessError`](#access-error).

Parâmetro `customFields` - campos opcionais no formato `JSON`. O tipo é uma `String` opcional.

O resultado pode chamar o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state) do protocolo [`ChatStateListener`](#chat-state-listener).

### Método `startChat(firstQuestion:customFields:)`

O método inicia um chat com os campos personalizados especificados e envia simultaneamente a primeira mensagem do visitante.

Em termos do serviço **Rox.Chat**, altera o estado atual do chat, representado pelo tipo `ChatState`, para `QUEUE`.

Ele pode gerar erros como [`AccessError`](#access-error).

Se as configurações da conta fornecerem mensagens de boas-vindas, nenhuma mensagem de boas-vindas será recebida antes de o chat ser iniciado (pelos métodos da série `startChat` ou com a primeira mensagem).

O parâmetro `firstQuestion` é a primeira mensagem do usuário. O tipo é uma `String` opcional.

Parâmetro `customFields` - campos adicionais no formato `JSON`. O tipo é opcional `String`.

O resultado pode chamar o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state) do protocolo [`ChatStateListener`](#chat-state-listener).

### Método `startChat(departmentKey:customFields:)`

O método inicia um chat com o departamento especificado e os campos opcionais especificados.

Em termos do serviço **Rox.Chat**, ele altera o estado atual do chat, representado pelo tipo `ChatState`, para `QUEUE`.

Ele pode gerar erros do tipo [`AccessError`](#access-error).

Quando um usuário envia uma mensagem ou um arquivo, o chat é iniciado automaticamente, mas se o estado atual de `VisitSessionState` for `DEPARTMENT_SELECTION`, o chat deverá ser iniciado com esse método.

O parâmetro `departmentKey` recebe o valor da chave do departamento, que pode ser obtido com o método [`getKey()`](#get-key) do protocolo [`Department`](#department).

O parâmetro `customFields` é um campo opcional no formato `JSON`. O tipo é uma `String` opcional.

O resultado pode chamar o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state) do protocolo [`ChatStateListener`](#chat-state-listener).

### Método `startChat(departmentKey:firstQuestion:customFields:)`

O método inicia um chat com o departamento especificado e os campos opcionais especificados, e envia a primeira mensagem do visitante ao mesmo tempo.

Em termos do serviço **Rox.Chat**, altera o estado atual do chat, representado pelo tipo `ChatState`, para `QUEUE`.

Ele pode gerar erros do tipo [`AccessError`](#access-error).

Quando um usuário envia uma mensagem ou um arquivo, o chat é iniciado automaticamente, mas se o estado atual de `VisitSessionState` for `DEPARTMENT_SELECTION`, o chat deverá ser iniciado com esse método.

O parâmetro `departmentkey` contém o valor da chave do departamento, que pode ser obtido usando o método [`getKey()`](#get-key) do protocolo [`Department`](#department).

Se as configurações da conta fornecerem mensagens de boas-vindas, nenhuma mensagem de boas-vindas será recebida antes de o chat ser iniciado (por métodos na série `startChat` ou com a primeira mensagem).

O parâmetro `firstQuestion` é a primeira mensagem do usuário. O tipo é uma `String` opcional.

Parâmetro `customFields` - campos adicionais no formato `JSON`. O tipo é opcional `String`.

O resultado pode chamar o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state) do protocolo [`ChatStateListener`](#chat-state-listener).

### Método `send(message:completionHandler:)` { #message-stream-send-message-completion-handler }

Corresponde ao método [`send(message:isHintQuestion:)`](#send-message-is-hint-question) com o parâmetro `isHintQuestion` omitido.

O parâmetro `completionHandler` é um objeto que implementa os métodos de protocolo do [`SendMessageCompletionHandler`](#send-message-completion-handler). O tipo é opcional.

### Método `sendKeyboardRequest(button:message:completionHandler:)` { #message-stream-send-keyboard-request-button-message-completion-handler }

O método é usado para enviar o item selecionado no teclado do chatbot para o serviço **Rox.Chat**.

Pode gerar erros do tipo [`AccessError`](#access-error).

O parâmetro `button` é um item no teclado do chatbot. O tipo é [`KeyboardButton`](#keyboard-button).

Parâmetro `message` - mensagem. Tipo - `Message`.

O parâmetro `completionHandler` é um objeto que implementa os métodos do protocolo [`SendKeyboardRequestCompletionHandler`](#send-keyboard-request-completion-handler). Tipo Opcional.

### Método `sendKeyboardRequest(buttonID:messageCurrentChatID:completionHandler:)`

Método usado para enviar o item selecionado no teclado do chatbot para o serviço **Rox.Chat**.

Pode gerar erros do tipo [`AccessError`](#access-error).

Parâmetro `buttonID` - ID do item no teclado do chatbot. O tipo é `String`.

Parâmetro `messageCurrentChatID` - ID da mensagem solicitada. Tipo - `Message`.

Parâmetro `completionHandler` - objeto que implementa métodos do protocolo [`SendKeyboardRequestCompletionHandler`](#send-keyboard-request-completion-handler). Tipo Opcional.

### Método `reply(message:repliedMessage:)`

O método é usado para citar a mensagem de um visitante para o serviço **Rox.Chat**.

Ele pode gerar erros do tipo [`AccessError`](#access-error).

O parâmetro `message` é a mensagem a ser enviada. O tipo é `String`.

Parâmetro `repliedMessage` - mensagem citada. O tipo é `Message`.

Retorna a ID da mensagem ou `nil` se a mensagem não puder ser citada.

Não requer que nenhum outro método seja chamado antes. Se os objetos [`MessageTracker`](#message-tracker) e [`MessageListener`](#message-listener) existirem, o envio de uma mensagem chamará o método [`added(message:after:)`](#added-message-new-message-after-previous-message) da interface [`MessageListener`](#message-listener) com uma nova mensagem com o status `MessageSendStatus.sent`.

O tamanho máximo da mensagem é de 32.000 caracteres. Mensagens maiores do que isso serão truncadas.

### Método `edit(message:text:completionHandler:)` { #message-stream-edit-message-text-completion-handler }

O método é usado para modificar a mensagem.

Ele pode gerar erros do tipo [`AccessError`](#access-error).

O parâmetro `message` é a mensagem a ser modificada. O tipo é `Message`.

Parâmetro `text` - texto da mensagem. Tipo - `String`.

O parâmetro `completionHandler` é um objeto que implementa os métodos do protocolo [`EditMessageCompletionHandler`](#edit-message-completion-handler). Tipo Opcional.

Retorna `true` se a mensagem puder ser editada.

Não requer que nenhum outro método seja chamado primeiro. Se os objetos [`MessageTracker`](#message-tracker) e [`MessageListener`](#message-listener) existirem, o envio de uma mensagem invocará o método [`changed(oldVersion:newVersion:)`](#changed-message-old-version-to-new-version) da interface [`MessageListener`](#message-listener) com uma nova mensagem com o status `MessageSendStatus.sent`.

O tamanho máximo da mensagem é de 32.000 caracteres. As mensagens maiores do que isso serão truncadas.

## Método `delete(message:completionHandler:)` { #message-stream-delete-message-completion-handler }

Método para excluir uma mensagem.

Pode gerar erros como [`AccessError`](#access-error).

O parâmetro `message` é a mensagem a ser excluída. O tipo é `Message`.

O parâmetro `completionHandler` é um objeto que implementa os métodos do protocolo [`DeleteMessageCompletionHandler`](#delete-message-completion-handler). Tipo Opcional.

Retorna `true` se a mensagem puder ser excluída.

Não requer que nenhum outro método seja chamado primeiro. Se os objetos [`MessageTracker`](#message-tracker) e [`MessageListener`](#message-listener) existirem, o envio de uma mensagem chamará o método [`removed(message:)`](#removed-message) da interface [`MessageListener`](#message-listener) com uma nova mensagem com o status `MessageSendStatus.sent`.

O tamanho máximo da mensagem é de 32.000 caracteres. Mensagens maiores do que isso serão truncadas.

Método `setChatRead()` ###

O método envia um sinal para o serviço **Rox.Chat** de que o visitante leu o chat.

### Método `sendDialogTo(emailAddress:completionHandler:)` { #message-stream-send-dialog-to-email-address-completion-handler }

Método usado para enviar a caixa de diálogo atual para um endereço de e-mail.

Ele pode gerar erros como [`AccessError`](#access-error).

Parâmetro `emailAddress` - e-mail a ser enviado. O tipo é `String`.

Parâmetro `completionHandler` - objeto que implementa os métodos do protocolo [`SendDialogToEmailAddressCompletionHandler`](#send-dialog-to-email-address-completion-handler). Tipo opcional.

### Método `getVisitSessionState()`

Retorna o estado da sessão atual com um valor do tipo [`VisitSessionState`](#visit-session-state).

### Método `getChatState()` { #get-chat-state }

Método para especificar o estado atual do chat.

Retorna um valor do tipo enumerado [`ChatState`](#chat-state).

### Método `getUnreadByOperatorTimestamp()` { #get-unread-by-operator-timestamp }

Retorna o ponto no tempo (do tipo ``Date``) após o qual todas as mensagens de bate-papo não são lidas pelo operador (no momento da atualização recebida do servidor).

### Método `getUnreadByVisitorMessageCount()` { #get-unread-by-visitor-message-count }

Retorna o número de mensagens não lidas pelo usuário.

### Método `getUnreadByVisitorTimestamp()` { #get-unread-by-visitor-timestamp }

Retorna o ponto no tempo (do tipo `Date`) após o qual todas as mensagens de bate-papo não foram lidas pelo visitante (no momento da atualização recebida do servidor) ou `nil` se não houver mensagens não lidas.

### Método `getDepartmentList()` { #get-department-list }

Retorna a lista de departamentos por meio de uma matriz de objetos do tipo [`Department`](#department) ou `nil` se os departamentos não estiverem em uso ou se a lista de departamentos ainda não tiver sido recuperada.

### Método `getLocationSettings()` { #get-location-settings }

Cada local pode ter configurações individuais. Use o método current para obter um objeto que represente as configurações de local atuais.

Retorna um objeto da classe [`LocationSettings`](#location-settings) correspondente à sessão atual.

### Método `getCurrentOperator()` { #get-current-operator }

Use esse método para especificar informações sobre o operador atual (se houver) da sessão de chat atual.

Retorna um objeto da classe [`Operator`](#protocol-operator) ou `nil` se o chat não tiver um operador no momento.

### Método `getLastRatingOfOperatorWith(id:)`

Use esse método para especificar a classificação atual (em números inteiros de 0 a 5) de um operador, sabendo o ID desse operador (consulte o método [`getID()`](#operator-get-id) do protocolo [`Operator`](#protocol-operator)).

O parâmetro `id` é o ID do operador cuja classificação o método deve retornar. O tipo é `String`.

Retorna a classificação do operador com o ID correspondente ao valor do parâmetro `id`, em números inteiros de 1 a 5 ou 0 se o operador não tiver classificação.

### Método `rateOperatorWith(id:rating:completionHandler:)` { #rate-operator-with-id-by-rating-rating }

Use esse método para enviar a classificação do operador do visitante atual.

O parâmetro `id` é o ID do operador cuja classificação deve ser enviada para o serviço **Rox.Chat**. O tipo é `String`. Opcional: se você passar `nil`, a avaliação será enviada para o operador do chat atual (se houver).

O parâmetro `rating` é a classificação do operador a ser enviada para o serviço **Rox.Chat**. A classificação deve ser um número inteiro de 1 a 5 (se você especificar o contrário, o método não executará nenhuma ação). O tipo é `Int`.

O parâmetro `completionHandler` é um objeto [`RateOperatorCompletionHandler`](#rate-operator-completion-handler).

Pode gerar erros como [`AccessError`](#access-error).

!!! Warning “Warning!”
    A implementação do mecanismo de avaliação do operador é deixada para os desenvolvedores do aplicativo móvel!

### Método `startChat()` { #start-chat }

O método inicia um chat. Em termos do serviço **Rox.Chat**, ele altera o estado atual do chat, representado pelo tipo [`ChatState`](#chat-state), para [`QUEUE`](#queue).

Pode gerar erros do tipo [`AccessError`](#access-error).

Quando um usuário envia uma mensagem ou arquivo, o chat é iniciado automaticamente, portanto, a chamada do método é opcional. Mas, se as configurações da conta fornecerem mensagens de boas-vindas, nenhuma mensagem de boas-vindas será recebida antes do início do chat (por métodos na série `startChat` ou com a primeira mensagem).

Como resultado, o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state)protocol [`ChatStateListener`](#chat-state-listener) pode ser chamado.

### Método `startChat(departmentKey:)` { #start-chat-department-key }

O método inicia um chat especificando um departamento específico. Em termos do serviço **Rox.Chat**, altera o estado atual do chat, representado pelo tipo [`ChatState`](#chat-state), para [`QUEUE`](#queue).

Pode gerar erros do tipo [`AccessError`](#access-error).

Quando uma mensagem ou um arquivo é enviado por um usuário, o chat é iniciado automaticamente, mas se o estado atual for [`VisitSessionState`](#visit-session-state) [`DEPARTMENT_SELECTION`](#department-selection), o chat deverá ser iniciado usando esse método.

Quando um usuário envia uma mensagem ou arquivo, o chat é iniciado automaticamente, portanto, não é necessário chamar esse método.

Se as configurações da conta fornecerem mensagens de boas-vindas, nenhuma mensagem de boas-vindas será recebida antes do início do chat (usando os métodos da série `startChat` ou com a primeira mensagem).

O parâmetro `departmentKey` recebe o valor da chave do departamento, que pode ser obtido pelo método [`getKey()`](#get-key) do protocolo [`Department`](#department).

Como resultado, o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state) do protocolo [`ChatStateListener`](#chat-state-listener) pode ser chamado.

### Método `startChat(firstQuestion:)`

O método inicia um chat e envia simultaneamente a primeira mensagem do visitante.

Em termos do serviço **Rox.Chat**, altera o estado atual do chat, representado pelo tipo [`ChatState`](#chat-state), para [`QUEUE`](#queue).

Pode gerar erros do tipo [`AccessError`](#access-error).

Quando um usuário envia uma mensagem ou arquivo, o chat é iniciado automaticamente, portanto, a chamada do método é opcional. Mas, se as configurações da conta fornecerem mensagens de boas-vindas, nenhuma mensagem de boas-vindas será recebida antes do início do chat (por métodos na série `startChat` ou com a primeira mensagem).

Como resultado, o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state)protocol [`ChatStateListener`](#chat-state-listener) pode ser chamado.

### Método `startChat(departmentKey:firstQuestion:)`

O método inicia um chat especificando um determinado departamento e envia simultaneamente a primeira mensagem do visitante.

Em termos do serviço **Rox.Chat**, altera o estado atual do chat, representado pelo tipo [`ChatState`](#chat-state), para [`QUEUE`](#queue).

Pode gerar erros do tipo [`AccessError`](#access-error).

Quando um usuário envia uma mensagem ou arquivo, o bate-papo é iniciado automaticamente, mas se o estado atual for [`VisitSessionState`](#visit-session-state) [`DEPARTMENT_SELECTION`](#department-selection), o bate-papo deverá ser iniciado usando esse método.

Se as configurações da conta fornecerem mensagens de boas-vindas, nenhuma mensagem de boas-vindas será recebida antes de o chat ser iniciado (pelos métodos da série `startChat` ou com a primeira mensagem).

O parâmetro `departmentKey` recebe o valor da chave do departamento, que pode ser obtido pelo método [`getKey()`](#get-key) do protocolo [`Department`](#department).

Como resultado, o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state)do protocolo [`ChatStateListener`](#chat-state-listener) pode ser chamado.

### Método `closeChat() (@available(*, deprecated))` { #close-chat }

!!! Observação “N.B.”
    O método não é recomendado para uso.

O método envia um sinal para o serviço **Rox.Chat** de que o visitante terminou o bate-papo. Em termos do serviço **Rox.Chat**, ele altera o estado atual do chat, representado pelo tipo [`ChatState`](#chat-state), para [`CLOSED_BY_VISITOR`](#closed-by-visitor).

Pode gerar erros como [`AccessError`](#access-error).

Pode resultar em uma chamada para o método [`changed(state previousState:to newState:)`](#changed-state-previous-state-to-new-state) do protocolo [`ChatStateListener`](#chat-state-listener).

### Método `setVisitorTyping(draftMessage:)`

O método é usado para enviar um sinal para o serviço **Rox.Chat** de que um visitante está digitando uma mensagem (ou parou de digitá-la (a mensagem)).

Se o método for chamado várias vezes consecutivas, o rascunho será enviado ao serviço **Rox.Chat** não com a mesma frequência, mas não mais do que uma vez por segundo.

Parâmetro `draftMessage` - a mensagem que o visitante já inseriu no campo correspondente, mas não a enviou. Tipo - opcional `String`, O valor do parâmetro `nil` corresponde à situação em que o visitante parou de digitar a mensagem ou apagou a mensagem escrita do campo de entrada.

Pode gerar erros do tipo [`AccessError`](#access-error).

### Método `send(message:isHintQuestion:)` { #send-message-is-hint-question }

O método é usado para enviar a mensagem de um visitante para o serviço **Rox.Chat**.

O parâmetro `message` é a mensagem a ser enviada. O tipo é `String`.

O comprimento máximo da mensagem é de 32.000 caracteres. Mensagens mais longas serão cortadas pelo servidor quando forem recebidas.

O parâmetro `isHintQuestion` é usado se o aplicativo tiver seu próprio mecanismo de exibição de dicas para o usuário. O tipo é opcional `Bool`. Caso o visitante não digite uma mensagem manualmente, mas escolha um dos prompts oferecidos, o valor do parâmetro deverá ser `true` e `false` caso contrário. O parâmetro é opcional e pode ser omitido.

Retorna uma ID gerada aleatoriamente para essa mensagem, que pode ser usada para identificar essa mensagem específica na lógica do aplicativo. O tipo é `String`.

Pode gerar erros do tipo [`AccessError`](#access-error).

Se os objetos [`MessageTracker`](#message-tracker) e [`MessageListener`](#message-listener) existirem, o envio de uma mensagem invocará o método [`added(newMessage:previousMessage: )`](#added-message-new-message-after-previous-message) do protocolo [`MessageListener`](#message-listener) com uma nova mensagem com status [`SENDING`](#sending) do tipo enumerado [`MessageSendStatus`](#message-send-status).

### Método `send(message:)`

Corresponde totalmente ao método [`send(message:isHintQuestion:)`](#send-message-is-hint-question) com o parâmetro omitido `isHintQuestion`.

### Método `send(file:filename:mimeType:completionHandler:)` { #send-file-filename-mime-type-completion-handler }

O método é usado para enviar um arquivo do visitante para o operador.

O parâmetro `file` é o próprio arquivo no formato `Data`.

O parâmetro `filename` é o nome do arquivo junto com a extensão. O tipo é `String`.

Parâmetro `mimeType` - tipo *MIME* do arquivo a ser transferido. O tipo é `String`.

O parâmetro `completionHandler` é um objeto que implementa os métodos do protocolo [`SendFileCompletionHandler`](#send-file-completion-handler). O tipo é opcional.

Retorna uma ID gerada aleatoriamente para essa mensagem, que pode ser usada para identificar essa mensagem específica na lógica do aplicativo. (O arquivo que está sendo enviado também é um tipo de mensagem.) O tipo é `String`.

Pode gerar erros do tipo [`AccessError`](#access-error).

Se os objetos [`MessageTracker`](#message-tracker) e [`MessageListener`](#message-listener) existirem, o envio de uma mensagem chamará o método [`added(newMessage:previousMessage: )`](#added-message-new-message-after-previous-message)protocolo [`MessageListener`](#message-listener) com uma nova mensagem com status [`SENDING`](#sending) do tipo enumerado [`MessageSendStatus`](#message-send-status).

### Método `newMessageTracker(messageListener:)` { #new-message-tracker-message-listener }

Esse método é usado para obter uma instância da classe [`MessageTracker`](#message-tracker).

O parâmetro `messageListener` é um objeto da classe que implementa os métodos do protocolo [`MessageListener`](#message-listener).

Retorna uma instância da classe [`MessageTracker`](#message-tracker) correspondente ao objeto [`MessageStream`](#message-stream) atual.

Pode gerar erros do tipo [`AccessError`](#access-error).

A obtenção de uma nova instância da classe [`MessageTracker`](#message-tracker) destrói automaticamente a instância anterior da classe [`MessageTracker`](#message-tracker).

### Método `set(visitSessionStateListener:)`

O método passa para o SDK uma referência a um objeto que implementa os métodos do protocolo [`VisitSessionStateListener`](#visit-session-state-listener).

O parâmetro `chatStateListener` é um objeto que implementa os métodos do protocolo [`VisitSessionStateListener`](#visit-session-state-listener).

### Método `set(chatStateListener:)` { #set-chat-state-listener }

O método passa para o SDK uma referência a um objeto que implementa os métodos do protocolo [`ChatStateListener`](#chat-state-listener).

O parâmetro `chatStateListener` é um objeto que implementa os métodos do protocolo [`ChatStateListener`](#chat-state-listener).

### Método `set(currentOperatorChangeListener:)` { #set-current-operator-change-listener }

O método passa uma referência a um objeto que implementa os métodos do protocolo [`CurrentOperatorChangeListener`](#current-operator-change-listener) para o SDK.

O parâmetro `currentOperatorChangeListener` é um objeto que implementa os métodos do protocolo [`CurrentOperatorChangeListener`](#current-operator-change-listener).

### Método `set(departmentListChangeListener:)`

O método passa uma referência a um objeto que implementa os métodos do protocolo [`DepartmentListChangeListener`](#department-list-change-listener) para o SDK.

O parâmetro currentOperatorChangeListener é um objeto que implementa os métodos do protocolo [`DepartmentListChangeListener`](#department-list-change-listener).

### Método `set(operatorTypingListener:)` { #set-operator-typing-listener }

O método passa para o SDK uma referência a um objeto que implementa os métodos do protocolo [OperatorTypingListener`](#operator-typing-listener).

O parâmetro `operatorTypingListener` é um objeto que implementa os métodos do protocolo [`OperatorTypingListener`](#operator-typing-listener).

### Método `set(locationSettingsChangeListener:)` { #set-location-settings-change-listener }

O método passa para o SDK uma referência a um objeto que implementa os métodos do protocolo [`LocationSettingsChangeListener`](#location-settings-change-listener).

O parâmetro `locationSettingsChangeListener` é um objeto que implementa os métodos do protocolo [`locationSettingsChangeListener`](#location-settings-change-listener).

### Método `set(onlineStatusChangeListener:)` { #set-session-online-status-change-listener }

O método passa para o SDK uma referência a um objeto que implementa os métodos do protocolo [``sessionOnlineStatusChangeListener``](#session-online-status-change-listener).

O parâmetro `sessionOnlineStatusChangeListener` é um objeto que implementa os métodos do protocolo [`SessionOnlineStatusChangeListener`](#session-online-status-change-listener).

### Método `set(unreadByOperatorTimestampChangeListener:)` { #set-unread-by-operator-timestamp-change-listener }

Passa o objeto [UnnreadByOperatorTimestampChangeListener`](#unread-by-operator-timestamp-change-listener).

###  Método `set(unreadByVisitorMessageCountChangeListener:)` { #set-unread-by-visitor-message-count-change-listener }

Passa o objeto [UnnreadByVisitorTimestampMessageCountListener`](#unread-by-visitor-message-count-change-listener).

### Método `set(unreadByVisitorTimestampChangeListener:)` { #set-unread-by-visitor-timestamp-change-listener }

Passa o objeto [UnnreadByVisitorTimestampChangeListener`](#unread-by-visitor-timestamp-change-listener).

### Método `getRawConfig(forLocation:completionHandler:)` { #message-stream-getrawconfig }

Método usado para obter a configuração de um local.

Ele pode gerar erros do tipo `AccessError`.

O parâmetro `forLocation` é o nome do local atual. O tipo é `String`.

O parâmetro `completionHandler` é um objeto que implementa os métodos do protocolo [`RawLocationConfigCompletionHandler`](#raw-location-config-completion-handler). Tipo Opcional.

### Método `getServerSideSettings(completionHandler:)` { #get-server-side-sttings }

Use esse método para obter as configurações do servidor.

O parâmetro `completionHandler` é um objeto que implementa os métodos do protocolo [`ServerSideSettingsCompletionHandler`](#server-side-settings-completion-handler). O tipo é opcional.

Pode gerar erros do tipo `AccessError`.

### Método `getChatId()`

Use esse método para obter o ID do chat atual.

Retorna o id do chat atual ou `nil` se ele não existir. O tipo é opcional `Int`.

---

## Protocolo `ServerSideSettingsCompletionHandler` { #server-side-settings-completion-handler }

Um objeto que implementa esse protocolo pode ser passado para o parâmetro `completionHandler` do método [`getServerSideSettings(completionHandler:)`](#get-server-side-sttings) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess(roxchatServerSideSettings:)`

Chamado quando o método `getServerSideSettings(completionHandler:)` do protocolo `MessageStream` é bem-sucedido.

O parâmetro `roxchatServerSideSettings` é a configuração do servidor. Tipo `RoxchatServerSideSettings`.

### Método `onFailure()`

Chamado quando o método `getServerSideSettings(completionHandler:)` do protocolo `MessageStream` falha.

---

## Protocolo `DataMessageCompletionHandler` { #data-message-completion-handler }

Um objeto de protocolo pode ser passado no parâmetro `completionHandler` do método [`send(message:data:completionHandler:)`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#send-message-data) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess(messageID:)`

O método é chamado quando a mensagem é enviada com êxito e o servidor processa o dicionário `data` transmitido (se não for `nil`) usando o método [`send(message:data:completionHandler:)`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#send-message-data) do protocolo [`MessageStream`](#message-stream).

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

### Método `onFailure(messageID:error:)` { #on-failure-message-id-error-data-message-completion-handler }

Chamado quando o servidor falha ao processar o dicionário `data` transmitido (se não for `nil`) pelo método [`send(message:data:completionHandler:)`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#send-message-data) do protocolo [`MessageStream`](#message-stream). Nesse caso, a própria mensagem será processada pelo servidor.

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

Parâmetro `error` - o erro que impediu o envio bem-sucedido do arquivo. Tipo - [`DataMessageError`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#data-message-error).

---

## Protocolo `DeleteMessageCompletionHandler` { #delete-message-completion-handler }

Um objeto de protocolo pode ser passado no parâmetro `completionHandler` do método [`send(message:data:completionHandler:)`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#send-message-data) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess(messageID:)`

Chamado quando a chamada ao método [`delete(message:completionHandler:)`](#message-stream-delete-message-completion-handler) do protocolo [`MessageStream`](#message-stream) é bem-sucedida.

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

### Método `onFailure(messageID:error:)`

Chamado quando a chamada ao método [`delete(message:completionHandler:)`](#message-stream-delete-message-completion-handler) do protocolo [`MessageStream`](#message-stream) falha.

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

O parâmetro `error` - o erro que impediu a exclusão bem-sucedida da mensagem. Tipo - [`DeleteMessageError`](#delete-message-error).

---

## Protocolo `RawLocationConfigCompletionHandler` { #raw-location-config-completion-handler }

Um objeto de protocolo pode ser passado no parâmetro `completionHandler` do método [`getRawConfig(forLocation:completionHandler:)`](#message-stream-getrawconfig) do protocolo `MessageStream`.

### Método `onSuccess(rawLocationConfig:)`

O método é chamado em uma solicitação bem-sucedida pelo método [`getRawConfig(forLocation:completionHandler:)`](#message-stream-getrawconfig) do protocolo `MessageStream`.

O parâmetro `rawLocationConfig` é a configuração do local. O tipo é `[String: Any?]`.

### Método `onFailure()`

Chamado quando a solicitação do método [`getRawConfig(forLocation:completionHandler:)`](#message-stream-getrawconfig) falha.

---

## Protocolo `SearchMessagesCompletionHandler` { #search-messages-completion-handler }

Um objeto subordinado ao protocolo pode ser passado no parâmetro `completionHandler` do método [`searchStreamMessagesBy(query:completionHandler:)`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#message-stream-searchstreammessagesby) do protocolo `MessageStream`.

### Método `onSearchMessageSuccess(query:messages:)`

O método é chamado quando uma consulta de histórico é bem-sucedida usando o método [`searchStreamMessagesBy(query:completionHandler:)`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#message-stream-searchstreammessagesby) do protocolo `MessageStream`.

O parâmetro `query` é uma consulta. O tipo é `String`.

Parâmetro `messages` - mensagens por solicitação. O tipo é `[String]`.

### Método `onSearchMessageFailure(query:)`

Chamado quando uma consulta de histórico falha usando o método [`searchStreamMessagesBy(query:completionHandler:)`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#message-stream-searchstreammessagesby) do protocolo `MessageStream`.

O parâmetro `query` é uma consulta. O tipo é `String`.

---

## Protocol `SendDialogToEmailAddressCompletionHandler` { #send-dialog-to-email-address-completion-handler }

Um objeto que implementa esse protocolo pode ser passado para o parâmetro `completionHandler` do método [`sendDialogTo(emailAddress:completionHandler:)`](#message-stream-send-dialog-to-email-address-completion-handler) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess()`

Chamado quando a chamada ao método [`sendDialogTo(emailAddress:completionHandler:)`](#message-stream-send-dialog-to-email-address-completion-handler) do protocolo [`MessageStream`](#message-stream) é bem-sucedida.

### Método `onFailure(error:)` { #send-dialog-to-email-address-completion-handler-on-failure }

Chamado quando a chamada ao método [`sendDialogTo(emailAddress:completionHandler:)`](#message-stream-send-dialog-to-email-address-completion-handler) do protocolo [`MessageStream`](#message-stream) falha.

---

## Tipo enumerado `SendDialogToEmailAddressError` { #send-dialog-to-email-address-error }

Possíveis erros que podem ser passados para o parâmetro `error` ao chamar o método [`SendDialogToEmailAddressCompletionHandler.onFailure(error:)`](#send-dialog-to-email-address-completion-handler-on-failure).

### Case `NO_CHAT`

O chat não existe.

### Case `SENT_TOO_MANY_TIMES`

O limite de tentativas de envio foi excedido.

### Caso `UNKNOWN`

Erro desconhecido.

---

## Protocolo `SendFileCompletionHandler` { #send-file-completion-handler }

Um objeto de protocolo pode ser passado no parâmetro `completionHandler` do método [`send(file:filename:mimeType:completionHandler:)`](#send-file-filename-mime-type-completion-handler) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess(messageID:)`

O método é chamado quando um arquivo é enviado com êxito usando o método [`send(file:filename:mimeType:completionHandler:)`](#send-file-filename-mime-type-completion-handler) do protocolo [`MessageStream`](#message-stream).

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

### Método `onFailure(messageID:error:)` { #on-failure-message-id-error }

Chamado quando o envio de um arquivo falha usando o método [`send(file:filename:mimeType:completionHandler:)`](#send-file-filename-mime-type-completion-handler) do protocolo [`MessageStream`](#message-stream).

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

O parâmetro `error` - o erro que impediu o envio bem-sucedido do arquivo. O tipo é [`SendFileError`](#send-file-error).

---

## Protocolo `SendKeyboardRequestCompletionHandler` { #send-keyboard-request-completion-handler }

Um objeto que implementa esse protocolo pode ser passado para o parâmetro `completionHandler` do método [`sendKeyboardRequest`](#message-stream-send-keyboard-request-button-message-completion-handler) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess(messageID:)`

Chamado quando a chamada ao método [`sendKeyboardRequest`](#message-stream-send-keyboard-request-button-message-completion-handler) do protocolo [`MessageStream`](#message-stream) é bem-sucedida.

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

### Método `onFailure(messageID:error:)`

Chamado quando a chamada ao método [`sendKeyboardRequest`](#message-stream-send-keyboard-request-button-message-completion-handler) do protocolo [`MessageStream`](#message-stream) falha.

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

O parâmetro `error` - o erro que impediu que o método fosse chamado com êxito. Tipo - [KeyboardResponseError](#keyboard-response-error).

---


---

## Protocolo `SendMessageCompletionHandler` { #send-message-completion-handler }

Um objeto que implementa esse protocolo pode ser passado para o parâmetro `completionHandler` do método [`send(message:completionHandler:)`](#message-stream-send-message-completion-handler) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess(messageID:)`

Chamado quando a chamada ao método [`send(message:completionHandler:)`](#message-stream-send-message-completion-handler) do protocolo [`MessageStream`](#message-stream) é bem-sucedida.

O parâmetro `messageid` é o ID da mensagem correspondente. O tipo é `String`.

---

## Protocolo `RateOperatorCompletionHandler` { #rate-operator-completion-handler }

Um objeto que obedece ao protocolo pode ser passado no parâmetro `completionHandler` do método [`rateOperatorWith(id:rating:completionHandler:)`](#rate-operator-with-id-by-rating-rating) do protocolo [`MessageStream`](#message-stream).

### Método `onSuccess()`

O método é chamado quando a chamada ao método [`rateOperatorWith(id:rating:completionHandler:)`](#rate-operator-with-id-by-rating-rating) do protocolo [`MessageStream`](#message-stream) é bem-sucedida.

### Método `onFailure(error:)` { #on-failure-error }

O método é chamado quando o método [`rateOperatorWith(id:rating:completionHandler:)`](#rate-operator-with-id-by-rating-rating) do protocolo [`MessageStream`](#message-stream) falha.

O parâmetro `error` é o erro que ocorreu. Tipo - [`RateOperatorError`](#rate-operator-error).

---

## Protocolo `visitSessionStateListener` { #visit-session-state-listener }

Um protocolo cuja adaptação permite que você acompanhe as alterações em [`visitSessionState`](#visit-session-state).

### Método `changed(state:to:)`

O método é chamado quando [`VisitSessionState`](#visit-session-state) é alterado.

Os valores antigo e novo são passados para os parâmetros do método.

---

## Protocolo `DepartmentListChangeListListListener` { #department-list-change-listener }

Um protocolo cuja adaptação permite o rastreamento de alterações na lista de departamentos.

### Método `received(departmentList:)`

O método é chamado quando uma nova lista de departamentos é recebida.

Uma matriz de objetos [`Department`](#department) é passada para o parâmetro do método.

---

## Protocolo `LocationSettings` { #location-settings }

Uma instância de uma classe que obedece ao protocolo pode ser recuperada usando o método [`getLocationSettings()`](#get-location-settings) do objeto [`MessageStream`](#message-stream). As configurações específicas do local atual podem ser recuperadas usando os métodos desse protocolo.

### Método `areHintsEnabled()`

Com esse método, recupera se as configurações do local atual exigem que as dicas sejam mostradas ao visitante ao digitar uma nova mensagem.

Retorna `true` se as dicas devem ser mostradas e `false` caso contrário. O tipo é `Bool`.

---

## Protocolo `ChatStateListener` { #chat-state-listener }

Um protocolo cujos métodos são implementados por alguma classe de aplicativo. Um objeto que obedece ao protocolo pode ser passado no parâmetro `chatStateListener` do método [`set(chatStateListener:)`](#set-chat-state-listener) do protocolo [`MessageStream`](#message-stream). Usado para rastrear alterações no estado atual do chat.

### Método `changed(state previousState:to newState:)` { #changed-state-previous-state-to-new-state }

O método é chamado quando o estado do chat atual é alterado.

O parâmetro `previousState` é o estado anterior do chat. O tipo é [`ChatState`](#chat-state).

O parâmetro `newState` é o novo estado do chat. Tipo - [`ChatState`](#chat-state).

---

## Protocolo `CurrentOperatorChangeListener` { #current-operator-change-listener }

Um protocolo cujos métodos são implementados por alguma classe de aplicativo. Um objeto que obedece ao protocolo pode ser passado no parâmetro currentOperatorChangeListener do método [`set(currentOperatorChangeListener:)`](#set-current-operator-change-listener) do protocolo [`MessageStream`](#message-stream).

### Método `changed(operator previousOperator:to newOperator:)`

O método é chamado quando o operador de chat atual foi alterado (ou o operador desapareceu).

O parâmetro `previousOperator` é o operador anterior. O tipo é [`Operator`](#protocol-operator).

Parâmetro `newOperator` - novo estado do chat. Tipo - opcional [`Operator`](#protocol-operator). Assume o valor `nil` se o operador tiver deixado o chat.

---

## Protocolo `OperatorTypingListener` { #operator-typing-listener }

Um objeto que obedece ao protocolo pode ser passado no parâmetro `operatorTypingListener` do método [`set(operatorTypingListener:)`](#set-operator-typing-listener) do protocolo [`MessageStream`](#message-stream).

### Método `onOperatorTypingStateChanged(isTyping:)`

O método é chamado quando o operador de chat atual começa a digitar uma mensagem.

O parâmetro `isTyping` é `true` se o operador estiver digitando uma mensagem e `false` caso contrário. O tipo é `Bool`.

---

## Protocolo `LocationSettingsChangeListener` { #location-settings-change-listener }

Um protocolo cujos métodos são implementados por alguma classe do aplicativo móvel. Um objeto da classe que obedece ao protocolo pode ser passado no parâmetro `locationSettingsChangeListener` do método [`set(locationSettingsChangeListener:)`](#set-location-settings-change-listener) do protocolo [`MessageStream`](#message-stream). Usado para rastrear alterações nas configurações de local atuais.

### Método `changed(locationSettings previousLocationSettings:to newLocationSettings:)`

O método é chamado quando as configurações de local atuais são alteradas.

O parâmetro `previousLocationSettings` é o valor anterior das configurações de local atuais. O tipo é [`LocationSettings`](#location-settings).

Parâmetro `newLocationSettings` - novo valor das configurações de local atuais. Tipo - [`LocationSettings`](#location-settings).

---

## Protocolo `OnlineStatusChangeListener` { #session-online-status-change-listener }

O protocolo é adaptado por entidades do aplicativo móvel. O objeto da classe que adaptou o protocolo pode ser passado no parâmetro `sessionOnlineStatusChangeListener` do método [`set(onlineStatusChangeListener:)`](#set-session-online-status-change-listener) do protocolo [`MessageStream`](#message-stream). Usado para receber notificações quando o status da sessão é alterado. O status da sessão é descrito em valores do tipo enumerado [`OnlineStatus`](#online-status).

### Método `changed(onlineStatus previousOnlineStatus:to newOnlineStatus:)` { #changed-session-online-status-previous-session-online-status-to-new-session-online-status }

O método é chamado quando o status da sessão é alterado.

O parâmetro `previousSessionOnlineStatus` é o status da sessão anterior. O tipo é [`OnlineStatus`](#online-status).

Parâmetro `newSessionOnlineStatus` - novo status de sessão (recebido). Tipo - [`OnlineStatus`](#online-status).

O método é chamado como resultado de uma notificação recebida do serviço **Rox.Chat**.

---

## Protocolo `UnreadByOperatorTimestampChangeListener` { #unread-by-operator-timestamp-change-listener }

Um protocolo que fornece métodos para lidar com alterações no parâmetro retornado pelo método [`getUnreadByOperatorTimestamp()`](#get-unread-by-operator-timestamp). O objeto de adaptação de protocolo é passado usando o método [`set(unreadByOperatorTimestampChangeListener:)`](#set-unread-by-operator-timestamp-change-listener).

### Método `changedUnreadByOperatorTimestampTo(newValue:)`

Um método que é chamado quando o parâmetro retornado pelo método [`getUnreadByOperatorTimestamp()`](#get-unread-by-operator-timestamp) é alterado.

O parâmetro `newValue` é o novo valor retornado pelo método [`getUnreadByOperatorTimestamp()`](#get-unread-by-operator-timestamp). O tipo é opcional `Date`.

---

## Protocolo `UnreadByVisitorMessageCountChangeListener` { #unread-by-visitor-message-count-change-listener }

Um protocolo que fornece métodos para lidar com alterações no parâmetro retornado pelo método [`getUnreadByVisitorMessageCount()`](#get-unread-by-visitor-message-count). O objeto que adapta o protocolo é passado usando o método [`set(unreadByVisitorMessageCountChangeListener:)`](#set-unread-by-visitor-message-count-change-listener).

!!! Observação “N.B.”
    O objeto de classe que implementa esse protocolo só pode ser recuperado depois que a sessão for iniciada usando o método [`resume()`](#resume). Esse objeto aumenta o valor do número de mensagens não lidas enviando solicitações apropriadas ao servidor a cada 30 segundos.

### Método `changedUnreadByVisitorMessageCountTo(newValue:)`

Um método que é chamado quando o parâmetro retornado pelo método [`getUnreadByVisitorMessageCount()`](#get-unread-by-visitor-message-count) é alterado.

O parâmetro `newValue` é o novo valor retornado pelo método [`getUnreadByVisitorMessageCount()`](#get-unread-by-visitor-message-count). O tipo é `Int`.

---

## Protocolo `UnreadByVisitorTimestampChangeListener` { #unread-by-visitor-timestamp-change-listener }

Um protocolo que fornece métodos para tratar alterações no parâmetro retornado pelo método [`getUnreadByVisitorTimestamp()`](#get-unread-by-visitor-timestamp). O objeto de adaptação de protocolo é passado usando o método [`set(unreadByVisitorTimestampChangeListener:)`](#set-unread-by-visitor-timestamp-change-listener).

### Método `changedUnreadByVisitorTimestampTo(newValue:)`

Um método que é chamado quando o parâmetro retornado pelo método [`getUnreadByVisitorTimestamp()`](#get-unread-by-visitor-timestamp) é alterado.

O parâmetro `newValue` é o novo valor retornado pelo método [`getUnreadByVisitorTimestamp()`](#get-unread-by-visitor-timestamp). O tipo é opcional `Date`.

---

## Protocolo `UploadedFile` { #uploaded-file }

Contém métodos que podem ser usados para obter informações sobre um arquivo.

### Método `getSize()`

Um método pelo qual o tamanho de um arquivo anexo pode ser obtido.

Retorna o tamanho do arquivo anexo em bytes. O tipo é `Int64`.

### Método `getGuid()`

Um método pelo qual o `guid` do arquivo de anexo pode ser obtido.

Retorna o valor em forma de texto. O tipo é `String`.

### Método `getFileName()`

Um método que pode ser usado para obter o nome do arquivo de anexo.

Retorna o nome do arquivo de anexo em formato de texto. O tipo é `String`.

### Método `getContentType()`

Um método pelo qual o tipo MIME do anexo pode ser obtido.

Retorna o tipo MIME do anexo em forma de texto. O tipo é uma `String` opcional.

### Método `getVisitorId()`

Um método que pode ser usado para obter o ID do remetente do arquivo.

Retorna o valor em formato de texto. O tipo é `String`.

### Método `getClientContentType()`

Um método pelo qual o tipo MIME de um anexo pode ser obtido.

Retorna o tipo MIME do anexo em forma de texto. O tipo é `String`.

### Método `getImageInfo()`

Um método que pode ser usado para obter informações sobre uma imagem.

Retorna informações sobre a imagem. O tipo é opcional [`ImageInfo`](#image-info).

---

## Tipo enumerado `ChatState` { #chat-state }

Possíveis opções de estado do chat (consulte o método [`getChatState()`](#get-chat-state) do protocolo [`MessageStream`](#message-stream)). O estado inicial é [`NONE`](#chat-state-none). Se o método [`startChat()`](#start-chat) ou um dos métodos de envio de mensagens do protocolo [`MessageStream`](#message-stream) for chamado, o estado será alterado para [`QUEUE`](#queue). Quando um operador aceita um chat no processamento, seu estado (chat) é alterado para [`CHATTING`](#chatting). Quando o método [`closeChat()`](#close-chat) do protocolo [`MessageStream`](#message-stream) é chamado, o estado do chat é alterado para [`CLOSED_BY_VISITOR`](#closed-by-visitor). Se o chat foi fechado por um operador - para [`CLOSED_BY_OPERATOR`](#closed-by-operator). Depois que o chat tiver sido fechado pelo visitante e pelo operador, seu estado retornará a [`NONE`](#chat-state-none). Isso também acontece depois de um longo período sem atividade no chat. O chat também pode ser reiniciado pelo operador: nesse caso, o estado do chat assume o valor [`INVITATION`](#invitation) e, depois que o visitante escreve algo de volta, o estado do chat assume o valor [`CHATTING`](#chatting).

### Caso `CHATTING` { #chatting }

O estado do chat quando o operador processa um chat iniciado pelo visitante ou quando um visitante responde a uma mensagem em um chat fechado anteriormente.

A partir desse estado, o chat pode passar para [`CLOSED_BY_OPERATOR`](#closed-by-operator), [`CLOSED_BY_VISITOR`](#closed-by-visitor) ou [`NONE`](#chat-state-none).

### Caso de `CHATTING_WITH_ROBOT` { #chatting-with-robot }

O estado de bate-papo quando um dos bots respondeu em um bate-papo iniciado por um visitante.

A partir desse estado, o chat pode ir para [`CHATTING`](#chatting), [`CLOSED_BY_VISITOR`](#closed-by-visitor) ou [`NONE`](#chat-state-none).

### Case `CLOSED_BY_OPERATOR` { #closed-by-operator }

O estado de um chat quando ele foi fechado por um operador, mas ainda não foi fechado por um visitante.

A partir desse estado, o chat pode ir para [`NONE`](#chat-state-none) ou [`QUEUE`](#queue) se o visitante escrever outra coisa.

### Case `CLOSED_BY_VISITOR` { #closed-by-visitor }

O estado do chat quando ele foi fechado pelo visitante, mas ainda não foi fechado pelo operador.

A partir desse estado, o chat pode ir para [`NONE`](#chat-state-none) ou [`QUEUE`](#queue) se o visitante escrever outra coisa.

### Case `INVITATION` { #invitation }

O estado do chat quando ele foi iniciado pelo operador.

A partir desse estado, o chat pode ir para [`NONE`](#chat-state-none) ou [`CHATTING`](#chatting).

### Caso `NONE` { #chat-state-none }

Denota a ausência de bate-papo.

A partir desse estado, o bate-papo pode ir para [`INVITATION`](#invitation) ou [`QUEUE`](#queue).

### Caso `QUEUE` { #queue }

O estado do chat quando ele foi iniciado por um visitante.

A partir desse estado, o chat pode ir para [`NONE`](#chat-state-none), [`CHATTING`](#chatting) ou [`CLOSED_BY_OPERATOR`](#closed-by-operator).

### Case `UNKNOWN`

Esse estado é recebido pelo bate-papo quando uma sessão é criada, antes da primeira atualização do estado do bate-papo recebida do servidor.

Além disso, esse estado pode ser recebido se o SDK não puder identificá-lo (por exemplo, o servidor tem novos valores de estado de bate-papo que a versão atual do SDK não sabe como tratar).

---

## Tipo enumerado `OnlineStatus` { #online-status }

Pode ser recuperado usando o método [`changed(onlineStatus previousOnlineStatus:to newOnlineStatus:)`](#changed-session-online-status-previous-session-online-status-to-new-session-online-status) do protocolo [`SessionOnlineStatusChangeListener`](#session-online-status-change-listener).

### Case `BUSY_OFFLINE`

Estado off-line com o número de limites de bate-papo excedido.

Significa que o visitante não pode enviar mensagens de forma alguma.

### Caso `BUSY_ONLINE`

Um estado on-line com o número de limites de bate-papo excedido.

Significa que o visitante pode enviar mensagens para a área off-line, mas o servidor pode rejeitá-las e retornar um erro.

### Case `OFFLINE`

Significa que o visitante pode enviar mensagens para a zona off-line.

### Case `ONLINE`

Significa que o visitante pode enviar mensagens sem nenhuma restrição.

### Caso `UNKNOWN`

Indica que o SDK ainda não recebeu a primeira atualização do status da sessão do serviço **Rox.Chat** ou que o status da sessão não é compatível com a versão atual do SDK.

---

## Tipo enumerado `VisitSessionState` { #visit-session-state }

Possíveis status de sessão.

### Case `CHAT`

O status da sessão de bate-papo.

### Case `DEPARTMENT_SELECTION` { #department-selection }

Indica que foi feita uma tentativa de iniciar um chat sem seleção de departamento e que o servidor está configurado para tornar a seleção de departamento obrigatória.

A sessão espera iniciar um chat usando o método [`startChat(departmentKey:)`](#start-chat-department-key).

### Caso `IDLE`

A sessão está ativa, mas o chat ainda não foi iniciado.

### Case `IDLE_AFTER_CHAT`

A sessão está ativa, mas o chat já foi encerrado.

### Case `OFFLINE_MESSAGE`

Off-line.

### Case `UNKNOWN`

O status ainda não foi recebido ou não é compatível com a versão atual do `RoxchatClientLibrary`.

---

## Tipo enumerado `SendFileError` { #send-file-error }

Possíveis erros que podem ser passados para o parâmetro `error` do método [`onFailure(messageID:error:)`](#on-failure-message-id-error) do protocolo [`SendFileCompletionHandler`](#send-file-completion-handler).

### Case `FILE_SIZE_EXCEEDED`

Indica que o tamanho do arquivo excede o tamanho máximo definido nas configurações do servidor.

### Caso `FILE_TYPE_NOT_ALLOWED`

Indica que o tipo de arquivo não está entre os tipos permitidos definidos nas configurações do servidor.

### Case `UPLOADED_FILE_NOT_FOUND`

Indica que o arquivo foi transferido de forma incorreta.

### Caso `UPLOAD_CANCELED`

Indica que o upload do arquivo foi cancelado devido a uma sessão desativada ou por outros motivos.

### Caso `UNKNOWN`

Erro desconhecido.

### Caso `UNAUTHORIZED`

Erro desconhecido.

---

## Tipo enumerado `RateOperatorError`. { #rate-operator-error }

Possíveis erros que podem ser passados para o parâmetro `error` do método [`onFailure(error:)`](#on-failure-error) do protocolo [`RateOperatorCompletionHandler`](#rate-operator-completion-handler).

### Caso `NO_CHAT`

Ocorre quando se tenta enviar uma avaliação de operador quando não há chat.

### Caso `WRONG_OPERATOR_ID`

Ocorre quando um ID de operador que não pertence ao chat atual foi passado em uma tentativa de enviar uma avaliação de operador.

### Caso `NOTE_IS_TOO_LONG`

O comentário é muito longo. O comprimento máximo é de 2000 caracteres.

---

## Protocolo `MessageTracker` { #message-tracker }

Uma instância de uma classe que obedece ao protocolo pode ser recuperada usando o método [`new(messageTracker:)`](#new-message-tracker-message-listener) do protocolo [`MessageStream`](#message-stream). Os métodos do protocolo são usados para manipular mensagens que existem no histórico de mensagens.

### Método `getLastMessages(byLimit:completion:)`

O método é usado para solicitar mensagens do início do histórico de mensagens.

O parâmetro `limitOfMessages` é o número de mensagens seguintes, não mais do que o método deve solicitar. O tipo é `Int`, o valor pode ser qualquer valor positivo maior que 1 (se um valor menor que 1 for passado, o método não fará nenhum trabalho).

O parâmetro `completion` é um fechamento que é executado após a conclusão da execução do método. O fechamento contém um parâmetro do tipo array `Message` e não tem tipo de retorno. Normalmente, o conjunto esperado de mensagens do histórico de mensagens é passado para o parâmetro. Se o parâmetro não contiver nenhum objeto do tipo [`Message`](#message) (a matriz está vazia), isso significa que o fim do histórico de mensagens foi alcançado. Se o método não lançar nenhum erro durante a execução, é garantido que a closure passada seja executada (com resultado vazio ou não).

Cada chamada subsequente a esse método só pode ser feita depois que a solicitação anterior tiver sido concluída (a closure foi chamada).

Pode gerar erros do tipo [`AccessError`](#access-error).

O método não fará nenhum trabalho se o objeto correspondente [`MessageTracker`](#message-tracker) tiver sido desativado (consulte o método [`destroy()`](#message-tracker-destroy)).

O método pode retornar o número de mensagens menor que o limite, mas isso não significa que não haja mais mensagens restantes. Em tal situação, o método pode ser reutilizado para descarregar mais mensagens. Se não houver mais mensagens, o método retornará null.

### Método `getNextMessages(byLimit:completion:)`

O método é usado para solicitar mensagens do histórico de mensagens que ainda não foram exibidas no feed de mensagens atual.

O parâmetro `limitOfMessages` é o número de mensagens seguintes, não mais do que o método deve solicitar. O tipo é `Int` e o valor pode ser qualquer valor positivo maior que 1 (se for passado um valor menor que 1, o método não fará nenhum trabalho).

O parâmetro `completion` é um fechamento que é executado após a conclusão da execução do método. O fechamento contém um parâmetro do tipo array [`Message`](#message) e não tem tipo de retorno. Normalmente, o conjunto esperado de mensagens do histórico de mensagens é passado para o parâmetro. Se o parâmetro não contiver nenhum objeto do tipo [`Message`](#message) (a matriz está vazia), isso significa que o fim do histórico de mensagens foi alcançado. Se o método não lançar nenhum erro durante a execução, é garantido que a closure passada seja executada (com resultado vazio ou não).

Cada chamada subsequente a esse método só pode ser feita depois que a solicitação anterior tiver sido concluída (a closure foi chamada).

Pode gerar erros do tipo [`AccessError`](#access-error).

O método não funcionará se o objeto [`MessageTracker`](#message-tracker) correspondente tiver sido desativado (consulte o método [`destroy()`](#message-tracker-destroy)).

### Método `getAllMessages(completion:)`

O método é usado para consultar todo o histórico de mensagens de uma só vez.

O parâmetro `completion` é um fechamento que é executado depois que o método é concluído. O fechamento contém um parâmetro do tipo array [`Message`](#message) e não tem tipo de retorno. Normalmente, o conjunto esperado de mensagens do histórico de mensagens é passado para o parâmetro. Se o parâmetro não contiver nenhum objeto do tipo [`Message`](#message) (a matriz está vazia), isso significa que o fim do histórico de mensagens foi alcançado. Se o método não lançar nenhum erro durante a execução, é garantido que a closure passada será executada (com resultado vazio ou não).

Pode gerar erros do tipo [`AccessError`](#access-error).

O método não funcionará se o objeto [`MessageTracker`](#message-tracker) correspondente tiver sido desativado (consulte o método [`destroy()`](#message-tracker-destroy)).

### Método `resetTo(message:)`

O objeto [`MessageTracker`](#message-tracker) armazena o intervalo atual de mensagens. Uma chamada a esse método pode “redefinir” o limite para o qual o objeto armazena o histórico de mensagens para uma mensagem específica.

O parâmetro `message` é a mensagem para a qual o limite do histórico de mensagens armazenadas deve ser “redefinido”. O tipo é [`Message`](#message).

Pode gerar erros do tipo [`AccessError`](#access-error).

O método só pode ser chamado após uma chamada anterior ao objeto [`MessageTracker`](#message-tracker) ter retornado um resultado; caso contrário, o método não funcionará.

### Método `destroy()` { #message-tracker-destroy }

Desativa o objeto [`MessageTracker`](#message-tracker) atual, após o qual nenhum método de protocolo poderá ser usado.

Pode gerar erros como [`AccessError`](#access-error).

---

## Protocolo `MessageListener` { #message-listener }

O protocolo deve ser adaptado por alguma classe de aplicativo. Os métodos do protocolo são chamados quando são feitas alterações no feed de mensagens.

### Método `added(newMessage:previousMessage:)` { #added-message-new-message-after-previous-message }

O método é chamado quando as mensagens são adicionadas ao feed atual. É importante ressaltar que chamar o método não é uma indicação de que uma nova mensagem foi recebida: é uma inserção lógica de mensagens no feed. Por exemplo, na primeira conexão bem-sucedida com o servidor, o SDK recupera todo o histórico de mensagens. Se ele contiver mensagens que estejam no período de tempo já exibido no feed, esse método também será chamado em cada uma dessas mensagens.

O parâmetro `newMessage` é a mensagem recebida. O tipo é [`Message`](#message).

Parâmetro `previousMessage` - a mensagem após a qual a mensagem recebida deve ser inserida. Tipo - opcional [`Message`](#message). Se o valor desse parâmetro for `nil`, a mensagem recebida deverá ser inserida no final da lista.

### Método `removed(message:)` { #removed-message }

O método é chamado quando uma mensagem é removida do feed.

O parâmetro `message` é a mensagem excluída. O tipo é [`Message`](#message).

### Método `removedAllMessages()`

O método é chamado quando todas as mensagens são removidas do feed.

### Método `changed(oldVersion:newVersion:)` { #changed-message-old-version-to-new-version }

O método é chamado quando qualquer mensagem é alterada.

As mensagens em si não são alteradas: um objeto é substituído por outro. Portanto, quando esse método é chamado, você pode comparar os campos da mensagem para descobrir quais são diferentes.

O parâmetro `oldVersion` é o objeto anterior da mensagem. O tipo é [`Message`](#message).

O parâmetro `newVersion` é o novo objeto da mensagem. O tipo é [`Message`](#message).

---

## Protocolo `Message` { #message }

Um protocolo é uma abstração que representa uma única mensagem no SDK. Os objetos [`Message`](#message) podem ser recuperados em chamadas para os métodos [`MessageListener`](#message-listener) do protocolo.

Os objetos [`Message`](#message) são imutáveis. As alterações em qualquer um de seus campos criam um novo objeto. Dois objetos ``Message`` podem ser verificados quanto a campos idênticos usando o método [`isEqual(to:)`](#is-equal-to-message). A correspondência lógica dos objetos de mensagem pode ser verificada pela comparação de seus IDs (consulte o método [`getID()`](#get-id)).

### Método `getRawData()`

Use esse método para obter um dicionário arbitrário gerado pelo servidor quando o `MessageType` `ACTION_REQUEST` for usado.

Retorna um dicionário do tipo `[String: Any?]` ou `nil` se não existir nenhum.

### Método `getData()` { #get-data }

As mensagens do tipo `FILE_FROM_OPERATOR` ou `FILE_FROM_VISITOR` podem conter arquivos aninhados. Use esse método para recuperar o arquivo.

Retorna uma instância da classe [`MessageData`](#message-data) ou `nil` se o arquivo estiver em processo de envio.

### Método `getCurrentChatID()`

Use esse método para obter o ID exclusivo do chat atual.

Ele retorna o ID da sala de bate-papo. O tipo é `String` ou `nil` se o ID estiver ausente.

### Método `getKeyboard()`

Use esse método para obter o elemento de teclado de um chatbot.

Retorna um teclado com botões. O tipo é opcional [`Keyboard`](#keyboard).

### Método `getKeyboardRequest()`

Esse método recupera o elemento do teclado que o usuário selecionou.

Retorna o elemento do teclado selecionado pelo usuário. O tipo é opcional [`KeyboardRequest`](#keyboard-request).

### Método `getQuote()`

Use esse método para obter informações sobre a mensagem citada.

Ele retorna a mensagem citada. O tipo é uma classe opcional [`Quote`](#quote).

### Método `isReadByOperator()`

Use esse método para obter informações sobre o status de uma mensagem. Se ela foi lida pelo operador ou não.

Retorna `true` se a mensagem foi lida pelo operador e `false` se não foi. O tipo é `Bool`.

### Método `canBeEdited()`

Use esse método para obter informações sobre se uma mensagem pode ser modificada ou excluída.

Retorna `true` se puder, e `false` se não puder. O tipo é `Bool`.

Para que o método retorne `true` em princípio, a funcionalidade correspondente ao método (edição e exclusão de mensagens) deve estar ativa na conta. Nesse caso, o valor do parâmetro `account config` `visitor_message_editing` deve ser `true`. Caso contrário, o método sempre retornará `false`.

### Método `canBeReplied()`

Use esse método para obter informações sobre se a mensagem fornecida pode ser respondida.

Retorna `true` se for possível e `false` se não for. O tipo é `Bool`.

Para que o método retorne `true` em princípio, a funcionalidade correspondente ao método (citação de mensagem) deve estar ativa na conta. Nesse caso, o valor do parâmetro `account config` `web_and_mobile_quoting` deve ser `true`. Caso contrário, o método sempre retornará `false`.

### Método `getID()` { #get-id }

Use esse método para obter o ID exclusivo de uma mensagem.

Ele retorna o ID da mensagem. O tipo é `String`.

### Método `getOperatorID()`

Use esse método para obter o ID do operador que enviou a mensagem.

Retorna o ID do operador ou `nil` se a mensagem tiver sido enviada por um não operador. O tipo é opcional `String`.

### Método `getSenderAvatarFullURL()`

Use esse método para obter a URL para carregar o avatar do remetente da mensagem (se houver).

Retorna a URL completa do avatar do remetente da mensagem ou `nil` se não houver avatar. O tipo é um URL opcional.

### Método `getSenderName()`

Use esse método para obter o nome do remetente da mensagem.

Retorna o nome do remetente da mensagem. O tipo é `String`.

### Método `getSendStatus()` { #get-send-status }

Use esse método para obter o status de envio de uma mensagem.

Ele retorna um valor do tipo enumerado [`MessageSendStatus`](#message-send-status).

### Método `getText()` { #get-text }

Use esse método para obter o texto de uma mensagem.

Ele retorna o texto da mensagem. O tipo é `String`.

### Método `getTime()`

Use esse método para obter a hora em que a mensagem foi enviada.

Tipo - `Date`.

### Método `getType()` { #get-type }

Use esse método para obter o tipo da mensagem.

Ele retorna o valor do tipo enumerado [`MessageType`](#message-type).

### Método `isEqual(to message:)` { #is-equal-to-message }

Use esse método para descobrir se duas mensagens são idênticas.

Exemplo de uso:

```
if messageOne.isEqual(to: messageTwo) { /* .... */ }
```

Onde `messageOne` e `messageTwo` são quaisquer instâncias do tipo [`Message`](#message).

O parâmetro `message` é a mensagem com a qual a mensagem na qual o método é chamado é comparada. O tipo é [`Message`](#message).

Retorna true se os campos de mensagem forem idênticos e `false` se não forem. Tipo - `Bool`.

### Método `isEdited()`

Use esse método para descobrir se uma mensagem foi editada ou não.

Retorna `true` se a mensagem tiver sido modificada e `false` se não tiver sido. O tipo é `Bool`.

---

## Protocol `MessageAttachment` { #message-attachment }

Protocol é uma abstração que representa um arquivo anexado a uma mensagem. Um objeto [`MessageAttachment`](#message-attachment) pode ser recuperado usando o método [`getAttachment()`](#get-attachment) [`Message`](#message).

### Método `getFileInfo()`

Um método que pode ser usado para obter informações sobre um arquivo anexado.

Retorna informações sobre o arquivo. O tipo é [`FileInfo`](#file-info).

### Método `getState()` { #message-attachment-get-state }

Um método para obter o status de upload de um arquivo para o servidor.

Retorna informações sobre o status de upload do arquivo. O tipo é [`AttachmentState`](https://rox.chat/kb/pt/mobile/sdk/ios-additional-features.html#attachment-state).

### Método `getDownloadProgress()`

Um método para obter a porcentagem do download do arquivo para o servidor.

Retorna a porcentagem de download do arquivo. O tipo é opcional `Int64`.

### Método `getErrorType()` { #message-attachment-get-error-type }

Um método para obter o tipo de erro que causou os problemas de upload do arquivo.

Retorna o tipo do erro. O tipo é uma `String` opcional.

### Método `getErrorMessage()` { #message-attachment-get-error-message }

Um método para obter o texto do erro que causou o problema de upload do arquivo.

Retorna o texto do erro. O tipo é opcional `String`.

### Método `getFilesInfo()`

Um método que pode ser usado para obter informações sobre os arquivos anexados.

Retorna informações sobre os arquivos. O tipo é [`FileInfo`](#file-info).

---

## Protocolo `ImageInfo` { #image-info }

O protocolo é uma abstração que representa informações sobre um anexo se ele for uma imagem. Um objeto `ImageInfo` pode ser recuperado usando o método [`getImageInfo()`](#get-image-info) do protocolo [`MessageAttachment`](#message-attachment).

### Método `getThumbURL()`

O método permite que você obtenha a URL para fazer download de uma visualização prévia de uma imagem. As dimensões vertical e horizontal máximas são 300 pixels, mas podem ser alteradas no servidor. Para saber o tamanho exato da visualização até que a imagem seja baixada, você pode usar o seguinte código:

```
let THUMB_SIZE = 300

var width = imageInfo.getWidth()

var height = imageInfo.getHeight()

se (altura > largura) {

width = (THUMB_SIZE * width) / height

height = THUMB_SIZE

} else {

height = (THUMB_SIZE * height) / width

width = THUMB_SIZE

}
```

Retorna o URL para baixar uma visualização da imagem. O link resultante é válido somente para a sessão atual.

### Método `getHeight()`

Um método que pode ser usado para obter a altura de uma imagem.

Retorna a altura da imagem em pixels ou `nil`. O tipo é opcional `Int`.

### Método `getWidth()`

Um método que pode ser usado para obter a largura da imagem.

Retorna a largura da imagem em pixels ou `nil`. O tipo é opcional `Int`.

---

## Tipo enumerado `MessageType` { #message-type }

Usado para definir o tipo de mensagem (consulte o método [`getType()`](#get-type) do protocolo [`Message`](#message)).

### Case `ACTION_REQUEST`

Uma mensagem que contém um dicionário de dados arbitrários a serem processados pelo aplicativo com base na lógica definida pelo cliente (consulte o método [`getData()`](#get-data)do protocolo [`Message`](#message)).

### Case `CONTACTS_REQUEST`

A mensagem que chega após o operador ter pressionado o botão de solicitação de contato. No momento, não há suporte automático para essa funcionalidade; qualquer carga útil dessa mensagem e da mensagem de resposta é encaminhada no texto da mensagem (consulte o método [`getText()`](#get-text) do protocolo [`Message`](#message)).

### Case `FILE_FROM_OPERATOR`

O arquivo enviado pelo operador.

### Case `FILE_FROM_VISITOR`

Um arquivo enviado por um visitante.

### Case `INFO`

Uma mensagem do sistema gerada automaticamente no servidor (por exemplo, uma saudação no início de um bate-papo).

### Case `KEYBOARD`

Uma mensagem enviada por um chatbot.

### Case `KEYBOARD_RESPONSE`

Uma mensagem do chatbot contendo informações sobre o botão que o usuário selecionou.

### Case `OPERATOR`

Uma mensagem de texto do operador.

### Case `OPERATOR_BUSY` (Operador ocupado)

Uma mensagem do sistema indicando que o operador está ocupado no momento.

### Case `VISITOR`

Uma mensagem de texto de um visitante.

---

## Tipo enumerado `MessageSendStatus` { #message-send-status }

Usado para determinar o status de envio de uma mensagem (consulte o método [`getSendStatus()`](#get-send-status) do protocolo [`Message`](#message)).

### Case `SENDING` { #sending }

Indica qualquer estado da mensagem até que ela tenha sido recebida, processada e enviada a todos os destinatários pelo servidor.

### Case `SENT`

Indica qualquer estado da mensagem após os eventos listados na descrição do valor [`SENDING`](#sending).

---

## Protocolo `Department`. { #department }

Uma representação de um único departamento. Fornece métodos para obter informações sobre um departamento. Os objetos `Department` podem ser obtidos adaptando-se o protocolo [`DepartmentListChangeListener`](#department-list-change-listener) ou chamando o método [`getDepartmentList()`](#get-department-list) do protocolo [`MessageStream`](#message-stream).

### Método `getKey()` { #get-key }

A chave do departamento é necessária para iniciar um chat com um método de departamento específico ([`startChat(departmentKey:)`](#start-chat-department-key) do método [`MessageStream`](#message-stream)).

O tipo do valor de retorno é `String`.

### Método `getName()`

Retorna o nome público do departamento.

O tipo do valor de retorno é `String`.

### Método `getDepartmentOnlineStatus()` { #get-department-online-status }

Retorna o status on-line de um departamento.

O tipo de valor de retorno é [`DepartmentOnlineStatus`](#department-online-status).

### Método `getOrder()`

Retorna um número que representa a ordem da saída do departamento na lista. Um número maior indica uma prioridade mais alta para a saída do departamento na lista.

O tipo do valor de retorno é `Int`.

### Método `getLocalizedNames()`

Retorna um dicionário de nomes de departamentos localizados, se houver um.

O tipo de valor de retorno é o opcional `[String: String]`. A chave é o nome da localidade, o valor é o nome do departamento correspondente à localidade.

### Método `getLogoURL()`

Retorna o URL do logotipo do departamento (se houver).

O tipo de valor de retorno é um URL opcional.

---

## Tipo enumerado `DepartmentOnlineStatus` { #department-online-status }

Possíveis status do departamento. Pode ser obtido chamando o método [`getDepartmentOnlineStatus()`](#get-department-online-status) do protocolo [`Department`](#department).

### Case `BUSY_OFFLINE`

Offline, limite de chat excedido.

### Caso `BUSY_ONLINE`

Online, limite de bate-papo excedido.

### Case `OFFLINE`

O visitante pode enviar mensagens off-line.

### Case `ONLINE`

O visitante pode enviar mensagens on-line.

### Case `UNKNOWN`

O status atual não é suportado por esta versão do `RoxchatClientLibrary`.

---

## Tipo enumerado `DeleteMessageError` { #delete-message-error }

Possíveis erros que podem ser passados para o parâmetro `error` ao chamar o método `DeleteMessageCompletionHandler.onFailure(messageID:error:)`.

### Case `UNKNOWN`

Erro desconhecido.

### Case `NOT_ALLOWED`

O servidor desativou a capacidade de excluir mensagens.

### Case `MESSAGE_NOT_OWNED`

Um visitante só pode excluir suas próprias mensagens. O identificador especificado pertence a outra mensagem.

### Caso `MESSAGE_NOT_FOUND`

A mensagem selecionada não foi encontrada.

---

## Protocol `Operator` { #protocol-operator }

Um objeto de protocolo é uma representação abstrata de cada operador de chat concreto. Os objetos Protocol `Operator` podem ser obtidos nos métodos de protocolo [`CurrentOperatorChangeListener`](#current-operator-change-listener) e no método [`getCurrentOperator()`](#get-current-operator) do protocolo [`MessageStream`](#message-stream).

### Método `getID()` { #operator-get-id }

O método permite que você obtenha o ID de um operador específico.

Retorna a ID de um operador específico. O tipo é `String`.

### Método `getName()` { #operator-get-name }

O método permite que você obtenha o nome de um operador específico.

Retorna o nome de um operador específico. O tipo é `String`.

### Método `getAvatarURL()`

O método permite que você obtenha a URL para fazer download do avatar de um operador específico (se houver).

Retorna o URL para download do avatar de um operador específico ou `nil`.

### Método `getTitle()`

O método permite que você obtenha o título de um funcionário.

Retorna o título do funcionário. O tipo é opcional `String`.

---

### Protocolo `RoxchatRemoteNotification` { #roxchat-remote-notification }

Um objeto de protocolo é uma representação abstrata de uma notificação push específica recebida por um aplicativo do serviço **Rox.Chat**. Os objetos de protocolo `RoxchatRemoteNotification` podem ser recuperados usando o método [`parse(remoteNotification:)`](#parse-remote-notification) da classe [`Roxchat`](#roxchat).

### Método `getType()` { #roxchat-remote-notification-get-type }

Use esse método para especificar informações úteis de um objeto [`RoxchatRemoteNotification`](#roxchat-remote-notification) específico.

Retorna o valor do tipo enumerado [`NotificationType`](#notification-type).

### Método `getEvent()` { #get-event }

Use esse método para especificar uma ação pretendida que envolva o recebimento desse objeto específico [`RoxchatRemoteNotification`](#roxchat-remote-notification).

Retorna um valor do tipo enumerado [`NotificationEvent`](#notification-event) ou `nil`.

### Método `getParameters()` { #get-parameters }

Use esse método para especificar a carga útil de um objeto [`RoxchatRemoteNotification`](#roxchat-remote-notification) específico, dependendo do seu tipo e contido em uma matriz.

Retorna uma matriz do tipo `String`. Consulte a descrição do tipo enumerado [`NotificationType`](#notification-type) para obter o conteúdo possível do array.

### Método `getLocation()`

O método pode ser chamado para obter a localização de uma sala de bate-papo.

Retorna um valor opcional do tipo `String`.

### Método `getUnreadByVisitorMessagesCount()`

O método pode ser chamado para obter o número de mensagens não lidas pelo usuário.

Ele retorna o número de mensagens. O tipo é `Int`.

---

## Protocolo `RoxchatAlert` { #roxchat-alert }

O protocolo foi projetado para lidar com alertas (alerts).

### Método `present(title:message)`

O método é usado para mostrar avisos sobre erros padrão.

O parâmetro `title` é o título do aviso, o tipo é `String`.

O parâmetro `message` é o conteúdo do aviso, do tipo `String`.

---

## Tipo enumerado `NotificationType` { #notification-type }

Os valores de tipo indicam o tipo de informação útil que compõe uma notificação push específica - pode ser recuperada usando o método [`getType()`](#roxchat-remote-notification-get-type) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification).

### Case `CONTACT_INFORMATION_REQUEST`

Indica um evento em que o operador enviou a um visitante uma solicitação de informações de contato.

O dicionário de parâmetros (consulte o método [`getParameters()`](#get-parameters) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification)) está vazio nesse caso.


### Case `OPERATOR_ACCEPTED`

Indica o evento em que um operador entrou na sala de bate-papo.

O dicionário de parâmetros (consulte o método [`getParameters()`](#get-parameters) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification)) contém apenas um valor nesse caso, o nome do operador.

### Case `OPERATOR_FILE`

Indica o evento em que o operador enviou um arquivo para a sala de bate-papo.

O dicionário de parâmetros (consulte o método [`getParameters()`](#get-parameters) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification)) nesse caso contém dois valores - nome do operador e nome do arquivo.

### Case `OPERATOR_MESSAGE`

Indica o evento em que um operador enviou uma mensagem para a sala de bate-papo.

O dicionário de parâmetros (consulte o método [`getParameters()`](#get-parameters) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification)) contém dois valores nesse caso, o nome do operador e o texto da mensagem.

### Caso `WIDGET`

Indica um evento em que um operador enviou uma mensagem de widget (essa funcionalidade não é suportada por padrão, você deve entrar em contato com o suporte para suportá-la).

O dicionário de parâmetros (consulte o método [`getParameters()`](#get-parameters) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification)) está vazio nesse caso.

### Case `rateOperator`

Indica o evento em que o operador enviou uma solicitação de taxa de operador para o visitante.

O dicionário de parâmetros (consulte o método [`getParameters()`](#get-parameters) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification)) está vazio nesse caso.

---

## Tipo enumerado `NotificationEvent` { #notification-event }

Indica um evento que implica o tipo de ação esperada do aplicativo ao receber essa notificação push específica - pode ser obtido usando o método [`getEvent()`](#get-event) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification).

### Case `ADD`

Adiciona as informações contidas nessa notificação push (consulte os métodos [`getType()`](#roxchat-remote-notification-get-type) e [`getParameters()`](#get-parameters) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification)).

### Case `DELETE`

Exclui as informações contidas nessa notificação por push (consulte os métodos [`getType()`](#roxchat-remote-notification-get-type) e [`getParameters()`](#get-parameters) do protocolo [`RoxchatRemoteNotification`](#roxchat-remote-notification)).

---

## Protocolo `FatalErrorHandler` { #fatal-error-handler }

Os métodos de protocolo são chamados quando necessário para tratar erros que o serviço **Rox.Chat** pode retornar durante a operação. Consulte os valores do tipo enumerado [`FatalErrorType`](#fatal-error-type) para obter descrições de erros

### Método `on(error:)` { #on-error }

Chamado quando um erro é recebido pelo serviço **Rox.Chat**. O objeto de protocolo [`RoxchatError`](#roxchat-error) é passado no parâmetro.

!!! Aviso “Aviso!”
    O método não é chamado na thread principal!

---

## Tipo enumerado `FatalErrorType` { #fatal-error-type }

Corresponde aos valores de possíveis erros que podem ocorrer no serviço **Rox.Chat** (consulte o método [`getErrorType()`](#get-error-type) do protocolo [`RoxchatError`](#roxchat-error)). A maioria desses erros é fatal e faz com que o objeto de sessão seja destruído.

### Caso `ACCOUNT_BLOCKED`

Indica que a conta do cliente no serviço **Rox.Chat** está bloqueada (por exemplo, por falta de pagamento).

A ocorrência do erro não depende das ações do visitante, e o possível comportamento do aplicativo no caso desse erro é apresentado como uma sugestão para que o visitante tente usar o chat mais tarde.

Causa a destruição da sessão.

### Case `PROVIDED_VISITOR_FIELDS_EXPIRED`

Indica que os dados do usuário fornecidos durante a criação da sessão (consulte os métodos [`set(visitorFieldsJSONString:)`](#set-visitor-fields-json-string-json-string) e [`set(visitorFieldsJSONData:)`](#set-visitor-fields-json-data-json-data) da classe [`SessionBuilder`](#session-builder)) não são mais válidos.

O comportamento proposto para o aplicativo é gerar novos dados de usuário e criar uma nova instância de sessão.

Faz com que a sessão seja destruída.

### Caso `UNKNOWN`

Indica a ocorrência de algum erro inesperado e não documentado.

Faz com que a sessão seja destruída.

### Caso `VISITOR_BANNED`

Ocorre quando um usuário com dados passados (consulte os métodos [`set(visitorFieldsJSONString:)`](#set-visitor-fields-json-string-json-string) e [`set(visitorFieldsJSONData:)`](#set-visitor-fields-json-data-json-data) da classe [`SessionBuilder`](#session-builder)) foi bloqueado pelo operador por qualquer motivo.

Faz com que a sessão seja destruída.

### Case `WRONG_PROVIDED_VISITOR_HASH`

Indica um erro na geração de dados do usuário. Não depende de ações do usuário, mas sinaliza um erro no algoritmo de geração de dados do aplicativo.

Causa a destruição da sessão.

---

## Protocolo `RoxchatError` { #roxchat-error }

Os objetos `RoxchatError` são passados para o parâmetro `error` do método [`on(error:)`](#on-error) do protocolo [`FatalErrorHandler`](#fatal-error-handler). Os métodos do protocolo foram projetados para lidar com erros fatais que podem ocorrer ao trabalhar com o serviço **Rox.Chat**.

### Método `getErrorType()` { #get-error-type }

O método destina-se a obter o tipo específico de erro que ocorreu.

Retorna um valor do tipo enumerado [`FatalErrorType`](#fatal-error-type).

### Método `getErrorString()`

O método pode ser chamado para obter uma representação textual do erro que ocorreu.

Retorna uma representação textual do erro que ocorreu. Tipo - `String`.

---

## Protocol `RoxchatNotFatalError` { #roxchat-not-fatal-error }

Os objetos `RoxchatNotFatalError` são passados para o parâmetro `error` do método [`onError(error:)`](#not-fatal-error-handler-on-error) do protocolo [`NotFatalErrorHandler`](#not-fatal-error-handler).

### Método `getErrorType()` { #roxchat-not-fatal-error-get-error-type }

O método destina-se a obter o tipo específico de erro que ocorreu.

Retorna um valor do tipo [`NotFatalErrorType`](#not-fatal-error-type).

### Método `getErrorString()`

O método pode ser chamado para obter uma representação textual do erro que ocorreu.

Retorna uma representação textual do erro ocorrido. O tipo é `String`.

---

## Tipo enumerado `AccessError` { #access-error }

O valor do tipo corresponde a erros que podem ser lançados por alguns métodos dos protocolos [`RoxchatSession`](#roxchat-session), [`MessageStream`](#message-stream) e [`MessageTracker`](#message-tracker).

### Caso de `INVALID_THREAD`

Ocorre quando o método foi chamado de um thread diferente daquele em que a instância da sessão foi criada.

### Caso de `INVALID_SESSION`

Ocorre quando é feita uma tentativa de usar métodos em uma instância de sessão inválida (por exemplo, após o método [`destroy()`](#destroy) ter sido chamado nela).

---

## Protocolo `RoxchatLogger` { #roxchat-logger }

Um protocolo que fornece métodos para implementar o “registro” da atividade da rede `RoxchatClientLibrary`. O mecanismo pode ser útil, por exemplo, ao depurar versões de produtos nos quais os registros `DEBUG` não estão disponíveis.

### Método `log(entry:)`

Um método que é chamado automaticamente quando uma nova entrada é liberada para o registro de atividades de rede da `RoxchatClientLibrary`.

A nova entrada é passada no parâmetro `entry` (tipo - `String`).

---

## Códigos de erro HTTP retornados

| Categoria                                                   | Código de Erro                           | Significado e possíveis soluções                                                                                                                                                                                                                                                                                                                                                                                                          |
| ----------------------------------------------------------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Erros gerais                                                |                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `account-blocked`                        | A conta do cliente no serviço **Rox.Chat** está bloqueada (por exemplo, por falta de pagamento). Entre em contato com o suporte técnico do serviço **Rox.Chat** para obter ajuda.                                                                                                                                                                                                                                                         |
|                                                             | `chat-required`                          | Responder a uma ação no chat sem chat                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                                             | `content_type_not_recognized`            | O tipo MIME do anexo não é reconhecido. Verifique se o arquivo que você está enviando está danificado. Além disso, certifique-se de que seu conteúdo corresponde a um dos [tipos MIME](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_MIME-%D1%82%D0%B8%D0%BF%D0%BE%D0%B2)                                                                                                                                            |
|                                                             | `domain-not-from-whitelist`              | O domínio não está na lista branca                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                                             | `max_file_size_exceeded`                 | O tamanho do arquivo enviado é muito grande. Tente reduzir o tamanho do arquivo ou aumentar o limite de peso para arquivos enviados                                                                                                                                                                                                                                                                                                       |
|                                                             | `file_size_too_small`                    | O tamanho do arquivo enviado é muito pequeno. Você pode estar tentando enviar um arquivo vazio                                                                                                                                                                                                                                                                                                                                            |
|                                                             | `not_allowed_file_type`                  | O envio deste formato de arquivo é proibido ou não é suportado. Altere o parâmetro responsável pelos tipos de arquivo permitidos para envio nas configurações do servidor                                                                                                                                                                                                                                                                 |
|                                                             | `not_allowed_mime_type`                  | O envio de um arquivo deste tipo MIME é proibido ou não é suportado. Altere o parâmetro responsável pelos tipos de arquivo MIME permitidos para envio nas configurações do servidor                                                                                                                                                                                                                                                       |
|                                                             | `no_previous_chats`                      | Chats anteriores estão ausentes                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `not_matching_magic_numbers`             | Os números mágicos não correspondem                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                                             | `max_files_count_per_chat_exceeded`      | O número máximo de arquivos enviados em um chat foi atingido                                                                                                                                                                                                                                                                                                                                                                              |
|                                                             | `provided-visitor-expired`               | Os dados do usuário fornecidos ao criar a sessão não são mais válidos. Este erro é resolvido automaticamente pela reinicialização                                                                                                                                                                                                                                                                                                         |
|                                                             | `reinit-required`                        | É necessária a reinicialização - provavelmente, o AuthToken está desatualizado. Este erro é resolvido automaticamente pela reinicialização                                                                                                                                                                                                                                                                                                |
|                                                             | `setting_disabled`                       | Configuração solicitada desativada                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                                             | `server-not-ready`                       | O servidor não está pronto para responder à solicitação. Este erro aparece quando você tenta contatar o servidor antes que ele esteja totalmente ligado. Tente esperar um pouco                                                                                                                                                                                                                                                           |
|                                                             | `session_not_found`                      | A sessão que você estava procurando não foi encontrada                                                                                                                                                                                                                                                                                                                                                                                    |
|                                                             | `unathorized`                            | Tentativa de acesso não autorizado. Autorização necessária                                                                                                                                                                                                                                                                                                                                                                                |
|                                                             | `uploaded-file-not-found`                | Arquivo enviado não encontrado                                                                                                                                                                                                                                                                                                                                                                                                            |
|                                                             | `visitor_banned`                         | O visitante foi bloqueado pelo operador                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                                             | `wrong-argument-value`                   | O erro ocorre quando uma solicitação chega ao servidor com um tipo de argumento incorreto (por exemplo, String em vez de int)                                                                                                                                                                                                                                                                                                             |
|                                                             | `wrong-provided-visitor-hash-value`      | Ocorre um erro quando um visitante com uma assinatura inválida tenta se autorizar                                                                                                                                                                                                                                                                                                                                                         |
| Erros de citação de mensagens no chat                       |                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `quoting-message-that-cannot-be-replied` | A mensagem não pode ser citada - não está marcada com o sinalizador `canBeReplied` ou o sinalizador não está definido como o valor `true`                                                                                                                                                                                                                                                                                                 |
|                                                             | `quoting-message-from-another-visitor`   | O ID da mensagem enviada corresponde a outro visitante                                                                                                                                                                                                                                                                                                                                                                                    |
|                                                             | `corrupted-quoted-message-id`            | ID de mensagem citada inválido                                                                                                                                                                                                                                                                                                                                                                                                            |
|                                                             | `multiple-quoted-messages-found`         | O ID da mensagem enviada corresponde a várias mensagens (provavelmente há um erro de banco de dados)                                                                                                                                                                                                                                                                                                                                      |
|                                                             | `quoted-message-not-found`               | O ID enviado não corresponde a nenhuma mensagem no banco de dados                                                                                                                                                                                                                                                                                                                                                                         |
|                                                             | `required-quote-args-missing`            | Um ou mais argumentos do sistema de citação do servidor não foram enviados                                                                                                                                                                                                                                                                                                                                                                |
| Erros de autenticação                                       |                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `provided-auth-token-not-found`          | O token de autenticação não foi encontrado no servidor. Este erro ocorre apenas ao usar um mecanismo de autenticação de cliente personalizado via token. Provavelmente, o token ainda não chegou ao serviço **Rox.Chat** do servidor do cliente e você precisa esperar um pouco                                                                                                                                                           |
| Erros relacionados ao envio, edição e exclusão de mensagens |                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `message_empty`                          | Tentativa de enviar uma mensagem vazia                                                                                                                                                                                                                                                                                                                                                                                                    |
|                                                             | `max-message-length-exceeded`            | O comprimento máximo permitido da mensagem foi atingido                                                                                                                                                                                                                                                                                                                                                                                   |
|                                                             | `message_not_found`                      | Mensagem com o ID necessário não encontrada                                                                                                                                                                                                                                                                                                                                                                                               |
|                                                             | `not_allowed`                            | A capacidade de editar/excluir mensagens está desativada no servidor                                                                                                                                                                                                                                                                                                                                                                      |
|                                                             | `message_not_owned`                      | O visitante está tentando editar/excluir uma mensagem do operador ou o ID especificado pertence a outra mensagem                                                                                                                                                                                                                                                                                                                          |
|                                                             | `wrong_message_kind`                     | Um visitante tenta editar uma mensagem não textual                                                                                                                                                                                                                                                                                                                                                                                        |
| Erros de taxa do agente                                     |                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `no-chat`                                | Ocorre nos seguintes casos:<br><br><ul><li>Ao tentar enviar uma avaliação do operador quando o chat não existe</li><li>Ao tentar enviar um pressionamento de tecla para o bot quando o chat não existe</li> <li>Ao enviar uma mensagem para um visitante quando o chat não existe e na configuração da conta o valor da propriedade `force_start_chat_on_visitor_message` é `false`</li></ul> |
|                                                             | `operator-not-in-chat`                   | Ocorre ao tentar enviar uma avaliação do operador, o ID de um operador que não pertence ao chat atual foi enviado                                                                                                                                                                                                                                                                                                                         |
|                                                             | `note-is-too-long`                       | Limite máximo de comprimento de comentário excedido - 2000 caracteres                                                                                                                                                                                                                                                                                                                                                                     |
| Erros de resposta do teclado                                |                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `button-id-not-set`                      | ID do botão não definido                                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                                             | `requset-message-id-not-set`             | ID da mensagem de solicitação não definido                                                                                                                                                                                                                                                                                                                                                                                                |
|                                                             | `can-not-create-response`                | Não é possível criar uma resposta                                                                                                                                                                                                                                                                                                                                                                                                         |
| Erros ao enviar chats por e-mail                            |                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `chat-history-sent-too-many-times`       | O histórico do chat foi enviado várias vezes                                                                                                                                                                                                                                                                                                                                                                                              |
| Erros de exclusão de arquivo                                |                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                                             | `file-has-been-sent`                     | O arquivo está anexado à mensagem e não pode ser excluído                                                                                                                                                                                                                                                                                                                                                                                 |
|                                                             | `file-not-found`                         | Arquivo não encontrado                                                                                                                                                                                                                                                                                                                                                                                                                    |
