lettermint 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eaf2c7d68c2a67e9bdcfff25733031fd17e23645ae6d5c2cc73100177ecd8865
-  data.tar.gz: 7ecfec4398f01936474380abb69c595e9220d1f90e3e990b9261e426e72c1772
+  metadata.gz: 4755559f2d03919f11cb88181b581062497106993656e9d1b0a87738769718e5
+  data.tar.gz: c5b8df6ea0033b41290f4db33aff06854a1ff02404af2391643d6fc736c38167
 SHA512:
-  metadata.gz: fa95bb5a225b54f848de6b62e0e334072207373ab84bbd0a56ba5babc23b47f6b60d4bbdf30097884c6df28c64209ae7956e4c9b551e7b38a735740555a43e09
-  data.tar.gz: a4e41473d58b93ced91c3219d6074d0eaf6382b61174758cc62a091c8ca59762fc75e1a1e9acd4de5372e5c86083cd3a34767c88d7561ab31a7d0ff7b5c4ad4f
+  metadata.gz: a7f78e00a6044e15e2e57efaa365d798a922e1d96fb58d418ba4279cb03785c48c05537e5c0921b177d75d4648c14b8ee0dcf81390dabe9402f21f9485184f5b
+  data.tar.gz: b254a766abe3503cbfb5fad105d9acf112e4d9ed2cb1c642caf42289a90f037ecdd3d2768b2148ee2f60590b5e3acff232e7fabdc409d249afb73e3f41120b08

data/.gemini/settings.json

@@ -0,0 +1,7 @@
+{
+  "codeReview": {
+    "enabled": true,
+    "autoReview": true,
+    "reviewStyle": "concise"
+  }
+}

data/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-04-01
+
+### Added
+
+- `TeamAPI` for managing team resources (members, invitations)
+- `SendingAPI` for domain and sender identity management
+- Resource class infrastructure (`BaseResource`, `Resource`)
+- Raw HTTP methods (`Client#get`, `#post`, `#put`, `#delete`) for arbitrary endpoint access
+- `ConnectionError` for network-level failures
+
+### Changed
+
+- HTTP response body validation before JSON parsing
+
+### Fixed
+
+- TypeError leak in webhook header parsing
+- Blank recipient validation
+
+[0.2.0]: https://github.com/onetimesecret/lettermint-ruby/compare/v0.1.0...v0.2.0
+
 ## [0.1.0] - 2026-02-18
 
 ### Added

data/lib/lettermint/client.rb

@@ -1,33 +1,7 @@
 # frozen_string_literal: true
 
 module Lettermint
-  class Client
-    attr_reader :configuration
-
-    def initialize(api_token:, base_url: nil, timeout: nil)
-      validate_api_token!(api_token)
-
-      @configuration = Configuration.new
-      @configuration.base_url = base_url || Lettermint.configuration.base_url
-      @configuration.timeout = timeout || Lettermint.configuration.timeout
-
-      yield @configuration if block_given?
-
-      @http_client = HttpClient.new(
-        api_token: api_token,
-        base_url: @configuration.base_url,
-        timeout: @configuration.timeout
-      )
-    end
-
-    def email
-      EmailMessage.new(http_client: @http_client)
-    end
-
-    private
-
-    def validate_api_token!(token)
-      raise ArgumentError, 'API token cannot be empty' if token.nil? || token.to_s.strip.empty?
-    end
-  end
+  # Backward compatibility: Client is an alias for SendingAPI.
+  # Use Lettermint::SendingAPI explicitly for clarity.
+  Client = SendingAPI
 end

data/lib/lettermint/email_message.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Lettermint
-  class EmailMessage
+  class EmailMessage # rubocop:disable Metrics/ClassLength
     def initialize(http_client:)
       @http_client = http_client
       reset
@@ -108,7 +108,8 @@ module Lettermint
 
     def validate_required_fields
       missing = %i[from subject].select { |f| blank?(f) }
-      missing << :to if @payload[:to].nil? || @payload[:to].none? { |e| e.is_a?(String) && !e.strip.empty? }
+      missing << :to unless valid_recipients?
+      missing << :body unless body?
       return if missing.empty?
 
       raise ArgumentError, "Missing required field(s): #{missing.join(', ')}"
@@ -118,6 +119,14 @@ module Lettermint
       @payload[field].nil? || @payload[field].to_s.strip.empty?
     end
 
+    def valid_recipients?
+      @payload[:to]&.any? { |e| e.is_a?(String) && !e.strip.empty? }
+    end
+
+    def body?
+      !blank?(:html) || !blank?(:text)
+    end
+
     def reset
       @payload = {}
       @idempotency_key = nil

