companyenrich 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b29a5f9bca5c9a4988c19c84b4c879d7ff44dcbffdb2c29bfc495e27740a0960
+  data.tar.gz: 628e62829990c88d4fbf9c725587232db9418a5bd7c0edc345dfcc74d397b27f
+SHA512:
+  metadata.gz: dc6253692f6c67c9c843a14e376bfc5d25da701545fedb4406e10ac17cbd80da57bcd3ab6edf914e05a1ea8893addfc8d9dbc39c81c7a37e6456b764b003fb6e
+  data.tar.gz: c133eff3296f9938f5ad1fc5da81ba3c5a11a48add44f3ce240b33289b3468d2e93bb0ef310db3fd79e375bfa66b78e7e98eb28189fcf7a68d282a436fcb5256

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 STDIO Ltd.
+
+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,327 @@
+# CompanyEnrich Ruby SDK
+
+[![Gem Version](https://img.shields.io/gem/v/companyenrich)](https://rubygems.org/gems/companyenrich)
+
+The official Ruby client for the [CompanyEnrich API](https://companyenrich.com): company and people enrichment, filter, semantic and lookalike search, work emails, and bulk jobs.
+
+It requires Ruby 3.1 or newer and has no runtime dependencies.
+
+## Install
+
+```sh
+gem install companyenrich
+```
+
+Or add it to your `Gemfile`:
+
+```
+gem "companyenrich"
+```
+
+## Quick start
+
+Create an API key in your [dashboard](https://companyenrich.com/dashboard) and keep it secret.
+
+```ruby
+require "companyenrich"
+
+# Reads COMPANYENRICH_API_KEY from the environment, or pass api_key: "your-api-key".
+client = CompanyEnrich::Client.new
+
+company = client.companies.enrich("stripe.com")
+puts company["name"], company["employees"]
+```
+
+Responses are plain hashes with the API's field names as string keys. Optional fields can be absent or `nil`.
+
+Method arguments are `snake_case` keywords. Hashes you pass, such as `filter`, use the API's own field names.
+
+## Companies
+
+```ruby
+# Add paid data to a lookup. Each expansion costs extra credits.
+detailed = client.companies.enrich("stripe.com", expand: %w[technologies workforce])
+
+# Up to 50 domains at once. Check each item's status.
+batch = client.companies.enrich_batch(["stripe.com", "adyen.com"])
+batch["items"].each do |item|
+  puts item["domain"], item.dig("company", "name") if item["status"] == "found"
+end
+
+# Filter search
+page = client.companies.search(
+  filter: { country: "US", employees: ["51-200", "201-500"], categories: "saas" },
+  page_size: 25
+)
+puts page["items"].size, page["nextCursor"]
+
+# Free count of the same query
+total = client.companies.count(filter: { country: "US" })
+puts total["count"]
+```
+
+## People
+
+```ruby
+results = client.people.search(
+  filter: { domain: "stripe.com", seniority: %w[c-suite founder] },
+  page_size: 10
+)
+
+person = client.people.enrich("jane@stripe.com")
+
+lookup = client.people.find_email(person["id"], domain: "stripe.com")
+puts lookup["email"], lookup["certainty"] if lookup["status"] == "found"
+```
+
+## Semantic and lookalike search
+
+Semantic search finds companies or people from a plain-language description. Lookalike search finds companies similar to ones you already know. A company search can use either mode but not both, and either can be combined with `filter`. `search_all` accepts the same arguments as `search`.
+
+| Search | Credits per result |
+| --- | --- |
+| Companies by filters | 1 |
+| Companies by description | 2 |
+| Lookalike companies | 5 |
+| People, in any mode | 2 |
+
+Paid expansions cost extra, and an empty result costs one result's base price. To try a query for free, pass the same arguments to `companies.preview` or `people.preview`, which need a plan with previews.
+
+### Companies by description
+
+By default, the API reads attributes such as location and size from your query and applies them. `interpretation` shows what it inferred.
+
+```ruby
+results = client.companies.search(
+  semantic: { query: "saas companies in Turkey" },
+  page_size: 25
+)
+
+results["items"].each do |company|
+  puts company["domain"], company["description"]
+end
+
+p results.dig("interpretation", "filter") # Inferred filters, such as the country
+p results.dig("interpretation", "boost") # Inferred ranking boosts, such as the category
+```
+
+Filters you pass take priority over inferred values of the same kind. Set `autoFilter: false` to turn inference off, or set `weight` (0 to 1) to control how much semantic similarity affects ranking.
+
+```ruby
+filtered = client.companies.search(
+  semantic: { query: "AI tools for hospitals", autoFilter: false },
+  filter: { country: "US", employees: ["51-200", "201-500"] },
+  page_size: 25
+)
+```
+
+### Lookalike companies
+
+Pass 1 to 10 seed domains. Use `minScore` (0 to 1) to require a minimum similarity.
+
+```ruby
+similar = client.companies.search(
+  lookalike: { domains: ["stripe.com", "adyen.com"] },
+  filter: { country: "US", employees: ["51-200", "201-500"] },
+  page_size: 25
+)
+
+scores = similar["scores"] || {} # Scores are not probabilities
+similar["items"].each do |company|
+  puts company["domain"], scores[company["id"]]
+end
+```
+
+Keep results in the order returned rather than sorting them by score.
+
+### People by description
+
+The API turns your query into person filters, such as role, seniority and country, plus a description of their current companies. `interpretation` shows both. A query it can't infer any filters from is rejected with an error, so include something concrete like a role or location.
+
+```ruby
+people = client.people.search(
+  semantic: { query: "marketing leaders at Series B fintech startups in London" },
+  page_size: 25
+)
+
+people["items"].each do |person|
+  puts person["name"], person["position"]
+end
+
+p people["interpretation"] # The inferred filters and company description
+```
+
+### People at matching companies
+
+Use `company` to find people by the kind of company they work at. These searches cover people at the 1,000 best-matching companies.
+
+```ruby
+# Executives at companies matching a description
+executives = client.people.search(
+  filter: { seniority: %w[c-suite vp] },
+  company: { semantic: { query: "AI tools for hospitals" } },
+  page_size: 25
+)
+
+# Executives at companies similar to your best customers
+similar_teams = client.people.search(
+  filter: { seniority: %w[c-suite vp] },
+  company: { lookalike: { domains: ["stripe.com", "adyen.com"] } },
+  page_size: 25
+)
+```
+
+## Pagination
+
+`search` returns one page. The `*_all` methods take a block, or return a lazy `Enumerator` that requests pages as you consume them.
+
+```ruby
+client.companies.search_all(filter: { country: "TR" }, page_size: 100) do |company|
+  puts company["domain"]
+end
+
+first_ten = client.people.search_all(filter: { domain: "stripe.com" }, page_size: 10).first(10)
+```
+
+These are available as `companies.search_all`, `people.search_all`, `batches.list_all`, and `geo.search_countries_all`, `geo.search_states_all` and `geo.search_cities_all`.
+
+Search credits are charged for every result on a fetched page, even if you stop iterating partway through it. Set `page_size` close to the number of results you plan to use.
+
+## Bulk jobs
+
+Bulk enrichment and search exports run in the background.
+
+```ruby
+job = client.companies.bulk_enrichment.create(["stripe.com", "adyen.com"])
+
+client.batches.wait_for_completion(job["id"]) do |batch|
+  puts "#{batch['progress']['succeeded']}/#{batch['progress']['total']}"
+end
+
+client.companies.bulk_enrichment.stream(job["id"]) do |record|
+  puts record["domain"], record.dig("company", "name") if record["success"]
+end
+```
+
+`companies.bulk_enrichment`, `companies.search_export` and `people.search_export` share the same methods:
+
+| Method | Returns |
+| --- | --- |
+| `create(...)` | The new batch's status |
+| `stream(id)` | Each record in turn, best for large jobs |
+| `results(id)` | One JSON document with every record |
+| `csv(id)` | The CSV as a string |
+| `csv_chunks(id)` | The CSV as raw bytes, for writing to a file |
+
+## Errors
+
+Failed requests raise a subclass of `CompanyEnrich::APIError`, which carries `status`, `title`, `detail`, `errors` (field-level validation messages) and `trace_id` (include it when contacting support).
+
+```ruby
+begin
+  client.companies.enrich("example.invalid")
+rescue CompanyEnrich::NotFoundError
+  puts "No company found"
+rescue CompanyEnrich::PaymentRequiredError
+  puts "Out of credits, or not included in this plan"
+rescue CompanyEnrich::APIError => e
+  puts e.status, e.detail, e.trace_id
+end
+```
+
+| Status | Class |
+| --- | --- |
+| 400 | `BadRequestError` |
+| 401 | `AuthenticationError` |
+| 402 | `PaymentRequiredError` |
+| 403 | `PermissionDeniedError` |
+| 404 | `NotFoundError` |
+| 422 | `ValidationError` |
+| 429 | `RateLimitError` |
+| 5xx | `ServerError` |
+| Other | `APIError` |
+
+`APIConnectionError` and `APITimeoutError` cover requests that never received a response or were cut off. Everything above extends `CompanyEnrich::Error`.
+
+## Retries and timeouts
+
+Failed requests are retried up to twice with exponential backoff.
+
+| Failure | GET and free POST endpoints | Other POST endpoints |
+| --- | --- | --- |
+| 429 rate limit | Retried | Retried |
+| 408, 5xx, connection error, timeout | Retried | Not retried |
+
+POST requests that consume credits or start a job are not repeated after an ambiguous failure, because the first attempt may already have been charged or created a batch. A download that fails partway through is never restarted, so you won't receive duplicate records.
+
+## Configuration
+
+```ruby
+configured = CompanyEnrich::Client.new(api_key: "your-api-key", timeout: 30, max_retries: 4)
+
+# Every method accepts per-request options.
+configured.me(options: { timeout: 5, max_retries: 0 })
+```
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `api_key` | `COMPANYENRICH_API_KEY` | Your API key |
+| `base_url` | `https://api.companyenrich.com` | API origin, for proxies |
+| `timeout` | `120` | Timeout in seconds. `nil` disables it |
+| `max_retries` | `2` | Retries after the first attempt |
+| `default_headers` | none | Headers added to every request |
+
+Each request uses its own connection, so one client can be shared across threads.
+
+## API reference
+
+| SDK method | Endpoint |
+| --- | --- |
+| `companies.get(id)` | `GET /v2/companies/{companyId}` |
+| `companies.enrich(domain)` | `GET /v2/companies/enrich` |
+| `companies.enrich_by_properties(...)` | `POST /v2/companies/enrich` |
+| `companies.enrich_batch(domains)` | `POST /v2/companies/enrich/batch` |
+| `companies.autocomplete(query)` | `GET /v2/companies/autocomplete` |
+| `companies.workforce(...)` | `GET /v2/companies/workforce` |
+| `companies.search(...)` | `POST /v2/companies/search` |
+| `companies.count(...)` | `POST /v2/companies/search/count` |
+| `companies.preview(...)` | `POST /v2/companies/search/preview` |
+| `companies.bulk_enrichment.*` | `/v2/companies/enrich/bulk` |
+| `companies.search_export.*` | `/v2/companies/search/export` |
+| `people.get(id)` | `GET /v2/people/{personId}` |
+| `people.enrich(email)` | `POST /v2/people/enrich` |
+| `people.find_email(id)` | `GET /v2/people/{personId}/email` |
+| `people.search(...)` | `POST /v2/people/search` |
+| `people.count(...)` | `POST /v2/people/search/count` |
+| `people.preview(...)` | `POST /v2/people/search/preview` |
+| `people.search_export.*` | `/v2/people/search/export` |
+| `batches.list(...)` | `GET /v2/batches` |
+| `batches.get(id)` | `GET /v2/batches/{id}` |
+| `batches.cancel(id)` | `POST /v2/batches/{id}/cancel` |
+| `batches.raw_results(id)` | `GET /v2/batches/{id}/results` |
+| `batches.wait_for_completion(id)` | Polls `GET /v2/batches/{id}` |
+| `geo.regions` | `GET /v2/geo/regions` |
+| `geo.country(code)` | `GET /v2/geo/countries/{countryCode}` |
+| `geo.search_countries(...)` | `POST /v2/geo/countries` |
+| `geo.search_states(...)` | `POST /v2/geo/states` |
+| `geo.search_cities(...)` | `POST /v2/geo/cities` |
+| `industries.list` | `GET /v2/industries` |
+| `keywords.autocomplete(query)` | `GET /v2/keywords/autocomplete` |
+| `technologies.autocomplete(query)` | `GET /v2/technologies/autocomplete` |
+| `positions.autocomplete(query)` | `GET /v2/positions/autocomplete` |
+| `me` | `GET /v2/me` |
+
+See the [API documentation](https://api.companyenrich.com/openapi/v2.json) for parameters and credit costs.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake
+```
+
+To release, bump `VERSION` in `lib/companyenrich/version.rb` and push to `main`. The publish workflow runs the checks and publishes that version to RubyGems if it is new.
+
+## License
+
+MIT

data/lib/companyenrich/client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "http_client"
+require_relative "resources/batches"
+require_relative "resources/companies"
+require_relative "resources/geo"
+require_relative "resources/people"
+require_relative "resources/reference"
+
+module CompanyEnrich
+  # Client for the CompanyEnrich API.
+  class Client
+    attr_reader :companies, :people, :batches, :geo, :industries, :keywords, :technologies, :positions
+
+    # @param api_key [String, nil] defaults to the +COMPANYENRICH_API_KEY+ environment variable
+    # @param base_url [String] API origin, for proxies
+    # @param timeout [Numeric, nil] timeout in seconds for each attempt. +nil+ disables it.
+    # @param max_retries [Integer] how many times to retry a failed request
+    # @param default_headers [Hash, nil] headers sent with every request
+    def initialize(api_key: nil, base_url: HTTPClient::DEFAULT_BASE_URL, timeout: HTTPClient::DEFAULT_TIMEOUT,
+                   max_retries: HTTPClient::DEFAULT_MAX_RETRIES, default_headers: nil)
+      @http = HTTPClient.new(
+        api_key: api_key, base_url: base_url, timeout: timeout,
+        max_retries: max_retries, default_headers: default_headers
+      )
+      @companies = Resources::Companies.new(@http)
+      @people = Resources::People.new(@http)
+      @batches = Resources::Batches.new(@http)
+      @geo = Resources::Geo.new(@http)
+      @industries = Resources::Industries.new(@http)
+      @keywords = Resources::Autocomplete.new(@http, "/v2/keywords/autocomplete")
+      @technologies = Resources::Autocomplete.new(@http, "/v2/technologies/autocomplete")
+      @positions = Resources::Autocomplete.new(@http, "/v2/positions/autocomplete")
+    end
+
+    # Returns the authenticated user, including credit balance and plan capabilities. Free.
+    def me(options: nil)
+      @http.request("GET", "/v2/me", options: options)
+    end
+  end
+end

data/lib/companyenrich/errors.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module CompanyEnrich
+  # Base class for every error raised by this SDK.
+  class Error < StandardError; end
+
+  # The request never produced a response, for example because of a DNS or socket failure.
+  class APIConnectionError < Error; end
+
+  # The request, or a +batches.wait_for_completion+ call, ran out of time.
+  class APITimeoutError < Error; end
+
+  # The API responded with a non-2xx status.
+  class APIError < Error
+    # @return [Integer] the HTTP status
+    attr_reader :status
+    # @return [Hash{String => String}] response headers, with lowercase names
+    attr_reader :headers
+    # @return [Object] the parsed response body, or the raw text if it was not JSON
+    attr_reader :body
+    # @return [Hash{String => Array<String>}, nil] field-level validation messages
+    attr_reader :errors
+    # @return [String, nil] value of the +x-trace-id+ header. Include it in support requests.
+    attr_reader :trace_id
+    attr_reader :type, :title, :detail, :instance
+
+    def initialize(status:, headers:, body:)
+      problem = body.is_a?(Hash) ? body : {}
+      super(self.class.format_message(status, problem))
+      @status = status
+      @headers = headers
+      @body = body
+      @type = problem["type"]
+      @title = problem["title"]
+      @detail = problem["detail"]
+      @instance = problem["instance"]
+      @errors = problem["errors"]
+      @trace_id = headers["x-trace-id"]
+    end
+
+    def self.format_message(status, problem)
+      summary = [problem["title"], problem["detail"]].compact.reject(&:empty?).join(": ")
+      fields = (problem["errors"] || {}).map { |field, messages| "#{field}: #{messages.join(", ")}" }.join("; ")
+      [status.to_s, summary, fields.empty? ? nil : "(#{fields})"].compact.reject(&:empty?).join(" ")
+    end
+  end
+
+  # +400+: the request was malformed.
+  class BadRequestError < APIError; end
+
+  # +401+: the API key is missing or invalid.
+  class AuthenticationError < APIError; end
+
+  # +402+: the account is out of credits or its plan does not include this request.
+  class PaymentRequiredError < APIError; end
+
+  # +403+: the API key may not perform this request.
+  class PermissionDeniedError < APIError; end
+
+  # +404+: the company, person, or batch does not exist.
+  class NotFoundError < APIError; end
+
+  # +422+: the request failed validation. See {APIError#errors}.
+  class ValidationError < APIError; end
+
+  # +429+: a rate limit was exceeded and automatic retries did not resolve it.
+  class RateLimitError < APIError; end
+
+  # +5xx+: the API failed to process the request.
+  class ServerError < APIError; end
+
+  ERRORS_BY_STATUS = {
+    400 => BadRequestError,
+    401 => AuthenticationError,
+    402 => PaymentRequiredError,
+    403 => PermissionDeniedError,
+    404 => NotFoundError,
+    422 => ValidationError,
+    429 => RateLimitError
+  }.freeze
+  private_constant :ERRORS_BY_STATUS
+
+  # @api private
+  def self.api_error(status:, headers:, body:)
+    fallback = status >= 500 ? ServerError : APIError
+    ERRORS_BY_STATUS.fetch(status, fallback).new(status: status, headers: headers, body: body)
+  end
+end

data/lib/companyenrich/http_client.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "time"
+require "uri"
+require "zlib"
+
+require_relative "errors"
+require_relative "ndjson_decoder"
+require_relative "version"
+
+module CompanyEnrich
+  # Sends requests, applies the retry policy, and maps failures to SDK errors.
+  # @api private
+  class HTTPClient
+    DEFAULT_BASE_URL = "https://api.companyenrich.com"
+    DEFAULT_TIMEOUT = 120
+    DEFAULT_MAX_RETRIES = 2
+
+    BASE_BACKOFF = 0.5
+    MAX_BACKOFF = 8.0
+    MAX_SERVER_REQUESTED_WAIT = 60.0
+    RETRYABLE_STATUSES = [408, 500, 502, 503, 504].freeze
+    TIMESPAN = /\A(\d+):(\d{2}):(\d{2}(?:\.\d+)?)\z/
+
+    TIMEOUT_ERRORS = [Timeout::Error, Errno::ETIMEDOUT].freeze
+    TRANSPORT_ERRORS = [
+      *TIMEOUT_ERRORS, SocketError, SystemCallError, IOError, OpenSSL::SSL::SSLError,
+      Net::ProtocolError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Zlib::Error
+    ].freeze
+
+    def initialize(api_key:, base_url:, timeout:, max_retries:, default_headers:)
+      @api_key = api_key || ENV.fetch("COMPANYENRICH_API_KEY", nil)
+      if @api_key.nil? || @api_key.empty?
+        raise Error, "Missing API key. Pass `api_key:` or set the COMPANYENRICH_API_KEY environment variable."
+      end
+
+      @base_uri = URI.parse(base_url.sub(%r{/+\z}, ""))
+      @timeout = timeout
+      @max_retries = max_retries
+      @default_headers = default_headers
+    end
+
+    # Keeps the API key out of logs and error messages.
+    def inspect
+      "#<#{self.class} base_url=#{@base_uri}>"
+    end
+
+    # Sends a request and parses the JSON response.
+    def request(method, path, query: nil, body: nil, retry_safe: nil, options: nil)
+      execute(method, path, query, body, retry_safe, options, accept: "application/json") do |response|
+        parse_json(response.read_body, response.code.to_i)
+      end
+    end
+
+    # Sends a GET request and yields the response body as it arrives.
+    def stream_chunks(path, query: nil, options: nil, &block)
+      execute("GET", path, query, nil, nil, options, accept: "*/*", stream: true) do |response|
+        read_chunks(response, &block)
+      end
+    end
+
+    # Sends a GET request to an NDJSON endpoint and yields one parsed record per line.
+    def stream_ndjson(path, query: nil, options: nil)
+      decoder = NdjsonDecoder.new
+      stream_chunks(path, query: query, options: options) do |chunk|
+        decoder.feed(chunk).each { |record| yield record }
+      end
+      decoder.flush.each { |record| yield record }
+    end
+
+    def pause(seconds)
+      sleep(seconds)
+    end
+
+    private
+
+    def execute(method, path, query, body, retry_safe, options, accept:, stream: false)
+      options ||= {}
+      max_retries = options.fetch(:max_retries, @max_retries)
+      safe = retry_safe.nil? ? method == "GET" : retry_safe
+      attempt = 0
+      streaming = false
+
+      begin
+        connect(options.fetch(:timeout, @timeout)) do |http|
+          http.request(build_request(method, path, query, body, options, accept)) do |response|
+            raise_for_status(response)
+            # Once records have been handed over, repeating the download would duplicate them.
+            streaming = stream
+            return yield(response)
+          end
+        end
+      rescue APIError, *TRANSPORT_ERRORS => e
+        raise if streaming
+
+        failure = normalize_failure(e)
+        delay = retry_delay(failure, attempt, safe)
+        raise failure if delay.nil? || attempt >= max_retries
+
+        pause(delay)
+        attempt += 1
+        retry
+      end
+    end
+
+    def connect(timeout, &)
+      Net::HTTP.start(
+        @base_uri.host, @base_uri.port,
+        use_ssl: @base_uri.scheme == "https",
+        open_timeout: timeout, read_timeout: timeout, write_timeout: timeout,
+        # Retries follow this SDK's policy only, so a request is never repeated behind its back.
+        max_retries: 0,
+        # By default Net::HTTP accepts a truncated body as complete, which would silently lose records.
+        ignore_eof: false,
+        &
+      )
+    end
+
+    def build_request(method, path, query, body, options, accept)
+      request_class = method == "POST" ? Net::HTTP::Post : Net::HTTP::Get
+      request = request_class.new(request_target(path, query), request_headers(accept, body, options))
+      if body
+        request.body = JSON.generate(body)
+      elsif method == "POST"
+        request["Content-Length"] = "0"
+        # Net::HTTP would otherwise label an empty POST as a submitted form.
+        request["Content-Type"] = "application/json"
+      end
+      request
+    end
+
+    def request_target(path, query)
+      target = "#{@base_uri.path}#{path}"
+      pairs = (query || {}).flat_map do |key, value|
+        next [] if value.nil?
+
+        Array(value).map { |item| [key.to_s, item.to_s] }
+      end
+      pairs.empty? ? target : "#{target}?#{URI.encode_www_form(pairs)}"
+    end
+
+    def request_headers(accept, body, options)
+      headers = {
+        "accept" => accept,
+        "authorization" => "Bearer #{@api_key}",
+        "user-agent" => "companyenrich-ruby/#{VERSION}"
+      }
+      headers["content-type"] = "application/json" if body
+      [@default_headers, options[:headers]].compact.each do |extra|
+        extra.each { |name, value| headers[name.to_s.downcase] = value }
+      end
+      headers
+    end
+
+    def raise_for_status(response)
+      status = response.code.to_i
+      return if status.between?(200, 299)
+
+      raise CompanyEnrich.api_error(
+        status: status, headers: response_headers(response), body: parse_error_body(response.read_body)
+      )
+    end
+
+    def response_headers(response)
+      response.to_hash.transform_values { |values| values.join(", ") }
+    end
+
+    # Hands each chunk to the caller. Network failures become SDK errors, while exceptions
+    # raised by the caller's own block pass through unchanged.
+    def read_chunks(response)
+      caller_failure = nil
+      response.read_body do |chunk|
+        yield chunk
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        caller_failure = e
+        raise
+      end
+    rescue *TRANSPORT_ERRORS => e
+      raise if e.equal?(caller_failure)
+      raise APITimeoutError, "Download timed out: #{e.message}" if timeout_error?(e)
+
+      raise APIConnectionError, "Download was interrupted: #{e.message}"
+    end
+
+    def normalize_failure(error)
+      return error if error.is_a?(APIError)
+
+      if timeout_error?(error)
+        APITimeoutError.new("Request timed out: #{error.message}")
+      else
+        APIConnectionError.new("Could not reach the CompanyEnrich API: #{error.message}")
+      end
+    end
+
+    def timeout_error?(error)
+      TIMEOUT_ERRORS.any? { |type| error.is_a?(type) }
+    end
+
+    # @return [Numeric, nil] how long to wait before retrying, or nil if the request must not be retried
+    def retry_delay(failure, attempt, safe)
+      return safe ? backoff(attempt) : nil unless failure.is_a?(APIError)
+
+      status = failure.status
+      # A 429 is rejected before any work happens, so it is safe to repeat for every request.
+      return nil unless status == 429 || (safe && RETRYABLE_STATUSES.include?(status))
+
+      requested = parse_retry_after(failure.headers["retry-after"])
+      requested ||= parse_timespan(failure.headers["x-ratelimit-window"]) if status == 429
+      return backoff(attempt) if requested.nil?
+
+      requested <= MAX_SERVER_REQUESTED_WAIT ? requested : nil
+    end
+
+    def backoff(attempt)
+      ceiling = [MAX_BACKOFF, BASE_BACKOFF * (2**attempt)].min
+      ceiling * (0.75 + (rand * 0.25))
+    end
+
+    def parse_retry_after(value)
+      return nil if value.nil? || value.empty?
+
+      [Float(value), 0.0].max
+    rescue ArgumentError
+      begin
+        [Time.httpdate(value) - Time.now, 0.0].max
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Parses a .NET TimeSpan such as 00:00:35.7551671 into seconds.
+    def parse_timespan(value)
+      match = TIMESPAN.match(value.to_s)
+      return nil unless match
+
+      (match[1].to_i * 3600) + (match[2].to_i * 60) + match[3].to_f
+    end
+
+    def parse_json(content, status)
+      return nil if content.nil? || content.empty?
+
+      JSON.parse(content)
+    rescue JSON::ParserError
+      raise Error, "The API returned an invalid JSON response (status #{status})"
+    end
+
+    def parse_error_body(content)
+      text = content.to_s.dup.force_encoding(Encoding::UTF_8).scrub
+      JSON.parse(text)
+    rescue JSON::ParserError
+      text
+    end
+  end
+end

data/lib/companyenrich/ndjson_decoder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "errors"
+
+module CompanyEnrich
+  # Splits a byte stream into JSON records, keeping partial lines between chunks.
+  # @api private
+  class NdjsonDecoder
+    def initialize
+      @buffer = String.new(encoding: Encoding::BINARY)
+    end
+
+    # @return [Array] the records completed by this chunk
+    def feed(chunk)
+      @buffer << chunk.b
+      lines = @buffer.split("\n", -1)
+      @buffer = lines.pop || String.new(encoding: Encoding::BINARY)
+      parse(lines)
+    end
+
+    # @return [Array] the final record, if the stream did not end with a newline
+    def flush
+      rest = @buffer
+      @buffer = String.new(encoding: Encoding::BINARY)
+      parse([rest])
+    end
+
+    private
+
+    def parse(lines)
+      lines.reject { |line| line.strip.empty? }.map do |line|
+        JSON.parse(line.dup.force_encoding(Encoding::UTF_8))
+      rescue JSON::ParserError
+        raise Error, "The API returned an invalid NDJSON record"
+      end
+    end
+  end
+end

data/lib/companyenrich/resources/batch_job.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "support"
+
+module CompanyEnrich
+  module Resources
+    # An asynchronous job: create it, wait with +batches.wait_for_completion+, then download its results.
+    class BatchJob
+      # @api private
+      def initialize(http, path)
+        @http = http
+        @path = path
+      end
+
+      # Downloads every settled record as one JSON document.
+      def results(batch_id, sig: nil, options: nil)
+        @http.request("GET", results_path(batch_id), query: { format: "json", sig: sig }, options: options)
+      end
+
+      # Streams settled records one at a time. Prefer this for large jobs.
+      # @return [Enumerator] when no block is given
+      def stream(batch_id, sig: nil, options: nil, &block)
+        enumerator = Enumerator.new do |yielder|
+          query = { format: "ndjson", sig: sig }
+          @http.stream_ndjson(results_path(batch_id), query: query, options: options) do |record|
+            yielder << record
+          end
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      # Downloads the results as CSV text. Use {#csv_chunks} for large jobs.
+      # @return [String]
+      def csv(batch_id, sig: nil, options: nil)
+        csv_chunks(batch_id, sig: sig, options: options).to_a.join
+                                                        .force_encoding(Encoding::UTF_8).delete_prefix("")
+      end
+
+      # Yields the CSV download as raw bytes, for example to write it to a file.
+      # @return [Enumerator] when no block is given
+      def csv_chunks(batch_id, sig: nil, options: nil, &block)
+        enumerator = Enumerator.new do |yielder|
+          query = { format: "csv", sig: sig }
+          @http.stream_chunks(results_path(batch_id), query: query, options: options) do |chunk|
+            yielder << chunk
+          end
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      private
+
+      def create_job(body, options)
+        @http.request("POST", @path, body: body.compact, options: options)
+      end
+
+      def results_path(batch_id)
+        "#{@path}/#{Support.escape(batch_id)}/results"
+      end
+    end
+  end
+end

data/lib/companyenrich/resources/batches.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "support"
+
+module CompanyEnrich
+  module Resources
+    class Batches
+      DEFAULT_POLL_INTERVAL = 2.0
+
+      # @api private
+      def initialize(http)
+        @http = http
+      end
+
+      # Returns one page of your batches, newest first.
+      def list(kind: nil, page_size: nil, cursor: nil, options: nil)
+        @http.request("GET", "/v2/batches", query: { kind: kind, pageSize: page_size, cursor: cursor },
+                                            options: options)
+      end
+
+      # Iterates over all of your batches, newest first.
+      # @return [Enumerator] when no block is given
+      def list_all(kind: nil, page_size: nil, cursor: nil, options: nil, &block)
+        enumerator = Support.paginate(cursor) do |next_cursor|
+          list(kind: kind, page_size: page_size, cursor: next_cursor, options: options)
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      # Retrieves a batch's status and progress.
+      def get(batch_id, options: nil)
+        @http.request("GET", "/v2/batches/#{Support.escape(batch_id)}", options: options)
+      end
+
+      # Stops remaining work. Results that were already charged stay downloadable.
+      def cancel(batch_id, options: nil)
+        @http.request("POST", "/v2/batches/#{Support.escape(batch_id)}/cancel", retry_safe: true, options: options)
+      end
+
+      # Streams the raw HTTP outcome of each request in the batch.
+      # @return [Enumerator] when no block is given
+      def raw_results(batch_id, sig: nil, options: nil, &block)
+        enumerator = Enumerator.new do |yielder|
+          path = "/v2/batches/#{Support.escape(batch_id)}/results"
+          @http.stream_ndjson(path, query: { sig: sig }, options: options) { |record| yielder << record }
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      # Polls until the batch is +completed+ or +cancelled+, then returns its final status.
+      # Yields the latest status after every check. Raises {APITimeoutError} if +timeout+ seconds
+      # pass first, and waits indefinitely by default.
+      def wait_for_completion(batch_id, poll_interval: DEFAULT_POLL_INTERVAL, timeout: nil, options: nil)
+        deadline = timeout && (now + timeout)
+        while true # rubocop:disable Style/InfiniteLoop
+          batch = get(batch_id, options: options)
+          yield batch if block_given?
+          return batch if %w[completed cancelled].include?(batch["status"])
+
+          wait = poll_interval
+          if deadline
+            remaining = deadline - now
+            raise APITimeoutError, "Batch #{batch_id} did not finish within #{timeout} seconds" if remaining <= 0
+
+            wait = [poll_interval, remaining].min
+          end
+          @http.pause(wait)
+        end
+      end
+
+      private
+
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/companyenrich/resources/companies.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "batch_job"
+require_relative "support"
+
+module CompanyEnrich
+  module Resources
+    # Asynchronous enrichment of up to 10,000 domains.
+    class CompanyBulkEnrichment < BatchJob
+      # Starts the job. It runs in the background and consumes credits as it progresses.
+      def create(domains, expand: nil, wait_for_enrichment: nil, options: nil)
+        create_job({ domains: domains, expand: expand, waitForEnrichment: wait_for_enrichment }, options)
+      end
+    end
+
+    # Asynchronous export of a company search.
+    class CompanySearchExport < BatchJob
+      # Starts the export. It runs in the background and consumes credits as it progresses.
+      def create(limit, filter: nil, semantic: nil, lookalike: nil, expand: nil, options: nil)
+        create_job({ limit: limit, filter: filter, semantic: semantic, lookalike: lookalike, expand: expand }, options)
+      end
+    end
+
+    class Companies
+      # @return [CompanyBulkEnrichment]
+      attr_reader :bulk_enrichment
+      # @return [CompanySearchExport]
+      attr_reader :search_export
+
+      # @api private
+      def initialize(http)
+        @http = http
+        @bulk_enrichment = CompanyBulkEnrichment.new(http, "/v2/companies/enrich/bulk")
+        @search_export = CompanySearchExport.new(http, "/v2/companies/search/export")
+      end
+
+      # Retrieves a stored company by its CompanyEnrich ID.
+      def get(company_id, expand: nil, options: nil)
+        @http.request("GET", "/v2/companies/#{Support.escape(company_id)}", query: { expand: expand }, options: options)
+      end
+
+      # Enriches a company by domain. Raises {NotFoundError} when there is no match.
+      def enrich(domain, expand: nil, wait_for_enrichment: nil, options: nil)
+        query = { domain: domain, expand: expand, waitForEnrichment: wait_for_enrichment }
+        @http.request("GET", "/v2/companies/enrich", query: query, options: options)
+      end
+
+      # Enriches a company from identifying properties such as its name or LinkedIn URL.
+      def enrich_by_properties(name: nil, linkedin_url: nil, linkedin_id: nil, twitter_url: nil, facebook_url: nil,
+                               instagram_url: nil, youtube_url: nil, expand: nil, options: nil)
+        body = {
+          name: name, linkedinUrl: linkedin_url, linkedinId: linkedin_id, twitterUrl: twitter_url,
+          facebookUrl: facebook_url, instagramUrl: instagram_url, youtubeUrl: youtube_url, expand: expand
+        }.compact
+        @http.request("POST", "/v2/companies/enrich", body: body, options: options)
+      end
+
+      # Enriches up to 50 domains in one request.
+      def enrich_batch(domains, expand: nil, wait_for_enrichment: nil, options: nil)
+        body = { domains: domains, expand: expand, waitForEnrichment: wait_for_enrichment }.compact
+        @http.request("POST", "/v2/companies/enrich/batch", body: body, options: options)
+      end
+
+      # Suggests up to 10 companies whose domain matches +query+.
+      def autocomplete(query, options: nil)
+        @http.request("GET", "/v2/companies/autocomplete", query: { query: query }, options: options)
+      end
+
+      # Retrieves workforce insights for exactly one of +company_id+ or +domain+.
+      # Pass +nextCursor+ from the response as +cursor+ to go back another 12 months.
+      def workforce(company_id: nil, domain: nil, cursor: nil, options: nil)
+        raise ArgumentError, "Provide exactly one of `company_id:` or `domain:`." if company_id.nil? == domain.nil?
+
+        query = { id: company_id, domain: domain, cursor: cursor }
+        @http.request("GET", "/v2/companies/workforce", query: query, options: options)
+      end
+
+      # Returns one page of companies matching filters, a semantic query, or lookalike seeds.
+      def search(filter: nil, semantic: nil, lookalike: nil, page_size: nil, cursor: nil, expand: nil, options: nil)
+        body = {
+          filter: filter, semantic: semantic, lookalike: lookalike,
+          pageSize: page_size, cursor: cursor, expand: expand
+        }.compact
+        @http.request("POST", "/v2/companies/search", body: body, options: options)
+      end
+
+      # Iterates over every matching company, fetching pages as needed. Accepts the same arguments as {#search}.
+      # Credits are charged per page, so set +page_size+ close to what you will consume.
+      # @return [Enumerator] when no block is given
+      def search_all(cursor: nil, options: nil, **params, &block)
+        enumerator = Support.paginate(cursor) do |next_cursor|
+          search(**params, cursor: next_cursor, options: options)
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      # Counts matching companies. Free.
+      def count(filter: nil, semantic: nil, lookalike: nil, options: nil)
+        body = { filter: filter, semantic: semantic, lookalike: lookalike }.compact
+        @http.request("POST", "/v2/companies/search/count", body: body, retry_safe: true, options: options)
+      end
+
+      # Returns up to 25 company summaries. Free, but requires a plan with previews.
+      def preview(filter: nil, semantic: nil, lookalike: nil, options: nil)
+        body = { filter: filter, semantic: semantic, lookalike: lookalike }.compact
+        @http.request("POST", "/v2/companies/search/preview", body: body, retry_safe: true, options: options)
+      end
+    end
+  end
+end

data/lib/companyenrich/resources/geo.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "support"
+
+module CompanyEnrich
+  module Resources
+    # Geographic reference data for search filters. Every endpoint here is free.
+    class Geo
+      # @api private
+      def initialize(http)
+        @http = http
+      end
+
+      # Lists all regions and their country codes.
+      def regions(options: nil)
+        @http.request("GET", "/v2/geo/regions", options: options)
+      end
+
+      # Retrieves a country by its two-letter code.
+      def country(country_code, options: nil)
+        @http.request("GET", "/v2/geo/countries/#{Support.escape(country_code)}", options: options)
+      end
+
+      def search_countries(query: nil, page_size: nil, cursor: nil, options: nil)
+        search("/v2/geo/countries", { query: query, pageSize: page_size, cursor: cursor }, options)
+      end
+
+      # @return [Enumerator] when no block is given
+      def search_countries_all(cursor: nil, options: nil, **params, &block)
+        enumerator = Support.paginate(cursor) do |next_cursor|
+          search_countries(**params, cursor: next_cursor, options: options)
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      def search_states(country_codes: nil, query: nil, page_size: nil, cursor: nil, options: nil)
+        body = { countryCodes: country_codes, query: query, pageSize: page_size, cursor: cursor }
+        search("/v2/geo/states", body, options)
+      end
+
+      # @return [Enumerator] when no block is given
+      def search_states_all(cursor: nil, options: nil, **params, &block)
+        enumerator = Support.paginate(cursor) do |next_cursor|
+          search_states(**params, cursor: next_cursor, options: options)
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      def search_cities(state_ids: nil, country_codes: nil, query: nil, page_size: nil, cursor: nil, options: nil)
+        body = { stateIds: state_ids, countryCodes: country_codes, query: query, pageSize: page_size, cursor: cursor }
+        search("/v2/geo/cities", body, options)
+      end
+
+      # @return [Enumerator] when no block is given
+      def search_cities_all(cursor: nil, options: nil, **params, &block)
+        enumerator = Support.paginate(cursor) do |next_cursor|
+          search_cities(**params, cursor: next_cursor, options: options)
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      private
+
+      def search(path, body, options)
+        @http.request("POST", path, body: body.compact, retry_safe: true, options: options)
+      end
+    end
+  end
+end

data/lib/companyenrich/resources/people.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "batch_job"
+require_relative "support"
+
+module CompanyEnrich
+  module Resources
+    # Asynchronous export of a people search.
+    class PersonSearchExport < BatchJob
+      # Starts the export. It runs in the background and consumes credits as it progresses.
+      def create(limit, filter: nil, semantic: nil, company: nil, expand: nil, options: nil)
+        create_job({ limit: limit, filter: filter, semantic: semantic, company: company, expand: expand }, options)
+      end
+    end
+
+    class People
+      # @return [PersonSearchExport]
+      attr_reader :search_export
+
+      # @api private
+      def initialize(http)
+        @http = http
+        @search_export = PersonSearchExport.new(http, "/v2/people/search/export")
+      end
+
+      # Retrieves a person by their CompanyEnrich ID.
+      def get(person_id, expand: nil, options: nil)
+        @http.request("GET", "/v2/people/#{Support.escape(person_id)}", query: { expand: expand }, options: options)
+      end
+
+      # Identifies a person from an email. Raises {NotFoundError} if there is no match.
+      def enrich(email, expand: nil, options: nil)
+        @http.request("POST", "/v2/people/enrich", body: { email: email, expand: expand }.compact, options: options)
+      end
+
+      # Finds a person's work email. Check +status+: only +found+ includes +email+.
+      def find_email(person_id, domain: nil, options: nil)
+        @http.request("GET", "/v2/people/#{Support.escape(person_id)}/email", query: { domain: domain },
+                                                                              options: options)
+      end
+
+      # Returns one page of people matching filters, a semantic query, or a company query.
+      def search(filter: nil, semantic: nil, company: nil, page_size: nil, cursor: nil, expand: nil, options: nil)
+        body = {
+          filter: filter, semantic: semantic, company: company,
+          pageSize: page_size, cursor: cursor, expand: expand
+        }.compact
+        @http.request("POST", "/v2/people/search", body: body, options: options)
+      end
+
+      # Iterates over every matching person, fetching pages as needed. Accepts the same arguments as {#search}.
+      # Credits are charged per page, so set +page_size+ close to what you will consume.
+      # @return [Enumerator] when no block is given
+      def search_all(cursor: nil, options: nil, **params, &block)
+        enumerator = Support.paginate(cursor) do |next_cursor|
+          search(**params, cursor: next_cursor, options: options)
+        end
+        Support.iterate(enumerator, block)
+      end
+
+      # Counts matching people. Free.
+      def count(filter: nil, semantic: nil, company: nil, options: nil)
+        body = { filter: filter, semantic: semantic, company: company }.compact
+        @http.request("POST", "/v2/people/search/count", body: body, retry_safe: true, options: options)
+      end
+
+      # Returns up to 10 person summaries. Free, but requires a plan with previews.
+      def preview(filter: nil, semantic: nil, company: nil, options: nil)
+        body = { filter: filter, semantic: semantic, company: company }.compact
+        @http.request("POST", "/v2/people/search/preview", body: body, retry_safe: true, options: options)
+      end
+    end
+  end
+end

data/lib/companyenrich/resources/reference.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CompanyEnrich
+  module Resources
+    class Industries
+      # @api private
+      def initialize(http)
+        @http = http
+      end
+
+      # Lists all industries and their NAICS code prefixes. Free.
+      def list(options: nil)
+        @http.request("GET", "/v2/industries", options: options)
+      end
+    end
+
+    # Suggests up to 10 values for a search filter, ordered by popularity. Free.
+    class Autocomplete
+      # @api private
+      def initialize(http, path)
+        @http = http
+        @path = path
+      end
+
+      def autocomplete(query, options: nil)
+        @http.request("GET", @path, query: { query: query }, options: options)
+      end
+    end
+  end
+end

data/lib/companyenrich/resources/support.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module CompanyEnrich
+  module Resources
+    # Helpers shared by the resource classes.
+    # @api private
+    module Support
+      module_function
+
+      def escape(value)
+        ERB::Util.url_encode(value.to_s)
+      end
+
+      # Runs the enumerator with the caller's block, or returns it for lazy use.
+      def iterate(enumerator, block)
+        block ? enumerator.each(&block) : enumerator
+      end
+
+      # Builds a lazy enumerator that requests a page only when it is needed.
+      def paginate(first_cursor, &fetch_page)
+        Enumerator.new do |yielder|
+          cursor = first_cursor
+          fetching = true
+          while fetching
+            page = fetch_page.call(cursor)
+            page.fetch("items").each { |item| yielder << item }
+            cursor = page["nextCursor"]
+            fetching = !(cursor.nil? || cursor.empty?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/companyenrich/version.rb

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

data/lib/companyenrich.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "companyenrich/version"
+require_relative "companyenrich/errors"
+require_relative "companyenrich/client"
+
+# Official Ruby SDK for the CompanyEnrich API.
+module CompanyEnrich
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: companyenrich
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- CompanyEnrich
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Company and people enrichment, filter, semantic and lookalike search,
+  work emails, and bulk jobs through the CompanyEnrich API.
+email:
+- support@companyenrich.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/companyenrich.rb
+- lib/companyenrich/client.rb
+- lib/companyenrich/errors.rb
+- lib/companyenrich/http_client.rb
+- lib/companyenrich/ndjson_decoder.rb
+- lib/companyenrich/resources/batch_job.rb
+- lib/companyenrich/resources/batches.rb
+- lib/companyenrich/resources/companies.rb
+- lib/companyenrich/resources/geo.rb
+- lib/companyenrich/resources/people.rb
+- lib/companyenrich/resources/reference.rb
+- lib/companyenrich/resources/support.rb
+- lib/companyenrich/version.rb
+homepage: https://github.com/CompanyEnrich/companyenrich-ruby-sdk
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://companyenrich.com
+  source_code_uri: https://github.com/CompanyEnrich/companyenrich-ruby-sdk
+  bug_tracker_uri: https://github.com/CompanyEnrich/companyenrich-ruby-sdk/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Official Ruby SDK for the CompanyEnrich API.
+test_files: []