vpndetection 5.0.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa0cdfbbc74c41bcfe5ecb123df7dc02f4d9255229d5b96764cd3046f290004a
-  data.tar.gz: 540b91db33957765bed48ab55b3cacc10dab5b55fa8d8a91d51ad21a3cee86de
+  metadata.gz: 6d5875418fd7eb25808f8708537f8a17008502cf24bf3ffcd808595f95f5d8d4
+  data.tar.gz: c695e3f997ddb7284324f8c990a910083b183bb6d379046c27258bd4ceeb09d4
 SHA512:
-  metadata.gz: 020525503bb0410d9c9a79b04230b6ce2956798813583d7dee1dd4f92c3f00cee496a273a5d8a4db240a1661d19674d939e8c0ceb9a2949669c2793eb3170a97
-  data.tar.gz: c0071cc728e2a67f3da1e6c33974ef223bc46e8b96057ea4a013909f408fc781246ba9ec4216ec35bd34001428d004f0d7709ea9957dac2689398b8c27349e15
+  metadata.gz: c69b0dad9c16c852b58d98faf6356a1f19704126f9963605afd002b7b186b7fdec26511219a68a7d111b4e4e718ca2a5a1415f01121046b0fe67a81bc20d8b6e
+  data.tar.gz: 2bc760ccdcf01d2ca3bb02489e4d12dc390af9e077bc35904d0147b24c4761f99632715c9b6c9ae2789cd48041191e644498681e059251ebe4476719e98a83c7

data/README.md

@@ -70,7 +70,7 @@ Usage counts against the anniversary of your subscription, not the calendar mont
 
 ### Batch lookup
 
-You can do batch lookups with a list, which parallelizes requests for you efficiently:
+Look up many addresses at once. Bogons and cached answers are handled locally, and everything else goes to the batch endpoint in chunks of up to 1000 addresses, in parallel:
 
 ```ruby
 results = client.lookup_batch(['45.83.91.1', '8.8.8.8', '1.1.1.1'])
@@ -84,12 +84,12 @@ results.each do |ip, result|
 end
 ```
 
-Results are keyed by address, so duplicates in your list collapse into a single request and one address failing never loses the rest.
+Results are keyed by address, in the order you first listed each one, so duplicates in your list collapse into a single entry and one address failing never loses the rest: it carries its error as its value, with the status the API would have given that address on its own.
 
-Concurrency and other variables are configurable per-call:
+How many chunks are in flight at once, and how many times a failed chunk is retried, are configurable per call:
 
 ```ruby
-results = client.lookup_batch(many_ips, concurrency: 32, retries: 4)
+results = client.lookup_batch(many_ips, concurrency: 4, retries: 4)
 ```
 
 ### Caching

data/lib/vpndetection/api/lookup_wire_api.rb

@@ -19,6 +19,74 @@ module VPNDetection
     def initialize(api_client = ApiClient.default)
       @api_client = api_client
     end