data/lib/lettermint/errors.rb

@@ -45,6 +45,15 @@ module Lettermint
 
   class TimeoutError < Error; end
 
+  class ConnectionError < Error
+    attr_reader :original_exception
+
+    def initialize(message:, original_exception: nil)
+      @original_exception = original_exception
+      super(message)
+    end
+  end
+
   class WebhookVerificationError < Error; end
 
   class InvalidSignatureError < WebhookVerificationError; end

data/lib/lettermint/http_client.rb

@@ -4,7 +4,7 @@ require 'faraday'
 
 module Lettermint
   class HttpClient
-    def initialize(api_token:, base_url:, timeout:)
+    def initialize(api_token:, base_url:, timeout:, auth_scheme: :project)
       normalized_url = "#{base_url.chomp('/')}/"
       @connection = Faraday.new(url: normalized_url) do |f|
         f.request :json
@@ -14,7 +14,7 @@ module Lettermint
         f.headers = {
           'Content-Type' => 'application/json',
           'Accept' => 'application/json',
-          'x-lettermint-token' => api_token,
+          **auth_headers(api_token, auth_scheme),
           'User-Agent' => "Lettermint/#{Lettermint::VERSION} (Ruby; ruby #{RUBY_VERSION})"
         }
       end
@@ -57,13 +57,21 @@ module Lettermint
 
     private
 
+    def auth_headers(token, scheme)
+      case scheme.to_sym
+      when :project then { 'x-lettermint-token' => token }
+      when :team    then { 'Authorization' => "Bearer #{token}" }
+      else raise ArgumentError, "Unknown auth_scheme: #{scheme}"
+      end
+    end
+
     def with_error_handling
       response = yield
       handle_response(response)
     rescue Faraday::TimeoutError, Timeout::Error
       raise Lettermint::TimeoutError, "Request timeout after #{@connection.options.timeout}s"
     rescue Faraday::ConnectionFailed => e
-      raise Lettermint::Error, e.message
+      raise Lettermint::ConnectionError.new(message: e.message, original_exception: e)
     end
 
     def handle_response(response)

data/lib/lettermint/resources/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Base class for Team API resources providing shared functionality.
+    class Base
+      def initialize(http_client:)
+        @http_client = http_client
+      end
+
+      private
+
+      # Builds query parameters for list endpoints.
+      # @param page_size [Integer, nil] Number of items per page
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @param sort [String, nil] Sort field (prefix with - for descending)
+      # @param include [String, nil] Related resources to include
+      # @param filters [Hash] Filter parameters (converted to filter[key]=value)
+      # @return [Hash, nil] Query parameters hash or nil if empty
+      def build_params(page_size: nil, page_cursor: nil, sort: nil, include: nil, **filters)
+        params = {
+          'page[size]' => page_size,
+          'page[cursor]' => page_cursor,
+          'sort' => sort,
+          'include' => include
+        }.compact
+
+        filters.each { |k, v| params["filter[#{k}]"] = v unless v.nil? }
+        params.empty? ? nil : params
+      end
+    end
+  end
+end

data/lib/lettermint/resources/domains.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Domains resource for managing sending domains and DNS verification.
+    class Domains < Base
+      # List all domains.
+      # @param page_size [Integer, nil] Number of items per page (default: 30)
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @param sort [String, nil] Sort field: domain, created_at, status_changed_at (prefix - for desc)
+      # @param status [String, nil] Filter by status (verified, partially_verified, etc.)
+      # @param domain [String, nil] Filter by domain (partial match)
+      # @return [Hash] Paginated list of domains
+      def list(page_size: nil, page_cursor: nil, sort: nil, status: nil, domain: nil)
+        params = build_params(page_size:, page_cursor:, sort:, status:, domain:)
+        @http_client.get(path: '/domains', params: params)
+      end
+
+      # Create a new domain.
+      # @param domain [String] Domain name (max 255 chars)
+      # @return [Hash] Created domain data
+      def create(domain:)
+        @http_client.post(path: '/domains', data: { domain: domain })
+      end
+
+      # Get domain details.
+      # @param id [String] Domain ID
+      # @param include [String, nil] Related data to include (dnsRecords, dnsRecordsCount, dnsRecordsExists)
+      # @return [Hash] Domain data with optional includes
+      def find(id, include: nil)
+        params = build_params(include: include)
+        @http_client.get(path: "/domains/#{id}", params: params)
+      end
+
+      # Delete a domain.
+      # @param id [String] Domain ID
+      # @return [Hash] Confirmation message
+      def delete(id)
+        @http_client.delete(path: "/domains/#{id}")
+      end
+
+      # Verify all DNS records for a domain.
+      # @param id [String] Domain ID
+      # @return [Hash] Verification result
+      def verify_dns(id)
+        @http_client.post(path: "/domains/#{id}/dns-records/verify")
+      end
+
+      # Verify a specific DNS record.
+      # @param domain_id [String] Domain ID
+      # @param record_id [String] DNS record ID
+      # @return [Hash] Verification result
+      def verify_dns_record(domain_id, record_id)
+        @http_client.post(path: "/domains/#{domain_id}/dns-records/#{record_id}/verify")
+      end
+
+      # Update projects associated with a domain.
+      # @param id [String] Domain ID
+      # @param project_ids [Array<String>] Array of project UUIDs
+      # @return [Hash] Updated domain data
+      def update_projects(id, project_ids:)
+        @http_client.put(path: "/domains/#{id}/projects", data: { project_ids: project_ids })
+      end
+    end
+  end
+end

