vpndetection 3.2.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3489ebf7b31c0307756abb483614adb213f1b9feb37890ed1e5b1f163f35c02
-  data.tar.gz: b0f1881979f90e0a0378bf399bf1442005c30d1fe775f1c332a71418470799b4
+  metadata.gz: a5e55f291802dac250f1170cbc48751d463f5fb2a0c182a69301fe1627c245a5
+  data.tar.gz: c8dc05902e2c94bc9a843897717684883bdc9429e36682c9c20b5486862da66a
 SHA512:
-  metadata.gz: a346d47d4e39b0b0ed62649db5d32bf9718f04e15472ff1a3ca6bf2a470cbc5ef69be8e1bfcaa72078d165724c386e948d1003db7eb0a96a02603b848737c53e
-  data.tar.gz: 72ad76f8e9fed8ac94b3aaee0fea5e82a40746da4c3a0f62c99f6ea4469fc94d13ec23b064de9025b29b44f163d3b5d174a08774bb965fab00c6d190698023df
+  metadata.gz: '0186489fad83fb671a47344cf3a5c63dbfaa05cab0b905c8dbeaa4c70c7305f36c3062828f747532b92be13f185659aa4fb282f6a4245557fc1b0328d757d42c'
+  data.tar.gz: e2cec75355df5c8d328939857e6249c22980bf8e4d90210297aa4b78ceb3e4c7491a53f37dfa41657b982c046a900ee379ff99cc8f10cf1ad8a68f07b31fd7e5

data/lib/vpndetection/api/account_wire_api.rb

