haskimail 1.0.0

data/lib/haskimail/clients.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative "base_client"
+require_relative "resources/emails"
+require_relative "resources/templates"
+require_relative "resources/messages"
+require_relative "resources/server_resources"
+require_relative "resources/account_resources"
+
+module Haskimail
+  # Token that validates send requests without sending anything.
+  TEST_TOKEN = "HASKIMAIL_API_TEST"
+
+  # Client authenticated with a server token (`X-Haskimail-Server-Token`):
+  # everything that belongs to one server, including sending email.
+  #
+  #   client = Haskimail::ServerClient.new(ENV.fetch("HASKIMAIL_SERVER_TOKEN"))
+  #   client.emails.deliver(from: "shop@example.com", to: "ivan@example.com",
+  #                         subject: "Привет", text_body: "Привет!")
+  #
+  # Pass {Haskimail::TEST_TOKEN} to validate send requests without sending.
+  # Instances are immutable and safe to share between threads.
+  class ServerClient < BaseClient
+    # Header that carries the server token.
+    TOKEN_HEADER = "X-Haskimail-Server-Token"
+
+    # @return [Resources::Emails]
+    attr_reader :emails
+    # @return [Resources::Templates]
+    attr_reader :templates
+    # @return [Resources::Messages]
+    attr_reader :messages
+    # @return [Resources::Opens]
+    attr_reader :opens
+    # @return [Resources::Clicks]
+    attr_reader :clicks
+    # @return [Resources::InboundMessages]
+    attr_reader :inbound_messages
+    # @return [Resources::Bounces]
+    attr_reader :bounces
+    # @return [Resources::MessageStreams]
+    attr_reader :message_streams
+    # @return [Resources::Suppressions]
+    attr_reader :suppressions
+    # @return [Resources::Webhooks]
+    attr_reader :webhooks
+    # @return [Resources::InboundRules]
+    attr_reader :inbound_rules
+    # @return [Resources::Stats]
+    attr_reader :stats
+
+    # @param token [String, nil] server token; defaults to ENV["HASKIMAIL_SERVER_TOKEN"]
+    def initialize(token = ENV.fetch("HASKIMAIL_SERVER_TOKEN", nil), **options)
+      super
+    end
+
+    protected
+
+    # Name of the authentication header.
+    def token_header
+      TOKEN_HEADER
+    end
+
+    # Creates the resource objects available with this token.
+    def build_resources
+      @emails = Resources::Emails.new(self)
+      @templates = Resources::Templates.new(self)
+      @messages = Resources::Messages.new(self)
+      @opens = Resources::Opens.new(self)
+      @clicks = Resources::Clicks.new(self)
+      @inbound_messages = Resources::InboundMessages.new(self)
+      @bounces = Resources::Bounces.new(self)
+      @message_streams = Resources::MessageStreams.new(self)
+      @suppressions = Resources::Suppressions.new(self)
+      @webhooks = Resources::Webhooks.new(self)
+      @inbound_rules = Resources::InboundRules.new(self)
+      @stats = Resources::Stats.new(self)
+    end
+  end
+
+  # Client authenticated with the account token (`X-Haskimail-Account-Token`).
+  #
+  # Manages servers and domains, moves templates between servers and — as the
+  # documentation allows for the account key — reads and manages data of all
+  # servers of the account at once: templates, messages, opens, clicks,
+  # bounces, message streams, webhooks and statistics.
+  #
+  # Sending email, inbound messages, inbound rules and suppression lists need a
+  # server token: use {ServerClient} for them.
+  #
+  #   account = Haskimail::AccountClient.new(ENV.fetch("HASKIMAIL_ACCOUNT_TOKEN"))
+  #   account.servers.each { |server| puts server.name }
+  class AccountClient < BaseClient
+    # Header that carries the account token.
+    TOKEN_HEADER = "X-Haskimail-Account-Token"
+
+    # @return [Resources::Servers]
+    attr_reader :servers
+    # @return [Resources::Domains]
+    attr_reader :domains
+    # @return [Resources::AccountTemplates]
+    attr_reader :templates
+    # @return [Resources::Messages]
+    attr_reader :messages
+    # @return [Resources::Opens]
+    attr_reader :opens
+    # @return [Resources::Clicks]
+    attr_reader :clicks
+    # @return [Resources::Bounces]
+    attr_reader :bounces
+    # With the account token `create` needs `server_id:`.
+    # @return [Resources::MessageStreams]
+    attr_reader :message_streams
+    # With the account token pass `message_stream:` to `create` explicitly.
+    # @return [Resources::Webhooks]
+    attr_reader :webhooks
+    # @return [Resources::Stats]
+    attr_reader :stats
+
+    # @param token [String, nil] account token; defaults to ENV["HASKIMAIL_ACCOUNT_TOKEN"]
+    def initialize(token = ENV.fetch("HASKIMAIL_ACCOUNT_TOKEN", nil), **options)
+      super
+    end
+
+    protected
+
+    # Name of the authentication header.
+    def token_header
+      TOKEN_HEADER
+    end
+
+    # Creates the resource objects available with this token.
+    def build_resources
+      @servers = Resources::Servers.new(self)
+      @domains = Resources::Domains.new(self)
+      @templates = Resources::AccountTemplates.new(self)
+      @messages = Resources::Messages.new(self)
+      @opens = Resources::Opens.new(self)
+      @clicks = Resources::Clicks.new(self)
+      @bounces = Resources::Bounces.new(self)
+      @message_streams = Resources::MessageStreams.new(self)
+      @webhooks = Resources::Webhooks.new(self)
+      @stats = Resources::Stats.new(self)
+    end
+  end
+end