data/lib/lettermint/resources/messages.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Messages resource for viewing sent and received messages.
+    class Messages < Base
+      # List messages.
+      # @param page_size [Integer, nil] Number of items per page (default: 30)
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @param sort [String, nil] Sort field: type, status, from_email, subject, created_at, status_changed_at
+      # @param type [String, nil] Filter: inbound, outbound
+      # @param status [String, nil] Filter by status
+      # @param route_id [String, nil] Filter by route ID
+      # @param domain_id [String, nil] Filter by domain ID
+      # @param tag [String, nil] Filter by tag
+      # @param from_email [String, nil] Filter by sender email
+      # @param subject [String, nil] Filter by subject
+      # @param from_date [String, nil] Filter from date (Y-m-d)
+      # @param to_date [String, nil] Filter to date (Y-m-d)
+      # @return [Hash] Paginated list of messages
+      # rubocop:disable Metrics/ParameterLists
+      def list(page_size: nil, page_cursor: nil, sort: nil, type: nil, status: nil,
+               route_id: nil, domain_id: nil, tag: nil, from_email: nil, subject: nil,
+               from_date: nil, to_date: nil)
+        params = build_params(
+          page_size: page_size,
+          page_cursor: page_cursor,
+          sort: sort,
+          type: type,
+          status: status,
+          route_id: route_id,
+          domain_id: domain_id,
+          tag: tag,
+          from_email: from_email,
+          subject: subject,
+          from_date: from_date,
+          to_date: to_date
+        )
+        @http_client.get(path: '/messages', params: params)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Get message details.
+      # @param id [String] Message ID
+      # @return [Hash] Message data
+      def find(id)
+        @http_client.get(path: "/messages/#{id}")
+      end
+
+      # Get message events (delivery history).
+      # @param id [String] Message ID
+      # @param sort [String, nil] Sort field: timestamp, event
+      # @return [Hash] List of message events
+      def events(id, sort: nil)
+        params = sort ? { 'sort' => sort } : nil
+        @http_client.get(path: "/messages/#{id}/events", params: params)
+      end
+
+      # Get raw message source (RFC822 format).
+      # @param id [String] Message ID
+      # @return [String] Raw message source (message/rfc822)
+      def source(id)
+        @http_client.get(path: "/messages/#{id}/source", headers: { 'Accept' => 'message/rfc822' })
+      end
+
+      # Get message HTML body.
+      # @param id [String] Message ID
+      # @return [String] HTML content (text/html)
+      def html(id)
+        @http_client.get(path: "/messages/#{id}/html", headers: { 'Accept' => 'text/html' })
+      end
+
+      # Get message plain text body.
+      # @param id [String] Message ID
+      # @return [String] Plain text content (text/plain)
+      def text(id)
+        @http_client.get(path: "/messages/#{id}/text", headers: { 'Accept' => 'text/plain' })
+      end
+    end
+  end
+end