@@ -0,0 +1,79 @@
+=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.13
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'cgi'
+
+module VPNDetection
+  class AccountWireApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Your key, plan and usage
+    # Answers what the presented key is, what plan is behind it, and what has been spent against that plan's allowance in the current window. 
+    # @param [Hash] opts the optional parameters
+    # @return [AccountMe]
+    def account_me(opts = {})
+      data, _status_code, _headers = account_me_with_http_info(opts)
+      data
+    end
+
+    # Your key, plan and usage
+    # Answers what the presented key is, what plan is behind it, and what has been spent against that plan's allowance in the current window. 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(AccountMe, Integer, Hash)>] AccountMe data, response status code and response headers
+    def account_me_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AccountWireApi.account_me ...'
+      end
+      # resource path
+      local_var_path = '/api/v1/account/me'
+
+      # 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']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'AccountMe'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['apiKeyQuery', 'bearerAuth', 'apiKeyHeader']
+
+      new_options = opts.merge(
+        :operation => :"AccountWireApi.account_me",
+        :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(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AccountWireApi#account_me\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+  end
+end

data/lib/vpndetection/api/database_wire_api.rb

@@ -226,7 +226,7 @@ module VPNDetection
     end
 
     # List
-    # Every database this organization holds a licence for, with the term and the license_type right beside each one. 
+    # Every database this organization may SEE, with where its licence stands. Not just the ones you hold: a customer with one grant should be able to tell what else is published without asking. `standing` is the difference - `licensed`, `expired`, or `unlicensed` for one never bought. 
     # @param [Hash] opts the optional parameters
     # @return [DatabaseList]
     def list_databases(opts = {})
@@ -235,7 +235,7 @@ module VPNDetection
     end
 
     # List
-    # Every database this organization holds a licence for, with the term and the license_type right beside each one. 
+    # Every database this organization may SEE, with where its licence stands. Not just the ones you hold: a customer with one grant should be able to tell what else is published without asking. `standing` is the difference - `licensed`, `expired`, or `unlicensed` for one never bought. 
     # @param [Hash] opts the optional parameters
     # @return [Array<(DatabaseList, Integer, Hash)>] DatabaseList data, response status code and response headers
     def list_databases_with_http_info(opts = {})

data/lib/vpndetection/configuration.rb

@@ -177,7 +177,7 @@ module VPNDetection
       @ignore_operation_servers = false
       @inject_format = false
       @force_ending_format = false
-      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+      @logger = defined?(::Rails) ? ::Rails.logger : Logger.new(STDOUT)
 
       yield(self) if block_given?
     end

data/lib/vpndetection/models/account_apikey.rb

@@ -0,0 +1,207 @@
+=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.13
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  # The credential itself. The key is never echoed - only its id, which is what the console shows and what you can act on. 
+  class AccountApikey < ApiModelBase
+    attr_accessor :id
+
+    # Null for a key with no end date, which is the normal case.
+    attr_accessor :expires
+
+    # The source addresses this key may be used from. EMPTY means unrestricted, never \"deny all\". 
+    attr_accessor :allowed_cidrs
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'id' => :'id',
+        :'expires' => :'expires',
+        :'allowed_cidrs' => :'allowed_cidrs'
+      }
+    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
+      {
+        :'id' => :'String',
+        :'expires' => :'Time',
+        :'allowed_cidrs' => :'Array<String>'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'expires',
+      ])
+    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::AccountApikey` 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::AccountApikey`. 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?(:'id')
+        self.id = attributes[:'id']
+      else
+        self.id = nil
+      end
+
+      if attributes.key?(:'expires')
+        self.expires = attributes[:'expires']
+      else
+        self.expires = nil
+      end
+
+      if attributes.key?(:'allowed_cidrs')
+        if (value = attributes[:'allowed_cidrs']).is_a?(Array)
+          self.allowed_cidrs = value
+        end
+      else
+        self.allowed_cidrs = 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 @id.nil?
+        invalid_properties.push('invalid value for "id", id cannot be nil.')
+      end
+
+      if @allowed_cidrs.nil?
+        invalid_properties.push('invalid value for "allowed_cidrs", allowed_cidrs 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 @id.nil?
+      return false if @allowed_cidrs.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] id Value to be assigned
+    def id=(id)
+      if id.nil?
+        fail ArgumentError, 'id cannot be nil'
+      end
+
+      @id = id
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] allowed_cidrs Value to be assigned
+    def allowed_cidrs=(allowed_cidrs)
+      if allowed_cidrs.nil?
+        fail ArgumentError, 'allowed_cidrs cannot be nil'
+      end
+
+      @allowed_cidrs = allowed_cidrs
+    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 &&
+          id == o.id &&
+          expires == o.expires &&
+          allowed_cidrs == o.allowed_cidrs
+    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
+      [id, expires, allowed_cidrs].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/account_error.rb

