kit-rb 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd1696be6db17ef8f8d6a5c010d7e827bb914f7ea32e1b8e0e68a55f4a548cfc
+  data.tar.gz: f68f531db1eaa19bd17f46f4a764f994419fbf01cf2349d141686f00c33ccc7f
+SHA512:
+  metadata.gz: fea1917e81a6eef748518e0609b9d0b4e6c5f347b5527d12ba5575dbf02a210ea3db32037163d98e30e83cb6d35a258a0a5a712a969306960ca9ffaedbafe612
+  data.tar.gz: '058e607d279ad4c3f462a50495874c5d4ce8792dc73961ca193488c7e44e5442fc2cb057b3563fc295b382d2184e4c467f4742d1b4478ac4fb1ea7c4a3493d86'

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project adheres
+to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.0.0] - 2026-09-04
+
+Name-reservation release: the P0 foundation and a working `GET /v4/account`
+vertical slice. Not yet feature-complete — resources land in 0.1.0 per docs/DESIGN.md.
+
+### Added
+- P0 foundations: gem skeleton on the clean `Kit` namespace, with rspec +
+  rubocop + steep gates green on CI (Ruby 3.2–3.4).
+- `Kit::Client` with API-key (`X-Kit-Api-Key`) and OAuth 2.0 bearer auth.
+- `http.rb`-backed `Kit::Connection` with JSON handling and a typed error
+  hierarchy (`Kit::AuthenticationError`, `NotFoundError`, `RateLimitError`, …).
+- `GET /v4/account` vertical slice returning immutable `Data` value objects.
+- RBS signatures for the public surface.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Lawrence Lin
+
+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,57 @@
+# kit-rb
+
+A modern, fully-typed Ruby client for the **Kit** (formerly ConvertKit) **API v4**.
+
+The gem is named `kit-rb`; the public namespace is the clean `Kit`.
+
+> Status: early. P0 (foundations + the `GET /v4/account` vertical slice) is in
+> place; resources are landing per [`docs/DESIGN.md`](docs/DESIGN.md).
+
+## Install
+
+```ruby
+gem "kit-rb"
+```
+
+Requires Ruby >= 3.2.
+
+## Usage
+
+```ruby
+require "kit-rb"
+
+# API key — simplest, for your own account (120 req / 60s):
+client = Kit::Client.new(api_key: ENV.fetch("KIT_API_KEY"))
+
+# or OAuth 2.0 (600 req / 60s; required for bulk & purchase endpoints):
+client = Kit::Client.new(access_token: oauth_access_token)
+
+info = client.account.get       # => Kit::Objects::AccountInfo
+info.account.plan_type          # => "creator_pro"
+info.user.email                 # => "you@example.com"
+```
+
+Responses are immutable `Data` value objects. Errors are typed:
+
+```ruby
+begin
+  client.account.get
+rescue Kit::AuthenticationError => e   # 401
+  warn e.status                        # => 401
+rescue Kit::RateLimitError => e        # 429
+  sleep e.retry_after
+rescue Kit::APIError => e              # any other non-2xx
+  warn e.errors                        # => ["..."] from Kit's body
+end
+```
+
+## Development
+
+```sh
+bin/setup
+bundle exec rake        # spec + rubocop + steep
+```
+
+## License
+
+MIT.

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+desc "Type-check with Steep"
+task :steep do
+  sh "bundle exec steep check"
+end
+
+task default: %i[spec rubocop steep]

data/Steepfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+target :lib do
+  signature "sig"
+  check "lib"
+
+  # http.rb and json ship without RBS here; treat their calls as untyped.
+  library "json"
+  configure_code_diagnostics(Steep::Diagnostic::Ruby.lenient)
+end

data/docs/DESIGN.md