data/lib/lettermint/resources/projects.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Projects resource for managing projects, members, and accessing routes.
+    class Projects < Base
+      # List all projects.
+      # @param page_size [Integer, nil] Number of items per page (default: 30)
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @param sort [String, nil] Sort field: name, created_at (prefix - for desc)
+      # @param search [String, nil] Search filter
+      # @return [Hash] Paginated list of projects
+      def list(page_size: nil, page_cursor: nil, sort: nil, search: nil)
+        params = build_params(page_size: page_size, page_cursor: page_cursor, sort: sort, search: search)
+        @http_client.get(path: '/projects', params: params)
+      end
+
+      # Create a new project.
+      # @param name [String] Project name (max 255 chars)
+      # @param smtp_enabled [Boolean, nil] Enable SMTP (default: false)
+      # @param initial_routes [String, nil] Initial routes: both, transactional, broadcast (default: both)
+      # @return [Hash] Created project data including api_token
+      def create(name:, smtp_enabled: nil, initial_routes: nil)
+        data = { name: name }
+        data[:smtp_enabled] = smtp_enabled unless smtp_enabled.nil?
+        data[:initial_routes] = initial_routes if initial_routes
+        @http_client.post(path: '/projects', data: data)
+      end
+
+      # Get project details.
+      #
+      # Note: Returns a Hash, not a resource object. To access routes for a project,
+      # use `projects.routes(project_id)` rather than chaining on the find result.
+      #
+      # @param id [String] Project ID
+      # @param include [String, nil] Related data: routes, domains, teamMembers, messageStats (+ Count/Exists variants)
+      # @return [Hash] Project data with optional includes
+      def find(id, include: nil)
+        params = include ? { 'include' => include } : nil
+        @http_client.get(path: "/projects/#{id}", params: params)
+      end
+
+      # Update a project.
+      # @param id [String] Project ID
+      # @param name [String, nil] New project name
+      # @param smtp_enabled [Boolean, nil] Enable/disable SMTP
+      # @param default_route_id [String, nil] Default route UUID
+      # @return [Hash] Updated project data
+      def update(id, name: nil, smtp_enabled: nil, default_route_id: nil)
+        data = {}
+        data[:name] = name if name
+        data[:smtp_enabled] = smtp_enabled unless smtp_enabled.nil?
+        data[:default_route_id] = default_route_id if default_route_id
+        @http_client.put(path: "/projects/#{id}", data: data)
+      end
+
+      # Delete a project.
+      # @param id [String] Project ID
+      # @return [Hash] Confirmation message
+      def delete(id)
+        @http_client.delete(path: "/projects/#{id}")
+      end
+
+      # Rotate the project API token.
+      # @param id [String] Project ID
+      # @return [Hash] Contains new_token
+      def rotate_token(id)
+        @http_client.post(path: "/projects/#{id}/rotate-token")
+      end
+
+      # Update project members (replace all).
+      # @param id [String] Project ID
+      # @param team_member_ids [Array<String>] Array of team member IDs
+      # @return [Hash] Confirmation
+      def update_members(id, team_member_ids:)
+        @http_client.put(path: "/projects/#{id}/members", data: { team_member_ids: team_member_ids })
+      end
+
+      # Add a member to the project.
+      # @param project_id [String] Project ID
+      # @param member_id [String] Team member ID
+      # @return [Hash] Confirmation
+      def add_member(project_id, member_id)
+        @http_client.post(path: "/projects/#{project_id}/members/#{member_id}")
+      end
+
+      # Remove a member from the project.
+      # @param project_id [String] Project ID
+      # @param member_id [String] Team member ID
+      # @return [Hash] Confirmation
+      def remove_member(project_id, member_id)
+        @http_client.delete(path: "/projects/#{project_id}/members/#{member_id}")
+      end
+
+      # Get a routes accessor scoped to this project.
+      # @param project_id [String] Project ID
+      # @return [Routes] Routes resource scoped to the project
+      def routes(project_id)
+        Routes.new(http_client: @http_client, project_id: project_id)
+      end
+    end
+  end
+end