data/lib/haskimail/configuration.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "uri"
+
+require_relative "errors"
+
+# Ruby SDK for the Haskimail transactional email API.
+module Haskimail
+  # Client settings. A global instance lives in {Haskimail.configuration};
+  # every client takes a frozen snapshot of it at construction time, so
+  # changing global settings later never affects clients that already exist.
+  #
+  #   Haskimail.configure do |config|
+  #     config.read_timeout = 15
+  #     config.max_retries  = 3
+  #     config.logger       = Rails.logger
+  #   end
+  class Configuration
+    # Production API endpoint.
+    DEFAULT_BASE_URL = "https://api.haskimail.ru"
+
+    # Every setting, in the order shown by #inspect.
+    ATTRIBUTES = %i[
+      base_url open_timeout read_timeout write_timeout max_retries
+      logger proxy ca_file user_agent
+    ].freeze
+
+    # @!attribute [r] base_url
+    #   @return [String] API endpoint (HTTPS)
+    # @!attribute [r] open_timeout
+    #   @return [Numeric] seconds to establish the connection
+    # @!attribute [r] read_timeout
+    #   @return [Numeric] seconds to wait for each read
+    # @!attribute [r] write_timeout
+    #   @return [Numeric] seconds to wait for each write
+    # @!attribute [r] max_retries
+    #   @return [Integer] automatic retries (0..10)
+    # @!attribute [r] logger
+    #   @return [Logger, nil] request log without tokens or addresses
+    # @!attribute [r] proxy
+    #   @return [URI::HTTP, false, nil] explicit proxy; false = direct; nil = from the environment
+    # @!attribute [r] ca_file
+    #   @return [String, nil] extra trusted CA bundle
+    # @!attribute [r] user_agent
+    #   @return [String, nil] suffix of the User-Agent header
+    attr_reader :base_url, :open_timeout, :read_timeout, :write_timeout, :max_retries,
+                :logger, :proxy, :ca_file, :user_agent
+
+    def initialize(**options)
+      @base_url = DEFAULT_BASE_URL
+      @open_timeout = 5
+      @read_timeout = 30
+      @write_timeout = 30
+      @max_retries = 2
+      @logger = nil
+      @proxy = nil
+      @ca_file = nil
+      @user_agent = nil
+      update(**options)
+    end
+
+    # Bulk assignment with validation.
+    # @return [self]
+    def update(**options)
+      unknown = options.keys - ATTRIBUTES
+      raise ConfigurationError, "Unknown option(s): #{unknown.join(', ')}" unless unknown.empty?
+
+      # All-or-nothing: validate on a copy, then apply.
+      staged = dup
+      options.each { |key, value| staged.public_send(:"#{key}=", value) }
+      ATTRIBUTES.each { |key| instance_variable_set(:"@#{key}", staged.public_send(key)) }
+      self
+    end
+
+    # HTTPS URL without credentials, query or fragment.
+    def base_url=(value)
+      @base_url = self.class.normalize_base_url(value)
+    end
+
+    # Seconds to establish the connection.
+    def open_timeout=(value)
+      @open_timeout = positive_number!(:open_timeout, value)
+    end
+
+    # Seconds to wait for each read of the response.
+    def read_timeout=(value)
+      @read_timeout = positive_number!(:read_timeout, value)
+    end
+
+    # Seconds to wait for each write of the request.
+    def write_timeout=(value)
+      @write_timeout = positive_number!(:write_timeout, value)
+    end
+
+    # Automatic retries after a failed attempt (0..10), see HTTP::RetryPolicy.
+    def max_retries=(value)
+      unless value.is_a?(Integer) && value.between?(0, 10)
+        raise ConfigurationError, "max_retries must be an Integer between 0 and 10"
+      end
+
+      @max_retries = value
+    end
+
+    # Any object responding to #debug/#info/#warn (Logger, Rails.logger...).
+    def logger=(value)
+      unless value.nil? || %i[debug info warn].all? { |m| value.respond_to?(m) }
+        raise ConfigurationError, "logger must respond to #debug, #info and #warn"
+      end
+
+      @logger = value
+    end
+
+    # Explicit HTTP proxy, e.g. "http://user:pass@proxy.local:3128". Traffic to
+    # Haskimail is still end-to-end TLS through the proxy (CONNECT tunnel).
+    # When nil, the `https_proxy`, `HTTPS_PROXY` or `http_proxy` environment
+    # variable is used (with `no_proxy`), validated the same way; `false`
+    # connects directly and ignores the environment.
+    def proxy=(value)
+      @proxy = value.nil? || value == false ? value : self.class.parse_proxy(value)
+    end
+
+    # Path to a PEM bundle of CAs trusted in addition to the system CAs
+    # (e.g. a corporate TLS proxy). Verification itself can never be disabled.
+    def ca_file=(value)
+      raise ConfigurationError, "ca_file #{value.inspect} does not exist" if value && !File.file?(value.to_s)
+
+      @ca_file = value&.to_s&.freeze
+    end
+
+    # Suffix appended to the SDK User-Agent, e.g. "my-shop/2.1".
+    # Visible ASCII and spaces only (it becomes an HTTP header value).
+    def user_agent=(value)
+      if !value.nil? && !value.to_s.b.match?(/\A[\x20-\x7e]*\z/n)
+        raise ConfigurationError, "user_agent may contain only printable ASCII characters"
+      end
+
+      @user_agent = value.nil? ? nil : value.to_s.dup.freeze
+    end
+
+    # Proxy password is masked; use #proxy for the real value.
+    def to_h
+      ATTRIBUTES.to_h { |key| [key, key == :proxy ? redacted_proxy : public_send(key)] }
+    end
+
+    # Like #to_h: the proxy password is masked.
+    def inspect
+      "#<#{self.class.name} #{to_h.map { |key, value| "#{key}=#{value.inspect}" }.join(' ')}>"
+    end
+    alias to_s inspect
+
+    # The proxy password must not end up in caches or dumps.
+    def marshal_dump
+      raise TypeError, "#{self.class.name} may hold credentials and cannot be marshalled"
+    end
+
+    # YAML (Psych) gets the redacted view, like #inspect.
+    def encode_with(coder)
+      coder.map = to_h.transform_keys(&:to_s).transform_values { |value| value.is_a?(String) ? value : value.inspect }
+    end
+
+    # @api private
+    # Validates a proxy URL. Net::HTTP talks to proxies in plain text, so an
+    # https:// proxy would silently send its credentials unencrypted: refused.
+    # @return [URI::HTTP] frozen
+    def self.parse_proxy(value, source: "proxy")
+      text = value.to_s.strip
+      text = "http://#{text}" unless text.include?("://") # "proxy.local:3128", as in many environments
+      uri = URI.parse(text)
+      unless uri.scheme == "http" && !uri.host.to_s.empty?
+        raise ConfigurationError, "#{source} must be an http:// URL (TLS to the proxy is not supported by Net::HTTP)"
+      end
+
+      uri.freeze
+    rescue URI::InvalidURIError
+      raise ConfigurationError, "#{source} is not a valid URL"
+    end
+
+    # @api private
+    # @return [String] frozen base URL without a trailing slash
+    def self.normalize_base_url(value)
+      uri = URI.parse(value.to_s)
+      raise ConfigurationError, "base_url must use https" unless uri.scheme == "https"
+      raise ConfigurationError, "base_url must contain a host" if uri.host.nil? || uri.host.empty?
+      raise ConfigurationError, "base_url must not contain credentials" if uri.userinfo
+      raise ConfigurationError, "base_url must not contain a query or fragment" if uri.query || uri.fragment
+
+      uri.to_s.chomp("/").freeze
+    rescue URI::InvalidURIError
+      raise ConfigurationError, "base_url is not a valid URL"
+    end
+
+    private
+
+    def redacted_proxy
+      proxy = @proxy
+      return proxy unless proxy
+      return proxy.to_s unless proxy.userinfo
+
+      # A lone user name may itself be a token, so it is masked too.
+      user = proxy.password ? "#{proxy.user}:[FILTERED]" : "[FILTERED]"
+      "#{proxy.scheme}://#{user}@#{proxy.host}:#{proxy.port}"
+    end
+
+    def positive_number!(name, value)
+      return value if value.is_a?(Numeric) && value.positive?
+
+      raise ConfigurationError, "#{name} must be a positive number of seconds"
+    end
+  end
+
+  # Global defaults live here (not in haskimail.rb) so that every file of the
+  # gem can be required on its own.
+  @configuration = Configuration.new.freeze
+  # Re-entrant: reading the configuration inside a configure block is fine.
+  @config_mutex = Monitor.new
+
+  class << self
+    # Global defaults (frozen), snapshotted by every client when it is created.
+    # Change them with {configure}.
+    # @return [Configuration]
+    def configuration
+      @config_mutex.synchronize { @configuration }
+    end
+
+    # Changes global defaults atomically: if the block raises, nothing changes.
+    #
+    #   Haskimail.configure { |config| config.max_retries = 3 }
+    #
+    # @yieldparam config [Configuration]
+    def configure
+      raise ConfigurationError, "Haskimail.configure needs a block" unless block_given?
+
+      @config_mutex.synchronize do
+        draft = @configuration.dup
+        yield draft
+        @configuration = draft.freeze
+      end
+    end
+
+    # Restores defaults (handy in tests).
+    def reset_configuration!
+      @config_mutex.synchronize { @configuration = Configuration.new.freeze }
+    end
+  end
+end

