laneful-ruby 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cebf80375fe3b41ce712f115c4e291c6f7ff0a9ceb4cf90de829422966b970b
-  data.tar.gz: 7fee98bf4a843ffe95123f1c544545760fd4f943651199619b93450e37c7727e
+  metadata.gz: ed5ff94086f558d6ea4bad6c914ec22cbc7b8d012cc27fc3d385d3cbc05c5c49
+  data.tar.gz: 02a6ba4d5c4dbee58809d4e15214623fc273770b3779d73fe6ae25b61de75252
 SHA512:
-  metadata.gz: 11e4cea266db6d53a73958d9bf4b6a4106c31fe1cb7bcba62f52959444fc9c70d2b2432906bb4c540365b0edbe76af09d4f55a80f84a1f16445595d0f8242cce
-  data.tar.gz: 0f94b21d5267eb709cbada7cca3225f2eb4a6cebdfa694a2d63caec3d2fc7a7bf3f375e564cbedec8632fd08c91b0546a883175a9d591661c759bf562de82270
+  metadata.gz: cc30d8a4112104938f451247b7c24654365f4bb6f8efb5dbeacff4947b00841115563bc7e93d4e36b2eb17e3f115a3616d91a99ebff081d0f322fc9ebdca2060
+  data.tar.gz: 560628e6bd7d5cefa3b9e3229c4be1806d8703d6a7c61e919b94d386b9b3e4a27f1ea95602096e5783236489f4c234233676ebeadf42591eb3db767ec4cf6875

data/lib/laneful/client.rb

@@ -1,13 +1,21 @@
 # frozen_string_literal: true
 
+require 'cgi'
+require 'json'
+
 module Laneful
-  # Main client for communicating with the Laneful email API
+  # Main client for communicating with the Laneful API.
+  # Email sending uses a send host (https://your-endpoint.send.laneful.net).
+  # Domain, unsubscribe-group, and analytics endpoints use the organization
+  # API host (https://api.laneful.net).
   class Client
     include HTTParty
 
-    # Default timeout in seconds
     DEFAULT_TIMEOUT = 30
 
+    # Repeat array keys as workspace_ids=1&workspace_ids=2 (not workspace_ids[]=).
+    query_string_normalizer HTTParty::Request::NON_RAILS_QUERY_STRING_NORMALIZER
+
     attr_reader :base_url, :auth_token, :timeout
 
     def initialize(base_url, auth_token, timeout: DEFAULT_TIMEOUT)
@@ -16,26 +24,112 @@ module Laneful
       @timeout = timeout
 
       validate_configuration!
-
-      # Configure HTTParty
-      self.class.base_uri @base_url
-      self.class.default_timeout @timeout
-      self.class.headers default_headers
     end
 
     # Sends a single email
-    def send_email(email)
-      send_emails([email])
+    def send_email(email, mail_settings = nil)
+      send_emails([email], mail_settings)
     end
 
     # Sends multiple emails
-    def send_emails(emails)
+    def send_emails(emails, mail_settings = nil)
       validate_emails!(emails)
 
       request_data = { 'emails' => emails.map(&:to_hash) }
-      response = self.class.post("/#{API_VERSION}/email/send", body: request_data.to_json)
+      request_data['mail_settings'] = mail_settings.to_hash if mail_settings
 