data/lib/lettermint/resources/routes.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Routes resource for managing project routes (transactional, broadcast, inbound).
+    # Can be instantiated with a project_id for scoped operations or without for direct route access.
+    class Routes < Base
+      # @param http_client [HttpClient] HTTP client instance
+      # @param project_id [String, nil] Optional project ID for scoped operations
+      def initialize(http_client:, project_id: nil)
+        super(http_client: http_client)
+        @project_id = project_id
+      end
+
+      # List routes for a project.
+      # Requires project_id to be set (via constructor or projects.routes(id)).
+      # @param page_size [Integer, nil] Number of items per page (default: 30)
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @param sort [String, nil] Sort field: name, slug, created_at (prefix - for desc)
+      # @param route_type [String, nil] Filter: transactional, broadcast, inbound
+      # @param is_default [Boolean, nil] Filter by default route status
+      # @param search [String, nil] Search filter
+      # @return [Hash] Paginated list of routes
+      # rubocop:disable Metrics/ParameterLists
+      def list(page_size: nil, page_cursor: nil, sort: nil, route_type: nil,
+               is_default: nil, search: nil)
+        raise ArgumentError, 'project_id required for listing routes' unless @project_id
+
+        params = build_params(
+          page_size: page_size,
+          page_cursor: page_cursor,
+          sort: sort,
+          route_type: route_type,
+          is_default: is_default,
+          search: search
+        )
+        @http_client.get(path: "/projects/#{@project_id}/routes", params: params)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Create a new route in a project.
+      # Requires project_id to be set.
+      # @param name [String] Route name (max 255 chars)
+      # @param route_type [String] Type: transactional, broadcast, inbound
+      # @param slug [String, nil] Optional slug (max 255 chars)
+      # @return [Hash] Created route data
+      def create(name:, route_type:, slug: nil)
+        raise ArgumentError, 'project_id required for creating routes' unless @project_id
+
+        data = { name: name, route_type: route_type }
+        data[:slug] = slug if slug
+        @http_client.post(path: "/projects/#{@project_id}/routes", data: data)
+      end
+
+      # Get route details.
+      # @param id [String] Route ID
+      # @param include [String, nil] Related data: project, statistics
+      # @return [Hash] Route data
+      def find(id, include: nil)
+        params = include ? { 'include' => include } : nil
+        @http_client.get(path: "/routes/#{id}", params: params)
+      end
+
+      # Update a route.
+      # @param id [String] Route ID
+      # @param name [String, nil] New route name
+      # @param settings [Hash, nil] Route settings (track_opens, track_clicks, disable_hosted_unsubscribe)
+      # @param inbound_settings [Hash, nil] Inbound settings (inbound_domain, spam_threshold, etc.)
+      # @return [Hash] Updated route data
+      def update(id, name: nil, settings: nil, inbound_settings: nil)
+        data = {}
+        data[:name] = name if name
+        data[:settings] = settings if settings
+        data[:inbound_settings] = inbound_settings if inbound_settings
+        @http_client.put(path: "/routes/#{id}", data: data)
+      end
+
+      # Delete a route.
+      # @param id [String] Route ID
+      # @return [Hash] Confirmation message
+      def delete(id)
+        @http_client.delete(path: "/routes/#{id}")
+      end
+
+      # Verify inbound domain for a route.
+      # @param id [String] Route ID
+      # @return [Hash] Verification result
+      def verify_inbound_domain(id)
+        @http_client.post(path: "/routes/#{id}/verify-inbound-domain")
+      end
+    end
+  end
+end

data/lib/lettermint/resources/stats.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Stats resource for retrieving email statistics.
+    class Stats < Base
+      # Get statistics for a date range.
+      # @param from [String] Start date (Y-m-d format, required)
+      # @param to [String] End date (Y-m-d format, required, max 90 days from start)
+      # @param project_id [String, nil] Filter by project ID
+      # @param route_id [String, nil] Filter by a single route ID
+      # @param route_ids [Array<String>, String, nil] Filter by multiple route IDs
+      # @return [Hash] Stats data with totals and daily breakdown
+      def get(from:, to:, project_id: nil, route_id: nil, route_ids: nil)
+        params = { 'from' => from, 'to' => to }
+        params['project_id'] = project_id if project_id
+        params['route_id'] = route_id if route_id
+        params['route_ids'] = route_ids if route_ids
+        @http_client.get(path: '/stats', params: params)
+      end
+    end
+  end
+end

data/lib/lettermint/resources/suppressions.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Suppressions resource for managing email suppression lists.
+    class Suppressions < Base
+      # List suppressions.
+      # @param page_size [Integer, nil] Number of items per page (default: 30)
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @param sort [String, nil] Sort field: value, created_at, reason
+      # @param scope [String, nil] Filter: team, project, route
+      # @param route_id [String, nil] Filter by route ID
+      # @param project_id [String, nil] Filter by project ID
+      # @param value [String, nil] Filter by suppression value (email/domain/extension)
+      # @param reason [String, nil] Filter: spam_complaint, hard_bounce, unsubscribe, manual
+      # @return [Hash] Paginated list of suppressions
+      # rubocop:disable Metrics/ParameterLists
+      def list(page_size: nil, page_cursor: nil, sort: nil, scope: nil,
+               route_id: nil, project_id: nil, value: nil, reason: nil)
+        params = build_params(
+          page_size: page_size,
+          page_cursor: page_cursor,
+          sort: sort,
+          scope: scope,
+          route_id: route_id,
+          project_id: project_id,
+          value: value,
+          reason: reason
+        )
+        @http_client.get(path: '/suppressions', params: params)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Create a suppression entry.
+      # @param reason [String] Reason: spam_complaint, hard_bounce, unsubscribe, manual
+      # @param scope [String] Scope: team, project, route
+      # @param email [String, nil] Single email to suppress (max 255 chars)
+      # @param emails [Array<String>, nil] Multiple emails to suppress (max 1000)
+      # @param route_id [String, nil] Route ID (required if scope is route)
+      # @param project_id [String, nil] Project ID (required if scope is project)
+      # @return [Hash] Created suppression data
+      def create(reason:, scope:, email: nil, emails: nil, route_id: nil, project_id: nil) # rubocop:disable Metrics/ParameterLists
+        data = { reason: reason, scope: scope }
+        data[:email] = email if email
+        data[:emails] = emails if emails
+        data[:route_id] = route_id if route_id
+        data[:project_id] = project_id if project_id
+        @http_client.post(path: '/suppressions', data: data)
+      end
+
+      # Delete a suppression entry.
+      # @param id [String] Suppression ID
+      # @return [Hash] Confirmation message
+      def delete(id)
+        @http_client.delete(path: "/suppressions/#{id}")
+      end
+    end
+  end
+end