@@ -0,0 +1,50 @@
+# kit-rb — design
+
+A modern, fully-typed Ruby client for the **Kit** (formerly ConvertKit) **API v4**.
+The existing Ruby gems all stop at API v3/v2; kit-rb targets v4 to a high bar.
+
+## Locked decisions
+
+| area | choice | why |
+|---|---|---|
+| HTTP | **http.rb** (`~> 5.2`) | one modern dependency; cleaner than Net::HTTP boilerplate, lighter than Faraday |
+| Auth | **API key + OAuth 2.0 from day one** | Kit's bulk & purchase-creation endpoints require OAuth |
+| Types | **RBS + steep**, response = **`Data` value objects** | Ruby-native, immutable, zero runtime type dep |
+| Ruby floor | **3.2** | `Data.define` |
+| Build process | P1 by hand; **P2 resources via local models + `forge`** | dogfood the reliable-edit workflow; Ruby verified across the fleet benchmarks |
+
+## Architecture
+
+```
+Kit::Client            # entry: picks an auth strategy, holds one Connection
+ ├─ Kit::Configuration # immutable; validates exactly-one-credential
+ ├─ Kit::Auth::ApiKey  # X-Kit-Api-Key header
+ ├─ Kit::Auth::OAuth   # Bearer; authorize/refresh/PKCE land in P1
+ ├─ Kit::Connection    # http.rb transport, JSON, auth injection, error mapping
+ ├─ Kit::Error (tree)  # typed exceptions mapped from HTTP status
+ ├─ Kit::Objects::*    # Data value objects, `.from(hash)` constructors
+ └─ Kit::Resources::*  # one class per resource group; client.account.get
+```
+
+Facts pinned from the OpenAPI spec (`developers.kit.com/api-reference/v4.json`,
+OpenAPI 3.0.3, "Kit API 4.0", host `https://api.kit.com`, 52 paths): API-key
+header `X-Kit-Api-Key`; OAuth authorize/token at `/v4/oauth/*`, scopes read/write;
+rate limits 120/60s (key) and 600/60s (OAuth); cursor pagination (`after`/`before`
++ `per_page`, response carries a `pagination` object).
+
+## Phases
+
+- **P0 — foundations (this).** Gem skeleton on the clean `Kit` namespace, gates
+  (rspec + rubocop + steep) green in CI (Ruby 3.2–3.4), and a walking-skeleton
+  vertical slice: `GET /v4/account` end to end (auth → request → typed error →
+  `Data` object) with full spec coverage.
+- **P1 — core, by hand.** Flesh out the transport: cursor auto-pagination
+  (lazy Enumerator), 429 rate-limit-aware retry with backoff, the full OAuth
+  authorization-code grant + refresh + PKCE, and instrumentation hooks.
+- **P2 — resources, spec-driven + local models.** One class + objects + specs per
+  resource group (subscribers, tags, custom fields, forms, sequences, broadcasts,
+  purchases, webhooks, email templates, segments, snippets), generated against
+  the OpenAPI spec via `forge`, gated by `rspec`/`steep`.
+- **P3 — quality.** Contract tests against the OpenAPI spec, edge cases
+  (pagination tail, nulls, large payloads), coverage floor.
+- **P4 — DX & release.** YARD docs, examples, signed gem, release automation.

data/lib/kit/auth/api_key.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Kit
+  module Auth
+    # API-key authentication: sends the key in the `X-Kit-Api-Key` header.
+    #
+    # Simplest way to reach your own account. Rate limit is 120 requests / 60s.
+    # Note: Kit's bulk and purchase-creation endpoints require OAuth, not a key.
+    class ApiKey
+      HEADER = "X-Kit-Api-Key"
+
+      def initialize(key)
+        raise ConfigurationError, "API key cannot be blank" if key.nil? || key.empty?
+
+        @key = key
+      end
+
+      # Adds the auth header to an outgoing request's header hash.
+      def headers
+        { HEADER => @key }
+      end
+    end
+  end
+end

data/lib/kit/auth/oauth.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Kit
+  module Auth
+    # OAuth 2.0 bearer-token authentication: sends `Authorization: Bearer <token>`.
+    #
+    # Rate limit is 600 requests / 60s, and OAuth is required for the bulk and
+    # purchase-creation endpoints.
+    #
+    # P0 scope: carry an already-obtained access token. The authorization-code
+    # grant (authorize/token URLs at /v4/oauth/*), refresh, and PKCE helper land
+    # in P1 — this class is the seam they plug into.
+    class OAuth
+      AUTHORIZE_URL = "https://api.kit.com/v4/oauth/authorize"
+      TOKEN_URL = "https://api.kit.com/v4/oauth/token"
+
+      def initialize(access_token)
+        raise ConfigurationError, "OAuth access token cannot be blank" if access_token.nil? || access_token.empty?
+
+        @access_token = access_token
+      end
+
+      def headers
+        { "Authorization" => "Bearer #{@access_token}" }
+      end
+    end
+  end
+end