-      handle_response(response)
+      request('POST', '/email/send', request_data)
+    end
+
+    # List unsubscribe groups for a workspace.
+    # Uses the organization API host (https://api.laneful.net).
+    def list_unsubscribe_groups(workspace_id, params = nil)
+      ListUnsubscribeGroupsResponse.from_hash(
+        request('GET', "/workspaces/#{workspace_id}/unsubscribe-groups", nil, params&.to_query)
+      )
+    end
+
+    # Create an unsubscribe group in a workspace.
+    def create_unsubscribe_group(workspace_id, name)
+      data = request('POST', "/workspaces/#{workspace_id}/unsubscribe-groups", { 'name' => name })
+      UnsubscribeGroup.from_hash(data['unsubscribe_group'] || data)
+    end
+
+    # Update an unsubscribe group.
+    def update_unsubscribe_group(workspace_id, unsubscribe_group_id, name)
+      data = request(
+        'PATCH',
+        "/workspaces/#{workspace_id}/unsubscribe-groups/#{unsubscribe_group_id}",
+        { 'name' => name }
+      )
+      UnsubscribeGroup.from_hash(data['unsubscribe_group'] || data)
+    end
+
+    # List sending domains for a workspace.
+    def list_domains(workspace_id, params = nil)
+      ListDomainsResponse.from_hash(
+        request('GET', "/workspaces/#{workspace_id}/domains", nil, params&.to_query)
+      )
+    end
+
+    # Get a single sending domain by name.
+    def get_domain(workspace_id, domain)
+      Domain.from_hash(
+        request('GET', "/workspaces/#{workspace_id}/domains/#{encode_path(domain)}")
+      )
+    end
+
+    # Create a sending domain in a workspace.
+    def create_domain(workspace_id, create_request)
+      Domain.from_hash(
+        request('POST', "/workspaces/#{workspace_id}/domains", create_request.to_hash)
+      )
+    end
+
+    # Update a domain's mutable settings (currently the email track).
+    def update_domain(workspace_id, domain, update_request)
+      Domain.from_hash(
+        request(
+          'PATCH',
+          "/workspaces/#{workspace_id}/domains/#{encode_path(domain)}",
+          update_request.to_hash
+        )
+      )
+    end
+
+    # Trigger DNS verification for a domain.
+    def verify_domain(workspace_id, domain)
+      Domain.from_hash(
+        request('POST', "/workspaces/#{workspace_id}/domains/#{encode_path(domain)}/verify")
+      )
+    end
+
+    # Delete a sending domain from a workspace.
+    def delete_domain(workspace_id, domain)
+      SuccessResponse.from_hash(
+        request('DELETE', "/workspaces/#{workspace_id}/domains/#{encode_path(domain)}")
+      )
+    end
+
+    # List domains whose spam complaint ratio reached a critical level.
+    def list_domain_spam_ratio_radar(params = nil)
+      ListDomainSpamRatioRadarResponse.from_hash(
+        request('GET', '/analytics/radar/domain-spam-ratio', nil, params&.to_query)
+      )
+    end
+
+    # List daily Google Postmaster Tools spam-rate reports.
+    def list_google_postmaster_spam_reports(params = nil)
+      ListGooglePostmasterSpamReportsResponse.from_hash(
+        request('GET', '/analytics/google-postmaster/spam-reports', nil, params&.to_query)
+      )
+    end
+
+    # List daily Microsoft SNDS reports for the organization's sending IPs.
+    def list_snds_reports(params = nil)
+      ListSndsReportsResponse.from_hash(
+        request('GET', '/analytics/microsoft-snds/reports', nil, params&.to_query)
+      )
     end
 
     private
@@ -45,7 +139,6 @@ module Laneful
 
       raise ValidationException, 'Auth token cannot be empty' if auth_token.nil? || auth_token.empty?
 