data/lib/lettermint/resources/team.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Team resource for managing team settings, usage, and members.
+    class Team < Base
+      # Get team details.
+      # @param include [String, nil] Related data to include (features, featuresCount, featuresExists)
+      # @return [Hash] Team data
+      def get(include: nil)
+        params = include ? { 'include' => include } : nil
+        @http_client.get(path: '/team', params: params)
+      end
+
+      # Update team settings.
+      # @param name [String] New team name (max 255 chars)
+      # @return [Hash] Updated team data
+      def update(name:)
+        @http_client.put(path: '/team', data: { name: name })
+      end
+
+      # Get team usage statistics.
+      # @return [Hash] Current period and up to 12 historical periods
+      def usage
+        @http_client.get(path: '/team/usage')
+      end
+
+      # List team members.
+      # @param page_size [Integer, nil] Number of items per page (default: 30)
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @return [Hash] Paginated list of team members
+      def members(page_size: nil, page_cursor: nil)
+        params = build_params(page_size: page_size, page_cursor: page_cursor)
+        @http_client.get(path: '/team/members', params: params)
+      end
+    end
+  end
+end

data/lib/lettermint/resources/webhooks.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Lettermint
+  module Resources
+    # Webhooks resource for managing webhook endpoints and viewing deliveries.
+    class Webhooks < Base
+      # List all webhooks.
+      # @param page_size [Integer, nil] Number of items per page (default: 30)
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @param sort [String, nil] Sort field: name, url, created_at (prefix - for desc)
+      # @param enabled [Boolean, nil] Filter by enabled status
+      # @param event [String, nil] Filter by event type
+      # @param route_id [String, nil] Filter by route ID
+      # @param search [String, nil] Search filter
+      # @return [Hash] Paginated list of webhooks
+      # rubocop:disable Metrics/ParameterLists
+      def list(page_size: nil, page_cursor: nil, sort: nil, enabled: nil,
+               event: nil, route_id: nil, search: nil)
+        params = build_params(
+          page_size: page_size,
+          page_cursor: page_cursor,
+          sort: sort,
+          enabled: enabled,
+          event: event,
+          route_id: route_id,
+          search: search
+        )
+        @http_client.get(path: '/webhooks', params: params)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Create a new webhook.
+      # @param route_id [String] Route ID to attach webhook to
+      # @param name [String] Webhook name (max 255 chars)
+      # @param url [String] Webhook URL (max 500 chars)
+      # @param events [Array<String>] Event types to subscribe (min 1)
+      # @param enabled [Boolean, nil] Enable webhook (default: true)
+      # @return [Hash] Created webhook data including secret (shown only once)
+      def create(route_id:, name:, url:, events:, enabled: nil)
+        data = { route_id: route_id, name: name, url: url, events: events }
+        data[:enabled] = enabled unless enabled.nil?
+        @http_client.post(path: '/webhooks', data: data)
+      end
+
+      # Get webhook details.
+      # @param id [String] Webhook ID
+      # @return [Hash] Webhook data including secret
+      def find(id)
+        @http_client.get(path: "/webhooks/#{id}")
+      end
+
+      # Update a webhook.
+      # @param id [String] Webhook ID
+      # @param name [String, nil] New webhook name
+      # @param url [String, nil] New webhook URL
+      # @param enabled [Boolean, nil] Enable/disable webhook
+      # @param events [Array<String>, nil] Event types (min 1)
+      # @return [Hash] Updated webhook data
+      def update(id, name: nil, url: nil, enabled: nil, events: nil)
+        data = {}
+        data[:name] = name if name
+        data[:url] = url if url
+        data[:enabled] = enabled unless enabled.nil?
+        data[:events] = events if events
+        @http_client.put(path: "/webhooks/#{id}", data: data)
+      end
+
+      # Delete a webhook.
+      # @param id [String] Webhook ID
+      # @return [Hash] Confirmation message
+      def delete(id)
+        @http_client.delete(path: "/webhooks/#{id}")
+      end
+
+      # Test a webhook by sending a test delivery.
+      # @param id [String] Webhook ID
+      # @return [Hash] Contains delivery_id for tracking
+      def test(id)
+        @http_client.post(path: "/webhooks/#{id}/test")
+      end
+
+      # Regenerate webhook secret.
+      # @param id [String] Webhook ID
+      # @return [Hash] Updated webhook data with new secret
+      def regenerate_secret(id)
+        @http_client.post(path: "/webhooks/#{id}/regenerate-secret")
+      end
+
+      # List webhook deliveries.
+      # @param webhook_id [String] Webhook ID
+      # @param page_size [Integer, nil] Number of items per page
+      # @param page_cursor [String, nil] Cursor for pagination
+      # @param sort [String, nil] Sort field: created_at, attempt_number
+      # @param status [String, nil] Filter: pending, success, failed, client_error, server_error, timeout
+      # @param event_type [String, nil] Filter by event type
+      # @param from_date [String, nil] Filter from date (Y-m-d)
+      # @param to_date [String, nil] Filter to date (Y-m-d)
+      # @return [Hash] Paginated list of deliveries
+      # rubocop:disable Metrics/ParameterLists
+      def deliveries(webhook_id, page_size: nil, page_cursor: nil, sort: nil,
+                     status: nil, event_type: nil, from_date: nil, to_date: nil)
+        params = build_params(
+          page_size: page_size,
+          page_cursor: page_cursor,
+          sort: sort,
+          status: status,
+          event_type: event_type,
+          from_date: from_date,
+          to_date: to_date
+        )
+        @http_client.get(path: "/webhooks/#{webhook_id}/deliveries", params: params)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Get a specific delivery.
+      # @param webhook_id [String] Webhook ID
+      # @param delivery_id [String] Delivery ID
+      # @return [Hash] Delivery data including payload and response
+      def delivery(webhook_id, delivery_id)
+        @http_client.get(path: "/webhooks/#{webhook_id}/deliveries/#{delivery_id}")
+      end
+    end
+  end
+end

