haskimail 1.0.0

data/lib/haskimail/util.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "date"
+require "json"
+require "time"
+require "uri"
+
+require_relative "errors"
+
+module Haskimail
+  # @api private
+  # Internal helpers: request-key conversion, path escaping, date formatting.
+  module Util
+    # API field names that do not follow plain CamelCase of the snake_case key.
+    IRREGULAR_KEYS = {
+      id: "ID",
+      server_id: "ServerID",
+      template_id: "TemplateId",
+      associated_server_id: "AssociatedServerId"
+    }.freeze
+
+    # Values under these keys are user data and are sent verbatim:
+    # their keys are never renamed and nil values are kept.
+    OPAQUE_KEYS = %w[Metadata TemplateModel TestRenderModel].freeze
+
+    # The API interprets every timestamp as Moscow time.
+    MOSCOW_OFFSET = "+03:00"
+    # The same offset in seconds, for Time#getlocal.
+    MOSCOW_UTC_OFFSET = 3 * 60 * 60
+
+    # Characters that must never reach an email header: control characters
+    # (except TAB) and Unicode line separators.
+    UNSAFE_HEADER_CHARS = /[\x00-\x08\x0A-\x1F\x7F\u0085\u2028\u2029]/
+
+    module_function
+
+    # Converts a Ruby-style key into the API field name.
+    #   :html_body  => "HtmlBody"
+    #   :HtmlBody   => "HtmlBody"
+    #   "HtmlBody"  => "HtmlBody" (strings are always taken verbatim)
+    def api_key(key)
+      case key
+      when String then key
+      when Symbol
+        IRREGULAR_KEYS.fetch(key) do
+          name = key.to_s
+          name.match?(/[A-Z]/) ? name : name.split("_").map(&:capitalize).join
+        end
+      else
+        raise ValidationError, "Field names must be Symbols or Strings, got #{key.class}"
+      end
+    end
+
+    # Deep-converts a request body into API form: renames keys, drops nil
+    # values (except inside opaque user data) and rejects duplicate fields
+    # such as `{ html_body: "a", "HtmlBody" => "b" }`.
+    def to_api(value, depth = 0)
+      check_depth!(depth)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, item), result|
+          next if item.nil?
+
+          name = api_key(key)
+          raise ValidationError, "Field #{name} is given more than once" if result.key?(name)
+
+          result[name] = OPAQUE_KEYS.include?(name) ? utf8_strings(item, depth + 1) : to_api(item, depth + 1)
+        end
+      when Array then value.map { |item| to_api(item, depth + 1) }
+      when String then utf8(value)
+      else value.respond_to?(:to_haskimail) ? to_api(value.to_haskimail, depth + 1) : value
+      end
+    end
+
+    # JSON is UTF-8: binary strings holding UTF-8 are relabelled, other
+    # encodings converted. Broken text raises ValidationError (json 3.0 will
+    # raise on binary input, so this keeps behaviour identical everywhere).
+    def utf8(text)
+      return text if text.encoding == Encoding::UTF_8 && text.valid_encoding?
+
+      converted = if text.encoding == Encoding::BINARY
+                    text.dup.force_encoding(Encoding::UTF_8)
+                  else
+                    text.encode(Encoding::UTF_8)
+                  end
+      raise ValidationError, "Text is not valid UTF-8: #{text.b[0, 40].inspect}" unless converted.valid_encoding?
+
+      converted
+    rescue EncodingError
+      raise ValidationError, "Text in #{text.encoding} cannot be converted to UTF-8"
+    end
+
+    # Converts strings inside opaque user data, keeping its keys as given.
+    def utf8_strings(value, depth = 0)
+      check_depth!(depth)
+      case value
+      when Hash then value.to_h { |key, item| [key.is_a?(String) ? utf8(key) : key, utf8_strings(item, depth + 1)] }
+      when Array then value.map { |item| utf8_strings(item, depth + 1) }
+      when String then utf8(value)
+      else value
+      end
+    end
+
+    # Request bodies deeper than JSON's own nesting limit (or cyclic ones)
+    # are refused before they reach the encoder.
+    MAX_DEPTH = 100
+
+    def check_depth!(depth)
+      raise ValidationError, "Request body is nested deeper than #{MAX_DEPTH} levels (or cyclic)" if depth > MAX_DEPTH
+    end
+
+    # True for nil, "" and whitespace — never raises on broken encodings.
+    def blank?(value)
+      text = value.to_s
+      text = text.scrub unless text.valid_encoding?
+      text.strip.empty?
+    end
+
+    # Stripped text; raises ValidationError instead of Encoding errors.
+    def strip_text(value, field)
+      text = value.to_s
+      raise ValidationError, "#{field} contains invalid #{text.encoding} bytes" unless text.valid_encoding?
+
+      text.strip
+    end
+
+    # Builds "/a/<escaped>/b" from a template with `%s` placeholders.
+    def path(template, *segments)
+      format(template, *segments.map { |segment| escape_segment(segment) })
+    end
+
+    # Escapes one URL path segment. Prevents path traversal and injection of
+    # extra segments or query strings through user-supplied IDs/aliases.
+    def escape_segment(value)
+      text = case value
+             when Integer
+               raise ValidationError, "ID must be positive, got #{value}" unless value.positive?
+
+               value.to_s
+             when String, Symbol then value.to_s
+             else raise ValidationError, "ID must be an Integer or String, got #{value.class}"
+             end
+
+      raise ValidationError, "ID must not be blank" if strip_text(text, "ID").empty?
+      raise ValidationError, "ID must not be #{text.inspect}" if %w[. ..].include?(text)
+
+      URI.encode_www_form_component(text).gsub("+", "%20")
+    end
+
+    # Converts a query hash: symbol keys are mapped through `mapping`
+    # (unknown symbols raise), string keys are sent verbatim; nil is dropped.
+    def query(params, mapping)
+      params.each_with_object({}) do |(key, value), result|
+        next if value.nil?
+
+        name = case key
+               when String then key
+               when Symbol
+                 mapping.fetch(key) do
+                   raise ValidationError,
+                         "Unknown parameter #{key.inspect}. Allowed: #{mapping.keys.map(&:inspect).join(', ')}"
+                 end
+               else raise ValidationError, "Parameter names must be Symbols or Strings"
+               end
+        result[name] = query_value(value)
+      end
+    end
+
+    # Converts one query value to its API string form.
+    def query_value(value)
+      case value
+      when Time then format_time(value)
+      when DateTime then format_time(value.to_time)
+      when Date then value.strftime("%Y-%m-%d")
+      when true, false, Numeric, String, Symbol then value.to_s
+      else raise ValidationError, "Unsupported query value #{value.class}"
+      end
+    end
+
+    # Time is converted to Moscow time — the API interprets all timestamps as MSK.
+    def format_time(time, separator: " ")
+      time.getlocal(MOSCOW_UTC_OFFSET).strftime("%Y-%m-%d#{separator}%H:%M:%S")
+    end
+
+    # Date-only parameter (stats, bounces): Time is reduced to its Moscow date.
+    def format_date(value)
+      case value
+      when nil then nil
+      when DateTime then format_date(value.to_time)
+      when Time then value.getlocal(MOSCOW_UTC_OFFSET).strftime("%Y-%m-%d")
+      when Date then value.strftime("%Y-%m-%d")
+      when String then value
+      else raise ValidationError, "Expected Date, Time or String, got #{value.class}"
+      end
+    end
+
+    # Parses an API timestamp: "YYYY-MM-DD HH:MM:SS" (Moscow time), ISO 8601,
+    # or RFC 2822 ("Sat, 31 Oct 2026 21:15:56 +0300", the Date of inbound mail).
+    # @return [Time, nil] nil for an empty or zero ("0000-00-00 00:00:00") value
+    def parse_time(value)
+      text = value.to_s.strip
+      return nil if text.empty?
+      return Time.rfc2822(text) if text.match?(/\A(?:[A-Za-z]{3},\s*)?\d{1,2}\s+[A-Za-z]{3}\s+\d{4}\s/)
+
+      if text.match?(/\A\d{4}-\d\d-\d\dT/)
+        # Timestamps without an offset are Moscow time, not the host's zone.
+        text = text.sub(/z\z/, "Z").sub(/([+-]\d\d)\z/, '\\1:00')
+        text += MOSCOW_OFFSET unless text.match?(/(?:Z|[+-]\d\d:?\d\d)\z/)
+        return Time.iso8601(text)
+      end
+
+      Time.strptime("#{text} #{MOSCOW_OFFSET}", "%Y-%m-%d %H:%M:%S %z")
+    rescue ArgumentError, EncodingError
+      nil
+    end
+
+    # Freezes a Hash/Array tree in place.
+    def deep_freeze(value)
+      case value
+      when Hash then value.each_value { |item| deep_freeze(item) }
+      when Array then value.each { |item| deep_freeze(item) }
+      end
+      value.freeze
+    end
+
+    # Mutable deep copy of a Hash/Array tree.
+    def deep_dup(value)
+      case value
+      when Hash then value.to_h { |key, item| [key.dup, deep_dup(item)] }
+      when Array then value.map { |item| deep_dup(item) }
+      when String then value.dup
+      else value
+      end
+    end
+
+    # Parses JSON from the network. `JSON.parse` never instantiates classes
+    # from "json_class" keys (unlike `JSON.load`), on json 2.x and 3.x alike.
+    # @raise [JSON::ParserError] including JSON::NestingError
+    def parse_json(body)
+      JSON.parse(body, max_nesting: 100)
+    end
+
+    # @raise [ValidationError] when the value cannot be encoded
+    def generate_json(value)
+      JSON.generate(value)
+    rescue JSON::JSONError, Encoding::UndefinedConversionError => e
+      raise ValidationError, "Request body cannot be encoded as JSON: #{e.message}"
+    end
+  end
+end

