unisender-ruby 0.1.0 → 0.2.0

data/lib/unisender/form.rb

@@ -6,11 +6,11 @@ module Unisender
     def self.encode(params)
       URI.encode_www_form(pairs(params, nil, 0))
     rescue EncodingError
-      raise ArgumentError, "Parameters must contain valid UTF-8 text", cause: nil
+      raise ValidationError.new(field: "parameters", code: :invalid_encoding), cause: nil
     end
 
     def self.pairs(value, prefix, depth)
-      raise ArgumentError, "Parameters are nested too deeply" if depth > 32
+      raise ValidationError.new(field: prefix.to_s, code: :too_deep) if depth > 32
 
       case value
       when Hash
@@ -24,43 +24,51 @@ module Unisender
 
     def self.hash_pairs(value, prefix, depth)
       keys = value.keys.map(&:to_s)
-      raise ArgumentError, "Duplicate parameter names" unless keys.uniq.size == keys.size
+      raise ValidationError.new(field: "parameters", code: :duplicate_key) unless keys.uniq.size == keys.size
 
       value.flat_map do |key, item|
-        name = key.to_s.encode(Encoding::UTF_8)
-        raise ArgumentError, "Parameter names cannot contain brackets" if name.match?(/[\[\]]/)
+        name = key_name(key)
         next [] if item.nil?
 
         pairs(item, prefix ? "#{prefix}[#{name}]" : name, depth + 1)
       end
     end
 
+    def self.key_name(key)
+      name = key.to_s.encode(Encoding::UTF_8)
+      raise ValidationError.new(field: "parameters", code: :invalid_key) if name.match?(/[\[\]]/)
+
+      name
+    end
+
     def self.scalar(value, name)
       case value
       when String
-        name.start_with?("attachments[") ? value.b : text(value)
+        name.start_with?("attachments[") ? value.b : text(value, name)
       when true then "1"
       when false then "0"
       when nil then ""
-      else numeric(value)
+      else numeric(value, name)
       end
     end
 
-    def self.text(value)
-      raise ArgumentError, "Parameters must contain valid UTF-8 text" unless value.valid_encoding?
+    def self.text(value, field = "parameters")
+      raise ValidationError.new(field:, code: :invalid_encoding) unless value.valid_encoding?
 
       value.encode(Encoding::UTF_8)
+    rescue EncodingError
+      raise ValidationError.new(field:, code: :invalid_encoding), cause: nil
     end
 
-    def self.numeric(value)
+    def self.numeric(value, field = "parameters")
       case value
       when Integer then value.to_s
       when Float
-        raise ArgumentError, "Numeric parameters must be finite" unless value.finite?
+        raise ValidationError.new(field:, code: :invalid_number) unless value.finite?
 
         value.to_s
       else
-        raise ArgumentError, "Unsupported parameter type"
+        raise ValidationError.new(field:, code: :invalid_type, actual_type: Diagnostics.type_name(value))
       end
     end
   end

data/lib/unisender/helpers.rb

@@ -3,26 +3,86 @@
 module Unisender
   # Explicit helpers for multiple requests.
   class Client
-    def each_page(method, page_size: 100, max_pages: 1000, **params)
-      Pagination.new(self, method, page_size, max_pages, params).each
+    def each_page(method, page_size: 100, max_pages: 1000, **params, &)
+      Iteration.call(Pagination.new(self, method, page_size, max_pages, params).each, &)
     end
 
     # rubocop:disable-next Metrics/ParameterLists -- Includes the documented import options.