data/lib/kit/client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kit
+  # The entry point. Construct with one credential, then reach resources:
+  #
+  #   client = Kit::Client.new(api_key: ENV.fetch("KIT_API_KEY"))
+  #   client.account.get.account.plan_type
+  #
+  #   client = Kit::Client.new(access_token: oauth_token) # OAuth
+  #
+  # A client is thread-safe to share: it holds immutable config and a stateless
+  # connection, and resource accessors are memoized per client.
+  class Client
+    attr_reader :config
+
+    def initialize(api_key: nil, access_token: nil, **options)
+      @config = Configuration.new(api_key: api_key, access_token: access_token, **options)
+      @connection = Connection.new(@config)
+    end
+
+    def account
+      @account ||= Resources::Account.new(@connection)
+    end
+  end
+end

data/lib/kit/configuration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Kit
+  # Immutable per-client configuration. Exactly one credential (api_key or
+  # access_token) must be supplied; the matching auth strategy is selected here.
+  class Configuration
+    attr_reader :auth, :base_url, :open_timeout, :read_timeout
+
+    def initialize(api_key: nil, access_token: nil, base_url: DEFAULT_BASE_URL,
+                   open_timeout: 10, read_timeout: 30)
+      @auth = build_auth(api_key, access_token)
+      @base_url = base_url
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+    end
+
+    private
+
+    def build_auth(api_key, access_token)
+      raise ConfigurationError, "supply either api_key or access_token, not both" if api_key && access_token
+
+      return Auth::ApiKey.new(api_key) if api_key
+      return Auth::OAuth.new(access_token) if access_token
+
+      raise ConfigurationError, "an api_key or access_token is required"
+    end
+  end
+end

data/lib/kit/connection.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "http"
+require "json"
+
+module Kit
+  # The transport layer: builds requests with http.rb, injects auth and JSON
+  # headers, parses responses, and maps non-2xx statuses onto the typed error
+  # hierarchy. Resources talk to the API only through this.
+  class Connection
+    JSON_TYPE = "application/json"
+
+    def initialize(config)
+      @config = config
+    end
+
+    # Issues a request and returns the parsed JSON body (a Hash) on success.
+    #
+    # @param method [Symbol] :get, :post, :put, :delete
+    # @param path [String] e.g. "/v4/account" (leading slash, no host)
+    # @param params [Hash] query string params
+    # @param body [Hash, nil] JSON request body
+    def request(method, path, params: {}, body: nil)
+      response = client.request(
+        method,
+        "#{@config.base_url}#{path}",
+        params: params,
+        json: body
+      )
+      handle(response)
+    rescue HTTP::Error => e
+      raise Error, "HTTP transport error: #{e.message}"
+    end
+
+    private
+
+    def client
+      HTTP
+        .headers(default_headers)
+        .timeout(connect: @config.open_timeout, read: @config.read_timeout)
+    end
+
+    def default_headers
+      {
+        "Accept" => JSON_TYPE,
+        "Content-Type" => JSON_TYPE,
+        "User-Agent" => "kit-rb/#{Kit::VERSION}"
+      }.merge(@config.auth.headers)
+    end
+
+    def handle(response)
+      status = response.status.to_i
+      parsed = parse(response)
+      return parsed if (200..299).cover?(status)
+
+      raise error_for(status, parsed, response)
+    end
+
+    def parse(response)
+      raw = response.body.to_s
+      return nil if raw.empty?
+
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      raw
+    end
+
+    def error_for(status, body, response)
+      klass = Error.class_for(status)
+      if klass == RateLimitError
+        klass.new(status: status, body: body, response: response,
+                  retry_after: response.headers["Retry-After"]&.to_i)
+      else
+        klass.new(status: status, body: body, response: response)
+      end
+    end
+  end
+end