@@ -0,0 +1,164 @@
+=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.13
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  class AccountError < ApiModelBase
+    attr_accessor :error
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'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
+      {
+        :'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::AccountError` 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::AccountError`. 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?(:'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 @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 @error.nil?
+      true
+    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 &&
+          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
+      [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/account_me.rb

@@ -0,0 +1,243 @@
+=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.13
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  class AccountMe < ApiModelBase
+    # The organization the key belongs to.
+    attr_accessor :org_id
+
+    attr_accessor :apikey
+
+    attr_accessor :plan
+
+    attr_accessor :usage
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'org_id' => :'org_id',
+        :'apikey' => :'apikey',
+        :'plan' => :'plan',
+        :'usage' => :'usage'
+      }
+    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
+      {
+        :'org_id' => :'String',
+        :'apikey' => :'AccountApikey',
+        :'plan' => :'AccountPlan',
+        :'usage' => :'AccountUsage'
+      }
+    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::AccountMe` 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::AccountMe`. 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?(:'org_id')
+        self.org_id = attributes[:'org_id']
+      else
+        self.org_id = nil
+      end
+
+      if attributes.key?(:'apikey')
+        self.apikey = attributes[:'apikey']
+      else
+        self.apikey = nil
+      end
+
+      if attributes.key?(:'plan')
+        self.plan = attributes[:'plan']
+      else
+        self.plan = nil
+      end
+
+      if attributes.key?(:'usage')
+        self.usage = attributes[:'usage']
+      else
+        self.usage = 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 @org_id.nil?
+        invalid_properties.push('invalid value for "org_id", org_id cannot be nil.')
+      end
+
+      if @apikey.nil?
+        invalid_properties.push('invalid value for "apikey", apikey cannot be nil.')
+      end
+
+      if @plan.nil?
+        invalid_properties.push('invalid value for "plan", plan cannot be nil.')
+      end
+
+      if @usage.nil?
+        invalid_properties.push('invalid value for "usage", usage 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 @org_id.nil?
+      return false if @apikey.nil?
+      return false if @plan.nil?
+      return false if @usage.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] org_id Value to be assigned
+    def org_id=(org_id)
+      if org_id.nil?
+        fail ArgumentError, 'org_id cannot be nil'
+      end
+
+      @org_id = org_id
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] apikey Value to be assigned
+    def apikey=(apikey)
+      if apikey.nil?
+        fail ArgumentError, 'apikey cannot be nil'
+      end
+
+      @apikey = apikey
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] plan Value to be assigned
+    def plan=(plan)
+      if plan.nil?
+        fail ArgumentError, 'plan cannot be nil'
+      end
+
+      @plan = plan
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] usage Value to be assigned
+    def usage=(usage)
+      if usage.nil?
+        fail ArgumentError, 'usage cannot be nil'
+      end
+
+      @usage = usage
+    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 &&
+          org_id == o.org_id &&
+          apikey == o.apikey &&
+          plan == o.plan &&
+          usage == o.usage
+    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
+      [org_id, apikey, plan, usage].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/account_plan.rb

@@ -0,0 +1,216 @@
+=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.13
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  class AccountPlan < ApiModelBase
+    # The plan the organization is on.
+    attr_accessor :key
+
+    # The field tier, which decides how much of a lookup answer comes back. What each tier includes is documented on the lookup endpoint rather than repeated here, so there is one place it can be wrong. 
+    attr_accessor :tier
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'key' => :'key',
+        :'tier' => :'tier'
+      }
+    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
+      {
+        :'key' => :'String',
+        :'tier' => :'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::AccountPlan` 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::AccountPlan`. 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?(:'key')
+        self.key = attributes[:'key']
+      else
+        self.key = nil
+      end
+
+      if attributes.key?(:'tier')
+        self.tier = attributes[:'tier']
+      else
+        self.tier = 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 @key.nil?
+        invalid_properties.push('invalid value for "key", key cannot be nil.')
+      end
+
+      if @tier.nil?
+        invalid_properties.push('invalid value for "tier", tier 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 @key.nil?
+      return false if @tier.nil?
+      tier_validator = EnumAttributeValidator.new('String', ["free", "starter", "scale", "max"])
+      return false unless tier_validator.valid?(@tier)
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] key Value to be assigned
+    def key=(key)
+      if key.nil?
+        fail ArgumentError, 'key cannot be nil'
+      end
+
+      @key = key
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] tier Object to be assigned
+    def tier=(tier)
+      validator = EnumAttributeValidator.new('String', ["free", "starter", "scale", "max"])
+      unless validator.valid?(tier)
+        fail ArgumentError, "invalid value for \"tier\", must be one of #{validator.allowable_values}."
+      end
+      @tier = tier
+    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 &&
+          key == o.key &&
+          tier == o.tier
+    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
+      [key, tier].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/account_usage.rb

