listmonk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 220f8532f40722ac0b228e586c8a3f8ecc765153783fb1aaa7195663f2f29e48
+  data.tar.gz: 145a0d505fce70f1527992b7aaab70c9b409752b740d710679f325d0f8454f50
+SHA512:
+  metadata.gz: 67792a4fc6008979036ecef64510cf56def26c26d824cc1d98fa33de6914283881410288fc0cc8ef41da5d9e2ffa5486c6f7bedab0e16c1b2693afaae5e10348
+  data.tar.gz: 67c86af4e3c7322cc336183af6dcefd38ce94c9c5452117c628b0885c716ee5c3ad722836d5782b36693fbdb873da148d388d10167823b806a69a04b16c24db3

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0
+
+- Add a resource-oriented client covering all operations in listmonk's published Swagger collection.
+- Support Basic and listmonk token-header authentication.
+- Add JSON response envelopes, typed HTTP errors, multipart uploads, and repeated query parameters.
+- Add an opt-in Docker integration suite against Listmonk 6.1.0 and PostgreSQL 17.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,175 @@
+# Listmonk
+
+A resource-oriented Ruby client for the [listmonk HTTP API](https://listmonk.app/docs/apis/apis/).
+
+## Installation
+
+Add the gem to your bundle:
+
+```bash
+bundle add listmonk
+```
+
+The gem requires Ruby 3.3 or newer.
+
+## Configuration
+
+Listmonk supports Basic authentication and its `Authorization: token` header. Basic authentication is the default:
+
+```ruby
+client = Listmonk::Client.new(
+  base_url: "https://newsletter.example.com",
+  username: ENV.fetch("LISTMONK_USERNAME"),
+  token: ENV.fetch("LISTMONK_TOKEN")
+)
+```
+
+Use token-header authentication when needed:
+
+```ruby
+client = Listmonk.client(
+  base_url: "https://newsletter.example.com/api",
+  username: ENV.fetch("LISTMONK_USERNAME"),
+  token: ENV.fetch("LISTMONK_TOKEN"),
+  auth: :token,
+  timeout: 30,
+  open_timeout: 10
+)
+```
+
+The client accepts a server root or an URL ending in `/api`. Credentials may be omitted for public endpoints.
+
+## Usage
+
+Every method returns a `Listmonk::Response`. Use `data` for the API payload, or inspect `status`, `headers`, and `body` when needed.
+
+```ruby
+response = client.subscribers.list(page: 1, per_page: 50, list_id: [1, 2])
+subscribers = response.data.fetch("results")
+
+subscriber = client.subscribers.create(
+  email: "reader@example.com",
+  name: "A Reader",
+  lists: [1],
+  attribs: {source: "website"}
+).data
+
+client.subscribers.update(subscriber.fetch("id"), name: "Reader")
+client.subscribers.send_optin(subscriber.fetch("id"))
+```
+
+Campaigns and transactional messages:
+
+```ruby
+campaign = client.campaigns.create(
+  name: "July news",
+  subject: "What's new",
+  lists: [1],
+  from_email: "News <news@example.com>",
+  content_type: "html",
+  messenger: "email",
+  type: "regular"
+).data
+
+client.campaigns.create_content(campaign.fetch("id"), body: "<h1>Hello</h1>")
+client.campaigns.start(campaign.fetch("id"))
+
+client.transactional.deliver(
+  template_id: 3,
+  subscriber_email: "reader@example.com",
+  data: {confirmation_url: "https://example.com/confirm"}
+)
+```
+
+Subscriber imports and media uploads use multipart requests:
+
+```ruby
+client.imports.create(
+  file: "/tmp/subscribers.zip",
+  params: {
+    mode: "subscribe",
+    subscription_status: "confirmed",
+    lists: [1],
+    overwrite: true
+  }
+)
+
+client.media.upload(file: "/tmp/banner.png", content_type: "image/png")
+```
+
+Resources cover all operations in the published Swagger collection:
+
+- `miscellaneous`, `settings`, `admin`, and `logs`
+- `subscribers`, `lists`, `imports`, and `bounces`
+- `campaigns`, `templates`, `media`, and `transactional`
+- `maintenance` and `public`
+
+For an undocumented or newly added endpoint, use the low-level request method:
+
+```ruby
+client.request(:get, "new-endpoint", params: {page: 1})
+client.request(:post, "new-endpoint", json: {enabled: true})
+```
+
+## Errors
+
+Non-successful responses raise typed exceptions. Every HTTP exception exposes `status`, `body`, and `response`.
+
+```ruby
+begin
+  client.lists.retrieve(999)
+rescue Listmonk::NotFoundError => error
+  warn "List not found: #{error.body.inspect}"
+rescue Listmonk::RateLimitError
+  # Retry with application-specific backoff.
+end
+```
+
+Connection failures raise `Listmonk::ConnectionError`, timeouts raise `Listmonk::TimeoutError`, and malformed JSON raises `Listmonk::ParseError`.
+
+## Development
+
+Install dependencies and run the complete verification task:
+
+```bash
+bin/setup
+bundle exec rake
+```
+
+RSpec uses WebMock for request-level tests and SimpleCov for coverage.
+
+### Docker integration tests
+
+Run the opt-in integration suite against an ephemeral Listmonk 6.1.0 and PostgreSQL 17 environment:
+
+```bash
+bundle exec rake integration
+```
+
+The task starts Docker Compose on `127.0.0.1:19000`, creates a temporary API user, runs live list, subscriber, template, authentication, and health checks, then removes the containers and database volume. Override the defaults with `LISTMONK_PORT` or `LISTMONK_IMAGE`.
+
+Normal `bundle exec rake` runs only the WebMock suite and does not require Docker.
+
+## Releasing
+
+Publishing uses [RubyGems trusted publishing](https://guides.rubygems.org/trusted-publishing/), so no long-lived RubyGems API key is stored in GitHub.
+
+Before the first release, create a pending trusted publisher in your RubyGems.org profile with:
+
+- Gem name: `listmonk`
+- Repository owner: `polydice`
+- Repository name: `listmonk-ruby`
+- Workflow filename: `release.yml`
+- Environment: `release`
+
+To publish a version:
+
+1. Update `lib/listmonk/version.rb` and `CHANGELOG.md`.
+2. Run `bundle exec rake`, `bundle exec rake integration`, and `bundle exec rbs validate`.
+3. Run `bundle exec rake build` and inspect the generated package under `pkg/`.
+4. Commit the release and create a matching version tag, for example `git tag v0.1.0`.
+5. Push `main` and the tag. The `Publish gem` GitHub workflow validates that the tag matches `Listmonk::VERSION` and publishes the gem.
+
+## License
+
+The gem is available under the terms of the [MIT License](LICENSE.txt).

data/lib/listmonk/client.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "faraday"
+require "faraday/multipart"
+require_relative "resource"
+
+module Listmonk
+  class Client
+    RESOURCE_NAMES = %i[
+      miscellaneous settings admin logs subscribers bounces lists imports campaigns
+      media templates transactional maintenance public
+    ].freeze
+
+    attr_reader :base_url
+
+    def initialize(base_url:, username: nil, token: nil, auth: :basic, timeout: 30, open_timeout: 10,
+                   connection: nil)
+      @base_url = normalize_base_url(base_url)
+      @connection = connection || build_connection(username, token, auth, timeout, open_timeout)
+    end
+
+    RESOURCE_NAMES.each do |name|
+      define_method(name) do
+        instance_variable_get("@#{name}") || instance_variable_set(
+          "@#{name}",
+          resource_class(name).new(self)
+        )
+      end
+    end
+
+    def request(method, path, params: nil, json: nil, body: nil, headers: {})
+      raw = @connection.run_request(method, clean_path(path), nil, headers) do |request|
+        request.params.update(compact(params)) if params
+        if json.nil?
+          request.body = body
+        else
+          request.headers["Content-Type"] = "application/json"
+          request.body = JSON.generate(json)
+        end
+      end
+
+      response = Response.new(
+        status: raw.status,
+        headers: raw.headers.to_h,
+        body: parse_body(raw.body, raw.headers["content-type"])
+      )
+      raise_http_error(response) unless response.success?
+
+      response
+    rescue Faraday::TimeoutError => e
+      raise TimeoutError, e.message
+    rescue Faraday::ConnectionFailed => e
+      raise ConnectionError, e.message
+    end
+
+    def file_part(file, content_type: "application/octet-stream", filename: nil)
+      return file if file.is_a?(Faraday::Multipart::FilePart)
+
+      filename ||= File.basename(file.respond_to?(:path) ? file.path : file.to_s)
+      Faraday::Multipart::FilePart.new(file, content_type, filename)
+    end
+
+    private
+
+    def build_connection(username, token, auth, timeout, open_timeout)
+      validate_credentials!(username, token)
+      Faraday.new(
+        url: base_url,
+        request: {
+          timeout: timeout,
+          open_timeout: open_timeout,
+          params_encoder: Faraday::FlatParamsEncoder
+        }
+      ) do |faraday|
+        faraday.request :multipart
+        faraday.request :url_encoded
+        faraday.headers["Accept"] = "application/json"
+        faraday.headers["User-Agent"] = "listmonk-ruby/#{VERSION}"
+        apply_auth(faraday, username, token, auth) if username && token
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def apply_auth(faraday, username, token, auth)
+      case auth.to_sym
+      when :basic
+        credentials = ["#{username}:#{token}"].pack("m0")
+        faraday.headers["Authorization"] = "Basic #{credentials}"
+      when :token
+        faraday.headers["Authorization"] = "token #{username}:#{token}"
+      else
+        raise ConfigurationError, "auth must be :basic or :token"
+      end
+    end
+
+    def validate_credentials!(username, token)
+      return if username.nil? == token.nil?
+
+      raise ConfigurationError, "username and token must be provided together"
+    end
+
+    def normalize_base_url(value)
+      uri = URI.parse(value.to_s)
+      valid = %w[http https].include?(uri.scheme) && uri.host
+      raise ConfigurationError, "base_url must be an absolute HTTP(S) URL" unless valid
+
+      uri.path = uri.path.sub(%r{/+\z}, "")
+      uri.path = "#{uri.path}/api" unless uri.path.end_with?("/api")
+      uri.to_s
+    rescue URI::InvalidURIError
+      raise ConfigurationError, "base_url must be an absolute HTTP(S) URL"
+    end
+
+    def clean_path(path)
+      path.to_s.sub(%r{\A/+}, "")
+    end
+
+    def compact(hash)
+      hash.compact
+    end
+
+    def parse_body(body, content_type)
+      return nil if body.nil? || body.empty?
+      return body unless content_type.to_s.include?("json") || body.lstrip.start_with?("{", "[")
+
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      raise ParseError, "Listmonk returned invalid JSON: #{e.message}"
+    end
+
+    def raise_http_error(response)
+      klass = HTTP_ERRORS.fetch(response.status, response.status >= 500 ? ServerError : Error)
+      message = (response.body["message"] || response.body["error"] if response.body.is_a?(Hash))
+      message ||= "Listmonk request failed with HTTP #{response.status}"
+      raise klass.new(message, response: response)
+    end
+
+    def resource_class(name)
+      require_relative "resources/#{name}"
+      Listmonk::Resources.const_get(name.to_s.capitalize)
+    end
+  end
+end

data/lib/listmonk/errors.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Listmonk
+  class Error < StandardError
+    attr_reader :response
+
+    def initialize(message = nil, response: nil)
+      @response = response
+      super(message)
+    end
+
+    def status
+      response&.status
+    end
+
+    def body
+      response&.body
+    end
+  end
+
+  class ConfigurationError < Error; end
+  class ConnectionError < Error; end
+  class TimeoutError < ConnectionError; end
+  class ParseError < Error; end
+  class BadRequestError < Error; end
+  class AuthenticationError < Error; end
+  class ForbiddenError < Error; end
+  class NotFoundError < Error; end
+  class MethodNotAllowedError < Error; end
+  class GoneError < Error; end
+  class ValidationError < Error; end
+  class RateLimitError < Error; end
+  class ServerError < Error; end
+
+  HTTP_ERRORS = {
+    400 => BadRequestError,
+    401 => AuthenticationError,
+    403 => ForbiddenError,
+    404 => NotFoundError,
+    405 => MethodNotAllowedError,
+    410 => GoneError,
+    422 => ValidationError,
+    429 => RateLimitError
+  }.freeze
+end

data/lib/listmonk/resource.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Listmonk
+  class Resource
+    def initialize(client)
+      @client = client
+    end
+
+    private
+
+    attr_reader :client
+
+    def segment(value)
+      URI.encode_www_form_component(value.to_s)
+    end
+
+    def get(path, params = nil)
+      client.request(:get, path, params: params)
+    end
+
+    def post(path, body = nil)
+      client.request(:post, path, json: body)
+    end
+
+    def put(path, body = nil)
+      client.request(:put, path, json: body)
+    end
+
+    def delete_request(path, params = nil)
+      client.request(:delete, path, params: params)
+    end
+  end
+end

data/lib/listmonk/resources/admin.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Admin < Resource
+      def reload = post("admin/reload")
+    end
+  end
+end

data/lib/listmonk/resources/bounces.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Bounces < Resource
+      def list(**params) = get("bounces", params)
+      def retrieve(id) = get("bounces/#{segment(id)}")
+      def delete(id) = delete_request("bounces/#{segment(id)}")
+
+      def delete_many(ids: nil, all: nil)
+        delete_request("bounces", id: ids && Array(ids).join(","), all: all)
+      end
+    end
+  end
+end

data/lib/listmonk/resources/campaigns.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Campaigns < Resource
+      def list(**params) = get("campaigns", params)
+      def create(**attributes) = post("campaigns", attributes)
+      def retrieve(id) = get("campaigns/#{segment(id)}")
+      def update(id, **attributes) = put("campaigns/#{segment(id)}", attributes)
+      def delete(id) = delete_request("campaigns/#{segment(id)}")
+      def running_stats = get("campaigns/running/stats")
+
+      def analytics(type, **params)
+        get("campaigns/analytics/#{segment(type)}", params)
+      end
+
+      def preview(id) = get("campaigns/#{segment(id)}/preview")
+      def update_preview(id, **attributes) = post("campaigns/#{segment(id)}/preview", attributes)
+      def preview_text(id, **attributes) = post("campaigns/#{segment(id)}/text", attributes)
+      def update_status(id, status:) = put("campaigns/#{segment(id)}/status", status: status)
+      def start(id) = update_status(id, status: "running")
+      def pause(id) = update_status(id, status: "paused")
+      def cancel(id) = update_status(id, status: "cancelled")
+
+      def update_archive(id, archive:, **attributes)
+        put("campaigns/#{segment(id)}/archive", attributes.merge(archive: archive))
+      end
+
+      def create_content(id, **attributes) = post("campaigns/#{segment(id)}/content", attributes)
+      def test(id, **attributes) = post("campaigns/#{segment(id)}/test", attributes)
+    end
+  end
+end

data/lib/listmonk/resources/imports.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Listmonk
+  module Resources
+    class Imports < Resource
+      def status = get("import/subscribers")
+
+      def create(file:, params:, content_type: "application/zip")
+        body = {
+          file: client.file_part(file, content_type: content_type),
+          params: JSON.generate(params)
+        }
+        client.request(:post, "import/subscribers", body: body)
+      end
+
+      def stop = delete_request("import/subscribers")
+      def logs = get("import/subscribers/logs")
+    end
+  end
+end

data/lib/listmonk/resources/lists.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Lists < Resource
+      def list(**params) = get("lists", params)
+      def create(**attributes) = post("lists", attributes)
+      def retrieve(id) = get("lists/#{segment(id)}")
+      def update(id, **attributes) = put("lists/#{segment(id)}", attributes)
+      def delete(id) = delete_request("lists/#{segment(id)}")
+    end
+  end
+end

data/lib/listmonk/resources/logs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Logs < Resource
+      def list = get("logs")
+    end
+  end
+end

data/lib/listmonk/resources/maintenance.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Maintenance < Resource
+      def delete_subscribers(type) = delete_request("maintenance/subscribers/#{segment(type)}")
+      def delete_analytics(type) = delete_request("maintenance/analytics/#{segment(type)}")
+      def delete_unconfirmed_subscriptions = delete_request("maintenance/subscriptions/unconfirmed")
+    end
+  end
+end

data/lib/listmonk/resources/media.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Media < Resource
+      def list = get("media")
+
+      def upload(file:, content_type: "application/octet-stream")
+        body = { file: client.file_part(file, content_type: content_type) }
+        client.request(:post, "media", body: body)
+      end
+
+      def retrieve(id) = get("media/#{segment(id)}")
+      def delete(id) = delete_request("media/#{segment(id)}")
+    end
+  end
+end

data/lib/listmonk/resources/miscellaneous.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Miscellaneous < Resource
+      def health = get("health")
+      def config = get("config")
+      def language(lang) = get("lang/#{segment(lang)}")
+      def dashboard_charts = get("dashboard/charts")
+      def dashboard_counts = get("dashboard/counts")
+    end
+  end
+end

data/lib/listmonk/resources/public.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Public < Resource
+      def lists = get("public/lists")
+
+      def subscribe(name:, email:,
+                    list_uuids:)
+        post("public/subscription", name: name, email: email, list_uuids: list_uuids)
+      end
+    end
+  end
+end

data/lib/listmonk/resources/settings.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Settings < Resource
+      def retrieve = get("settings")
+      def update(**attributes) = put("settings", attributes)
+      def test_smtp(**attributes) = post("settings/smtp/test", attributes)
+    end
+  end
+end

data/lib/listmonk/resources/subscribers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Subscribers < Resource
+      def list(**params) = get("subscribers", params)
+      def create(**attributes) = post("subscribers", attributes)
+      def retrieve(id) = get("subscribers/#{segment(id)}")
+      def update(id, **attributes) = put("subscribers/#{segment(id)}", attributes)
+      def delete(id) = delete_request("subscribers/#{segment(id)}")
+
+      def delete_many(ids)
+        delete_request("subscribers", id: Array(ids).join(","))
+      end
+
+      def manage_lists(**attributes) = put("subscribers/lists", attributes)
+      def manage_list(list_id, **attributes) = put("subscribers/lists/#{segment(list_id)}", attributes)
+      def manage_blocklist(**attributes) = put("subscribers/blocklist", attributes)
+
+      def manage_blocklist_for(id, **attributes)
+        put("subscribers/#{segment(id)}/blocklist", attributes)
+      end
+
+      def export(id) = get("subscribers/#{segment(id)}/export")
+      def bounces(id) = get("subscribers/#{segment(id)}/bounces")
+      def delete_bounces(id) = delete_request("subscribers/#{segment(id)}/bounces")
+      def send_optin(id) = post("subscribers/#{segment(id)}/optin")
+      def delete_by_query(**attributes) = post("subscribers/query/delete", attributes)
+      def blocklist_by_query(**attributes) = put("subscribers/query/blocklist", attributes)
+      def manage_lists_by_query(**attributes) = put("subscribers/query/lists", attributes)
+    end
+  end
+end

data/lib/listmonk/resources/templates.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Templates < Resource
+      def list(**params) = get("templates", params)
+      def create(**attributes) = post("templates", attributes)
+      def retrieve(id) = get("templates/#{segment(id)}")
+      def update(id, **attributes) = put("templates/#{segment(id)}", attributes)
+      def delete(id) = delete_request("templates/#{segment(id)}")
+      def preview(**attributes) = post("templates/preview", attributes)
+      def preview_by_id(id) = get("templates/#{segment(id)}/preview")
+      def set_default(id) = put("templates/#{segment(id)}/default")
+    end
+  end
+end

data/lib/listmonk/resources/transactional.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Listmonk
+  module Resources
+    class Transactional < Resource
+      def deliver(**attributes) = post("tx", attributes)
+    end
+  end
+end

data/lib/listmonk/response.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Listmonk
+  class Response
+    attr_reader :status, :headers, :body
+
+    def initialize(status:, headers:, body:)
+      @status = status
+      @headers = headers.freeze
+      @body = body
+    end
+
+    def success?
+      status.between?(200, 299)
+    end
+
+    def data
+      return body unless body.is_a?(Hash)
+
+      body.key?("data") ? body["data"] : body
+    end
+  end
+end

data/lib/listmonk/version.rb

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

data/lib/listmonk.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "listmonk/version"
+require_relative "listmonk/errors"
+require_relative "listmonk/response"
+require_relative "listmonk/client"
+
+module Listmonk
+  class << self
+    def client(**)
+      Client.new(**)
+    end
+  end
+end

data/sig/listmonk.rbs

@@ -0,0 +1,64 @@
+module Listmonk
+  VERSION: String
+
+  def self.client: (**untyped) -> Client
+
+  class Response
+    attr_reader status: Integer
+    attr_reader headers: Hash[String, String]
+    attr_reader body: untyped
+
+    def success?: () -> bool
+    def data: () -> untyped
+  end
+
+  class Error < StandardError
+    attr_reader response: Response?
+    def status: () -> Integer?
+    def body: () -> untyped
+  end
+
+  class ConfigurationError < Error
+  end
+
+  class ConnectionError < Error
+  end
+
+  class TimeoutError < ConnectionError
+  end
+
+  class ParseError < Error
+  end
+
+  class Client
+    attr_reader base_url: String
+
+    def initialize: (
+      base_url: String,
+      ?username: String?,
+      ?token: String?,
+      ?auth: Symbol,
+      ?timeout: Numeric,
+      ?open_timeout: Numeric,
+      ?connection: untyped
+    ) -> void
+
+    def request: (Symbol method, String path, ?params: Hash[Symbol, untyped]?, ?json: untyped, ?body: untyped, ?headers: Hash[String, String]) -> Response
+    def file_part: (untyped file, ?content_type: String, ?filename: String?) -> untyped
+
+    def miscellaneous: () -> untyped
+    def settings: () -> untyped
+    def admin: () -> untyped
+    def logs: () -> untyped
+    def subscribers: () -> untyped
+    def bounces: () -> untyped
+    def lists: () -> untyped
+    def imports: () -> untyped
+    def campaigns: () -> untyped
+    def media: () -> untyped
+    def templates: () -> untyped
+    def transactional: () -> untyped
+    def maintenance: () -> untyped
+    def public: () -> untyped
+  end
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: listmonk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Richard Lee
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A resource-oriented Ruby client for listmonk's HTTP API.
+email:
+- 14349+dlackty@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/listmonk.rb
+- lib/listmonk/client.rb
+- lib/listmonk/errors.rb
+- lib/listmonk/resource.rb
+- lib/listmonk/resources/admin.rb
+- lib/listmonk/resources/bounces.rb
+- lib/listmonk/resources/campaigns.rb
+- lib/listmonk/resources/imports.rb
+- lib/listmonk/resources/lists.rb
+- lib/listmonk/resources/logs.rb
+- lib/listmonk/resources/maintenance.rb
+- lib/listmonk/resources/media.rb
+- lib/listmonk/resources/miscellaneous.rb
+- lib/listmonk/resources/public.rb
+- lib/listmonk/resources/settings.rb
+- lib/listmonk/resources/subscribers.rb
+- lib/listmonk/resources/templates.rb
+- lib/listmonk/resources/transactional.rb
+- lib/listmonk/response.rb
+- lib/listmonk/version.rb
+- sig/listmonk.rbs
+homepage: https://github.com/polydice/listmonk-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/polydice/listmonk-ruby
+  source_code_uri: https://github.com/polydice/listmonk-ruby
+  changelog_uri: https://github.com/polydice/listmonk-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: A Ruby client for the listmonk API
+test_files: []