data/lib/kit/errors.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Kit
+  # Base class for every error the gem raises. Rescue `Kit::Error` to catch all.
+  class Error < StandardError; end
+
+  # Raised for configuration problems detected before any request is made
+  # (e.g. no credentials supplied).
+  class ConfigurationError < Error; end
+
+  # Base for every error that carries an HTTP response. `status` is the code,
+  # `body` the parsed JSON body (or the raw string when it wasn't JSON), and
+  # `errors` the `errors` array Kit returns on validation failures.
+  class APIError < Error
+    attr_reader :status, :body, :errors, :response
+
+    def initialize(message = nil, status:, body: nil, response: nil)
+      @status = status
+      @body = body
+      @response = response
+      @errors = body.is_a?(Hash) ? Array(body["errors"]) : []
+      super(message || default_message)
+    end
+
+    private
+
+    def default_message
+      base = "Kit API request failed with status #{status}"
+      @errors.empty? ? base : "#{base}: #{@errors.join(", ")}"
+    end
+  end
+
+  # 401 — missing or invalid credentials.
+  class AuthenticationError < APIError; end
+  # 403 — authenticated but not permitted (e.g. an API-key-only call needing OAuth).
+  class AuthorizationError < APIError; end
+  # 404 — no such resource.
+  class NotFoundError < APIError; end
+  # 422 — the request was well-formed but semantically invalid.
+  class UnprocessableEntityError < APIError; end
+
+  # 429 — rate limited. `retry_after` is the seconds to wait, when Kit sends it.
+  class RateLimitError < APIError
+    attr_reader :retry_after
+
+    def initialize(message = nil, status:, body: nil, response: nil, retry_after: nil)
+      @retry_after = retry_after
+      super(message, status: status, body: body, response: response)
+    end
+  end
+
+  # 5xx — a Kit-side failure.
+  class ServerError < APIError; end
+
+  # Maps an HTTP status to the most specific error class above.
+  class Error
+    def self.class_for(status)
+      case status
+      when 401 then AuthenticationError
+      when 403 then AuthorizationError
+      when 404 then NotFoundError
+      when 422 then UnprocessableEntityError
+      when 429 then RateLimitError
+      when 500..599 then ServerError
+      else APIError
+      end
+    end
+  end
+end

data/lib/kit/objects/account.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kit
+  module Objects
+    # The user half of GET /v4/account.
+    User = Data.define(:email, :id) do
+      def self.from(hash)
+        new(email: hash["email"], id: hash["id"])
+      end
+    end
+
+    # The account half of GET /v4/account. Extra fields Kit adds later are
+    # ignored rather than crashing the client (forward-compatible).
+    Account = Data.define(:id, :name, :plan_type, :primary_email_address, :created_at) do
+      def self.from(hash)
+        new(
+          id: hash["id"],
+          name: hash["name"],
+          plan_type: hash["plan_type"],
+          primary_email_address: hash["primary_email_address"],
+          created_at: hash["created_at"]
+        )
+      end
+    end
+
+    # The whole GET /v4/account response: { user:, account: }.
+    AccountInfo = Data.define(:user, :account) do
+      def self.from(hash)
+        new(
+          user: User.from(hash.fetch("user", {})),
+          account: Account.from(hash.fetch("account", {}))
+        )
+      end
+    end
+  end
+end

data/lib/kit/resources/account.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Kit
+  module Resources
+    # The /v4/account endpoints. P0 covers the current-account read; colors,
+    # creator_profile, email_stats, and growth_stats follow in P1/P2.
+    class Account < Base
+      # GET /v4/account — current account and user info.
+      #
+      # @return [Kit::Objects::AccountInfo]
+      def get
+        Objects::AccountInfo.from(super("/v4/account"))
+      end
+    end
+  end
+end

data/lib/kit/resources/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Kit
+  module Resources
+    # Shared base for every resource group. Holds the connection and exposes
+    # thin verb helpers so resource classes read as `get("/v4/account")`.
+    class Base
+      def initialize(connection)
+        @connection = connection
+      end
+
+      private
+
+      def get(path, params: {})
+        @connection.request(:get, path, params: params)
+      end
+
+      def post(path, body: nil, params: {})
+        @connection.request(:post, path, params: params, body: body)
+      end
+
+      def put(path, body: nil, params: {})
+        @connection.request(:put, path, params: params, body: body)
+      end
+
+      def delete(path, params: {})
+        @connection.request(:delete, path, params: params)
+      end
+    end
+  end
+end

data/lib/kit/version.rb

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

data/lib/kit-rb.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# kit-rb — a Ruby client for the Kit (formerly ConvertKit) API v4.
+#
+# The gem is named `kit-rb`; the public namespace is the clean `Kit`
+# (like redis-rb → Redis). Require it and talk to the API through a client:
+#
+#   client = Kit::Client.new(api_key: ENV.fetch("KIT_API_KEY"))
+#   client.account.get.plan_type # => "creator_pro"
+module Kit
+  # Base URL for the v4 REST API. Overridable per-client for tests/mocks.
+  DEFAULT_BASE_URL = "https://api.kit.com"
+end
+
+require "kit/version"
+require "kit/errors"
+require "kit/configuration"
+require "kit/auth/api_key"
+require "kit/auth/oauth"
+require "kit/connection"
+require "kit/objects/account"
+require "kit/resources/base"
+require "kit/resources/account"
+require "kit/client"