-    def import_contacts_in_batches(field_names:, data:, batch_size: 500, overwrite_tags: nil,
-                                   overwrite_lists: nil, telegram_bot_channel_id: nil)
-      Batches.each(data, batch_size, 500) do |batch|
-        import_contacts(field_names:, data: batch, overwrite_tags:, overwrite_lists:, telegram_bot_channel_id:)
+    def import_contacts_in_batches(field_names: nil, data: nil, records: nil, batch_size: 500, overwrite_tags: nil,
+                                   overwrite_lists: nil, telegram_bot_channel_id: nil, retention: :full,
+                                   on_progress: nil)
+      accumulator = BatchAccumulator.new(retention)
+      import_batches(field_names:, data:, records:, batch_size:, overwrite_tags:, overwrite_lists:,
+                     telegram_bot_channel_id:, accumulator:, on_progress:).each { |_response| nil }
+      accumulator.report
+    rescue ValidationError => e
+      raise e.with_operation("importContacts"), cause: nil
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists -- Includes the documented import options.
+    def each_import_batch(field_names: nil, data: nil, records: nil, batch_size: 500, overwrite_tags: nil,
+                          overwrite_lists: nil, telegram_bot_channel_id: nil, retention: :full, on_progress: nil, &)
+      batches = import_batches(field_names:, data:, records:, batch_size:, overwrite_tags:, overwrite_lists:,
+                               telegram_bot_channel_id:, retention:, on_progress:)
+      Iteration.call(batches, &)
+    rescue ValidationError => e
+      raise e.with_operation("importContacts"), cause: nil
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists -- Shares the batch options without changing public signatures.
+    def import_batches(field_names:, data:, records:, batch_size:, overwrite_tags:, overwrite_lists:,
+                       telegram_bot_channel_id:, accumulator: nil, retention: :full, on_progress: nil)
+      source = import_source(field_names, data, records)
+      Batches.each(source, batch_size, 500, accumulator:, retention:, on_progress:, execution: @execution) do |batch|
+        names = case source
+                when RecordRows then source.field_names
+                else field_names
+                end
+        import_contacts(field_names: names, data: batch, overwrite_tags:, overwrite_lists:, telegram_bot_channel_id:)
       end
     end
+    private :import_batches
+
+    def track_events_in_batches(events:, batch_size: 25, retention: :full, on_progress: nil)
+      accumulator = BatchAccumulator.new(retention)
+      event_batches(events, batch_size, accumulator:, on_progress:).each { |_response| nil }
+      accumulator.report
+    rescue ValidationError => e
+      raise e.with_operation("track_events"), cause: nil
+    end
+
+    def each_event_batch(events:, batch_size: 25, retention: :full, on_progress: nil, &)
+      Iteration.call(event_batches(events, batch_size, retention:, on_progress:), &)
+    rescue ValidationError => e
+      raise e.with_operation("track_events"), cause: nil
+    end
 
-    def track_events_in_batches(events:, batch_size: 25)
-      Batches.each(events, batch_size, 25) { |batch| track_events(events: batch) }
+    def event_batches(events, batch_size, accumulator: nil, retention: :full, on_progress: nil)
+      chunks = EventBatches.each(events, batch_size)
+      Batches.each_chunks(chunks, accumulator:, retention:, on_progress:, execution: @execution) do |batch|
+        track_events(events: batch)
+      end
     end
+    private :event_batches
 
-    def wait_for_task(task_uuid:, interval: 1, timeout: 60, clock: nil, sleeper: nil)
+    def wait_for_task(task_uuid:, interval: 1, timeout: 60, clock: nil, sleeper: nil, &progress)
       clock ||= -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       sleeper ||= ->(delay) { sleep(delay) }
-      TaskWaiter.new(self, clock:, sleeper:).call(task_uuid, interval, timeout) # : Response[task_completed]
+      TaskWaiter.new(self, clock:, sleeper:, progress:).call(task_uuid, interval, timeout)
+    end
+
+    private
+
+    def import_source(field_names, data, records)
+      if records
+        raise ValidationError.new(field: "records", code: :conflicting_input) if field_names || data
+
+        return RecordRows.new(records)
+      end
+      raise ValidationError.new(field: "data", code: :required) unless data
+
+      Validation.required!({ field_names: }, %w[field_names])
+      data
     end
   end
 end