data/lib/haskimail/errors.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Haskimail
+  # Base class for every error raised by this library.
+  # `rescue Haskimail::Error` catches every failure of an API call, of input
+  # validation and of webhook parsing. Only calling a Ruby method with the
+  # wrong arguments (e.g. a missing keyword) raises Ruby's own ArgumentError.
+  class Error < StandardError; end
+
+  # Invalid client configuration (missing token, non-HTTPS base URL, bad timeout...).
+  class ConfigurationError < Error; end
+
+  # The request was rejected on the client side before anything was sent.
+  class ValidationError < Error; end
+
+  # Webhook payload signature does not match.
+  class SignatureVerificationError < Error; end
+
+  # Webhook body is larger than the configured limit. A subclass of
+  # ValidationError, so answer it with a 413 rather than a 403: for inbound
+  # email a 403 stops Haskimail's retries and the message is lost.
+  class WebhookPayloadTooLargeError < ValidationError; end
+
+  # Network-level failure: DNS, refused connection, TLS, timeout.
+  class ConnectionError < Error
+    # @return [Exception, nil] the low-level exception
+    attr_reader :original_error
+
+    def initialize(message = nil, original_error: nil, request_sent: true)
+      super(message)
+      @original_error = original_error
+      @request_sent = request_sent
+    end
+
+    # `false` means the request certainly never reached Haskimail, so even a
+    # non-idempotent call (sending an email) is safe to repeat.
+    def request_sent?
+      @request_sent
+    end
+  end
+
+  # Connect, read or write timeout.
+  class TimeoutError < ConnectionError; end
+
+  # TLS handshake or certificate verification failure. Never retried.
+  class TlsError < ConnectionError; end
+
+  # Haskimail answered with an error. Carries the HTTP status and the API
+  # `ErrorCode` (see {Haskimail::ErrorCodes}).
+  class ApiError < Error
+    attr_reader :http_status, :error_code, :api_message, :response_body, :response_headers
+
+    def initialize(message = nil, http_status: nil, error_code: nil, api_message: nil,
+                   response_body: nil, response_headers: {})
+      super(message)
+      @http_status = http_status
+      @error_code = error_code
+      @api_message = api_message
+      @response_body = response_body
+      @response_headers = response_headers
+    end
+
+    # Description of {#error_code} from the documentation, if known.
+    def error_code_description
+      ErrorCodes.describe(error_code)
+    end
+  end
+
+  # HTTP 401 — the token is missing, wrong, or of the wrong kind
+  # (e.g. a server token used for account-level methods; ErrorCode 10).
+  class AuthenticationError < ApiError; end
+
+  # HTTP 403 — the IP address is not in the account allow-list.
+  class ForbiddenError < ApiError; end
+
+  # HTTP 404 — unknown API method or object.
+  class NotFoundError < ApiError; end
+
+  # HTTP 413 — the batch is larger than 50 MB.
+  class PayloadTooLargeError < ApiError; end
+
+  # HTTP 422 — validation failed; inspect {#error_code}.
+  class UnprocessableEntityError < ApiError; end
+
+  # HTTP 429 — not described in the docs, handled defensively.
+  class RateLimitError < ApiError; end
+
+  # HTTP 5xx — server-side failure. GET/PUT/DELETE are retried automatically;
+  # a POST that got 500/502/504 MAY already have been executed (an email may
+  # have been sent), so check the message log before repeating it.
+  class ServerError < ApiError; end
+
+  # HTTP 503 — temporary unavailability; the request was not executed.
+  class ServiceUnavailableError < ServerError; end
+
+  # A successful status with a body the SDK cannot interpret (not JSON, or
+  # not the documented shape). For send calls the email MAY have been
+  # accepted — check the message log before re-sending.
+  class UnexpectedResponseError < ApiError; end
+
+  # Numeric `ErrorCode` values documented at
+  # https://haskimail.ru/developer/api/overview#error-codes
+  module ErrorCodes
+    # Неверный API-ключ.
+    INVALID_API_TOKEN = 10
+    # Объект не найден или неполный запрос.
+    NOT_FOUND_OR_INCOMPLETE_REQUEST = 12
+    # Внутренняя ошибка, повторите запрос позже.
+    INTERNAL_ERROR = 100
+    # Неизвестный метод API.
+    UNKNOWN_API_METHOD = 404
+
+    # Не все обязательные параметры.
+    MISSING_REQUIRED_FIELDS = 3
+    # Аккаунт не может отправлять.
+    ACCOUNT_CANNOT_SEND = 4
+    # Некорректный email-адрес.
+    INVALID_EMAIL_ADDRESS = 6
+    # Действие запрещено.
+    ACTION_NOT_ALLOWED = 15
+    # Слишком большое вложение.
+    ATTACHMENT_TOO_LARGE = 26
+    # Недопустимый тип вложения.
+    INVALID_ATTACHMENT_TYPE = 33
+    # Отправка недоступна.
+    SENDING_UNAVAILABLE = 35
+    # Временная ошибка отправки, повторите запрос позже.
+    TEMPORARY_SENDING_ERROR = 36
+    # Некорректные заголовки письма.
+    INVALID_HEADERS = 40
+    # Адрес отправителя не подтвержден.
+    SENDER_SIGNATURE_NOT_CONFIRMED = 52
+    # Неверное значение поля или неверный пакет писем.
+    INVALID_FIELD_VALUE_OR_BATCH = 300
+    # Отправитель не подтвержден (аккаунт на модерации).
+    SENDER_NOT_CONFIRMED = 400
+    # Неверное поле запроса (тестовый режим).
+    INVALID_REQUEST_FIELD = 403
+    # Запрещенный тип вложения (тестовый режим).
+    FORBIDDEN_ATTACHMENT_TYPE = 411
+    # Получатель не подтвержден (аккаунт на модерации).
+    RECIPIENT_NOT_CONFIRMED = 412
+    # Шаблон не найден.
+    TEMPLATE_NOT_FOUND = 1101
+    # Канал не найден.
+    MESSAGE_STREAM_NOT_FOUND = 1226
+    # Через входящий канал нельзя отправлять письма.
+    CANNOT_SEND_VIA_INBOUND_STREAM = 1236
+
+    # Неверные параметры запроса сообщений.
+    INVALID_MESSAGES_QUERY = 700
+    # Сообщение не найдено.
+    MESSAGE_NOT_FOUND = 701
+    # Пропустить можно только заблокированное входящее письмо.
+    BYPASS_ONLY_BLOCKED = 702
+    # Повторить можно только входящее письмо с ошибкой.
+    RETRY_ONLY_FAILED = 703
+    # Неверные параметры запроса правил.
+    INVALID_RULE_REQUEST = 800
+    # Такое правило уже есть.
+    RULE_ALREADY_EXISTS = 810
+    # Правило не найдено.
+    RULE_NOT_FOUND = 812
+    # Неверное правило.
+    INVALID_RULE = 813
+
+    # Не найден домен или сервер.
+    DOMAIN_OR_SERVER_NOT_FOUND = 510
+    # Домен уже добавлен.
+    DOMAIN_ALREADY_EXISTS = 512
+    # Неверный формат домена.
+    INVALID_DOMAIN = 516
+    # Нечего проверять или неверная модель.
+    TEMPLATE_VALIDATION_NOTHING_TO_CHECK = 1120
+
+    # Некорректный входящий домен.
+    INVALID_INBOUND_DOMAIN = 600
+    # Входящий домен уже используется.
+    INBOUND_DOMAIN_IN_USE = 602
+    # Неверный InboundHookUrl.
+    INVALID_INBOUND_HOOK_URL = 606
+    # У входящего домена нет MX-записи inbound.haskimail.ru.
+    INBOUND_DOMAIN_MISSING_MX = 610
+    # Неверный InboundSpamThreshold.
+    INVALID_INBOUND_SPAM_THRESHOLD = 611
+
+    # Неверный MessageStreamType.
+    INVALID_MESSAGE_STREAM_TYPE = 1221
+    # Входящий канал создать нельзя.
+    CANNOT_CREATE_INBOUND_STREAM = 1228
+    # Входящий канал нельзя архивировать.
+    CANNOT_ARCHIVE_INBOUND_STREAM = 1229
+
+    # Russian description of every documented code.
+    DESCRIPTIONS = {
+      INVALID_API_TOKEN => "Неверный API-ключ",
+      NOT_FOUND_OR_INCOMPLETE_REQUEST => "Объект не найден или неполный запрос",
+      INTERNAL_ERROR => "Внутренняя ошибка, повторите запрос позже",
+      UNKNOWN_API_METHOD => "Неизвестный метод API",
+      MISSING_REQUIRED_FIELDS => "Не все обязательные параметры",
+      ACCOUNT_CANNOT_SEND => "Аккаунт не может отправлять",
+      INVALID_EMAIL_ADDRESS => "Некорректный email-адрес",
+      ACTION_NOT_ALLOWED => "Действие запрещено",
+      ATTACHMENT_TOO_LARGE => "Слишком большое вложение",
+      INVALID_ATTACHMENT_TYPE => "Недопустимый тип вложения",
+      SENDING_UNAVAILABLE => "Отправка недоступна",
+      TEMPORARY_SENDING_ERROR => "Временная ошибка отправки, повторите запрос позже",
+      INVALID_HEADERS => "Некорректные заголовки письма",
+      SENDER_SIGNATURE_NOT_CONFIRMED => "Адрес отправителя не подтвержден",
+      INVALID_FIELD_VALUE_OR_BATCH => "Неверное значение поля или неверный пакет писем",
+      SENDER_NOT_CONFIRMED => "Отправитель не подтвержден (аккаунт на модерации)",
+      INVALID_REQUEST_FIELD => "Неверное поле запроса (тестовый режим)",
+      FORBIDDEN_ATTACHMENT_TYPE => "Запрещенный тип вложения (тестовый режим)",
+      RECIPIENT_NOT_CONFIRMED => "Получатель не подтвержден (аккаунт на модерации)",
+      TEMPLATE_NOT_FOUND => "Шаблон не найден",
+      MESSAGE_STREAM_NOT_FOUND => "Канал не найден",
+      CANNOT_SEND_VIA_INBOUND_STREAM => "Через входящий канал нельзя отправлять письма",
+      INVALID_MESSAGES_QUERY => "Неверные параметры запроса сообщений",
+      MESSAGE_NOT_FOUND => "Сообщение не найдено",
+      BYPASS_ONLY_BLOCKED => "Пропустить можно только заблокированное входящее письмо",
+      RETRY_ONLY_FAILED => "Повторить можно только входящее письмо с ошибкой",
+      INVALID_RULE_REQUEST => "Неверные параметры запроса правил",
+      RULE_ALREADY_EXISTS => "Такое правило уже есть",
+      RULE_NOT_FOUND => "Правило не найдено",
+      INVALID_RULE => "Неверное правило",
+      DOMAIN_OR_SERVER_NOT_FOUND => "Не найден домен или сервер",
+      DOMAIN_ALREADY_EXISTS => "Домен уже добавлен",
+      INVALID_DOMAIN => "Неверный формат домена",
+      TEMPLATE_VALIDATION_NOTHING_TO_CHECK => "Нечего проверять или неверная модель",
+      INVALID_INBOUND_DOMAIN => "Некорректный входящий домен",
+      INBOUND_DOMAIN_IN_USE => "Входящий домен уже используется",
+      INVALID_INBOUND_HOOK_URL => "Неверный InboundHookUrl",
+      INBOUND_DOMAIN_MISSING_MX => "У входящего домена нет MX-записи inbound.haskimail.ru",
+      INVALID_INBOUND_SPAM_THRESHOLD => "Неверный InboundSpamThreshold",
+      INVALID_MESSAGE_STREAM_TYPE => "Неверный MessageStreamType",
+      CANNOT_CREATE_INBOUND_STREAM => "Входящий канал создать нельзя",
+      CANNOT_ARCHIVE_INBOUND_STREAM => "Входящий канал нельзя архивировать"
+    }.freeze
+
+    # @param code [Integer, nil]
+    # @return [String, nil]
+    def self.describe(code)
+      DESCRIPTIONS[code]
+    end
+  end
+end