data/lib/lettermint/sending_api.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Lettermint
+  # Client for the Lettermint Sending API (project-level email sending).
+  # Authenticates with project tokens via x-lettermint-token header.
+  class SendingAPI
+    attr_reader :configuration
+
+    def initialize(api_token:, base_url: nil, timeout: nil)
+      validate_api_token!(api_token)
+
+      @configuration = Configuration.new
+      @configuration.base_url = base_url || Lettermint.configuration.base_url
+      @configuration.timeout = timeout || Lettermint.configuration.timeout
+
+      yield @configuration if block_given?
+
+      @http_client = HttpClient.new(
+        api_token: api_token,
+        base_url: @configuration.base_url,
+        timeout: @configuration.timeout,
+        auth_scheme: :project
+      )
+    end
+
+    def email
+      EmailMessage.new(http_client: @http_client)
+    end
+
+    # Makes a GET request to an arbitrary API endpoint.
+    #
+    # @param path [String] The API endpoint path (e.g., '/domains')
+    # @param params [Hash, nil] Query parameters to include in the request
+    # @param headers [Hash, nil] Additional HTTP headers
+    # @return [Hash] The parsed JSON response body
+    def get(path, params: nil, headers: nil)
+      @http_client.get(path: path, params: params, headers: headers)
+    end
+
+    # Makes a POST request to an arbitrary API endpoint.
+    #
+    # @param path [String] The API endpoint path
+    # @param data [Hash, nil] The request body (will be JSON-encoded)
+    # @param headers [Hash, nil] Additional HTTP headers
+    # @return [Hash] The parsed JSON response body
+    def post(path, data: nil, headers: nil)
+      @http_client.post(path: path, data: data, headers: headers)
+    end
+
+    # Makes a PUT request to an arbitrary API endpoint.
+    #
+    # @param path [String] The API endpoint path
+    # @param data [Hash, nil] The request body (will be JSON-encoded)
+    # @param headers [Hash, nil] Additional HTTP headers
+    # @return [Hash] The parsed JSON response body
+    def put(path, data: nil, headers: nil)
+      @http_client.put(path: path, data: data, headers: headers)
+    end
+
+    # Makes a DELETE request to an arbitrary API endpoint.
+    #
+    # @param path [String] The API endpoint path
+    # @param headers [Hash, nil] Additional HTTP headers
+    # @return [Hash] The parsed JSON response body
+    def delete(path, headers: nil)
+      @http_client.delete(path: path, headers: headers)
+    end
+
+    private
+
+    def validate_api_token!(token)
+      raise ArgumentError, 'API token cannot be empty' if token.nil? || token.to_s.strip.empty?
+    end
+  end
+end