data/lib/unisender/hooks.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Unisender
+  # The documented hook record, with unknown fields retained through Record.
+  class Hook < IdentifierRecord
+    def url
+      text!("url")
+    end
+
+    def event_format
+      text!("event_format")
+    end
+
+    def max_parallel
+      integer!("max_parallel")
+    end
+
+    def single_event
+      integer!("single_event")
+    end
+
+    def status
+      text!("status")
+    end
+
+    def events
+      value = self["events"]
+      raise InvalidResponseError, "Expected hook event filters" unless value.is_a?(Record)
+
+      value
+    end
+
+    protected
+
+    def normalize
+      super
+      url
+      event_format
+      max_parallel
+      single_event
+      status
+      events
+    end
+  end
+
+  # Hook mutation result shapes are not specified by the upstream reference.
+  class Client
+    # https://www.unisender.com/ru/support/api/common/sistema-uvedomlenij-o-sobytiyah-webhooks/
+    # rubocop:disable-next Metrics/ParameterLists -- Mirrors the documented operation.
+    def set_hook(hook_url:, events:, event_format: :json_post_gzip, max_parallel: nil, single_event: false,
+                 status: :active)
+      events = hook_events(events, max_parallel)
+      params = { hook_url:, events:, event_format:, max_parallel:, single_event:, status: }
+      request("setHook", params: prepare("setHook", params, required: %w[hook_url events]))
+    rescue ValidationError => e
+      raise e.with_operation("setHook"), cause: nil
+    end
+
+    def hook_events(events, max_parallel)
+      if !max_parallel.nil? && !(max_parallel.is_a?(Integer) && max_parallel.positive?)
+        raise ValidationError.new(field: "max_parallel", code: :invalid_range, operation: "setHook")
+      end
+      raise ValidationError.new(field: "events", code: :invalid_type, operation: "setHook") unless events.is_a?(Hash)
+
+      events.to_h do |name, filters|
+        [name, filters.is_a?(Array) ? Validation.comma_list(filters) : filters]
+      end
+    end
+    private :hook_events
+
+    def list_hooks
+      invoke("listHooks", {})
+    end
+
+    def remove_hook(hook_url:)
+      request("removeHook", params: prepare("removeHook", { hook_url: }, required: %w[hook_url]))
+    end
+  end
+end

data/lib/unisender/import_cells.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Converts only documented system columns on the records input path.
+  module ImportCells
+    LISTS = %w[tags email_list_ids email_unsubscribed_list_ids email_excluded_list_ids
+               phone_list_ids phone_unsubscribed_list_ids phone_excluded_list_ids].freeze
+    TIMES = %w[email_subscribe_times phone_subscribe_times].freeze
+
+    def self.convert(name, value, index)
+      case value
+      when Array then array(name, value, index)
+      when Time then TIMES.include?(name) ? times(value, index) : invalid!(index)
+      when Hash then invalid!(index)
+      else value
+      end
+    rescue ValidationError => e
+      raise ValidationError.new(field: "records[#{index}].#{name}", code: e.code, operation: "importContacts", index:),
+            cause: nil
+    end
+
+    def self.array(name, value, index)
+      return list(value, index) if LISTS.include?(name)
+      return times(value, index) if TIMES.include?(name)
+
+      invalid!(index)
+    end
+
+    def self.list(values, index)
+      values.map do |value|
+        invalid!(index) unless (value.is_a?(String) || value.is_a?(Integer)) && !value.to_s.include?(",")
+        value.to_s
+      end.join(",")
+    end
+
+    def self.times(value, index)
+      values = value.is_a?(Array) ? value : [value]
+      values.map do |item|
+        case item
+        when Time then item.getutc.strftime("%Y-%m-%d %H:%M:%S")
+        when String then item
+        else invalid!(index)
+        end
+      end.join(",")
+    end
+
+    def self.validate_times(record, index)
+      TIMES.each do |name|
+        times = record[name]
+        lists = record[name.sub("subscribe_times", "list_ids")]
+        next unless times.is_a?(Array) && lists.is_a?(Array) && times.size != lists.size
+
+        raise ValidationError.new(field: "records[#{index}].#{name}", code: :invalid_cell,
+                                  operation: "importContacts", index:)
+      end
+    end
+
+    def self.invalid!(index)
+      raise ValidationError.new(field: "records[#{index}]", code: :invalid_cell, operation: "importContacts", index:)
+    end
+  end
+end

data/lib/unisender/input_types.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Named input types are structural; account rules remain server decisions.
+  module InputTypes
+    # @type var kinds: Hash[String, Module]
+    kinds = { "string" => String, "integer" => Integer, "float" => Float, "symbol" => Symbol,
+              "hash" => Hash, "time" => Time, "attachment" => Attachment, "enumerable" => Enumerable }
+    KINDS = kinds.freeze
+
+    def self.validate!(value, types, field)
+      arrays = types.grep(/\Aarray:/)
+      if value.is_a?(Array) && !arrays.empty?
+        elements = arrays.map { |type| type.delete_prefix("array:") }
+        value.each_with_index { |item, index| validate!(item, elements, "#{field}[#{index}]") }
+      elsif types.none? { |type| accepts?(value, type) }
+        raise ValidationError.new(field:, code: :invalid_type, expected_type: types.join(" | "),
+                                  actual_type: Diagnostics.type_name(value))
+      end
+    end
+
+    def self.accepts?(value, type)
+      return true if type == "parameter"
+      return [true, false].include?(value) if type == "boolean"
+
+      kind = KINDS[type]
+      kind ? value.is_a?(kind) : false
+    end
+  end
+end

