unisender-ruby 0.1.0

data/lib/unisender/task_waiter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Polls an existing asynchronous job without starting or downloading an export.
+  class TaskWaiter
+    PENDING = %w[new processing].freeze
+
+    def initialize(client, clock:, sleeper:)
+      @client = client
+      @clock = clock
+      @sleeper = sleeper
+    end
+
+    def call(task_uuid, interval, timeout)
+      validate!(interval, timeout)
+      deadline = @clock.call + timeout
+      loop do
+        response = @client.get_task_result(task_uuid:)
+        return response if complete?(response)
+
+        wait(interval, deadline)
+      end
+    end
+
+    private
+
+    def validate!(interval, timeout)
+      [interval, timeout].each do |value|
+        unless value.is_a?(Numeric) && value.positive? && value.finite?
+          raise ArgumentError, "Polling interval and timeout must be positive and finite"
+        end
+      end
+    end
+
+    def complete?(response)
+      result = response.result
+      raise TaskError, response unless result.is_a?(Hash)
+      return true if result["status"] == "completed"
+      raise TaskError, response unless PENDING.include?(result["status"])
+
+      false
+    end
+
+    def wait(interval, deadline)
+      remaining = deadline - @clock.call
+      raise TimeoutError, "Timed out waiting for the UniSender task" unless remaining.positive?
+
+      @sleeper.call([interval, remaining].min)
+      raise TimeoutError, "Timed out waiting for the UniSender task" if @clock.call >= deadline
+    end
+  end
+end

data/lib/unisender/transport.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+
+module Unisender
+  # Verified HTTPS transport with explicit timeouts and no implicit retries.
+  class Transport
+    def initialize(open_timeout: 5, read_timeout: 60, write_timeout: 30, http_factory: nil)
+      [open_timeout, read_timeout, write_timeout].each do |timeout|
+        unless timeout.is_a?(Numeric) && timeout.positive? && timeout.finite?
+          raise ArgumentError, "Timeouts must be positive finite numbers"
+        end
+      end
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+      @write_timeout = write_timeout
+      @http_factory = http_factory || ->(uri) { Net::HTTP.new(uri.hostname.to_s, uri.port) }
+      freeze
+    end
+
+    def post(uri, headers:, body:)
+      exchange(uri, headers:, body:)
+    rescue Timeout::Error
+      raise TimeoutError, "UniSender request timed out", cause: nil
+    rescue OpenSSL::SSL::SSLError
+      raise TransportError, "UniSender TLS connection failed", cause: nil
+    rescue IOError, SystemCallError, SocketError
+      raise TransportError.new("UniSender connection failed", retryable: true), cause: nil
+    end
+
+    private
+
+    def exchange(uri, headers:, body:)
+      request = Net::HTTP::Post.new(uri, headers)
+      request.body = body
+      response = configured_http(uri).request(request)
+      headers = response.to_hash.transform_values { |items| items.join(", ") }
+      HTTPResponse.new(status: response.code.to_i, headers:, body: response.body.to_s)
+    end
+
+    def configured_http(uri)
+      http = @http_factory.call(uri)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.open_timeout = @open_timeout
+      http.read_timeout = @read_timeout
+      http.write_timeout = @write_timeout
+      http.max_retries = 0
+      http
+    end
+  end
+end

data/lib/unisender/validation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Structural checks only. Account permissions and business rules belong to the API.
+  module Validation
+    def self.operation!(method, params)
+      case method
+      when "importContacts" then import!(params)
+      when "getTemplate" then template!(params)
+      when "createEmailMessage" then email_message!(params)
+      when "createCampaign" then campaign!(params)
+      end
+    end
+
+    def self.email_message!(params)
+      required!(params, %w[subject body]) if params[:template_id].nil? && params[:system_template_id].nil?
+    end
+
+    def self.campaign!(params)
+      return unless params[:contacts] && params[:contacts_url]
+
+      raise ArgumentError,
+            "contacts and contacts_url are mutually exclusive"
+    end
+
+    def self.template!(params)
+      return unless params[:template_id].nil? && params[:system_template_id].nil?
+
+      raise ArgumentError, "Provide template_id or system_template_id"
+    end
+
+    def self.import!(params)
+      fields = params[:field_names]
+      unless fields.is_a?(Array) && fields.all?(String) && fields.include?("email") && fields.uniq == fields
+        raise ArgumentError, "field_names must contain unique column names including email"
+      end
+
+      rows!(params[:data], fields.size)
+    end
+
+    def self.rows!(rows, width)
+      unless rows.is_a?(Array) && (1..500).cover?(rows.size) && rows.all? do |row|
+        row.is_a?(Array) && row.size == width
+      end
+        raise ArgumentError, "data must contain 1 to 500 rows matching field_names"
+      end
+    end
+
+    def self.required!(params, names)
+      names.each do |name|
+        value = params[name.to_sym]
+        raise ArgumentError, "Missing required parameter: #{name}" if missing?(value)
+      end
+    end
+
+    def self.missing?(value)
+      case value
+      when nil then true
+      when String, Array, Hash then value.empty?
+      else false
+      end
+    end
+
+    def self.comma_list(value)
+      unless value.all? { |item| item.is_a?(String) || item.is_a?(Integer) }
+        raise ArgumentError, "Comma-separated lists require strings or integers"
+      end
+
+      value.join(",")
+    end
+  end
+end