+    # Batch
+    # Answers up to 1000 addresses in one call. Each distinct string in `ips` is one lookup: it costs exactly what `GET /{ip}` costs for that address and comes back with exactly the fields that call would carry for your plan. Exact duplicates collapse to one entry and one lookup.  Both maps in the answer are keyed by the string you sent, so nothing has to be lined up by position; the `ip` inside each result is the normalized form. An address that could not be answered sits in `errors` with the status and message the single lookup would have given, and never disturbs the others: a string that is not an address is a `400` there, and an allowance that runs out part way through leaves the remaining entries as `429`s.  The call itself fails only for the reasons below, and a `429` on the call always carries `Retry-After`: the batch is admitted or refused whole by the rate limit, so a per-entry `429` is always a spent allowance and never a throttle. 
+    # @param batch_lookup_request [BatchLookupRequest] 
+    # @param [Hash] opts the optional parameters
+    # @return [BatchLookupResponse]
+    def lookup_batch(batch_lookup_request, opts = {})
+      data, _status_code, _headers = lookup_batch_with_http_info(batch_lookup_request, opts)
+      data
+    end
+
+    # Batch
+    # Answers up to 1000 addresses in one call. Each distinct string in `ips` is one lookup: it costs exactly what `GET /{ip}` costs for that address and comes back with exactly the fields that call would carry for your plan. Exact duplicates collapse to one entry and one lookup.  Both maps in the answer are keyed by the string you sent, so nothing has to be lined up by position; the `ip` inside each result is the normalized form. An address that could not be answered sits in `errors` with the status and message the single lookup would have given, and never disturbs the others: a string that is not an address is a `400` there, and an allowance that runs out part way through leaves the remaining entries as `429`s.  The call itself fails only for the reasons below, and a `429` on the call always carries `Retry-After`: the batch is admitted or refused whole by the rate limit, so a per-entry `429` is always a spent allowance and never a throttle. 
+    # @param batch_lookup_request [BatchLookupRequest] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(BatchLookupResponse, Integer, Hash)>] BatchLookupResponse data, response status code and response headers
+    def lookup_batch_with_http_info(batch_lookup_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: LookupWireApi.lookup_batch ...'
+      end
+      # verify the required parameter 'batch_lookup_request' is set
+      if @api_client.config.client_side_validation && batch_lookup_request.nil?
+        fail ArgumentError, "Missing the required parameter 'batch_lookup_request' when calling LookupWireApi.lookup_batch"
+      end
+      # resource path
+      local_var_path = '/batch'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(batch_lookup_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'BatchLookupResponse'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['apiKeyQuery', 'bearerAuth', 'apiKeyHeader']
+
+      new_options = opts.merge(
+        :operation => :"LookupWireApi.lookup_batch",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: LookupWireApi#lookup_batch\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # Lookup
     # Answers what is known about a single IPv4 or IPv6 address. Which fields come back is decided by the plan behind the presented key; with no key the answer is `ip` and `is_vpn`. 
     # @param ip [String] The IPv4 or IPv6 address to classify.

data/lib/vpndetection/client.rb

@@ -9,6 +9,9 @@ module VPNDetection
   DEFAULT_CONCURRENCY = 8
   DEFAULT_RETRIES = 2
   DEFAULT_TIMEOUT = 10
+  # The most addresses POST /batch takes in one call; a larger batch is sent in
+  # chunks of this size.
+  BATCH_MAX = 1000
 
   # A client for the VPNDetection API.
   #
@@ -23,7 +26,7 @@ module VPNDetection
     #   address.
     # @param cache [Boolean] pass false to disable caching.
     # @param cache_ttl [Numeric] how long an answer stays fresh, in seconds.
-    # @param concurrency [Integer] in-flight requests during a batch.
+    # @param concurrency [Integer] batch requests - chunks of up to 1000 addresses - in flight during a batch.
     # @param retries [Integer] extra attempts for a transient failure.
     # @param transport [Transport, nil] override the HTTP layer, mostly for tests.
     def initialize(api_key: nil, base_url: DEFAULT_BASE_URL, cache: true,
@@ -108,13 +111,19 @@ module VPNDetection
       end
     end
 
-    # Classify many addresses in parallel.
+    # Classify many addresses in as few requests as possible.
     #
-    # Keyed by address rather than positional, so duplicates in the input
-    # collapse to a single request and the caller never has to line two lists
-    # up. An address that fails carries its error as its value, so one bad entry
-    # cannot lose the rest of the answers.
+    # Bogons are answered locally and cached answers are reused; everything else
+    # goes to the batch endpoint in chunks of up to 1000 addresses, with at most
+    # `concurrency` chunks in flight. Keyed by address rather than positional, so
+    # duplicates in the input collapse to a single entry and the caller never has
+    # to line two lists up. An address that fails carries its error as its value,
+    # so one bad entry cannot lose the rest of the answers: the API reports a
+    # per-entry failure with the status the single lookup would have answered,
+    # and a chunk that fails as a whole marks every address in it.
     #
+    # @param concurrency [Integer, nil] chunks in flight, for THIS batch only.
+    # @param retries [Integer, nil] extra attempts for a failed chunk, for THIS batch only.
     # @return [Hash{String => Result, Error}] in the order the addresses were given
     def lookup_batch(ips, concurrency: nil, retries: nil)
       addresses = ips.to_a.uniq
@@ -126,7 +135,8 @@ module VPNDetection
         hit.nil? ? pending << ip : answers[ip] = hit
       end
       unless pending.empty?
-        run_batch(pending, answers, concurrency || @concurrency, retries || @retries)
+        run_batch(pending.each_slice(BATCH_MAX).to_a, answers,
+                  concurrency || @concurrency, retries || @retries)
       end
 
       # Reinstated in input order: a hydra settles in completion order, and a
@@ -138,37 +148,58 @@ module VPNDetection
 
     # One hydra per call, sized for THIS call. Reusing an instance-level hydra
     # would silently cap a per-call concurrency at the client's setting, and
-    # would not be safe to drive from two threads either.
-    def run_batch(pending, answers, concurrency, retries)
+    # would not be safe to drive from two threads either. Each request is one
+    # chunk of up to 1000 addresses.
+    def run_batch(chunks, answers, concurrency, retries)
       hydra = Typhoeus::Hydra.new(max_concurrency: concurrency)
       attempts = Hash.new(0)
 
-      enqueue = lambda do |ip|
-        request = @transport.lookup_request(ip)
+      enqueue = lambda do |chunk|
+        request = @transport.batch_request(chunk)
         request.on_complete do |response|
-          outcome = settle(ip, response, attempts, retries, enqueue)
-          answers[ip] = outcome unless outcome.nil?
+          outcome = settle(chunk, response, attempts, retries, enqueue)
+          answers.merge!(outcome) unless outcome.nil?
         end
         hydra.queue(request)
       end
 
-      pending.each { |ip| enqueue.call(ip) }
+      chunks.each { |chunk| enqueue.call(chunk) }
       hydra.run
     end
 
-    def settle(ip, response, attempts, retries, enqueue)
-      result = Transport.lookup_result(response)
-      @cache&.set(ip, result)
-      result
+    # One POST /batch, mapped back onto the addresses it was asked about. A
+    # chunk-level failure - the call refused, the transport failing, the retries
+    # exhausted - becomes every address's error, exactly as it would have been
+    # had each been looked up alone.
+    def settle(chunk, response, attempts, retries, enqueue)
+      body = Transport.batch_body(response)
+      chunk.to_h do |ip|
+        answer = batch_answer(ip, body)
+        @cache&.set(ip, answer) if answer.is_a?(Result)
+        [ip, answer]
+      end
     rescue Error => e
-      return e unless e.retryable? && attempts[ip] < retries
+      return chunk.to_h { |ip| [ip, e] } unless e.retryable? && attempts[chunk] < retries
 
-      attempts[ip] += 1
+      attempts[chunk] += 1
       # Sleeping here stalls the whole hydra, which is what a server-supplied
       # delay asks for: it is telling every request to this host to back off.
-      sleep(Retries.delay_for(e, attempts[ip]))
-      enqueue.call(ip)
+      sleep(Retries.delay_for(e, attempts[chunk]))
+      enqueue.call(chunk)
       nil
     end
+
+    # Every address lands in exactly one of `results` and `errors`; an address in
+    # neither is the server breaking its own contract, and is reported as such
+    # rather than lost.
+    def batch_answer(ip, body)
+      if (served = body['results'][ip])
+        Result.new(served)
+      elsif (failed = body['errors'][ip])
+        Error.from_entry(failed['status'], failed['error'])
+      else
+        Error.new(:server_error, "the batch answer did not include #{ip}", status: 200)
+      end
+    end
   end
 end

data/lib/vpndetection/errors.rb

@@ -67,6 +67,13 @@ module VPNDetection
       new(:network, message)
     end
 
+    # A per-entry failure inside a successful batch: the status the single lookup
+    # would have answered, and its message, with no headers at all - so a 429
+    # here is a spent allowance, which is the only kind the API puts in an entry.
+    def self.from_entry(status, message)
+      from_status(status.to_i, {}, nil, message: message.to_s)
+    end
+
     # Case-insensitive, and works with a plain Hash as well as with the
     # case-blind header object Typhoeus builds from a live response.
     def self.header(headers, name)

data/lib/vpndetection/models/batch_lookup_error.rb

@@ -0,0 +1,193 @@
+=begin
+#VPNDetection API
+
+#The VPNDetection API: classify any IP address, and download the databases behind the answers.  See https://docs.vpndetection.io for guides and https://github.com/vpndetection-io for the official client libraries. 
+
+The version of the OpenAPI document: 2026.09.15
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  # Why one entry of a batch was not answered, as the single lookup would have reported it.
+  class BatchLookupError < ApiModelBase
+    # The HTTP status `GET /{ip}` would have answered for this entry: `400` for a string that is not an address, `429` for a spent allowance, `500` when the VPN dataset could not be consulted. A `429` here is never a throttle; the whole call is refused instead. 
+    attr_accessor :status
+
+    # The same message the single lookup carries for that status.
+    attr_accessor :error
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'status' => :'status',
+        :'error' => :'error'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'status' => :'Integer',
+        :'error' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `VPNDetection::BatchLookupError` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `VPNDetection::BatchLookupError`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'status')
+        self.status = attributes[:'status']
+      else
+        self.status = nil
+      end
+
+      if attributes.key?(:'error')
+        self.error = attributes[:'error']
+      else
+        self.error = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @status.nil?
+        invalid_properties.push('invalid value for "status", status cannot be nil.')
+      end
+
+      if @error.nil?
+        invalid_properties.push('invalid value for "error", error cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @status.nil?
+      return false if @error.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] status Value to be assigned
+    def status=(status)
+      if status.nil?
+        fail ArgumentError, 'status cannot be nil'
+      end
+
+      @status = status
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] error Value to be assigned
+    def error=(error)
+      if error.nil?
+        fail ArgumentError, 'error cannot be nil'
+      end
+
+      @error = error
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          status == o.status &&
+          error == o.error
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [status, error].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/vpndetection/models/batch_lookup_request.rb

@@ -0,0 +1,185 @@
+=begin
+#VPNDetection API
+
+#The VPNDetection API: classify any IP address, and download the databases behind the answers.  See https://docs.vpndetection.io for guides and https://github.com/vpndetection-io for the official client libraries. 
+
+The version of the OpenAPI document: 2026.09.15
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  class BatchLookupRequest < ApiModelBase
+    # The addresses to classify, 1 to 1000 per call, counted before duplicates collapse. Each distinct string is one lookup. 
+    attr_accessor :ips
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'ips' => :'ips'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'ips' => :'Array<String>'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `VPNDetection::BatchLookupRequest` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `VPNDetection::BatchLookupRequest`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'ips')
+        if (value = attributes[:'ips']).is_a?(Array)
+          self.ips = value
+        end
+      else
+        self.ips = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @ips.nil?
+        invalid_properties.push('invalid value for "ips", ips cannot be nil.')
+      end
+
+      if @ips.length > 1000
+        invalid_properties.push('invalid value for "ips", number of items must be less than or equal to 1000.')
+      end
+
+      if @ips.length < 1
+        invalid_properties.push('invalid value for "ips", number of items must be greater than or equal to 1.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @ips.nil?
+      return false if @ips.length > 1000
+      return false if @ips.length < 1
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] ips Value to be assigned
+    def ips=(ips)
+      if ips.nil?
+        fail ArgumentError, 'ips cannot be nil'
+      end
+
+      if ips.length > 1000
+        fail ArgumentError, 'invalid value for "ips", number of items must be less than or equal to 1000.'
+      end
+
+      if ips.length < 1
+        fail ArgumentError, 'invalid value for "ips", number of items must be greater than or equal to 1.'
+      end
+
+      @ips = ips
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          ips == o.ips
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [ips].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/vpndetection/models/batch_lookup_response.rb

@@ -0,0 +1,196 @@
+=begin
+#VPNDetection API
+
+#The VPNDetection API: classify any IP address, and download the databases behind the answers.  See https://docs.vpndetection.io for guides and https://github.com/vpndetection-io for the official client libraries. 
+
+The version of the OpenAPI document: 2026.09.15
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  class BatchLookupResponse < ApiModelBase
+    # One answer per input string that was classified, keyed by the string as you sent it; the `ip` inside is the normalized form. Each value is exactly what `GET /{ip}` answers for your plan. 
+    attr_accessor :results
+
+    # One entry per input string that could not be classified, keyed the same way. Empty when every entry was answered. 
+    attr_accessor :errors
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'results' => :'results',
+        :'errors' => :'errors'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'results' => :'Hash<String, LookupResponse>',
+        :'errors' => :'Hash<String, BatchLookupError>'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `VPNDetection::BatchLookupResponse` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `VPNDetection::BatchLookupResponse`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'results')
+        if (value = attributes[:'results']).is_a?(Hash)
+          self.results = value
+        end
+      else
+        self.results = nil
+      end
+
+      if attributes.key?(:'errors')
+        if (value = attributes[:'errors']).is_a?(Hash)
+          self.errors = value
+        end
+      else
+        self.errors = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @results.nil?
+        invalid_properties.push('invalid value for "results", results cannot be nil.')
+      end
+
+      if @errors.nil?
+        invalid_properties.push('invalid value for "errors", errors cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @results.nil?
+      return false if @errors.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] results Value to be assigned
+    def results=(results)
+      if results.nil?
+        fail ArgumentError, 'results cannot be nil'
+      end
+
+      @results = results
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] errors Value to be assigned
+    def errors=(errors)
+      if errors.nil?
+        fail ArgumentError, 'errors cannot be nil'
+      end
+
+      @errors = errors
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          results == o.results &&
+          errors == o.errors
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [results, errors].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/vpndetection/transport.rb