@@ -0,0 +1,259 @@
+=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.13
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  class AccountUsage < ApiModelBase
+    # Requests counted in the current window. The same number the lookup API gates on, and it can lag by a few seconds. 
+    attr_accessor :requests
+
+    # What the plan includes. Zero on a plan that includes none.
+    attr_accessor :quota
+
+    # Where we stop serving. NULL means never, which is the normal state of an uncapped paid plan and is not the same as zero. Above the quota and below this, requests are served and billed as overage. 
+    attr_accessor :hard_limit
+
+    # When the current allowance period began.
+    attr_accessor :window_start
+
+    # When the allowance next resets.
+    attr_accessor :window_end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'requests' => :'requests',
+        :'quota' => :'quota',
+        :'hard_limit' => :'hard_limit',
+        :'window_start' => :'window_start',
+        :'window_end' => :'window_end'
+      }
+    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
+      {
+        :'requests' => :'Integer',
+        :'quota' => :'Integer',
+        :'hard_limit' => :'Integer',
+        :'window_start' => :'Time',
+        :'window_end' => :'Time'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'hard_limit',
+      ])
+    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::AccountUsage` 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::AccountUsage`. 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?(:'requests')
+        self.requests = attributes[:'requests']
+      else
+        self.requests = nil
+      end
+
+      if attributes.key?(:'quota')
+        self.quota = attributes[:'quota']
+      else
+        self.quota = nil
+      end
+
+      if attributes.key?(:'hard_limit')
+        self.hard_limit = attributes[:'hard_limit']
+      else
+        self.hard_limit = nil
+      end
+
+      if attributes.key?(:'window_start')
+        self.window_start = attributes[:'window_start']
+      else
+        self.window_start = nil
+      end
+
+      if attributes.key?(:'window_end')
+        self.window_end = attributes[:'window_end']
+      else
+        self.window_end = 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 @requests.nil?
+        invalid_properties.push('invalid value for "requests", requests cannot be nil.')
+      end
+
+      if @quota.nil?
+        invalid_properties.push('invalid value for "quota", quota cannot be nil.')
+      end
+
+      if @window_start.nil?
+        invalid_properties.push('invalid value for "window_start", window_start cannot be nil.')
+      end
+
+      if @window_end.nil?
+        invalid_properties.push('invalid value for "window_end", window_end 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 @requests.nil?
+      return false if @quota.nil?
+      return false if @window_start.nil?
+      return false if @window_end.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] requests Value to be assigned
+    def requests=(requests)
+      if requests.nil?
+        fail ArgumentError, 'requests cannot be nil'
+      end
+
+      @requests = requests
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] quota Value to be assigned
+    def quota=(quota)
+      if quota.nil?
+        fail ArgumentError, 'quota cannot be nil'
+      end
+
+      @quota = quota
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] window_start Value to be assigned
+    def window_start=(window_start)
+      if window_start.nil?
+        fail ArgumentError, 'window_start cannot be nil'
+      end
+
+      @window_start = window_start
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] window_end Value to be assigned
+    def window_end=(window_end)
+      if window_end.nil?
+        fail ArgumentError, 'window_end cannot be nil'
+      end
+
+      @window_end = window_end
+    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 &&
+          requests == o.requests &&
+          quota == o.quota &&
+          hard_limit == o.hard_limit &&
+          window_start == o.window_start &&
+          window_end == o.window_end
+    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
+      [requests, quota, hard_limit, window_start, window_end].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/database.rb

@@ -23,6 +23,7 @@ module VPNDetection
 
     attr_accessor :summary
 
+    # What a license permits you to do with the data. Null for a family you hold no license for, which is every one with standing `unlicensed`. 
     attr_accessor :license_type
 
     attr_accessor :starts
@@ -99,7 +100,7 @@ module VPNDetection
         :'base' => :'String',
         :'name' => :'String',
         :'summary' => :'String',
-        :'license_type' => :'LicenseType',
+        :'license_type' => :'String',
         :'starts' => :'Time',
         :'expires' => :'Time',
         :'renews_at' => :'Time',