data/sig/kit-rb.rbs

@@ -0,0 +1,100 @@
+# RBS type signatures for the public surface of kit-rb (P0: account slice).
+# Expanded per-resource as coverage grows in P1/P2.
+
+module Kit
+  VERSION: String
+  DEFAULT_BASE_URL: String
+
+  class Error < StandardError
+    def self.class_for: (Integer status) -> singleton(APIError)
+  end
+  class ConfigurationError < Error
+  end
+
+  class APIError < Error
+    attr_reader status: Integer
+    attr_reader body: untyped
+    attr_reader errors: Array[untyped]
+    attr_reader response: untyped
+    def initialize: (?String? message, status: Integer, ?body: untyped, ?response: untyped) -> void
+  end
+  class AuthenticationError < APIError
+  end
+  class AuthorizationError < APIError
+  end
+  class NotFoundError < APIError
+  end
+  class UnprocessableEntityError < APIError
+  end
+  class RateLimitError < APIError
+    attr_reader retry_after: Integer?
+    def initialize: (?String? message, status: Integer, ?body: untyped, ?response: untyped, ?retry_after: Integer?) -> void
+  end
+  class ServerError < APIError
+  end
+
+  module Auth
+    class ApiKey
+      HEADER: String
+      def initialize: (String key) -> void
+      def headers: () -> Hash[String, String]
+    end
+
+    class OAuth
+      AUTHORIZE_URL: String
+      TOKEN_URL: String
+      def initialize: (String access_token) -> void
+      def headers: () -> Hash[String, String]
+    end
+  end
+
+  class Configuration
+    attr_reader auth: (Auth::ApiKey | Auth::OAuth)
+    attr_reader base_url: String
+    attr_reader open_timeout: Integer
+    attr_reader read_timeout: Integer
+    def initialize: (?api_key: String?, ?access_token: String?, ?base_url: String, ?open_timeout: Integer, ?read_timeout: Integer) -> void
+  end
+
+  class Connection
+    JSON_TYPE: String
+    def initialize: (Configuration config) -> void
+    def request: (Symbol method, String path, ?params: Hash[untyped, untyped], ?body: Hash[untyped, untyped]?) -> untyped
+  end
+
+  module Objects
+    class User
+      attr_reader email: String?
+      attr_reader id: Integer?
+      def self.from: (Hash[String, untyped] hash) -> User
+    end
+    class Account
+      attr_reader id: Integer?
+      attr_reader name: String?
+      attr_reader plan_type: String?
+      attr_reader primary_email_address: String?
+      attr_reader created_at: String?
+      def self.from: (Hash[String, untyped] hash) -> Account
+    end
+    class AccountInfo
+      attr_reader user: User
+      attr_reader account: Account
+      def self.from: (Hash[String, untyped] hash) -> AccountInfo
+    end
+  end
+
+  module Resources
+    class Base
+      def initialize: (Connection connection) -> void
+    end
+    class Account < Base
+      def get: () -> Objects::AccountInfo
+    end
+  end
+
+  class Client
+    attr_reader config: Configuration
+    def initialize: (?api_key: String?, ?access_token: String?, **untyped options) -> void
+    def account: () -> Resources::Account
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: kit-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Lawrence Lin
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+description: kit-rb wraps the Kit v4 REST API with API-key and OAuth 2.0 auth, cursor
+  pagination, typed errors, and immutable value objects.
+email:
+- deduce@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- docs/DESIGN.md
+- lib/kit-rb.rb
+- lib/kit/auth/api_key.rb
+- lib/kit/auth/oauth.rb
+- lib/kit/client.rb
+- lib/kit/configuration.rb
+- lib/kit/connection.rb
+- lib/kit/errors.rb
+- lib/kit/objects/account.rb
+- lib/kit/resources/account.rb
+- lib/kit/resources/base.rb
+- lib/kit/version.rb
+- sig/kit-rb.rbs
+homepage: https://github.com/solcreek/kit-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/solcreek/kit-rb
+  source_code_uri: https://github.com/solcreek/kit-rb
+  changelog_uri: https://github.com/solcreek/kit-rb/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.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A modern, fully-typed Ruby client for the Kit (ConvertKit) API v4.
+test_files: []