-      # Basic URL validation
       return if base_url.match?(%r{^https?://})
 
       raise ValidationException, 'Base URL must be a valid HTTP/HTTPS URL'
@@ -59,18 +152,46 @@ module Laneful
       end
     end
 
-    def default_headers
-      {
+    def default_headers(with_json: true)
+      headers = {
         'Authorization' => "Bearer #{auth_token}",
-        'Content-Type' => 'application/json',
         'Accept' => 'application/json',
         'User-Agent' => USER_AGENT
       }
+      headers['Content-Type'] = 'application/json' if with_json
+      headers
+    end
+
+    def build_url(path)
+      "#{base_url.chomp('/')}/#{API_VERSION}/#{path.sub(%r{\A/}, '')}"
+    end
+
+    def encode_path(value)
+      CGI.escape(value.to_s).gsub('+', '%20')
+    end
+
+    def request(method, path, json = nil, query = nil)
+      url = build_url(path)
+
+      options = {
+        headers: default_headers(with_json: !json.nil?),
+        timeout: timeout
+      }
+      options[:query] = query unless query.nil? || query.empty?
+      options[:body] = json.to_json unless json.nil?
+
+      begin
+        response = self.class.send(method.downcase, url, options)
+      rescue StandardError => e
+        raise HttpException.new("HTTP request failed: #{e.message}", 0, e)
+      end
+
+      handle_response(response)
     end
 
     def handle_response(response)
       case response.code
-      when 200, 201, 202
+      when 200, 201, 202, 204
         parse_success_response(response)
       when 404
         raise HttpException.new(

data/lib/laneful/models.rb

@@ -59,12 +59,15 @@ module Laneful
 
   # Configuration for email tracking settings
   class TrackingSettings
-    attr_reader :opens, :clicks, :unsubscribes
+    attr_reader :opens, :clicks, :unsubscribes, :unsubscribe_group_id, :unsubscribe_group_name
 
-    def initialize(opens: false, clicks: false, unsubscribes: false)
+    def initialize(opens: false, clicks: false, unsubscribes: false,
+                   unsubscribe_group_id: nil, unsubscribe_group_name: nil)
       @opens = opens
       @clicks = clicks
       @unsubscribes = unsubscribes
+      @unsubscribe_group_id = unsubscribe_group_id
+      @unsubscribe_group_name = unsubscribe_group_name
     end
 
     # Creates tracking settings from a hash representation
@@ -72,22 +75,31 @@ module Laneful
       new(
         opens: data['opens'] || false,
         clicks: data['clicks'] || false,
-        unsubscribes: data['unsubscribes'] || false
+        unsubscribes: data['unsubscribes'] || false,
+        unsubscribe_group_id: data['unsubscribe_group_id'],
+        unsubscribe_group_name: data['unsubscribe_group_name']
       )
     end
 
     def to_hash
-      {
+      hash = {
         'opens' => opens,
         'clicks' => clicks,
         'unsubscribes' => unsubscribes
       }
+      hash['unsubscribe_group_id'] = unsubscribe_group_id unless unsubscribe_group_id.nil?
+      hash['unsubscribe_group_name'] = unsubscribe_group_name unless unsubscribe_group_name.nil?
+      hash
     end
 
     def ==(other)
       return false unless other.is_a?(TrackingSettings)
 
-      opens == other.opens && clicks == other.clicks && unsubscribes == other.unsubscribes
+      opens == other.opens &&
+        clicks == other.clicks &&
+        unsubscribes == other.unsubscribes &&
+        unsubscribe_group_id == other.unsubscribe_group_id &&
+        unsubscribe_group_name == other.unsubscribe_group_name
     end
 
     def eql?(other)
@@ -95,7 +107,7 @@ module Laneful
     end
 
     def hash
-      [opens, clicks, unsubscribes].hash
+      [opens, clicks, unsubscribes, unsubscribe_group_id, unsubscribe_group_name].hash
     end
 
     def to_s
@@ -103,14 +115,53 @@ module Laneful
     end
   end
 
+  # Request-level mail settings (sandbox mode, return message IDs)
+  class MailSettings
+    attr_reader :sandbox_mode, :return_message_ids
+
+    def initialize(sandbox_mode: nil, return_message_ids: nil)
+      @sandbox_mode = sandbox_mode
+      @return_message_ids = return_message_ids
+    end
+
+    def self.from_hash(data)
+      new(
+        sandbox_mode: data['sandbox_mode'],
+        return_message_ids: data['return_message_ids']
+      )
+    end
+
+    def to_hash
+      hash = {}
+      hash['sandbox_mode'] = sandbox_mode unless sandbox_mode.nil?
+      hash['return_message_ids'] = return_message_ids unless return_message_ids.nil?
+      hash
+    end
+
+    def ==(other)
+      return false unless other.is_a?(MailSettings)
+
+      sandbox_mode == other.sandbox_mode && return_message_ids == other.return_message_ids
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      [sandbox_mode, return_message_ids].hash
+    end
+  end
+
   # Represents a file attachment for an email
   class Attachment
-    attr_reader :filename, :content_type, :content
+    attr_reader :filename, :content_type, :content, :inline_id
 
-    def initialize(filename, content_type, content)
+    def initialize(filename, content_type, content, inline_id = nil)
       @filename = filename
       @content_type = content_type
       @content = content
+      @inline_id = inline_id
       validate!
     end
 
@@ -124,22 +175,27 @@ module Laneful
 
     # Creates an attachment from a hash representation
     def self.from_hash(data)
-      filename = data['file_name'] || data['filename']  # Support both field names
-      new(filename, data['content_type'], data['content'])
+      filename = data['file_name'] || data['filename']
+      new(filename, data['content_type'], data['content'], data['inline_id'])
     end
 
     def to_hash
-      {
+      hash = {
         'file_name' => filename,
         'content_type' => content_type,
         'content' => content
       }
+      hash['inline_id'] = inline_id if inline_id && !inline_id.empty?
+      hash
     end
 
     def ==(other)
       return false unless other.is_a?(Attachment)
 
-      filename == other.filename && content_type == other.content_type && content == other.content
+      filename == other.filename &&
+        content_type == other.content_type &&
+        content == other.content &&
+        inline_id == other.inline_id
     end
 
     def eql?(other)
@@ -147,7 +203,7 @@ module Laneful
     end
 
     def hash
-      [filename, content_type, content].hash
+      [filename, content_type, content, inline_id].hash
     end
 
     def to_s
@@ -193,12 +249,13 @@ module Laneful
 
   # Represents a single email to be sent
   class Email
-    attr_reader :from, :to, :cc, :bcc, :subject, :text_content, :html_content,
+    attr_reader :from, :from_header, :to, :cc, :bcc, :subject, :text_content, :html_content,
                 :template_id, :template_data, :attachments, :headers, :reply_to,
                 :send_time, :webhook_data, :tag, :tracking
 
     def initialize(builder)
       @from = builder.instance_variable_get(:@from)
+      @from_header = builder.instance_variable_get(:@from_header)
       @to = builder.instance_variable_get(:@to).dup.freeze
       @cc = builder.instance_variable_get(:@cc).dup.freeze
       @bcc = builder.instance_variable_get(:@bcc).dup.freeze
@@ -222,6 +279,7 @@ module Laneful
       builder = Builder.new
 
       builder.from(Address.from_hash(data['from'])) if data && data['from']
+      builder.from_header(Address.from_hash(data['from_header'])) if data && data['from_header']
 
       data['to'].each { |to_data| builder.to(Address.from_hash(to_data)) } if data && data['to']
 
@@ -253,6 +311,7 @@ module Laneful
 
       # Required fields
       hash['from'] = from.to_hash
+      hash['from_header'] = from_header.to_hash if from_header
       hash['to'] = to.map(&:to_hash)
       hash['subject'] = subject if subject
 
@@ -278,6 +337,7 @@ module Laneful
       return false unless other.is_a?(Email)
 
       from == other.from &&
+        from_header == other.from_header &&
         to == other.to &&
         cc == other.cc &&
         bcc == other.bcc &&
@@ -300,7 +360,7 @@ module Laneful
     end
 
     def hash
-      [from, to, cc, bcc, subject, text_content, html_content, template_id,
+      [from, from_header, to, cc, bcc, subject, text_content, html_content, template_id,
        template_data, attachments, headers, reply_to, send_time, webhook_data, tag, tracking].hash
     end
 
@@ -340,6 +400,15 @@ module Laneful
         raise ValidationException, 'Email must have either content (text/HTML) or a template ID'
       end
 
+      if webhook_data
+        raise ValidationException, 'Webhook data cannot have more than 20 keys' if webhook_data.size > 20
+
+        webhook_data.each do |key, value|
+          raise ValidationException, 'Webhook data keys cannot exceed 50 characters' if key.to_s.length > 50
+          raise ValidationException, 'Webhook data values cannot exceed 100 characters' if value.to_s.length > 100
+        end
+      end
+
       # Validate send time
       return unless send_time && send_time <= Time.now.to_i
 
@@ -360,6 +429,11 @@ module Laneful
         self
       end
 
+      def from_header(address)
+        @from_header = address
+        self
+      end
+
       def to(address)
         @to << address
         self

data/lib/laneful/org_models.rb

@@ -0,0 +1,452 @@
+# frozen_string_literal: true
+
+module Laneful
+  # An unsubscribe group in a workspace
+  class UnsubscribeGroup
+    attr_reader :unsubscribe_group_id, :name, :created_at
+
+    def initialize(unsubscribe_group_id:, name:, created_at: 0)
+      @unsubscribe_group_id = unsubscribe_group_id
+      @name = name
+      @created_at = created_at
+    end
+
+    def self.from_hash(data)
+      new(
+        unsubscribe_group_id: (data['unsubscribe_group_id'] || 0).to_i,
+        name: data['name'] || '',
+        created_at: (data['created_at'] || 0).to_i
+      )
+    end
+
+    def to_hash
+      {
+        'unsubscribe_group_id' => unsubscribe_group_id,
+        'name' => name,
+        'created_at' => created_at
+      }
+    end
+  end
+
+  # Paginated list of unsubscribe groups
+  class ListUnsubscribeGroupsResponse
+    attr_reader :unsubscribe_groups, :next_cursor
+
+    def initialize(unsubscribe_groups:, next_cursor: nil)
+      @unsubscribe_groups = unsubscribe_groups || []
+      @next_cursor = next_cursor
+    end
+
+    def self.from_hash(data)
+      groups = (data['unsubscribe_groups'] || []).map { |group| UnsubscribeGroup.from_hash(group) }
+      new(unsubscribe_groups: groups, next_cursor: data['next_cursor'])
+    end
+  end
+
+  # Query parameters for listing unsubscribe groups
+  class ListUnsubscribeGroupsParams
+    attr_reader :cursor, :limit, :search
+
+    def initialize(cursor: nil, limit: nil, search: nil)
+      @cursor = cursor
+      @limit = limit
+      @search = search
+    end
+
+    def to_query
+      query = {}
+      query['cursor'] = cursor if present?(cursor)
+      query['limit'] = limit if limit&.positive?
+      query['search'] = search if present?(search)
+      query
+    end
+
+    private
+
+    def present?(value)
+      !value.nil? && !value.to_s.empty?
+    end
+  end
+
+  # A sending domain and its verification state
+  class Domain
+    attr_reader :domain, :tracking, :return_path, :verified, :tracking_verified,
+                :return_path_verified, :dkim1_verified, :dkim2_verified,
+                :dmarc_verified, :require_tls, :email_track_id
+
+    def initialize(domain:, tracking: '', return_path: '', verified: false, tracking_verified: false,
+                   return_path_verified: false, dkim1_verified: false, dkim2_verified: false,
+                   dmarc_verified: false, require_tls: false, email_track_id: '')
+      @domain = domain
+      @tracking = tracking
+      @return_path = return_path
+      @verified = verified
+      @tracking_verified = tracking_verified
+      @return_path_verified = return_path_verified
+      @dkim1_verified = dkim1_verified
+      @dkim2_verified = dkim2_verified
+      @dmarc_verified = dmarc_verified
+      @require_tls = require_tls
+      @email_track_id = email_track_id
+    end
+
+    def self.from_hash(data)
+      new(
+        domain: data['domain'] || '',
+        tracking: data['tracking'] || '',
+        return_path: data['return_path'] || '',
+        verified: truthy?(data['verified']),
+        tracking_verified: truthy?(data['tracking_verified']),
+        return_path_verified: truthy?(data['return_path_verified']),
+        dkim1_verified: truthy?(data['dkim1_verified']),
+        dkim2_verified: truthy?(data['dkim2_verified']),
+        dmarc_verified: truthy?(data['dmarc_verified']),
+        require_tls: truthy?(data['require_tls']),
+        email_track_id: data['email_track_id'] || ''
+      )
+    end
+
+    def to_hash
+      {
+        'domain' => domain,
+        'tracking' => tracking,
+        'return_path' => return_path,
+        'verified' => verified,
+        'tracking_verified' => tracking_verified,
+        'return_path_verified' => return_path_verified,
+        'dkim1_verified' => dkim1_verified,
+        'dkim2_verified' => dkim2_verified,
+        'dmarc_verified' => dmarc_verified,
+        'require_tls' => require_tls,
+        'email_track_id' => email_track_id
+      }
+    end
+
+    def self.truthy?(value)
+      value == true
+    end
+  end
+
+  # Paginated list of sending domains
+  class ListDomainsResponse
+    attr_reader :domains, :next_cursor
+
+    def initialize(domains:, next_cursor: nil)
+      @domains = domains || []
+      @next_cursor = next_cursor
+    end
+
+    def self.from_hash(data)
+      pagination = data['pagination'] || {}
+      new(
+        domains: (data['domains'] || []).map { |domain| Domain.from_hash(domain) },
+        next_cursor: pagination['next_cursor']
+      )
+    end
+  end
+
+  # Query parameters for listing domains
+  class ListDomainsParams
+    attr_reader :cursor, :limit, :filter_domain
+
+    def initialize(cursor: nil, limit: nil, filter_domain: nil)
+      @cursor = cursor
+      @limit = limit
+      @filter_domain = filter_domain
+    end
+
+    def to_query
+      query = {}
+      query['cursor'] = cursor if present?(cursor)
+      query['limit'] = limit if limit&.positive?
+      query['filter[domain]'] = filter_domain if present?(filter_domain)
+      query
+    end
+
+    private
+
+    def present?(value)
+      !value.nil? && !value.to_s.empty?
+    end
+  end
+
+  # Request body for creating a sending domain
+  class CreateDomainRequest
+    attr_reader :domain, :tracking, :return_path, :require_tls, :email_track_id
+
+    def initialize(domain:, tracking:, return_path:, require_tls: nil, email_track_id: nil)
+      @domain = domain
+      @tracking = tracking
+      @return_path = return_path
+      @require_tls = require_tls
+      @email_track_id = email_track_id
+    end
+
+    def to_hash
+      hash = {
+        'domain' => domain,
+        'tracking' => tracking,
+        'return_path' => return_path
+      }
+      hash['require_tls'] = require_tls unless require_tls.nil?
+      hash['email_track_id'] = email_track_id if email_track_id && !email_track_id.empty?
+      hash
+    end
+  end
+
+  # Request body for updating a domain's mutable settings.
+  # Pass a track ID to set the email track, an empty string to clear it,
+  # or nil to leave it unchanged.
+  class UpdateDomainRequest
+    attr_reader :email_track_id
+
+    def initialize(email_track_id = nil)
+      @email_track_id = email_track_id
+    end
+
+    def to_hash
+      return {} if email_track_id.nil?
+
+      { 'email_track_id' => email_track_id }
+    end
+  end
+
+  # Generic success message from mutating endpoints
+  class SuccessResponse
+    attr_reader :message
+
+    def initialize(message:)
+      @message = message
+    end
+
+    def self.from_hash(data)
+      new(message: data['message'] || '')
+    end
+
+    def to_hash
+      { 'message' => message }
+    end
+  end
+
+  # A sending domain whose spam complaint ratio reached a critical level
+  class DomainSpamRatioRadar
+    attr_reader :workspace_id, :domain, :esp, :spam_ratio, :date
+
+    def initialize(workspace_id:, domain:, esp:, spam_ratio:, date:)
+      @workspace_id = workspace_id
+      @domain = domain
+      @esp = esp
+      @spam_ratio = spam_ratio
+      @date = date
+    end
+
+    def self.from_hash(data)
+      new(
+        workspace_id: (data['workspace_id'] || 0).to_i,
+        domain: data['domain'] || '',
+        esp: data['esp'] || '',
+        spam_ratio: (data['spam_ratio'] || 0).to_f,
+        date: (data['date'] || '').to_s
+      )
+    end
+  end
+
+  # Paginated list of domain spam-ratio radar entries
+  class ListDomainSpamRatioRadarResponse
+    attr_reader :radar, :next_cursor
+
+    def initialize(radar:, next_cursor: nil)
+      @radar = radar || []
+      @next_cursor = next_cursor
+    end
+
+    def self.from_hash(data)
+      new(
+        radar: (data['radar'] || []).map { |entry| DomainSpamRatioRadar.from_hash(entry) },
+        next_cursor: data['next_cursor']
+      )
+    end
+  end
+
+  # Query parameters for listing domain spam-ratio radar entries
+  class ListDomainSpamRatioRadarParams
+    attr_reader :workspace_ids, :domain, :start_date, :end_date, :cursor, :limit
+
+    def initialize(workspace_ids: [], domain: nil, start_date: nil, end_date: nil, cursor: nil, limit: nil)
+      @workspace_ids = workspace_ids || []
+      @domain = domain
+      @start_date = start_date
+      @end_date = end_date
+      @cursor = cursor
+      @limit = limit
+    end
+
+    def to_query
+      query = {}
+      query['workspace_ids'] = workspace_ids unless workspace_ids.empty?
+      query['domain'] = domain if present?(domain)
+      query['start_date'] = start_date if present?(start_date)
+      query['end_date'] = end_date if present?(end_date)
+      query['cursor'] = cursor if present?(cursor)
+      query['limit'] = limit if limit&.positive?
+      query
+    end
+
+    private
+
+    def present?(value)
+      !value.nil? && !value.to_s.empty?
+    end
+  end
+
+  # A daily Gmail spam-rate report from Google Postmaster Tools
+  class GooglePostmasterSpamReport
+    attr_reader :workspace_id, :domain, :date, :spam_ratio
+
+    def initialize(workspace_id:, domain:, date:, spam_ratio:)
+      @workspace_id = workspace_id
+      @domain = domain
+      @date = date
+      @spam_ratio = spam_ratio
+    end
+
+    def self.from_hash(data)
+      new(
+        workspace_id: (data['workspace_id'] || 0).to_i,
+        domain: data['domain'] || '',
+        date: (data['date'] || '').to_s,
+        spam_ratio: (data['spam_ratio'] || 0).to_f
+      )
+    end
+  end
+
+  # Paginated list of Google Postmaster spam reports
+  class ListGooglePostmasterSpamReportsResponse
+    attr_reader :spam_reports, :next_cursor
+
+    def initialize(spam_reports:, next_cursor: nil)
+      @spam_reports = spam_reports || []
+      @next_cursor = next_cursor
+    end
+
+    def self.from_hash(data)
+      new(
+        spam_reports: (data['spam_reports'] || []).map { |report| GooglePostmasterSpamReport.from_hash(report) },
+        next_cursor: data['next_cursor']
+      )
+    end
+  end
+
+  # Query parameters for listing Google Postmaster spam reports
+  class ListGooglePostmasterSpamReportsParams
+    attr_reader :workspace_ids, :domain, :start_date, :end_date, :cursor, :limit
+
+    def initialize(workspace_ids: [], domain: nil, start_date: nil, end_date: nil, cursor: nil, limit: nil)
+      @workspace_ids = workspace_ids || []
+      @domain = domain
+      @start_date = start_date
+      @end_date = end_date
+      @cursor = cursor
+      @limit = limit
+    end
+
+    def to_query
+      query = {}
+      query['workspace_ids'] = workspace_ids unless workspace_ids.empty?
+      query['domain'] = domain if present?(domain)
+      query['start_date'] = start_date if present?(start_date)
+      query['end_date'] = end_date if present?(end_date)
+      query['cursor'] = cursor if present?(cursor)
+      query['limit'] = limit if limit&.positive?
+      query
+    end
+
+    private
+
+    def present?(value)
+      !value.nil? && !value.to_s.empty?
+    end
+  end
+
+  # A daily Microsoft SNDS report for a sending IP
+  class SndsReport
+    FILTER_UNKNOWN = ''
+    FILTER_GREEN = 'GREEN'
+    FILTER_YELLOW = 'YELLOW'
+    FILTER_RED = 'RED'
+
+    attr_reader :ip, :date, :rcpt_commands, :data_commands, :message_recipients,
+                :filter_result, :complaint_rate, :trap_hits
+
+    def initialize(ip:, date:, rcpt_commands:, data_commands:, message_recipients:,
+                   filter_result:, complaint_rate:, trap_hits:)
+      @ip = ip
+      @date = date
+      @rcpt_commands = rcpt_commands
+      @data_commands = data_commands
+      @message_recipients = message_recipients
+      @filter_result = filter_result
+      @complaint_rate = complaint_rate
+      @trap_hits = trap_hits
+    end
+
+    def self.from_hash(data)
+      new(
+        ip: data['ip'] || '',
+        date: (data['date'] || '').to_s,
+        rcpt_commands: (data['rcpt_commands'] || 0).to_i,
+        data_commands: (data['data_commands'] || 0).to_i,
+        message_recipients: (data['message_recipients'] || 0).to_i,
+        filter_result: data['filter_result'] || FILTER_UNKNOWN,
+        complaint_rate: (data['complaint_rate'] || 0).to_f,
+        trap_hits: (data['trap_hits'] || 0).to_i
+      )
+    end
+  end
+
+  # Paginated list of Microsoft SNDS reports
+  class ListSndsReportsResponse
+    attr_reader :snds_reports, :next_cursor
+
+    def initialize(snds_reports:, next_cursor: nil)
+      @snds_reports = snds_reports || []
+      @next_cursor = next_cursor
+    end
+
+    def self.from_hash(data)
+      new(
+        snds_reports: (data['snds_reports'] || []).map { |report| SndsReport.from_hash(report) },
+        next_cursor: data['next_cursor']
+      )
+    end
+  end
+
+  # Query parameters for listing Microsoft SNDS reports
+  class ListSndsReportsParams
+    attr_reader :ip, :start_date, :end_date, :cursor, :limit
+
+    def initialize(ip: nil, start_date: nil, end_date: nil, cursor: nil, limit: nil)
+      @ip = ip
+      @start_date = start_date
+      @end_date = end_date
+      @cursor = cursor
+      @limit = limit
+    end
+
+    def to_query
+      query = {}
+      query['ip'] = ip if present?(ip)
+      query['start_date'] = start_date if present?(start_date)
+      query['end_date'] = end_date if present?(end_date)
+      query['cursor'] = cursor if present?(cursor)
+      query['limit'] = limit if limit&.positive?
+      query
+    end
+
+    private
+
+    def present?(value)
+      !value.nil? && !value.to_s.empty?
+    end
+  end
+end

data/lib/laneful/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Laneful
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

data/lib/laneful/webhooks.rb

@@ -12,7 +12,7 @@ module Laneful
 
     # Valid event types as documented
     VALID_EVENT_TYPES = %w[
-      delivery open click drop spam_complaint unsubscribe bounce
+      request delivery open click drop spam_complaint unsubscribe bounce
     ].freeze
 
     # UUID pattern for lane_id validation

data/lib/laneful.rb

@@ -8,6 +8,7 @@ require 'base64'
 require_relative 'laneful/version'
 require_relative 'laneful/exceptions'
 require_relative 'laneful/models'
+require_relative 'laneful/org_models'
 require_relative 'laneful/client'
 require_relative 'laneful/webhooks'
 
@@ -23,5 +24,5 @@ module Laneful
   DEFAULT_TIMEOUT = 30
 
   # User agent string
-  USER_AGENT = 'laneful-ruby/1.0.1'
+  USER_AGENT = "laneful-ruby/#{VERSION}".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: laneful-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Laneful Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-10 00:00:00.000000000 Z
+date: 2026-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -50,6 +50,7 @@ files:
 - lib/laneful/client.rb
 - lib/laneful/exceptions.rb
 - lib/laneful/models.rb
+- lib/laneful/org_models.rb
 - lib/laneful/version.rb
 - lib/laneful/webhooks.rb
 homepage: https://github.com/laneful/laneful-ruby