data/lib/haskimail/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Haskimail
+  # Gem version (SemVer).
+  VERSION = "1.0.0"
+end

data/lib/haskimail/webhook.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "openssl"
+require "strscan"
+
+require_relative "errors"
+require_relative "util"
+require_relative "api_object"
+
+module Haskimail
+  # Parsing and verification of incoming webhooks.
+  # https://haskimail.ru/developer/webhooks/webhooks-overview
+  #
+  # Rails example:
+  #
+  #   def haskimail
+  #     event = Haskimail::Webhook.construct_event(
+  #       request.raw_post, signing_key: ENV.fetch("HASKIMAIL_WEBHOOK_KEY")
+  #     )
+  #     ProcessHaskimailEventJob.perform_later(event.to_h) # answer fast, work later
+  #     head :ok
+  #   rescue Haskimail::SignatureVerificationError, Haskimail::ValidationError
+  #     head :forbidden # event webhooks are not retried after a 4xx
+  #   end
+  #
+  # Inbound email is different: Haskimail waits up to 60 seconds, retries any
+  # answer except 2xx and 403, and a 403 stops retries for good
+  # (see examples/rails_webhook_controller.rb).
+  module Webhook
+    # Default size limits (override with `max_size:`). 1 MB is far above any
+    # event payload. Inbound emails carry Base64 attachments and, when enabled,
+    # the raw source, and the documentation sets no limit, so the default is generous.
+    MAX_EVENT_SIZE = 1024 * 1024
+    # Default limit for inbound emails.
+    MAX_INBOUND_SIZE = 64 * 1024 * 1024
+
+    # Shapes of the two signed fields. They are concatenated without a
+    # delimiter before hashing, so constraining them limits how an attacker
+    # could shift the boundary between them.
+    RECIPIENT_FORMAT = /\A[^@\s]+@[^@\s]+\z/
+    # MessageID: letters, digits, "-" and "_" (empty for events without an email).
+    MESSAGE_ID_FORMAT = /\A[0-9A-Za-z_-]*\z/
+
+    # Fields whose look-alikes (e.g. "Recipient") are refused, because the SDK
+    # reads them and only some of them are signed.
+    GUARDED_FIELDS = %w[recipient messageid secret event email].freeze
+
+    # Parsing a JSON integer with millions of digits takes tens of seconds
+    # on some Ruby/json versions, so numbers this long are refused. Digits
+    # inside strings (an inbound email body, say) are fine.
+    HUGE_NUMBER = /(?<![0-9])[0-9]{10000}/
+    # A complete JSON string; possessive, so scanning stays linear.
+    JSON_STRING = /"(?:[^"\\]++|\\.)*+"/
+    # A webhook body must be a JSON object.
+    JSON_OBJECT_START = /\A[ \t\r\n]*+\{/
+
+    module_function
+
+    # Parses an event body and verifies its signature.
+    #
+    # The signature covers only `recipient` and `message_id` (a limitation of
+    # the Haskimail protocol): other fields such as `event` are not signed.
+    # Keep the webhook URL secret, use HTTPS and, ideally, HTTP basic auth too.
+    #
+    # @param payload [String] raw request body (do not re-serialize parsed params)
+    # @param signing_key [String] webhook signing key from the Haskimail UI
+    # @return [Event]
+    # @raise [SignatureVerificationError] signature missing or wrong
+    # @raise [ValidationError] body is not a well-formed event
+    def construct_event(payload, signing_key:, max_size: MAX_EVENT_SIZE)
+      event = parse_event(payload, max_size: max_size)
+      unless valid_signature?(event.to_h, signing_key: signing_key)
+        raise SignatureVerificationError, "Webhook signature verification failed"
+      end
+
+      event
+    end
+
+    # Parses an event body WITHOUT verifying it. Use only behind another
+    # authentication layer (HTTP basic auth, IP allow-list).
+    # @return [Event]
+    def parse_event(payload, max_size: MAX_EVENT_SIZE)
+      data = parse_object(payload, max_size)
+      # Field access is case-insensitive, so "Recipient" next to "recipient"
+      # could make the application read a different value than was signed.
+      guarded = data.keys.map { |key| ApiObject.normalize(key) }.select { |key| GUARDED_FIELDS.include?(key) }
+      raise ValidationError, "Webhook payload has ambiguous duplicate fields" if guarded.uniq.size != guarded.size
+
+      Event.new(data)
+    end
+
+    # `secret == md5(recipient + message_id + signing_key)`, compared in
+    # constant time. Both signed fields must be present with exact names.
+    #
+    # @param event [Hash, Event] parsed payload
+    # @param signing_key [String]
+    # @raise [ConfigurationError] when signing_key is blank
+    def valid_signature?(event, signing_key:)
+      raise ConfigurationError, "signing_key must not be blank" if Util.blank?(signing_key)
+
+      key = signing_key.to_s
+      return false unless event.respond_to?(:to_h)
+
+      data = event.to_h
+      recipient = data["recipient"]
+      # Events not tied to an email carry "" (a missing/null value is signed as "").
+      message_id = data["message_id"].nil? ? "" : data["message_id"]
+      secret = data["secret"]
+      return false unless recipient.is_a?(String) && RECIPIENT_FORMAT.match?(recipient)
+      return false unless message_id.is_a?(String) && MESSAGE_ID_FORMAT.match?(message_id)
+      return false unless secret.is_a?(String) && !secret.empty?
+
+      expected = Digest::MD5.hexdigest("#{recipient}#{message_id}#{key}")
+      OpenSSL.secure_compare(expected, secret.downcase)
+    end
+
+    # Parses the inbound-email webhook (Postmark-compatible format, no signature:
+    # protect the URL with HTTP basic auth — `https://user:pass@host/path`).
+    # @return [InboundMessage]
+    def parse_inbound(payload, max_size: MAX_INBOUND_SIZE)
+      InboundMessage.new(parse_object(payload, max_size))
+    end
+
+    # @api private
+    # @return [Hash]
+    def parse_object(payload, limit)
+      # Rack's raw_post is binary; the body itself must be UTF-8 JSON.
+      text = payload.to_s.dup.force_encoding(Encoding::UTF_8)
+      raise WebhookPayloadTooLargeError, "Webhook payload is larger than #{limit} bytes" if text.bytesize > limit
+      raise ValidationError, "Webhook payload is not valid UTF-8" unless text.valid_encoding?
+      raise ValidationError, "Webhook payload must be a JSON object" unless JSON_OBJECT_START.match?(text)
+      raise ValidationError, "Webhook payload contains an oversized number" if huge_number?(text)
+
+      # Starts with "{", so a successful parse is always a Hash.
+      Util.parse_json(text)
+    rescue JSON::ParserError => e
+      raise ValidationError, "Webhook payload is not valid JSON: #{e.message}"
+    end
+    private_class_method :parse_object
+
+    # @api private
+    # True when a run of 10 000+ digits appears outside JSON strings.
+    # A single regex pass rules out almost every body; only bodies that do
+    # contain such a run are walked token by token (linear; an unterminated
+    # string ends the walk, the JSON parser rejects such a body anyway).
+    def huge_number?(text)
+      return false unless HUGE_NUMBER.match?(text)
+
+      scanner = StringScanner.new(text)
+      until scanner.eos?
+        scanner.skip(/[^"0-9]++/)
+        next if scanner.skip(JSON_STRING)
+        return false if scanner.check(/"/)
+        return true if scanner.match?(HUGE_NUMBER)
+
+        scanner.skip(/[0-9]++/)
+      end
+      false
+    end
+    private_class_method :huge_number?
+
+    # A delivery/bounce/open/click/spam-complaint/subscription-change event.
+    # All raw fields remain available (`event.recipient`, `event["code"]`...).
+    class Event < ApiObject
+      # Lower-case `event` value => #type.
+      TYPES = {
+        "sent" => :sent, # sandbox servers only
+        "delivered" => :delivered,
+        "bounced" => :bounced,
+        "complained" => :complained,
+        "opened" => :opened,
+        "clicked" => :clicked,
+        "subscriptionchange" => :subscription_change
+      }.freeze
+
+      # bounce_category value => Symbol.
+      BOUNCE_CATEGORIES = {
+        "hrd" => :hard_bounce,
+        "sft" => :soft_bounce,
+        "blk" => :blocked,
+        "spm" => :spam_block
+      }.freeze
+
+      # Normalized event type. The docs use both cases ("complained" and
+      # "COMPLAINED"), so comparison is case-insensitive.
+      # @return [Symbol] one of TYPES values, or :unknown
+      def type
+        TYPES.fetch(self["event"].to_s.downcase, :unknown)
+      end
+
+      TYPES.each_value do |name|
+        define_method(:"#{name}?") do
+          # @type self: Event
+          type == name
+        end
+      end
+
+      # The signed recipient field (exact key, never a look-alike).
+      # @return [String, nil]
+      def recipient
+        exact("recipient")
+      end
+
+      # MessageID of the email (signed field); "" for events not tied to an email.
+      def message_id
+        exact("message_id").to_s
+      end
+
+      # Raw `email` field (an unsigned copy of `recipient`).
+      def email
+        exact("email")
+      end
+
+      # Tag of the email (sent as `campaign_id`).
+      def tag
+        self["campaign_id"].to_s
+      end
+
+      # Metadata of the email. The API sends it as a JSON string (or, in some
+      # examples, as an object); both are returned as a Hash.
+      # @return [Hash]
+      def metadata
+        raw = to_h["custom_vars"]
+        case raw
+        when Hash then raw
+        when String
+          parsed = raw.strip.empty? ? {} : Util.parse_json(raw)
+          parsed.is_a?(Hash) ? parsed : {}
+        else {}
+        end
+      rescue JSON::ParserError
+        {}
+      end
+
+      # @return [Integer, nil]
+      def server_id
+        value = self["server_id"]
+        value.nil? ? nil : Integer(value.to_s, 10)
+      rescue ArgumentError
+        nil
+      end
+
+      # @return [String, nil]
+      def stream_id
+        value = self["stream_id"]
+        value&.to_s
+      end
+
+      # Event time as Time (UTC field preferred, Moscow time as fallback).
+      # @return [Time, nil]
+      def occurred_at
+        utc = self["event_time_utc"].to_s
+        return Util.parse_time(self["event_time"]) unless utc.match?(/\A\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\z/)
+
+        Time.strptime("#{utc} +00:00", "%Y-%m-%d %H:%M:%S %z").utc
+      rescue ArgumentError
+        Util.parse_time(self["event_time"])
+      end
+
+      # Bounce category: :hard_bounce, :soft_bounce, :blocked, :spam_block.
+      # @return [Symbol, nil]
+      def bounce_category
+        BOUNCE_CATEGORIES[self["bounce_category"].to_s]
+      end
+
+      # Subscription change: true when the address was added to the suppression list.
+      def suppressed?
+        %w[true 1].include?(self["SuppressSending"].to_s.strip.downcase)
+      end
+
+      # Key for de-duplication: Haskimail may deliver the same event twice.
+      # Clicks include the link, so clicks on two links in the same second
+      # stay distinct.
+      # @return [String]
+      def idempotency_key
+        [type, message_id, recipient, exact("event_time"), exact("url_original")].join("|")
+      end
+    end
+
+    # Inbound email as delivered to the inbound webhook.
+    class InboundMessage < ApiObject
+      # @return [Array<InboundAttachment>] decoded attachments
+      def attachments
+        items = to_h["Attachments"]
+        return [] unless items.is_a?(Array)
+
+        items.filter_map do |item|
+          next unless item.is_a?(Hash)
+
+          InboundAttachment.new(
+            name: item["Name"].to_s,
+            content_type: item["ContentType"].to_s,
+            content_id: item["ContentID"].to_s,
+            content: item["Content"].to_s.unpack1("m")
+          )
+        end
+      end
+
+      # @return [String, nil] value of a header by case-insensitive name
+      def header(name)
+        wanted = name.to_s.downcase
+        headers = to_h["Headers"]
+        return nil unless headers.is_a?(Array)
+
+        headers.each do |header|
+          return header["Value"] if header.is_a?(Hash) && header["Name"].to_s.downcase == wanted
+        end
+        nil
+      end
+
+      # @return [Float, nil] value of the X-Spam-Score header
+      def spam_score
+        value = header("X-Spam-Score")
+        value.nil? ? nil : Float(value)
+      rescue ArgumentError, TypeError # not a number, or not even a String
+        nil
+      end
+
+      # Short form: bodies, headers and Base64 attachments (up to 64 MB) are
+      # left out. Use #to_h for everything.
+      def inspect
+        summary = %w[MessageID From To Subject].filter_map do |key|
+          value = exact(key)
+          "#{key}=#{value.inspect}" unless value.nil?
+        end
+        attachments = exact("Attachments")
+        summary << "attachments=#{attachments.size}" if attachments.is_a?(Array)
+        "#<#{self.class.name} #{summary.join(' ')}>"
+      end
+      alias to_s inspect
+
+      # `pp` and IRB print the same short form.
+      def pretty_print(printer)
+        printer.text(inspect)
+      end
+    end
+
+    # Decoded attachment of an inbound email. The name comes from the sender:
+    # never use it as a file path without sanitizing.
+    class InboundAttachment
+      attr_reader :name, :content_type, :content_id, :content
+
+      # @param name [String] file name chosen by the sender
+      # @param content_type [String]
+      # @param content_id [String] "" for regular attachments
+      # @param content [String] decoded bytes
+      def initialize(name:, content_type:, content_id:, content:)
+        @name = name
+        @content_type = content_type
+        @content_id = content_id
+        @content = content
+        freeze
+      end
+
+      # True for inline attachments (with a content ID).
+      def inline?
+        !content_id.empty?
+      end
+
+      # Decoded size in bytes.
+      def size
+        content.bytesize
+      end
+
+      # @return [Hash{Symbol => String}]
+      def to_h
+        { name: name, content_type: content_type, content_id: content_id, content: content }
+      end
+
+      # Same class and same fields.
+      def ==(other)
+        other.instance_of?(self.class) && other.to_h == to_h
+      end
+      alias eql? ==
+
+      # Consistent with #eql?.
+      def hash
+        [self.class, to_h].hash
+      end
+
+      # Name, type and size; never the content.
+      def inspect
+        "#<#{self.class.name} name=#{name.inspect} content_type=#{content_type.inspect} size=#{size}>"
+      end
+      alias to_s inspect
+
+      # `pp` and IRB print the same short form, never the content.
+      def pretty_print(printer)
+        printer.text(inspect)
+      end
+    end
+  end
+end

data/lib/haskimail.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "haskimail/version"
+require_relative "haskimail/errors"
+require_relative "haskimail/redacted"
+require_relative "haskimail/configuration"
+require_relative "haskimail/util"
+require_relative "haskimail/api_object"
+require_relative "haskimail/attachment"
+require_relative "haskimail/http/net_http_transport"
+require_relative "haskimail/http/retry_policy"
+require_relative "haskimail/http/response_parser"
+require_relative "haskimail/base_client"
+require_relative "haskimail/resources/base"
+require_relative "haskimail/resources/emails"
+require_relative "haskimail/resources/templates"
+require_relative "haskimail/resources/messages"
+require_relative "haskimail/resources/server_resources"
+require_relative "haskimail/resources/account_resources"
+require_relative "haskimail/clients"
+require_relative "haskimail/webhook"
+require_relative "haskimail/test_addresses"
+
+# Ruby SDK for the Haskimail transactional email API.
+# https://haskimail.ru/developer
+module Haskimail
+  class << self
+    # Parses an API timestamp ("YYYY-MM-DD HH:MM:SS" in Moscow time) into Time.
+    # @return [Time, nil]
+    def parse_time(value)
+      Util.parse_time(value)
+    end
+  end
+end