@@ -15,6 +15,7 @@ module VPNDetection
     LOOKUP_PATH = '/{ip}'
     MYIP_PATH = '/myip'
     ENTITLEMENT_PATH = '/api/v1/entitlement'
+    BATCH_PATH = '/batch'
 
     # The generated Configuration applies EVERY security scheme the spec lists,
     # so a keyless client would send `Authorization: Bearer `, an empty
@@ -107,6 +108,16 @@ module VPNDetection
       )
     end
 
+    # The one request with a body: the batch.
+    def batch_request(ips)
+      build_request(
+        :POST, BATCH_PATH,
+        header_params: { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+        body: { ips: ips },
+        auth_names: %w[bearerAuth apiKeyHeader apiKeyQuery],
+      )
+    end
+
     def self.entitlement_result(response)
       raise Error.from_transport(response) if transport_failure?(response)
       raise Error.from_status(response.code, response.headers, response.body) unless response.success?
@@ -121,6 +132,18 @@ module VPNDetection
       Result.new(parse_object(response))
     end
 
+    # The two maps of a batch answer, each present even when empty.
+    def self.batch_body(response)
+      raise Error.from_transport(response) if transport_failure?(response)
+      raise Error.from_status(response.code, response.headers, response.body) unless response.success?
+
+      body = parse_object(response)
+      {
+        'results' => body['results'].is_a?(Hash) ? body['results'] : {},
+        'errors' => body['errors'].is_a?(Hash) ? body['errors'] : {},
+      }
+    end
+
     def self.transport_failure?(response)
       response.timed_out? || response.code.to_i.zero?
     end

data/lib/vpndetection/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module VPNDetection
-  VERSION = '5.0.0'
+  VERSION = '5.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vpndetection
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Mslm Dev
@@ -78,6 +78,9 @@ files:
 - lib/vpndetection/models/account_user.rb
 - lib/vpndetection/models/apikey_detail.rb
 - lib/vpndetection/models/apikey_list.rb
+- lib/vpndetection/models/batch_lookup_error.rb
+- lib/vpndetection/models/batch_lookup_request.rb
+- lib/vpndetection/models/batch_lookup_response.rb
 - lib/vpndetection/models/class_detail.rb
 - lib/vpndetection/models/database.rb
 - lib/vpndetection/models/database_checksums_response.rb