data/lib/unisender/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Unisender
+  VERSION = "0.1.0"
+end

data/lib/unisender.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "unisender/version"
+require "uri"
+require_relative "unisender/response"
+require_relative "unisender/errors"
+require_relative "unisender/protocol"
+require_relative "unisender/form"
+require_relative "unisender/transport"
+require_relative "unisender/validation"
+require_relative "unisender/event_payload"
+require_relative "unisender/retry_policy"
+require_relative "unisender/client"
+require_relative "unisender/events"
+require_relative "unisender/paginated_operations"
+require_relative "unisender/pagination"
+require_relative "unisender/batches"
+require_relative "unisender/task_waiter"
+require_relative "unisender/helpers"
+require_relative "unisender/operations/contacts_1"
+require_relative "unisender/operations/contacts_2"
+require_relative "unisender/operations/inputs_1"
+require_relative "unisender/operations/messages_1"
+require_relative "unisender/operations/messages_2"
+require_relative "unisender/operations/messages_3"
+require_relative "unisender/operations/notes_1"
+require_relative "unisender/operations/statistics_1"
+require_relative "unisender/operations/statistics_2"
+require_relative "unisender/operations/templates_1"

data/sig/operations.rbs

@@ -0,0 +1,78 @@
+module Unisender
+  type id = String | Integer
+  type flag = bool | 0 | 1
+  type list = { "id" => id, "title" => String }
+  type list_created = { "id" => id }
+  type subscription = { "person_id" => id }
+  type message_created = { "message_id" => id }
+  type campaign_created = { "campaign_id" => id, "status" => String }
+  type task_created = { "task_uuid" => String }
+  type task_completed = { "status" => String, "file_to_download" => String }
+
+  type object = Hash[String, json]
+  type objects = Array[object]
+  type contact_count = { "count" => String }
+  type total_contacts = { "total" => Integer }
+  type delivery_status = { "status" => String }
+  type message_version = { "message_id" => id, "actual_version_id" => id }
+  type note = { "id" => id, "content" => String }
+  type event_accepted = { "success" => true }
+
+  class Client
+    def create_list: (title: String, ?before_subscribe_url: String | nil, ?after_subscribe_url: String | nil, ?sub_user_rights: params | nil) -> Response[list_created]
+    def delete_list: (list_id: id) -> Response[object | objects]
+    def exclude: (contact_type: String, contact: String, ?list_ids: String | Array[id] | nil) -> Response[object | objects]
+    def export_contacts: (?notify_url: String | nil, ?list_id: id | nil, ?field_names: Array[String] | nil, ?email: String | nil, ?phone: String | nil, ?tag: String | nil, ?email_status: String | nil, ?phone_status: String | nil, ?contact_status: String | nil) -> Response[task_created]
+    def get_contact_count: (list_id: id, params: params) -> Response[contact_count]
+    def get_lists: () -> Response[Array[list]]
+    def get_total_contacts_count: (login: String) -> Response[total_contacts]
+    def import_contacts: (field_names: Array[String], data: Array[Array[parameter]], ?overwrite_tags: flag | nil, ?overwrite_lists: flag | nil, ?telegram_bot_channel_id: String | nil) -> Response[object]
+    def subscribe: (list_ids: String | Array[id], fields: params, ?tags: String | Array[id] | nil, ?double_optin: Integer | nil, ?overwrite: Integer | nil) -> Response[subscription]
+    def update_list: (list_id: id, title: String, ?before_subscribe_url: String | nil, ?after_subscribe_url: String | nil, ?sub_user_rights: params | nil) -> Response[object | objects]
+    def is_contact_in_lists: (email: String, list_ids: String | Array[id], condition: String) -> Response[bool]
+    def get_contact: (email: String, ?include_lists: flag | nil, ?include_fields: flag | nil, ?include_details: flag | nil) -> Response[object]
+    def unsubscribe: (contact_type: String, contact: String, ?list_ids: String | Array[id] | nil) -> Response[object | objects]
+    def cancel_campaign: (campaign_id: id) -> Response[objects]
+    def check_email: (email_id: String | Array[id]) -> Response[objects]
+    def check_sms: (sms_id: id) -> Response[delivery_status]
+    def create_campaign: (message_id: id, ?start_time: String | nil, ?timezone: String | nil, ?track_read: flag | nil, ?track_links: flag | nil, ?contacts: String | Array[id] | nil, ?contacts_url: String | nil, ?track_ga: flag | nil, ?payment_limit: Integer | Float | nil, ?payment_currency: String | nil, ?ga_medium: String | nil, ?ga_source: String | nil, ?ga_campaign: String | nil, ?ga_content: String | nil, ?ga_term: String | nil) -> Response[campaign_created]
+    def create_email_message: (sender_name: String, sender_email: String, list_id: id, ?subject: String | nil, ?body: String | nil, ?text_body: String | nil, ?generate_text: flag | nil, ?tag: String | nil, ?attachments: Hash[String, String] | nil, ?lang: String | nil, ?template_id: id | nil, ?system_template_id: id | nil, ?wrap_type: String | nil, ?categories: String | Array[id] | nil) -> Response[message_created]
+    def create_sms_message: (sender: String, body: String, list_id: id, ?tag: String | nil) -> Response[message_created]
+    def delete_message: (message_id: id) -> Response[object | objects]
+    def get_actual_message_version: (message_id: id) -> Response[message_version]
+    def get_web_version: (campaign_id: id) -> Response[object]
+    def send_email: (email: String, sender_name: String, sender_email: String, subject: String, body: String, list_id: id, ?attachments: Hash[String, String] | nil, ?lang: String | nil, ?track_read: flag | nil, ?track_links: flag | nil, ?cc: String | nil, ?headers: String | params | nil, ?images_as: String | nil, ?ref_key: String | nil, ?error_checking: flag | nil, ?metadata: params | nil) -> Response[object | objects]
+    def send_sms: (phone: String, sender: String, text: String) -> Response[object]
+    def send_test_email: (email: String | Array[id], id: id) -> Response[object | objects]
+    def update_email_message: (id: id, ?sender_name: String | nil, ?sender_email: String | nil, ?subject: String | nil, ?body: String | nil, ?list_id: id | nil, ?text_body: String | nil, ?lang: String | nil, ?categories: String | Array[id] | nil) -> Response[message_created]
+    def update_opt_in_email: (sender_name: String, sender_email: String, subject: String, body: String, list_id: id) -> Response[object | objects]
+    def get_sender_domain_list: (username: String, ?domain: String | nil, ?limit: Integer | nil, ?offset: Integer | nil) -> Response[objects]
+    def get_campaign_common_stats: (campaign_id: id) -> Response[object]
+    def get_campaign_delivery_stats: (campaign_id: id, ?notify_url: String | nil, ?changed_since: String | nil, ?field_ids: Array[id] | nil) -> Response[task_created]
+    def get_campaign_status: (campaign_id: id) -> Response[delivery_status]
+    def get_messages: (date_from: String, date_to: String, ?limit: Integer | nil, ?offset: Integer | nil) -> Response[objects]
+    def get_visited_links: (campaign_id: id, ?group: flag | nil) -> Response[object]
+    def list_messages: (date_from: String, date_to: String, ?limit: Integer | nil, ?offset: Integer | nil) -> Response[objects]
+    def get_campaigns: (from: String, ?to: String | nil, ?limit: Integer | nil, ?offset: Integer | nil) -> Response[objects]
+    def get_message: (id: id) -> Response[objects]
+    def get_task_result: (task_uuid: String) -> Response[object]
+    def create_email_template: (title: String, subject: String, body: String, ?description: String | nil, ?text_body: String | nil, ?lang: String | nil) -> Response[list_created]
+    def delete_template: (template_id: id) -> Response[object | objects]
+    def get_template: (?template_id: id | nil, ?system_template_id: id | nil) -> Response[object]
+    def get_templates: (?type: String | nil, ?date_from: String | nil, ?date_to: String | nil, ?limit: Integer | nil, ?offset: Integer | nil) -> Response[objects]
+    def list_templates: (?type: String | nil, ?date_from: String | nil, ?date_to: String | nil, ?limit: Integer | nil, ?offset: Integer | nil) -> Response[objects]
+    def update_email_template: (template_id: id, ?title: String | nil, ?description: String | nil, ?subject: String | nil, ?body: String | nil, ?text_body: String | nil, ?lang: String | nil) -> Response[list_created]
+    def create_field: (name: String, type: String, ?public_name: String | nil) -> Response[list_created]
+    def delete_field: (id: id) -> Response[object | objects]
+    def delete_tag: (id: id) -> Response[object | objects]
+    def get_fields: () -> Response[objects]
+    def get_tags: () -> Response[objects]
+    def update_field: (id: id, name: String, ?public_name: String | nil) -> Response[object | objects]
+    def get_contact_field_values: (email: String, field_ids: String | Array[id]) -> Response[object]
+    def create_subscriber_note: (subscriber_id: id, content: String) -> Response[list_created]
+    def update_subscriber_note: (id: id, content: String) -> Response[list_created]
+    def delete_subscriber_note: (id: id) -> Response[object | objects]
+    def get_subscriber_note: (id: id) -> Response[note]
+    def get_subscriber_notes: (subscriber_id: id, ?limit: Integer | nil, ?offset: Integer | nil, ?order_type: String | nil, ?order_by: String | nil, ?is_pinned: flag | nil) -> Response[objects]
+  end
+end

