bigdatacloud 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 788fbb2ae51c6e2253342f4df3845af0f8b6d8663362315bfdd569598519d70c
+  data.tar.gz: 220e7a0a41738e2eeb45ba7313fc21b47ef7c7bc7fdf81bdb7fd9d8e5df27ce7
+SHA512:
+  metadata.gz: 8dfbecf1b39da4aaae11645bcac43ff00ca0aa213be216539b8c5912e9b21b9d8e40e0dcb6834e955e1aea4fdc9b5f2583a72b6a0d57382b09f2825fa4170280
+  data.tar.gz: c9021ebaa92728d4b745b922791071015eca9a831b66254912d0263887780d87198af386520a3e905a8265cfa9ae5c391c6beacba304a63f9989473b947fa31d

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to the `bigdatacloud` Ruby gem will be documented here.
+
+This project follows [Semantic Versioning](https://semver.org/).
+
+---
+
+## [1.0.0] - 2026-04-11
+
+### Initial Release
+- Full typed client with 4 API groups: IP Geolocation, Reverse Geocoding, Verification, Network Engineering
+- All 13 IP Geolocation endpoints covered
+- All 3 Reverse Geocoding endpoints covered
+- All 3 Verification endpoints covered (phone + email)
+- All 7 Network Engineering endpoints covered
+- `BigDataCloud::ConfidenceArea.split_into_polygons()` for multi-polygon confidence areas
+- `BigDataCloud::Client.from_environment` factory reading `BIGDATACLOUD_API_KEY`
+- `validate_phone` and `validate_phone_by_ip` require explicit country/IP — never silently uses server IP
+- Ruby 3.0+ required; tested on Ruby 4.0
+- Zero external dependencies — stdlib `net/http` + `json` only
+- 4 sample scripts verified against live API

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 BigDataCloud Pty 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 OF 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,114 @@
+# BigDataCloud Ruby SDK
+
+[![Gem Version](https://img.shields.io/gem/v/bigdatacloud)](https://rubygems.org/gems/bigdatacloud)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Ruby](https://img.shields.io/badge/Ruby-3.0%2B-red)](https://www.ruby-lang.org)
+
+Official Ruby SDK for [BigDataCloud](https://www.bigdatacloud.com) APIs. Strongly-typed client for IP Geolocation, Reverse Geocoding, Phone & Email Verification, and Network Engineering.
+
+Zero external dependencies — stdlib `net/http` and `json` only.
+
+## Installation
+
+```bash
+gem install bigdatacloud
+```
+
+Or add to your `Gemfile`:
+
+```ruby
+gem "bigdatacloud"
+```
+
+## API Key
+
+Get a free API key at [bigdatacloud.com/login](https://www.bigdatacloud.com/login). No credit card required.
+
+```bash
+export BIGDATACLOUD_API_KEY=your-key-here
+```
+
+## Quick Start
+
+```ruby
+require "bigdatacloud"
+
+# Reads BIGDATACLOUD_API_KEY from environment
+client = BigDataCloud::Client.from_environment
+
+# Or pass the key directly
+# client = BigDataCloud::Client.new("your-key-here")
+
+# IP Geolocation
+geo = client.ip_geolocation.get(ip: "1.1.1.1")
+puts "#{geo.location.city}, #{geo.country.name}"
+
+# Reverse Geocoding
+place = client.reverse_geocoding.reverse_geocode(-33.87, 151.21)
+puts "#{place.city}, #{place.country_name}"
+
+# Phone Validation — country_code is required
+phone = client.verification.validate_phone("+61412345678", "AU")
+puts "Valid: #{phone.is_valid}, Type: #{phone.line_type}"
+
+# Email Verification
+email = client.verification.verify_email("user@example.com")
+puts "Valid: #{email.is_valid}, Disposable: #{email.is_disposable}"
+```
+
+## Confidence Area
+
+The `confidence_area` field may encode multiple polygons. Use the helper:
+
+```ruby
+geo = client.ip_geolocation.get_with_confidence_area(ip: "1.1.1.1")
+polygons = BigDataCloud::ConfidenceArea.split_into_polygons(geo.confidence_area)
+polygons.each_with_index do |ring, i|
+  puts "Ring #{i + 1}: #{ring.size} points"
+end
+```
+
+## Available APIs
+
+| Client | Methods |
+|--------|---------|
+| `client.ip_geolocation` | `get`, `get_with_confidence_area`, `get_full`, `get_country_by_ip`, `get_country_info`, `get_all_countries`, `get_hazard_report`, `get_user_risk`, `get_asn_info`, `get_network_by_ip`, `get_timezone_by_iana_id`, `get_timezone_by_ip`, `parse_user_agent` |
+| `client.reverse_geocoding` | `reverse_geocode`, `reverse_geocode_with_timezone`, `get_timezone_by_location` |
+| `client.verification` | `validate_phone`, `validate_phone_by_ip`, `verify_email` |
+| `client.network_engineering` | `get_asn_info_full`, `get_receiving_from`, `get_transit_to`, `get_bgp_prefixes`, `get_networks_by_cidr`, `get_asn_rank_list`, `get_tor_exit_nodes` |
+
+## Phone Validation
+
+Both methods require explicit country context — never uses server IP silently:
+
+```ruby
+# You know the country
+phone = client.verification.validate_phone("+61412345678", "AU")
+
+# You know the end user's IP (pass their IP, not your server's)
+phone = client.verification.validate_phone_by_ip("0412345678", user_ip)
+```
+
+## Error Handling
+
+```ruby
+begin
+  geo = client.ip_geolocation.get(ip: "1.1.1.1")
+rescue BigDataCloud::Error => e
+  puts "API error #{e.status_code}: #{e.message}"
+end
+```
+
+## Samples
+
+```bash
+export BIGDATACLOUD_API_KEY=your-key-here
+ruby samples/ip_geolocation.rb
+ruby samples/reverse_geocoding.rb
+ruby samples/verification.rb
+ruby samples/network_engineering.rb
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/lib/bigdatacloud/api/ip_geolocation.rb

@@ -0,0 +1,94 @@
+module BigDataCloud
+  module Api
+    # IP Geolocation package — 13 endpoints.
+    class IpGeolocation
+      def initialize(http)
+        @http = http
+      end
+
+      # Returns geolocation data for an IP address. Pass nil to use the caller's IP.
+      def get(ip: nil, locality_language: "en")
+        Models::IpGeolocationResponse.new(
+          @http.get("ip-geolocation", { ip: ip, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns geolocation including confidence area polygon(s).
+      def get_with_confidence_area(ip: nil, locality_language: "en")
+        Models::IpGeolocationWithConfidenceAreaResponse.new(
+          @http.get("ip-geolocation-with-confidence", { ip: ip, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns full geolocation including confidence area and hazard report.
+      def get_full(ip: nil, locality_language: "en")
+        Models::IpGeolocationFullResponse.new(
+          @http.get("ip-geolocation-full", { ip: ip, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns country information for an IP address.
+      def get_country_by_ip(ip: nil, locality_language: "en")
+        data = @http.get("country-by-ip", { ip: ip, localityLanguage: locality_language })
+        Models::CountryInfo.new(data["country"] || data)
+      end
+
+      # Returns detailed information about a country by ISO code.
+      def get_country_info(country_code, locality_language: "en")
+        Models::CountryInfo.new(
+          @http.get("country-info", { code: country_code, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns a list of all countries with full details.
+      def get_all_countries(locality_language: "en")
+        data = @http.get("countries", { localityLanguage: locality_language })
+        Array(data).map { |c| Models::CountryInfo.new(c) }
+      end
+
+      # Returns a detailed hazard and threat report for an IP address.
+      def get_hazard_report(ip: nil)
+        Models::HazardReport.new(@http.get("hazard-report", { ip: ip }))
+      end
+
+      # Returns a risk assessment suitable for e-commerce and sign-up flows.
+      def get_user_risk(ip: nil)
+        Models::UserRisk.new(@http.get("user-risk", { ip: ip }))
+      end
+
+      # Returns short ASN information (no peers/transit lists).
+      def get_asn_info(asn, locality_language: "en")
+        Models::AsnInfoResponse.new(
+          @http.get("asn-info", { asn: asn, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns detailed network information for an IP address.
+      def get_network_by_ip(ip, locality_language: "en")
+        Models::NetworkByIpResponse.new(
+          @http.get("network-by-ip", { ip: ip, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns timezone information for an IANA timezone ID (e.g. "Australia/Sydney").
+      def get_timezone_by_iana_id(iana_time_zone_id)
+        Models::TimezoneResponse.new(
+          @http.get("timezone-info", { timeZoneId: iana_time_zone_id })
+        )
+      end
+
+      # Returns timezone information for an IP address.
+      def get_timezone_by_ip(ip: nil)
+        Models::TimezoneResponse.new(@http.get("timezone-by-ip", { ip: ip }))
+      end
+
+      # Parses a User-Agent string into device, OS and browser info.
+      def parse_user_agent(user_agent_string)
+        raise ArgumentError, "user_agent_string must not be empty" if user_agent_string.to_s.strip.empty?
+        Models::UserAgentResponse.new(
+          @http.get("user-agent-info", { userAgentRaw: user_agent_string })
+        )
+      end
+    end
+  end
+end

data/lib/bigdatacloud/api/network_engineering.rb

@@ -0,0 +1,59 @@
+module BigDataCloud
+  module Api
+    # Network Engineering package — 7 endpoints.
+    class NetworkEngineering
+      def initialize(http)
+        @http = http
+      end
+
+      # Returns extended ASN info including peers, transit, prefix counts, and service area.
+      def get_asn_info_full(asn, locality_language: "en")
+        Models::AsnInfoFullResponse.new(
+          @http.get("asn-info-full", { asn: asn, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns paginated upstream providers (ASNs this ASN receives traffic from).
+      def get_receiving_from(asn, batch_size: 25, offset: 0, locality_language: "en")
+        Models::AsnInfoFullResponse.new(
+          @http.get("asn-info-receiving-from", { asn: asn, batchSize: batch_size, offset: offset, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns paginated downstream peers (ASNs this ASN provides transit to).
+      def get_transit_to(asn, batch_size: 25, offset: 0, locality_language: "en")
+        Models::AsnInfoFullResponse.new(
+          @http.get("asn-info-transit-to", { asn: asn, batchSize: batch_size, offset: offset, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns paginated active BGP prefixes for an ASN. Set +ipv4: false+ for IPv6.
+      def get_bgp_prefixes(asn, ipv4: true, batch_size: 25, offset: 0)
+        Models::PrefixesListResponse.new(
+          @http.get("prefixes-list", { asn: asn, isv4: ipv4 ? "true" : "false", batchSize: batch_size, offset: offset })
+        )
+      end
+
+      # Returns all networks announced on BGP within a CIDR range.
+      def get_networks_by_cidr(cidr, locality_language: "en")
+        Models::NetworkByCidrResponse.new(
+          @http.get("network-by-cidr", { cidr: cidr, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns a paginated ranked list of all ASNs by IPv4 address space.
+      def get_asn_rank_list(batch_size: 15, offset: 0)
+        Models::AsnRankListResponse.new(
+          @http.get("asn-rank-list", { batchSize: batch_size, offset: offset })
+        )
+      end
+
+      # Returns a paginated list of active Tor exit nodes.
+      def get_tor_exit_nodes(batch_size: 25, offset: 0)
+        Models::TorExitNodesResponse.new(
+          @http.get("tor-exit-nodes-list", { batchSize: batch_size, offset: offset })
+        )
+      end
+    end
+  end
+end

data/lib/bigdatacloud/api/reverse_geocoding.rb

@@ -0,0 +1,31 @@
+module BigDataCloud
+  module Api
+    # Reverse Geocoding package — 3 endpoints.
+    class ReverseGeocoding
+      def initialize(http)
+        @http = http
+      end
+
+      # Converts GPS coordinates to city, locality, subdivision, and country.
+      def reverse_geocode(latitude, longitude, locality_language: "en")
+        Models::ReverseGeocodeResponse.new(
+          @http.get("reverse-geocode", { latitude: latitude, longitude: longitude, localityLanguage: locality_language })
+        )
+      end
+
+      # Converts GPS coordinates to locality and timezone in a single call.
+      def reverse_geocode_with_timezone(latitude, longitude, locality_language: "en")
+        Models::ReverseGeocodeWithTimezoneResponse.new(
+          @http.get("reverse-geocode-with-timezone", { latitude: latitude, longitude: longitude, localityLanguage: locality_language })
+        )
+      end
+
+      # Returns timezone information for GPS coordinates.
+      def get_timezone_by_location(latitude, longitude)
+        Models::TimezoneResponse.new(
+          @http.get("timezone-by-location", { latitude: latitude, longitude: longitude })
+        )
+      end
+    end
+  end
+end

data/lib/bigdatacloud/api/verification.rb

@@ -0,0 +1,42 @@
+module BigDataCloud
+  module Api
+    # Phone & Email Verification package — 3 endpoints.
+    class Verification
+      def initialize(http)
+        @http = http
+      end
+
+      # Validates a phone number. +country_code+ (e.g. "AU") is required.
+      # If you know the caller's IP but not their country, use #validate_phone_by_ip instead.
+      def validate_phone(phone_number, country_code)
+        raise ArgumentError, "phone_number must not be empty" if phone_number.to_s.strip.empty?
+        raise ArgumentError,
+              'country_code is required for validate_phone (e.g. "AU"). ' \
+              "If you know the caller's IP, use validate_phone_by_ip instead." if country_code.to_s.strip.empty?
+        Models::PhoneValidationResponse.new(
+          @http.get("phone-number-validate", { number: phone_number, countryCode: country_code })
+        )
+      end
+
+      # Validates a phone number using +ip+ for country detection.
+      # +ip+ must be the end user's IP address — never the server's.
+      def validate_phone_by_ip(phone_number, ip)
+        raise ArgumentError, "phone_number must not be empty" if phone_number.to_s.strip.empty?
+        raise ArgumentError,
+              "ip is required for validate_phone_by_ip — pass the end user's IP. " \
+              "If you know the country, use validate_phone instead." if ip.to_s.strip.empty?
+        Models::PhoneValidationResponse.new(
+          @http.get("phone-number-validate-by-ip", { number: phone_number, ip: ip })
+        )
+      end
+
+      # Verifies an email address — checks syntax, mail server, and disposable status.
+      def verify_email(email_address)
+        raise ArgumentError, "email_address must not be empty" if email_address.to_s.strip.empty?
+        Models::EmailVerificationResponse.new(
+          @http.get("email-verify", { emailAddress: email_address })
+        )
+      end
+    end
+  end
+end

data/lib/bigdatacloud/client.rb

@@ -0,0 +1,32 @@
+module BigDataCloud
+  # Official Ruby client for BigDataCloud APIs.
+  #
+  # Thread-safe — create once and reuse across your application.
+  #
+  # @example
+  #   client = BigDataCloud::Client.from_environment
+  #   geo = client.ip_geolocation.get(ip: "1.1.1.1")
+  #   puts "#{geo.location.city}, #{geo.country.name}"
+  class Client
+    attr_reader :ip_geolocation, :reverse_geocoding, :verification, :network_engineering
+
+    def initialize(api_key, timeout: 30)
+      raise ArgumentError, "api_key must not be empty" if api_key.to_s.strip.empty?
+      http = HttpClient.new(api_key)
+      @ip_geolocation      = Api::IpGeolocation.new(http)
+      @reverse_geocoding   = Api::ReverseGeocoding.new(http)
+      @verification        = Api::Verification.new(http)
+      @network_engineering = Api::NetworkEngineering.new(http)
+    end
+
+    # Creates a client reading the API key from the +BIGDATACLOUD_API_KEY+ environment variable.
+    #
+    # @raise [RuntimeError] if the environment variable is not set.
+    def self.from_environment
+      key = ENV["BIGDATACLOUD_API_KEY"]
+      raise "BIGDATACLOUD_API_KEY environment variable is not set. " \
+            "Set it with: export BIGDATACLOUD_API_KEY=your-key-here" if key.to_s.strip.empty?
+      new(key)
+    end
+  end
+end

data/lib/bigdatacloud/confidence_area.rb

@@ -0,0 +1,57 @@
+module BigDataCloud
+  # Helper for working with confidence area point arrays.
+  #
+  # The +confidence_area+ field may encode multiple polygons in a flat array.
+  # Do NOT treat the entire array as a single polygon ring.
+  #
+  # @example
+  #   geo = client.ip_geolocation.get_with_confidence_area("1.1.1.1")
+  #   polygons = BigDataCloud::ConfidenceArea.split_into_polygons(geo.confidence_area)
+  #   polygons.each_with_index do |ring, i|
+  #     puts "Ring #{i + 1}: #{ring.size} points"
+  #   end
+  module ConfidenceArea
+    # Splits a flat confidence area point list into individual closed polygon rings.
+    #
+    # @param points [Array<Models::GeoPoint>] Raw confidence_area from the API.
+    # @return [Array<Array<Models::GeoPoint>>] Array of closed polygon rings.
+    def self.split_into_polygons(points)
+      return [] if points.nil? || points.empty?
+
+      polygons = []
+      current  = []
+
+      points.each do |point|
+        if current.any?
+          first = current.first
+          if approx_equal(first.latitude, point.latitude) &&
+             approx_equal(first.longitude, point.longitude)
+            current << point
+            polygons << current.dup if current.size >= 4
+            current = []
+            next
+          end
+        end
+        current << point
+      end
+
+      # Handle unclosed trailing polygon
+      if current.size >= 3
+        current << current.first
+        polygons << current
+      end
+
+      polygons
+    end
+
+    # Returns true when the confidence area encodes more than one polygon.
+    def self.multi_polygon?(points)
+      split_into_polygons(points).size > 1
+    end
+
+    def self.approx_equal(a, b)
+      (a - b).abs < 1e-5
+    end
+    private_class_method :approx_equal
+  end
+end

data/lib/bigdatacloud/error.rb

@@ -0,0 +1,12 @@
+module BigDataCloud
+  # Raised when the BigDataCloud API returns an error response.
+  class Error < StandardError
+    attr_reader :status_code, :response_body
+
+    def initialize(message, status_code: 0, response_body: "")
+      super(message)
+      @status_code   = status_code
+      @response_body = response_body
+    end
+  end
+end

data/lib/bigdatacloud/http_client.rb

@@ -0,0 +1,41 @@
+require "net/http"
+require "json"
+require "uri"
+
+module BigDataCloud
+  # Lightweight Net::HTTP wrapper. Thread-safe — each request opens its own connection.
+  class HttpClient
+    BASE_URL = "https://api-bdc.net/data/"
+    TIMEOUT  = 30
+
+    def initialize(api_key)
+      @api_key = api_key
+    end
+
+    def get(endpoint, params = {})
+      params = params.merge(key: @api_key).reject { |_, v| v.nil? || v.to_s.empty? }
+      uri = URI("#{BASE_URL}#{endpoint}")
+      uri.query = URI.encode_www_form(params)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl     = true
+      http.read_timeout = TIMEOUT
+      http.open_timeout = TIMEOUT
+
+      request = Net::HTTP::Get.new(uri)
+      request["Accept"] = "application/json"
+
+      response = http.request(request)
+
+      unless response.is_a?(Net::HTTPSuccess)
+        raise BigDataCloud::Error.new(
+          "BigDataCloud API error #{response.code} on '#{endpoint}'.",
+          status_code: response.code.to_i,
+          response_body: response.body.to_s
+        )
+      end
+
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/bigdatacloud/models/base.rb

@@ -0,0 +1,39 @@
+module BigDataCloud
+  module Models
+    # Base model — converts a JSON hash into an object with accessor methods.
+    # Uses snake_case accessors mapped from camelCase JSON keys.
+    class Base
+      def initialize(data = {})
+        return unless data.is_a?(Hash)
+        data.each do |key, value|
+          setter = :"#{snake_case(key)}="
+          send(setter, value) if respond_to?(setter, true)
+        end
+      end
+
+      private
+
+      def snake_case(str)
+        str.to_s
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+
+      def self.attr_model(name, klass)
+        define_method(name) { instance_variable_get(:"@#{name}") }
+        define_method(:"#{name}=") do |val|
+          instance_variable_set(:"@#{name}", val.is_a?(Hash) ? klass.new(val) : val)
+        end
+      end
+
+      def self.attr_model_array(name, klass)
+        define_method(name) { instance_variable_get(:"@#{name}") || [] }
+        define_method(:"#{name}=") do |val|
+          arr = Array(val).map { |v| v.is_a?(Hash) ? klass.new(v) : v }
+          instance_variable_set(:"@#{name}", arr)
+        end
+      end
+    end
+  end
+end

data/lib/bigdatacloud/models/common.rb

@@ -0,0 +1,70 @@
+module BigDataCloud
+  module Models
+    class GeoPoint < Base
+      attr_accessor :latitude, :longitude
+    end
+
+    class Currency < Base
+      attr_accessor :numeric_code, :code, :name, :iso_name
+    end
+
+    class WBClassification < Base
+      attr_accessor :id, :value
+    end
+
+    class CountryInfo < Base
+      attr_accessor :iso_alpha2, :iso_alpha3, :m49_code, :name, :iso_name,
+                    :iso_name_full, :un_region, :calling_code, :country_flag_emoji
+      attr_model     :currency,        Currency
+      attr_model     :wb_region,       WBClassification
+      attr_model     :wb_income_level, WBClassification
+    end
+
+    class Location < Base
+      attr_accessor :continent, :continent_code, :is_european_union, :city,
+                    :postcode, :plus_code, :principal_subdivision,
+                    :principal_subdivision_code, :country_name, :country_code
+
+      def locality_name=(val); @locality = val; end
+      def locality; @locality; end
+    end
+
+    class AdministrativeArea < Base
+      attr_accessor :name, :description, :iso_name, :iso_code, :admin_level, :order
+    end
+
+    class LocalityInfo < Base
+      attr_model_array :administrative, AdministrativeArea
+      attr_model_array :informative,    AdministrativeArea
+    end
+
+    class Carrier < Base
+      attr_accessor :asn, :asn_numeric, :organisation
+    end
+
+    class Network < Base
+      attr_accessor :registry, :registry_status, :registered_country,
+                    :registered_country_name, :organisation, :bgp_prefix,
+                    :asn, :is_bogon
+      attr_model_array :carriers, Carrier
+    end
+
+    class TimezoneResponse < Base
+      attr_accessor :iana_time_id, :display_name, :utc_offset,
+                    :utc_offset_seconds, :is_daylight_saving_time, :local_time
+    end
+
+    class UserRisk < Base
+      attr_accessor :risk, :description
+    end
+
+    class HazardReport < Base
+      attr_accessor :is_known_as_tor_server, :is_known_as_vpn, :is_known_as_proxy,
+                    :is_known_as_datacenter, :is_known_as_bot, :is_spamhaus_drop,
+                    :is_spamhaus_edrop, :is_spamhaus_asn_drop, :is_blacklisted_uceprotect,
+                    :is_blacklisted_blocklist_de, :is_blacklisted_aa_tools,
+                    :hosting_likelihood, :is_hosting_asn, :is_cellular, :security_threat
+      attr_model :user_risk, UserRisk
+    end
+  end
+end

data/lib/bigdatacloud/models/ip_geolocation.rb

@@ -0,0 +1,32 @@
+module BigDataCloud
+  module Models
+    class IpGeolocationResponse < Base
+      attr_accessor :ip, :last_updated
+      attr_model       :country,  CountryInfo
+      attr_model       :location, Location
+      attr_model       :network,  Network
+    end
+
+    class IpGeolocationWithConfidenceAreaResponse < Base
+      attr_accessor :ip, :confidence, :last_updated
+      attr_model       :country,         CountryInfo
+      attr_model       :location,        Location
+      attr_model       :network,         Network
+      attr_model_array :confidence_area, GeoPoint
+    end
+
+    class IpGeolocationFullResponse < Base
+      attr_accessor :ip, :confidence, :security_threat, :last_updated
+      attr_model       :country,         CountryInfo
+      attr_model       :location,        Location
+      attr_model       :network,         Network
+      attr_model       :hazard_report,   HazardReport
+      attr_model_array :confidence_area, GeoPoint
+    end
+
+    class UserAgentResponse < Base
+      attr_accessor :user_agent_raw, :user_agent_display, :user_agent,
+                    :device, :os, :is_mobile, :is_spider
+    end
+  end
+end

data/lib/bigdatacloud/models/network.rb

@@ -0,0 +1,66 @@
+module BigDataCloud
+  module Models
+    class AsnInfoResponse < Base
+      attr_accessor :asn, :asn_numeric, :organisation, :name, :registry,
+                    :registered_country, :rank, :rank_text,
+                    :total_ipv4_addresses, :total_ipv4_prefixes, :total_ipv6_prefixes
+    end
+
+    class AsnPeer < Base
+      attr_accessor :asn, :asn_numeric, :organisation, :registered_country,
+                    :rank, :rank_text
+    end
+
+    class AsnInfoFullResponse < Base
+      attr_accessor :asn, :asn_numeric, :organisation, :name, :registry,
+                    :registered_country, :rank, :rank_text,
+                    :total_ipv4_addresses, :total_ipv4_prefixes, :total_ipv6_prefixes,
+                    :total_receiving_from, :total_transit_to
+      attr_model_array :receiving_from,  AsnPeer
+      attr_model_array :transit_to,      AsnPeer
+      attr_model_array :confidence_area, GeoPoint
+    end
+
+    class NetworkByIpResponse < Base
+      attr_accessor :ip, :registry, :registry_status, :registered_country,
+                    :registered_country_name, :organisation, :is_reachable_globally,
+                    :is_bogon, :bgp_prefix, :bgp_prefix_network_address,
+                    :bgp_prefix_last_address, :total_addresses
+      attr_model_array :carriers, Carrier
+    end
+
+    class BgpPrefix < Base
+      attr_accessor :bgp_prefix, :bgp_prefix_network_address, :bgp_prefix_last_address,
+                    :total_addresses, :allocation_date, :is_bogon
+    end
+
+    class PrefixesListResponse < Base
+      attr_accessor :asn, :total
+      attr_model_array :prefixes, BgpPrefix
+    end
+
+    class NetworkByCidrResponse < Base
+      attr_accessor :cidr, :parent
+      attr_model :network, Network
+    end
+
+    class AsnRankEntry < Base
+      attr_accessor :asn, :asn_numeric, :organisation, :registered_country,
+                    :rank, :rank_text, :total_ipv4_addresses
+    end
+
+    class AsnRankListResponse < Base
+      attr_accessor :total
+      attr_model_array :asns, AsnRankEntry
+    end
+
+    class TorExitNode < Base
+      attr_accessor :ip, :country_code, :country_name, :asn, :organisation
+    end
+
+    class TorExitNodesResponse < Base
+      attr_accessor :total
+      attr_model_array :nodes, TorExitNode
+    end
+  end
+end

data/lib/bigdatacloud/models/reverse_geocoding.rb

@@ -0,0 +1,26 @@
+module BigDataCloud
+  module Models
+    class ReverseGeocodeResponse < Base
+      attr_accessor :latitude, :longitude, :plus_code, :city, :postcode,
+                    :principal_subdivision, :principal_subdivision_code,
+                    :country_name, :country_code, :continent, :continent_code,
+                    :is_european_union
+      attr_model     :locality_info, LocalityInfo
+
+      def locality_name=(val); @locality = val; end
+      def locality; @locality; end
+    end
+
+    class ReverseGeocodeWithTimezoneResponse < Base
+      attr_accessor :latitude, :longitude, :plus_code, :city, :postcode,
+                    :principal_subdivision, :principal_subdivision_code,
+                    :country_name, :country_code, :continent, :continent_code,
+                    :is_european_union
+      attr_model     :locality_info, LocalityInfo
+      attr_model     :time_zone,     TimezoneResponse
+
+      def locality_name=(val); @locality = val; end
+      def locality; @locality; end
+    end
+  end
+end

data/lib/bigdatacloud/models/verification.rb

@@ -0,0 +1,15 @@
+module BigDataCloud
+  module Models
+    class PhoneValidationResponse < Base
+      attr_accessor :is_valid, :e164_format, :international_format,
+                    :national_format, :line_type, :location
+      attr_model :country, CountryInfo
+    end
+
+    class EmailVerificationResponse < Base
+      attr_accessor :input_data, :is_valid, :is_syntax_valid,
+                    :is_mail_server_defined, :is_known_spammer_domain,
+                    :is_disposable, :is_valid_for_receiving
+    end
+  end
+end

data/lib/bigdatacloud/version.rb

@@ -0,0 +1,3 @@
+module BigDataCloud
+  VERSION = "1.0.0"
+end

data/lib/bigdatacloud.rb

@@ -0,0 +1,15 @@
+require_relative "bigdatacloud/version"
+require_relative "bigdatacloud/error"
+require_relative "bigdatacloud/http_client"
+require_relative "bigdatacloud/confidence_area"
+require_relative "bigdatacloud/models/base"
+require_relative "bigdatacloud/models/common"
+require_relative "bigdatacloud/models/ip_geolocation"
+require_relative "bigdatacloud/models/reverse_geocoding"
+require_relative "bigdatacloud/models/verification"
+require_relative "bigdatacloud/models/network"
+require_relative "bigdatacloud/api/ip_geolocation"
+require_relative "bigdatacloud/api/reverse_geocoding"
+require_relative "bigdatacloud/api/verification"
+require_relative "bigdatacloud/api/network_engineering"
+require_relative "bigdatacloud/client"

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: bigdatacloud
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- BigDataCloud Pty Ltd
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Official Ruby SDK for BigDataCloud APIs — IP Geolocation, Reverse Geocoding,
+  Phone & Email Verification, Network Engineering
+email:
+- support@bigdatacloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/bigdatacloud.rb
+- lib/bigdatacloud/api/ip_geolocation.rb
+- lib/bigdatacloud/api/network_engineering.rb
+- lib/bigdatacloud/api/reverse_geocoding.rb
+- lib/bigdatacloud/api/verification.rb
+- lib/bigdatacloud/client.rb
+- lib/bigdatacloud/confidence_area.rb
+- lib/bigdatacloud/error.rb
+- lib/bigdatacloud/http_client.rb
+- lib/bigdatacloud/models/base.rb
+- lib/bigdatacloud/models/common.rb
+- lib/bigdatacloud/models/ip_geolocation.rb
+- lib/bigdatacloud/models/network.rb
+- lib/bigdatacloud/models/reverse_geocoding.rb
+- lib/bigdatacloud/models/verification.rb
+- lib/bigdatacloud/version.rb
+homepage: https://www.bigdatacloud.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.bigdatacloud.com
+  source_code_uri: https://github.com/bigdatacloudapi/bigdatacloud-ruby
+  documentation_uri: https://www.bigdatacloud.com/docs/sdks
+  changelog_uri: https://github.com/bigdatacloudapi/bigdatacloud-ruby/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: Official Ruby SDK for BigDataCloud APIs
+test_files: []