@@ -113,6 +114,7 @@ module VPNDetection
     # List of attributes with nullable: true
     def self.openapi_nullable
       Set.new([
+        :'license_type',
         :'starts',
         :'expires',
         :'renews_at',
@@ -222,10 +224,6 @@ module VPNDetection
         invalid_properties.push('invalid value for "summary", summary cannot be nil.')
       end
 
-      if @license_type.nil?
-        invalid_properties.push('invalid value for "license_type", license_type cannot be nil.')
-      end
-
       if @in_term.nil?
         invalid_properties.push('invalid value for "in_term", in_term cannot be nil.')
       end
@@ -248,7 +246,8 @@ module VPNDetection
       return false if @base.nil?
       return false if @name.nil?
       return false if @summary.nil?
-      return false if @license_type.nil?
+      license_type_validator = EnumAttributeValidator.new('String', ["evaluation", "standard", "redistribute"])
+      return false unless license_type_validator.valid?(@license_type)
       return false if @in_term.nil?
       return false if @standing.nil?
       return false if @versions.nil?
@@ -285,13 +284,13 @@ module VPNDetection
       @summary = summary
     end
 
-    # Custom attribute writer method with validation
-    # @param [Object] license_type Value to be assigned
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] license_type Object to be assigned
     def license_type=(license_type)
-      if license_type.nil?
-        fail ArgumentError, 'license_type cannot be nil'
+      validator = EnumAttributeValidator.new('String', ["evaluation", "standard", "redistribute"])
+      unless validator.valid?(license_type)
+        fail ArgumentError, "invalid value for \"license_type\", must be one of #{validator.allowable_values}."
       end
-
       @license_type = license_type
     end
 

data/lib/vpndetection/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vpndetection
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Mslm Dev
@@ -48,6 +48,7 @@ files:
 - LICENSE
 - README.md
 - lib/vpndetection.rb
+- lib/vpndetection/api/account_wire_api.rb
 - lib/vpndetection/api/database_wire_api.rb
 - lib/vpndetection/api/lookup_wire_api.rb
 - lib/vpndetection/api_client.rb
@@ -63,6 +64,11 @@ files:
 - lib/vpndetection/middleware.rb
 - lib/vpndetection/middleware/condition.rb
 - lib/vpndetection/middleware/core.rb
+- lib/vpndetection/models/account_apikey.rb
+- lib/vpndetection/models/account_error.rb
+- lib/vpndetection/models/account_me.rb
+- lib/vpndetection/models/account_plan.rb
+- lib/vpndetection/models/account_usage.rb
 - lib/vpndetection/models/class_detail.rb
 - lib/vpndetection/models/database.rb
 - lib/vpndetection/models/database_checksums_response.rb
@@ -76,7 +82,6 @@ files:
 - lib/vpndetection/models/download.rb
 - lib/vpndetection/models/download_list.rb
 - lib/vpndetection/models/error_envelope.rb
-- lib/vpndetection/models/license_type.rb
 - lib/vpndetection/models/lookup_error.rb
 - lib/vpndetection/models/lookup_response.rb
 - lib/vpndetection/models/proxy_detail.rb

data/lib/vpndetection/models/license_type.rb

@@ -1,41 +0,0 @@
-=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.13
-Contact: support@vpndetection.io
-Generated by: https://openapi-generator.tech
-Generator version: 7.25.0
-
-=end
-
-require 'date'
-require 'time'
-
-module VPNDetection
-  class LicenseType
-    EVALUATION = "evaluation".freeze
-    STANDARD = "standard".freeze
-    REDISTRIBUTE = "redistribute".freeze
-
-    def self.all_vars
-      @all_vars ||= [EVALUATION, STANDARD, REDISTRIBUTE].freeze
-    end
-
-    # Builds the enum from string
-    # @param [String] The enum value in the form of the string
-    # @return [String] The enum value
-    def self.build_from_hash(value)
-      new.build_from_hash(value)
-    end
-
-    # Builds the enum from string
-    # @param [String] The enum value in the form of the string
-    # @return [String] The enum value
-    def build_from_hash(value)
-      return value if LicenseType.all_vars.include?(value)
-      raise "Invalid ENUM value #{value} for class #LicenseType"
-    end
-  end
-end