data/lib/lettermint/team_api.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Lettermint
+  # Client for the Lettermint Team API (team-level management operations).
+  # Authenticates with team tokens (lm_team_*) via Authorization: Bearer header.
+  class TeamAPI
+    attr_reader :configuration
+
+    def initialize(team_token:, base_url: nil, timeout: nil)
+      validate_team_token!(team_token)
+
+      @configuration = Configuration.new
+      @configuration.base_url = base_url || Lettermint.configuration.base_url
+      @configuration.timeout = timeout || Lettermint.configuration.timeout
+
+      yield @configuration if block_given?
+
+      @http_client = HttpClient.new(
+        api_token: team_token,
+        base_url: @configuration.base_url,
+        timeout: @configuration.timeout,
+        auth_scheme: :team
+      )
+    end
+
+    # Health check endpoint (accepts both token types)
+    # @return [Hash] Parsed response body, e.g. { 'ok' => true } on success
+    def ping
+      @http_client.get(path: '/ping')
+    end
+
+    # Team resource accessor
+    # @return [Resources::Team]
+    def team
+      Resources::Team.new(http_client: @http_client)
+    end
+
+    # Domains resource accessor
+    # @return [Resources::Domains]
+    def domains
+      Resources::Domains.new(http_client: @http_client)
+    end
+
+    # Projects resource accessor
+    # @return [Resources::Projects]
+    def projects
+      Resources::Projects.new(http_client: @http_client)
+    end
+
+    # Webhooks resource accessor
+    # @return [Resources::Webhooks]
+    def webhooks
+      Resources::Webhooks.new(http_client: @http_client)
+    end
+
+    # Messages resource accessor
+    # @return [Resources::Messages]
+    def messages
+      Resources::Messages.new(http_client: @http_client)
+    end
+
+    # Suppressions resource accessor
+    # @return [Resources::Suppressions]
+    def suppressions
+      Resources::Suppressions.new(http_client: @http_client)
+    end
+
+    # Stats resource accessor
+    # @return [Resources::Stats]
+    def stats
+      Resources::Stats.new(http_client: @http_client)
+    end
+
+    # Routes resource accessor (top-level for direct route access)
+    # For project-scoped routes, use projects.routes(project_id)
+    # @return [Resources::Routes]
+    def routes
+      Resources::Routes.new(http_client: @http_client)
+    end
+
+    private
+
+    def validate_team_token!(token)
+      raise ArgumentError, 'Team token cannot be empty' if token.nil? || token.to_s.strip.empty?
+      return if token.to_s.start_with?('lm_team_')
+
+      raise ArgumentError, "Invalid team token format (expected 'lm_team_*')"
+    end
+  end
+end

data/lib/lettermint/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lettermint
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/lettermint.rb

@@ -7,6 +7,21 @@ require_relative 'lettermint/configuration'
 require_relative 'lettermint/http_client'
 require_relative 'lettermint/email_message'
 require_relative 'lettermint/webhook'
+
+# Resources (Team API)
+require_relative 'lettermint/resources/base'
+require_relative 'lettermint/resources/team'
+require_relative 'lettermint/resources/domains'
+require_relative 'lettermint/resources/projects'
+require_relative 'lettermint/resources/routes'
+require_relative 'lettermint/resources/webhooks'
+require_relative 'lettermint/resources/messages'
+require_relative 'lettermint/resources/suppressions'
+require_relative 'lettermint/resources/stats'
+
+# API Clients
+require_relative 'lettermint/sending_api'
+require_relative 'lettermint/team_api'
 require_relative 'lettermint/client'
 
 module Lettermint

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lettermint
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Delano
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gemini/settings.json"
 - CHANGELOG.md
 - LICENSE
 - README.md
@@ -41,6 +42,17 @@ files:
 - lib/lettermint/email_message.rb
 - lib/lettermint/errors.rb
 - lib/lettermint/http_client.rb
+- lib/lettermint/resources/base.rb
+- lib/lettermint/resources/domains.rb
+- lib/lettermint/resources/messages.rb
+- lib/lettermint/resources/projects.rb
+- lib/lettermint/resources/routes.rb
+- lib/lettermint/resources/stats.rb
+- lib/lettermint/resources/suppressions.rb
+- lib/lettermint/resources/team.rb
+- lib/lettermint/resources/webhooks.rb
+- lib/lettermint/sending_api.rb
+- lib/lettermint/team_api.rb
 - lib/lettermint/types.rb
 - lib/lettermint/version.rb
 - lib/lettermint/webhook.rb