data/sig/unisender.rbs

@@ -0,0 +1,218 @@
+module Unisender
+  VERSION: String
+
+  type json = nil | bool | Integer | Float | String | Array[json] | Hash[String, json]
+  type parameter = nil | bool | Integer | Float | String | Array[parameter] | Hash[String | Symbol | Integer, parameter]
+  type params = Hash[String | Symbol | Integer, parameter]
+  type duration = Integer | Float
+
+  class HTTPResponse < Data
+    attr_reader status: Integer
+    attr_reader headers: Hash[String, String]
+    attr_reader body: String
+    def self.new: (status: Integer, headers: Hash[String, String], body: String) -> HTTPResponse
+    def inspect: () -> String
+    alias to_s inspect
+  end
+
+  class Response[out Result = json]
+    EMPTY_WARNINGS: Array[json]
+    @data: Hash[String, json]
+    @status: Integer
+    @headers: Hash[String, String]
+    attr_reader data: Hash[String, json]
+    attr_reader status: Integer
+    attr_reader headers: Hash[String, String]
+    def initialize: (data: Hash[String, json], status: Integer, headers: Hash[String, String]) -> void
+    def result: () -> Result
+    def warnings: () -> json
+    def inspect: () -> String
+    private
+    def immutable: (json) -> json
+    def immutable_hash: (Hash[String, json]) -> Hash[String, json]
+  end
+
+  class Error < StandardError
+    OPERATIONS: Array[String]
+    @operation: String?
+    attr_reader operation: String?
+    def with_operation: (String) -> self
+    def to_s: () -> String
+    def inspect: () -> String
+  end
+  class APIError < Error
+    SAFE_CODES: Array[String]
+    attr_reader response: Response
+    attr_reader code: json
+    attr_reader details: json
+    def initialize: (Response) -> void
+  end
+  class HTTPError < Error
+    attr_reader response: Response
+    def initialize: (Response) -> void
+  end
+  class InvalidResponseError < Error
+  end
+  class TransportError < Error
+    @retryable: bool
+    def initialize: (String, ?retryable: bool) -> void
+    def retryable?: () -> bool
+  end
+  class TimeoutError < TransportError
+  end
+  class EventError < HTTPError
+    def code: () -> json
+    def details: () -> json
+    def possibly_partially_accepted?: () -> bool
+  end
+
+  class BatchError < Error
+    attr_reader completed_responses: Array[Response]
+    attr_reader failed_range: Range[Integer]
+    attr_reader error: StandardError
+    def initialize: (completed_responses: Array[Response], failed_range: Range[Integer], error: StandardError) -> void
+  end
+  class PaginationError < Error
+  end
+  class PartialFailure < Error
+    attr_reader response: Response
+    def initialize: (Response) -> void
+  end
+  class TaskError < Error
+    attr_reader response: Response
+    def initialize: (Response) -> void
+  end
+
+  module PaginatedOperations
+    DEFINITIONS: Hash[String, [String, Array[Symbol], Array[Symbol], Integer?]]
+    def self.call: (Client, String | Symbol, params) -> Response[objects]
+    def self.page_limit: (String | Symbol) -> Integer?
+    def self.definition: (String | Symbol) -> [String, Array[Symbol], Array[Symbol], Integer?]
+  end
+
+  class Pagination
+    @client: Client
+    @method: String
+    @page_size: Integer
+    @max_pages: Integer
+    @params: params
+    def initialize: (Client, String | Symbol, Integer, Integer, params) -> void
+    def each: () -> Enumerator[Response, void]
+    private
+    def validate!: (Integer?) -> void
+    def validate_limit!: (Integer?) -> void
+    def page_length: (Response) -> Integer
+    def initial_offset: () -> Integer
+    def fetch_pages: (_ResponseSink, Integer) -> void
+  end
+
+  module Batches
+    def self.each: [T] (Enumerable[T], Integer, Integer) { (Array[T]) -> Response } -> Enumerator[Response, void]
+    def self.execute: [T] (Array[T], Integer, Array[Response]) { (Array[T]) -> Response } -> Response
+  end
+
+  class TaskWaiter
+    PENDING: Array[String]
+    @client: Client
+    @clock: ^() -> Float
+    @sleeper: ^(duration) -> void
+    def initialize: (Client, clock: ^() -> Float, sleeper: ^(duration) -> void) -> void
+    def call: (String, duration, duration) -> Response
+    private
+    def validate!: (duration, duration) -> void
+    def complete?: (Response) -> bool
+    def wait: (duration, Float) -> void
+  end
+
+  module EventPayload
+    def self.encode: (Array[params]) -> String
+    def self.validate: (json) -> Hash[String, json]
+    def self.validate_name: (json) -> void
+    def self.validate_email: (json) -> void
+    def self.normalize: (parameter, Integer) -> json
+    def self.normalize_hash: (params, Integer) -> Hash[String, json]
+  end
+
+  class RetryPolicy
+    READ_ONLY: Array[String]
+    TRANSIENT_CODES: Array[String]
+    @max_retries: Integer
+    @max_elapsed: duration
+    @clock: ^() -> Float
+    @sleeper: ^(Float) -> void
+    @random: ^() -> Float
+    def initialize: (?max_retries: Integer, ?max_elapsed: duration, ?clock: ( ^() -> Float)?, ?sleeper: ( ^(Float) -> void)?, ?random: ( ^() -> Float)?) -> void
+    def call: [T] (String) { () -> T } -> T
+    private
+    def transient?: (Error) -> bool
+    def retry_after: (Error) -> Float
+    def validate!: (Integer, duration) -> void
+    def wait?: (Error, Integer, Float) -> bool
+  end
+
+  module Protocol
+    def self.parse: (HTTPResponse, ?method: String?) -> Response
+    def self.result?: (Hash[String, json], String?) -> bool
+    def self.decode: (HTTPResponse) -> Hash[String, json]
+  end
+
+  module Form
+    def self.encode: (params) -> String
+    def self.pairs: (parameter, String?, Integer) -> Array[[String, String]]
+    def self.hash_pairs: (params, String?, Integer) -> Array[[String, String]]
+    def self.scalar: (parameter, String) -> String
+    def self.numeric: (parameter) -> String
+    def self.text: (String) -> String
+  end
+
+  module Validation
+    def self.operation!: (String, params) -> void
+    def self.template!: (params) -> void
+    def self.import!: (params) -> void
+    def self.email_message!: (params) -> void
+    def self.campaign!: (params) -> void
+    def self.rows!: (parameter, Integer) -> void
+    def self.required!: (params, Array[String]) -> void
+    def self.missing?: (parameter) -> bool
+    def self.comma_list: (Array[parameter]) -> String
+  end
+
+  interface _Transport
+    def post: (URI::Generic, headers: Hash[String, String], body: String) -> HTTPResponse
+  end
+
+  interface _ResponseSink
+    def <<: (Response) -> void
+  end
+
+  class Transport
+    @open_timeout: duration
+    @read_timeout: duration
+    @write_timeout: duration
+    @http_factory: ^(URI::Generic) -> Net::HTTP
+    def initialize: (?open_timeout: duration, ?read_timeout: duration, ?write_timeout: duration, ?http_factory: (^(URI::Generic) -> Net::HTTP)?) -> void
+    def post: (URI::Generic, headers: Hash[String, String], body: String) -> HTTPResponse
+    private
+    def configured_http: (URI::Generic) -> Net::HTTP
+    def exchange: (URI::Generic, headers: Hash[String, String], body: String) -> HTTPResponse
+  end
+
+  class Client
+    RESERVED_PARAMETERS: Array[String]
+    @api_key: String
+    @language: String
+    @transport: _Transport
+    @retry_policy: RetryPolicy
+    def initialize: (api_key: String, ?transport: _Transport, ?language: String | Symbol, ?retry_policy: RetryPolicy) -> void
+    def request: (String, ?params: params) -> Response
+    def track_events: (events: Array[params]) -> Response[event_accepted]
+    def each_page: (String | Symbol, ?page_size: Integer, ?max_pages: Integer, **parameter) -> Enumerator[Response, void]
+    def import_contacts_in_batches: (field_names: Array[String], data: Enumerable[Array[parameter]], ?batch_size: Integer, ?overwrite_tags: flag?, ?overwrite_lists: flag?, ?telegram_bot_channel_id: String?) -> Enumerator[Response, void]
+    def track_events_in_batches: (events: Enumerable[params], ?batch_size: Integer) -> Enumerator[Response, void]
+    def wait_for_task: (task_uuid: String, ?interval: duration, ?timeout: duration, ?clock: ( ^() -> Float)?, ?sleeper: ( ^(duration) -> void)?) -> Response[task_completed]
+    def inspect: () -> String
+    private
+    def invoke: [Result] (String, params, ?required: Array[String], ?comma: Array[String]) -> Response[Result]
+    def validate_request: (String, params) -> void
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: unisender-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Leonid Svyatov
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby library for integrating with the UniSender API.
+email:
+- leonid@svyatov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE.txt
+- README.md
+- docs/api.md
+- examples/campaign.rb
+- examples/check_connection.rb
+- examples/events.rb
+- examples/export.rb
+- examples/import.rb
+- examples/offline.rb
+- examples/quickstart.rb
+- examples/subscribe.rb
+- lib/unisender.rb
+- lib/unisender/batches.rb
+- lib/unisender/client.rb
+- lib/unisender/errors.rb
+- lib/unisender/event_payload.rb
+- lib/unisender/events.rb
+- lib/unisender/form.rb
+- lib/unisender/helpers.rb
+- lib/unisender/operations/contacts_1.rb
+- lib/unisender/operations/contacts_2.rb
+- lib/unisender/operations/inputs_1.rb
+- lib/unisender/operations/messages_1.rb
+- lib/unisender/operations/messages_2.rb
+- lib/unisender/operations/messages_3.rb
+- lib/unisender/operations/notes_1.rb
+- lib/unisender/operations/statistics_1.rb
+- lib/unisender/operations/statistics_2.rb
+- lib/unisender/operations/templates_1.rb
+- lib/unisender/paginated_operations.rb
+- lib/unisender/pagination.rb
+- lib/unisender/protocol.rb
+- lib/unisender/response.rb
+- lib/unisender/retry_policy.rb
+- lib/unisender/task_waiter.rb
+- lib/unisender/transport.rb
+- lib/unisender/validation.rb
+- lib/unisender/version.rb
+- sig/operations.rbs
+- sig/unisender.rbs
+homepage: https://github.com/svyatov/unisender-ruby
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/svyatov/unisender-ruby
+  bug_tracker_uri: https://github.com/svyatov/unisender-ruby/issues
+  documentation_uri: https://github.com/svyatov/unisender-ruby/blob/main/README.md
+  changelog_uri: https://github.com/svyatov/unisender-ruby/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.23
+specification_version: 4
+summary: Ruby client for the UniSender API.
+test_files: []