data/lib/unisender/inputs.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Local structural failures omit parameter values from diagnostics.
+  class ValidationError < ArgumentError
+    attr_reader :field, :code, :operation, :index, :expected_type, :actual_type
+
+    # rubocop:disable-next Metrics/ParameterLists -- Structured diagnostic fields remain explicit.
+    def initialize(field:, code:, operation: nil, index: nil, expected_type: nil, actual_type: nil)
+      @field = Diagnostics.input_path(field)
+      @code = code
+      @operation = operation
+      @index = index
+      @expected_type = expected_type
+      @actual_type = actual_type
+      super("Invalid parameter #{@field}: #{code}")
+    end
+
+    alias path field
+
+    def diagnostics
+      Diagnostics.for_error(self)
+    end
+
+    def documentation_url
+      Diagnostics::URLS[@operation.to_s]
+    end
+
+    def with_operation(operation)
+      @operation = Error.safe_operation(operation)
+      self
+    end
+
+    def category
+      :invalid_argument
+    end
+
+    def recovery_hint
+      "Check the operation parameters."
+    end
+
+    def transient?
+      false
+    end
+
+    def safe_to_retry?
+      false
+    end
+  end
+
+  # Converts convenience values only on the named-operation path.
+  module Inputs
+    MODES = {
+      double_optin: { request_confirmation: 0, already_confirmed: 3, confirm_if_needed: 4 }.freeze,
+      overwrite: { preserve: 0, replace: 1, update: 2 }.freeze
+    }.freeze
+    MINUTES = %w[getMessages listMessages getTemplates listTemplates createCampaign].freeze
+    SECONDS = %w[getCampaigns async/getCampaignDeliveryStats].freeze
+    DATES = %i[date_from date_to from to start_time changed_since].freeze
+
+    def self.normalize(method, params)
+      result = operation_values(method, NamedInputs.normalize(method, attachment_parameters(params)))
+      format = timestamp_format(method)
+      return result unless format
+
+      DATES.each { |key| result[key] = timestamp(result[key], format, key) if result.key?(key) }
+      result
+    end
+
+    def self.operation_values(method, result)
+      case method
+      when "sendSms" then result[:phone] = SmsInputs.phone(result[:phone])
+      when "sendEmail" then result = MailInputs.normalize(result)
+      when "createCampaign" then schedule_timezone!(result)
+      when "subscribe" then MODES.each { |key, modes| result[key] = mode(result[key], modes, key) }
+      end
+      result
+    end
+
+    def self.schedule_timezone!(params)
+      return unless params[:start_time].is_a?(Time)
+
+      unless params[:timezone].nil? || params[:timezone] == "UTC"
+        raise ValidationError.new(field: "timezone", code: :conflicting_input)
+      end
+
+      params[:timezone] = "UTC"
+    end
+
+    def self.attachment_parameters(params)
+      result = params.dup
+      result[:attachments] = attachments(result[:attachments]) if result.key?(:attachments)
+      result
+    end
+
+    def self.attachments(value)
+      return value if value.nil? || value.is_a?(Hash)
+
+      output = {} # : Hash[String, parameter]
+      attachment_items(value).each do |item|
+        raise ValidationError.new(field: "attachments", code: :duplicate_filename) if output.key?(item.filename)
+
+        output[item.filename] = item.bytes
+      end
+      output
+    end
+
+    def self.attachment_items(value)
+      items = value.is_a?(Attachment) ? [value] : value
+      raise ValidationError.new(field: "attachments", code: :invalid_type) unless items.is_a?(Array)
+
+      items.map do |item|
+        raise ValidationError.new(field: "attachments", code: :invalid_type) unless item.is_a?(Attachment)
+
+        item
+      end
+    end
+
+    def self.timestamp_format(method)
+      return "%Y-%m-%d %H:%M" if MINUTES.include?(method)
+      return "%Y-%m-%d %H:%M:%S" if SECONDS.include?(method)
+
+      nil
+    end
+
+    def self.mode(value, modes, field)
+      return nil if value.nil?
+      return modes.fetch(value) if value.is_a?(Symbol) && modes.key?(value)
+      return value if value.is_a?(Integer) && modes.value?(value)
+
+      raise ValidationError.new(field: field.to_s, code: :invalid_mode, operation: "subscribe")
+    end
+
+    def self.timestamp(value, format, field)
+      return value if value.nil? || value.is_a?(String)
+      return value.getutc.strftime(format) if value.is_a?(Time)
+
+      raise ValidationError.new(field: field.to_s, code: :invalid_timestamp)
+    end
+
+    def self.contact_fields(fields, email)
+      validate_email_alias(email)
+      unless fields.nil? || fields.is_a?(Hash)
+        raise ValidationError.new(field: "fields", code: :invalid_type, operation: "subscribe")
+      end
+
+      # @type var result: params
+      result = fields ? fields.dup : {}
+      names = result.keys.map(&:to_s)
+      raise ValidationError.new(field: "fields", code: :duplicate_key, operation: "subscribe") if names.uniq != names
+
+      merge_email(result, email) if email
+      validate_email(result)
+      result
+    end
+
+    def self.validate_email_alias(email)
+      return if email.nil? || email.is_a?(String)
+
+      raise ValidationError.new(field: "email", code: :invalid_type, operation: "subscribe",
+                                expected_type: "String", actual_type: Diagnostics.type_name(email))
+    end
+
+    def self.merge_email(result, email)
+      existing = result[:email] || result["email"]
+      if existing && existing != email
+        raise ValidationError.new(field: "fields.email", code: :conflicting_value, operation: "subscribe")
+      end
+
+      result.delete(:email)
+      result["email"] = email
+    end
+
+    def self.validate_email(result)
+      address = result[:email] || result["email"]
+      return if address.is_a?(String) && !address.empty?
+
+      raise ValidationError.new(field: "fields.email", code: :required, operation: "subscribe")
+    end
+  end
+
+  # SMS numbers remain strings and share one bounded recipient list.
+  module SmsInputs
+    def self.phone(value)
+      text = case value
+             when Array then Validation.comma_list(value, field: "phone")
+             when String then value
+             else raise ValidationError.new(field: "phone", code: :invalid_type)
+             end
+      phones = text.split(",", -1)
+      unless (1..150).cover?(phones.size) && phones.none? { |phone| phone.strip.empty? }
+        raise ValidationError.new(field: "phone", code: :invalid_count)
+      end
+
+      text
+    end
+  end
+
+  # Contact selectors and filters keep their wire forms behind named inputs.
+  module ContactInputs
+    def self.contact_selector(params, operation)
+      selected = params.slice(:email, :phone).compact
+      return params.slice(:contact_type, :contact, :list_ids) if selected.empty?
+
+      validate_selector(params, selected, operation)
+      kind = selected.key?(:email) ? :email : :phone
+      { contact_type: kind.to_s, contact: selected.fetch(kind), list_ids: params[:list_ids] }
+    rescue ValidationError => e
+      raise e.with_operation(operation), cause: nil
+    end
+
+    def self.validate_selector(params, selected, operation)
+      if selected.size != 1 || params[:contact_type] || params[:contact]
+        raise ValidationError.new(field: "contact", code: :conflicting_input, operation:)
+      end
+
+      value = selected.values.fetch(0)
+      unless value.is_a?(String) && !value.empty?
+        raise ValidationError.new(field: "contact", code: :invalid_contact, operation:)
+      end
+
+      Validation.required!(params, %w[list_ids])
+    end
+
+    def self.count_filters(params, tag_id, contact_type, search)
+      params = filter_container(params)
+      validate_filters(tag_id, search)
+      if params && [tag_id, contact_type, search].any?
+        raise ValidationError.new(field: "params", code: :conflicting_input, operation: "getContactCount")
+      end
+      return params if params
+
+      type = count_contact_type(contact_type)
+      raise ValidationError.new(field: "contact_type", code: :required, operation: "getContactCount") if search && !type
+
+      { tagId: tag_id, type:, search: }.compact
+    end
+
+    def self.filter_container(value)
+      return value if value.nil? || value.is_a?(Hash)
+
+      raise ValidationError.new(field: "params", code: :invalid_type, operation: "getContactCount")
+    end
+
+    def self.validate_filters(tag_id, search)
+      if !tag_id.nil? && !tag_id.is_a?(String) && !tag_id.is_a?(Integer)
+        raise ValidationError.new(field: "tag_id", code: :invalid_type, operation: "getContactCount")
+      end
+      return if search.nil? || search.is_a?(String)
+
+      raise ValidationError.new(field: "search", code: :invalid_type, operation: "getContactCount")
+    end
+
+    def self.count_contact_type(value)
+      return nil if value.nil?
+      return "address" if %w[email address].include?(value.to_s)
+      return "phone" if value.to_s == "phone"
+
+      raise ValidationError.new(field: "contact_type", code: :invalid_choice, operation: "getContactCount")
+    end
+  end
+end

data/lib/unisender/iteration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Applies an optional block without changing the iterator's return type.
+  module Iteration
+    def self.items(pages)
+      Enumerator.new { |output| pages.each { |page| page.each { |item| output << item } } }
+    end
+
+    def self.call(items, &block)
+      items.each(&block) if block
+      items
+    end
+  end
+end

data/lib/unisender/iterators.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Unisender
+  # Lazy typed iteration over every page of a supported operation.
+  class Client
+    def each_campaign(from:, to: nil, page_size: 100, max_pages: 1000, offset: 0, &)
+      pages = each_page(
+        :get_campaigns, from:, to:, page_size:, max_pages:, offset:
+      ) # : Enumerator[PageResponse[Campaign], void]
+      Iteration.call(Iteration.items(pages), &)
+    end
+
+    def each_message(date_from:, date_to:, page_size: 100, max_pages: 1000, offset: 0, &)
+      pages = each_page(
+        :get_messages, date_from:, date_to:, page_size:, max_pages:, offset:
+      ) # : Enumerator[PageResponse[Message], void]
+      Iteration.call(Iteration.items(pages), &)
+    end
+
+    def each_message_summary(date_from:, date_to:, page_size: 100, max_pages: 1000, offset: 0, &)
+      pages = each_page(
+        :list_messages, date_from:, date_to:, page_size:, max_pages:, offset:
+      ) # : Enumerator[PageResponse[Message], void]
+      Iteration.call(Iteration.items(pages), &)
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists -- Includes the operation keywords and pagination controls.
+    def each_template(type: nil, date_from: nil, date_to: nil, page_size: 100, max_pages: 1000, offset: 0, &)
+      pages = each_page(
+        :get_templates, type:, date_from:, date_to:, page_size:, max_pages:, offset:
+      ) # : Enumerator[PageResponse[Template], void]
+      Iteration.call(Iteration.items(pages), &)
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists -- Includes the operation keywords and pagination controls.
+    def each_template_summary(type: nil, date_from: nil, date_to: nil, page_size: 100, max_pages: 1000, offset: 0,
+                              &)
+      pages = each_page(
+        :list_templates, type:, date_from:, date_to:, page_size:, max_pages:, offset:
+      ) # : Enumerator[PageResponse[Template], void]
+      Iteration.call(Iteration.items(pages), &)
+    end
+
+    def each_sender_domain_group(username:, domain: nil, page_size: 100, max_pages: 1000, offset: 0, &)
+      pages = each_page(
+        :get_sender_domain_list, username:, domain:, page_size:, max_pages:, offset:
+      ) # : Enumerator[PageResponse[SenderDomainGroup], void]
+      Iteration.call(Iteration.items(pages), &)
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists -- Includes the operation keywords and pagination controls.
+    def each_subscriber_note(subscriber_id:, order_type: nil, order_by: nil,
+                             is_pinned: nil, page_size: 100, max_pages: 1000, offset: 0, &)
+      pages = each_page(
+        :get_subscriber_notes, subscriber_id:, order_type:, order_by:, is_pinned:, page_size:, max_pages:, offset:
+      ) # : Enumerator[PageResponse[Note], void]
+      Iteration.call(Iteration.items(pages), &)
+    end
+  end
+end