trinsic_api 2.3.0.pre.alpha2 → 3.0.0

data/lib/trinsic_api/models/match_data.rb

@@ -14,25 +14,39 @@ require 'date'
 require 'time'
 
 module TrinsicApi
+  # Match results for the data being matched against.              This applies to Providers which operate based on matching data / biometrics against a government database, returning match scores or results as opposed to the data itself.
   class MatchData
+    # Whether the provided National ID Number matched the information on file for the individual
     attr_accessor :national_id_number
 
+    # The match score for the full name of the individual.              Higher values indicate a closer match.
     attr_accessor :full_name
 
+    # The match score for the given (first) name of the individual.              Higher values indicate a closer match.
     attr_accessor :given_name
 
+    # The match score for the middle name(s) of the individual.              Higher values indicate a closer match.
     attr_accessor :middle_name
 
+    # The match score for the family (last) name of the individual.              Higher values indicate a closer match.
     attr_accessor :family_name
 
+    # Whether the provided sex of the individual matched the information on file for the individual
     attr_accessor :sex
 
+    # Whether the provided date of birth matched the information on file for the individual
     attr_accessor :date_of_birth
 
+    # Whether the provided phone number matched the information on file for the individual
+    attr_accessor :phone_number
+
+    # The match score for the face match between the provided selfie image and the biometrics on file for the individual.              Higher values indicate greater match confidence.
     attr_accessor :face_match
 
+    # The confidence score for the liveness check performed against the selfie image of the individual.              Higher values indicate lower suspicion.
     attr_accessor :liveness
 
+    # The confidence score for the image manipulation check performed against the selfie image of the individual.              Higher values indicate lower suspicion of image manipulation.
     attr_accessor :image_authenticity
 
     # Attribute mapping from ruby-style variable name to JSON key.
@@ -45,6 +59,7 @@ module TrinsicApi
         :'family_name' => :'familyName',
         :'sex' => :'sex',
         :'date_of_birth' => :'dateOfBirth',
+        :'phone_number' => :'phoneNumber',
         :'face_match' => :'faceMatch',
         :'liveness' => :'liveness',
         :'image_authenticity' => :'imageAuthenticity'
@@ -71,6 +86,7 @@ module TrinsicApi
         :'family_name' => :'Match',
         :'sex' => :'Match',
         :'date_of_birth' => :'Match',
+        :'phone_number' => :'Match',
         :'face_match' => :'Match',
         :'liveness' => :'Match',
         :'image_authenticity' => :'Match'
@@ -87,6 +103,7 @@ module TrinsicApi
         :'family_name',
         :'sex',
         :'date_of_birth',
+        :'phone_number',
         :'face_match',
         :'liveness',
         :'image_authenticity'
@@ -137,6 +154,10 @@ module TrinsicApi
         self.date_of_birth = attributes[:'date_of_birth']
       end
 
+      if attributes.key?(:'phone_number')
+        self.phone_number = attributes[:'phone_number']
+      end
+
       if attributes.key?(:'face_match')
         self.face_match = attributes[:'face_match']
       end
@@ -177,6 +198,7 @@ module TrinsicApi
           family_name == o.family_name &&
           sex == o.sex &&
           date_of_birth == o.date_of_birth &&
+          phone_number == o.phone_number &&
           face_match == o.face_match &&
           liveness == o.liveness &&
           image_authenticity == o.image_authenticity
@@ -191,7 +213,7 @@ module TrinsicApi
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [national_id_number, full_name, given_name, middle_name, family_name, sex, date_of_birth, face_match, liveness, image_authenticity].hash
+      [national_id_number, full_name, given_name, middle_name, family_name, sex, date_of_birth, phone_number, face_match, liveness, image_authenticity].hash
     end
 
     # Builds the object from hash

data/lib/trinsic_api/models/{mdl_identity_data.rb → mdl_output.rb}

@@ -14,13 +14,16 @@ require 'date'
 require 'time'
 
 module TrinsicApi
-  class MdlIdentityData
-    # Information about the IACA Root Certificate which signed the Issuer Certificate for this mDL.
+  class MdlOutput
+    # Information about the IACA Root Certificate which signed (directly or indirectly) the Document Signer Certificate for this mDL.
     attr_accessor :iaca_root_certificate
 
     # Information about the Document Signer Certificate which signed the mDL presented by the user.
     attr_accessor :document_signer_certificate
 
+    # The document type of the mDL presented by the user.              Common values: - \"org.iso.18013.5.1.mDL\" for ISO 18013-5 mDLs - \"com.google.wallet.idcard.1\" for Google Wallet ID Cards
+    attr_accessor :document_type
+
     # The namespaces, and fields within those namespaces, which were present in the processed mDL.
     attr_accessor :name_spaces
 
@@ -29,6 +32,7 @@ module TrinsicApi
       {
         :'iaca_root_certificate' => :'iacaRootCertificate',
         :'document_signer_certificate' => :'documentSignerCertificate',
+        :'document_type' => :'documentType',
         :'name_spaces' => :'nameSpaces'
       }
     end
@@ -46,9 +50,10 @@ module TrinsicApi
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'iaca_root_certificate' => :'MdlCertificateData',
-        :'document_signer_certificate' => :'MdlCertificateData',
-        :'name_spaces' => :'Hash<String, Hash<String, ExternalMdlFieldData>>'
+        :'iaca_root_certificate' => :'MdlOutputCertificateData',
+        :'document_signer_certificate' => :'MdlOutputCertificateData',
+        :'document_type' => :'String',
+        :'name_spaces' => :'Hash<String, Hash<String, MdlOutputFieldData>>'
       }
     end
 
@@ -62,14 +67,14 @@ module TrinsicApi
     # @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 `TrinsicApi::MdlIdentityData` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `TrinsicApi::MdlOutput` 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 `TrinsicApi::MdlIdentityData`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+          fail ArgumentError, "`#{k}` is not a valid attribute in `TrinsicApi::MdlOutput`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
         end
         h[k.to_sym] = v
       }
@@ -86,6 +91,12 @@ module TrinsicApi
         self.document_signer_certificate = nil
       end
 
+      if attributes.key?(:'document_type')
+        self.document_type = attributes[:'document_type']
+      else
+        self.document_type = nil
+      end
+
       if attributes.key?(:'name_spaces')
         if (value = attributes[:'name_spaces']).is_a?(Hash)
           self.name_spaces = value
@@ -108,6 +119,10 @@ module TrinsicApi
         invalid_properties.push('invalid value for "document_signer_certificate", document_signer_certificate cannot be nil.')
       end
 
+      if @document_type.nil?
+        invalid_properties.push('invalid value for "document_type", document_type cannot be nil.')
+      end
+
       if @name_spaces.nil?
         invalid_properties.push('invalid value for "name_spaces", name_spaces cannot be nil.')
       end
@@ -121,6 +136,7 @@ module TrinsicApi
       warn '[DEPRECATED] the `valid?` method is obsolete'
       return false if @iaca_root_certificate.nil?
       return false if @document_signer_certificate.nil?
+      return false if @document_type.nil?
       return false if @name_spaces.nil?
       true
     end
@@ -145,6 +161,16 @@ module TrinsicApi
       @document_signer_certificate = document_signer_certificate
     end
 
+    # Custom attribute writer method with validation
+    # @param [Object] document_type Value to be assigned
+    def document_type=(document_type)
+      if document_type.nil?
+        fail ArgumentError, 'document_type cannot be nil'
+      end
+
+      @document_type = document_type
+    end
+
     # Custom attribute writer method with validation
     # @param [Object] name_spaces Value to be assigned
     def name_spaces=(name_spaces)
@@ -162,6 +188,7 @@ module TrinsicApi
       self.class == o.class &&
           iaca_root_certificate == o.iaca_root_certificate &&
           document_signer_certificate == o.document_signer_certificate &&
+          document_type == o.document_type &&
           name_spaces == o.name_spaces
     end
 
@@ -174,7 +201,7 @@ module TrinsicApi
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [iaca_root_certificate, document_signer_certificate, name_spaces].hash
+      [iaca_root_certificate, document_signer_certificate, document_type, name_spaces].hash
     end
 
     # Builds the object from hash

data/lib/trinsic_api/models/{mdl_certificate_data.rb → mdl_output_certificate_data.rb}

@@ -14,14 +14,14 @@ require 'date'
 require 'time'
 
 module TrinsicApi
-  class MdlCertificateData
+  class MdlOutputCertificateData
     # The serial number of the certificate
     attr_accessor :serial_number
 
     # The common name (CN) of the certificate
     attr_accessor :common_name
 
-    # The state or province name (ST) of the certificate.              May be an empty string for certificates which are not state-specific (e.g., Google Wallet's ID Pass certificates).
+    # The stateOrProvinceName field from the signing certificate.              Per the ISO 18013-5 (mDL) spec, this is an ISO 3166-2:2020 country subdivision code (e.g., \"US-CA\" for California, USA).              May be an empty string for certificates which are not state-specific (e.g., Google Wallet's ID Pass certificates).
     attr_accessor :state_or_province_name
 
     # The date before which this certificate is not valid.
@@ -72,14 +72,14 @@ module TrinsicApi
     # @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 `TrinsicApi::MdlCertificateData` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `TrinsicApi::MdlOutputCertificateData` 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 `TrinsicApi::MdlCertificateData`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+          fail ArgumentError, "`#{k}` is not a valid attribute in `TrinsicApi::MdlOutputCertificateData`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
         end
         h[k.to_sym] = v
       }

data/lib/trinsic_api/models/{external_mdl_field_data.rb → mdl_output_field_data.rb}

@@ -14,7 +14,7 @@ require 'date'
 require 'time'
 
 module TrinsicApi
-  class ExternalMdlFieldData
+  class MdlOutputFieldData
     # The type of data contained in `value`.
     attr_accessor :type
 
@@ -64,7 +64,7 @@ module TrinsicApi
     # Attribute type mapping.
     def self.openapi_types
       {
-        :'type' => :'MdlFieldDataType',
+        :'type' => :'MdlOutputFieldDataType',
         :'value' => :'String'
       }
     end
@@ -79,14 +79,14 @@ module TrinsicApi
     # @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 `TrinsicApi::ExternalMdlFieldData` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `TrinsicApi::MdlOutputFieldData` 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 `TrinsicApi::ExternalMdlFieldData`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+          fail ArgumentError, "`#{k}` is not a valid attribute in `TrinsicApi::MdlOutputFieldData`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
         end
         h[k.to_sym] = v
       }

data/lib/trinsic_api/models/{mdl_field_data_type.rb → mdl_output_field_data_type.rb}

@@ -14,15 +14,16 @@ require 'date'
 require 'time'
 
 module TrinsicApi
-  class MdlFieldDataType
+  class MdlOutputFieldDataType
     STRING = "String".freeze
     BOOLEAN = "Boolean".freeze
     NUMBER = "Number".freeze
     BASE64_URL = "Base64Url".freeze
     ENCODED_CBOR = "EncodedCbor".freeze
+    INTENTIONALLY_OMITTED = "IntentionallyOmitted".freeze
 
     def self.all_vars
-      @all_vars ||= [STRING, BOOLEAN, NUMBER, BASE64_URL, ENCODED_CBOR].freeze
+      @all_vars ||= [STRING, BOOLEAN, NUMBER, BASE64_URL, ENCODED_CBOR, INTENTIONALLY_OMITTED].freeze
     end
 
     # Builds the enum from string
@@ -36,8 +37,8 @@ module TrinsicApi
     # @param [String] The enum value in the form of the string
     # @return [String] The enum value
     def build_from_hash(value)
-      return value if MdlFieldDataType.all_vars.include?(value)
-      raise "Invalid ENUM value #{value} for class #MdlFieldDataType"
+      return value if MdlOutputFieldDataType.all_vars.include?(value)
+      raise "Invalid ENUM value #{value} for class #MdlOutputFieldDataType"
     end
   end
 end

data/lib/trinsic_api/models/mexico_curp_provider_output.rb

@@ -14,6 +14,7 @@ require 'date'
 require 'time'
 
 module TrinsicApi
+  # Exposed properties for the `mexico-curp-lookup` Provider which do not directly map to the normalized IdentityData model.
   class MexicoCurpProviderOutput
     # Curp status for the subject.              Possible values: - AN: Alta Normal (Normal registration) - Active - AH: Alta con Homonimia (Registration with homonymy) - Active - RCC: Registro de cambio afectando a CURP (Change affecting CURP) - Active - RCN: Registro de cambio no afectando a CURP (Change not affecting CURP) - Active - BAP: Baja por documento apócrifo (Low due to apocryphal document) - Inactive - BSU: Baja sin uso (Low curp without use) - Inactive - BD: Baja por defunción (Low curp due to death) - Inactive - BDM: Baja administrativa (Low, due to administrative process) - Inactive - BDP: Baja por adopción (Low, due to adoption) - Inactive - BJD: Baja Judicial (Low for judicial reasons) - Inactive
     attr_accessor :curp_status

data/lib/trinsic_api/models/mit_id_provider_output.rb

@@ -0,0 +1,333 @@
+=begin
+#Trinsic API
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: v1
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.13.0
+
+=end
+
+require 'date'
+require 'time'
+
+module TrinsicApi
+  # Exposed properties for the `denmark-mitid` Provider which do not directly map to the normalized IdentityData model.
+  class MitIdProviderOutput
+    # The full name of the individual.
+    attr_accessor :full_name
+
+    # The date of birth of the individual.
+    attr_accessor :date_of_birth
+
+    # A stable unique identifier representing the user in MitID's system. It is recommended to use this identifier instead of using the civil registration number (CPR number) directly.
+    attr_accessor :unique_identifier
+
+    # The authentication assurance level (AAL) for the verification. The National Institute of Standards and Technology (NIST) measures the confidence in a digital identity's authentication strength set by a set of requirements for different levels. More information can be found here: https://pages.nist.gov/800-63-4/sp800-63b/aal/#AAL_SEC4 Possible values:              -  https://data.gov.dk/concept/core/nsis/Low - (Level 1) Provides basic confidence that the authenticator is either single factor or multifactor authentication. - https://data.gov.dk/concept/core/nsis/Substantial - (Level 2) Provides high confidence that the authenticator uses two distinct authentication factors that use secure authentication protocols. - https://data.gov.dk/concept/core/nsis/High - (Level 3) Provides very high confidence that the authenticator uses an non-exportable private key and another authentication factor.              **Note**: These urls are not valid anymore, but they still contain the level of assurance name.
+    attr_accessor :authentication_assurance_level
+
+    # The identity assurance level (IAL) for the verification. The National Institute of Standards and Technology (NIST) measures the confidence of the digital identity's verification set by a set of requirements for different levels. More information can be found here: https://pages.nist.gov/800-63-4/sp800-63b/aal/#AAL_SEC4 Possible values:              -  https://data.gov.dk/concept/core/nsis/Low - (Level 1) The user has self asserted their identity and is neither verified nor validated. - https://data.gov.dk/concept/core/nsis/Substantial - (Level 2) The user has performed either a remote or in-person identity proofing. - https://data.gov.dk/concept/core/nsis/High - (Level 3) The user has performed an in person identity proofing with an authorized representative.              **Note**: These urls are not valid anymore, but they still contain the level of assurance name.
+    attr_accessor :identity_authentication_level
+
+    # The level of assurance (LOA) for the verification. This is an older retired model that is a combination of Identity Assurance Level and Authentication Assurance Level. The National Institute of Standards and Technology (NIST) measures the confidence of the digital identity's verification and authentication strength by a set of requirements for different levels.              Possible values: -  https://data.gov.dk/concept/core/nsis/Low - (Level 1) The user has self asserted their identity and multifactor authentication is not required. - https://data.gov.dk/concept/core/nsis/Substantial - (Level 3) The user has performed either a remote or in-person identity proofing and multifactor authentication is required. - https://data.gov.dk/concept/core/nsis/High - (Level 4) The user has performed an in person identity proofing with an authorized representative and has strong cryptographic authentication requirements.              **Note**: These urls are not valid anymore, but they still contain the level of assurance name. MitID only returns three of the four potential levels and does not include level 2.              More information can be found here: - https://pages.nist.gov/800-63-3/sp800-63-3.html - https://pages.nist.gov/800-63-3/
+    attr_accessor :level_of_assurance
+
+    # The source of the identification for the verification              Possible values: - private - The verification is from a private individual. - professional - The verification is a user in behalf of a organization.
+    attr_accessor :identification_source
+
+    # The civil registration number (CPR number) of the individual for the verification.              The CPR number is a 10-digit number in the format DDMMYYY-XXXX, where: - DDMMYYY represents the individual's date of birth (day, month, year). - XXXX is a unique identifier.              If XXXX is even, the individual is female. If XXXX is odd, the individual is male.              More information can be found here: https://international.kk.dk/live/cpr-registration-and-documents/cpr-number
+    attr_accessor :civil_registration_number
+
+    # The name of the organization for the verification
+    attr_accessor :organization_name
+
+    # The organization number (CVR number). This is an 8-digit unique identifier for the organization. This will be prefixed with \"DK\" for VAT numbers.
+    attr_accessor :organization_number
+
+    # The organization number (CVR number) of the organization the user is authorized to represent. This is only returned if the requested scope is for an organization verification and the user provides a private source in behalf of a company.
+    attr_accessor :authorized_representative_number
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'full_name' => :'fullName',
+        :'date_of_birth' => :'dateOfBirth',
+        :'unique_identifier' => :'uniqueIdentifier',
+        :'authentication_assurance_level' => :'authenticationAssuranceLevel',
+        :'identity_authentication_level' => :'identityAuthenticationLevel',
+        :'level_of_assurance' => :'levelOfAssurance',
+        :'identification_source' => :'identificationSource',
+        :'civil_registration_number' => :'civilRegistrationNumber',
+        :'organization_name' => :'organizationName',
+        :'organization_number' => :'organizationNumber',
+        :'authorized_representative_number' => :'authorizedRepresentativeNumber'
+      }
+    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
+      {
+        :'full_name' => :'String',
+        :'date_of_birth' => :'Date',
+        :'unique_identifier' => :'String',
+        :'authentication_assurance_level' => :'String',
+        :'identity_authentication_level' => :'String',
+        :'level_of_assurance' => :'String',
+        :'identification_source' => :'String',
+        :'civil_registration_number' => :'String',
+        :'organization_name' => :'String',
+        :'organization_number' => :'String',
+        :'authorized_representative_number' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'full_name',
+        :'date_of_birth',
+        :'unique_identifier',
+        :'authentication_assurance_level',
+        :'identity_authentication_level',
+        :'level_of_assurance',
+        :'identification_source',
+        :'civil_registration_number',
+        :'organization_name',
+        :'organization_number',
+        :'authorized_representative_number'
+      ])
+    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 `TrinsicApi::MitIdProviderOutput` 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 `TrinsicApi::MitIdProviderOutput`. 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?(:'full_name')
+        self.full_name = attributes[:'full_name']
+      end
+
+      if attributes.key?(:'date_of_birth')
+        self.date_of_birth = attributes[:'date_of_birth']
+      end
+
+      if attributes.key?(:'unique_identifier')
+        self.unique_identifier = attributes[:'unique_identifier']
+      end
+
+      if attributes.key?(:'authentication_assurance_level')
+        self.authentication_assurance_level = attributes[:'authentication_assurance_level']
+      end
+
+      if attributes.key?(:'identity_authentication_level')
+        self.identity_authentication_level = attributes[:'identity_authentication_level']
+      end
+
+      if attributes.key?(:'level_of_assurance')
+        self.level_of_assurance = attributes[:'level_of_assurance']
+      end
+
+      if attributes.key?(:'identification_source')
+        self.identification_source = attributes[:'identification_source']
+      end
+
+      if attributes.key?(:'civil_registration_number')
+        self.civil_registration_number = attributes[:'civil_registration_number']
+      end
+
+      if attributes.key?(:'organization_name')
+        self.organization_name = attributes[:'organization_name']
+      end
+
+      if attributes.key?(:'organization_number')
+        self.organization_number = attributes[:'organization_number']
+      end
+
+      if attributes.key?(:'authorized_representative_number')
+        self.authorized_representative_number = attributes[:'authorized_representative_number']
+      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
+      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'
+      true
+    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 &&
+          full_name == o.full_name &&
+          date_of_birth == o.date_of_birth &&
+          unique_identifier == o.unique_identifier &&
+          authentication_assurance_level == o.authentication_assurance_level &&
+          identity_authentication_level == o.identity_authentication_level &&
+          level_of_assurance == o.level_of_assurance &&
+          identification_source == o.identification_source &&
+          civil_registration_number == o.civil_registration_number &&
+          organization_name == o.organization_name &&
+          organization_number == o.organization_number &&
+          authorized_representative_number == o.authorized_representative_number
+    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
+      [full_name, date_of_birth, unique_identifier, authentication_assurance_level, identity_authentication_level, level_of_assurance, identification_source, civil_registration_number, organization_name, organization_number, authorized_representative_number].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
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = TrinsicApi.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_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
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/lib/trinsic_api/models/mobile_id_input.rb

@@ -70,7 +70,7 @@ module TrinsicApi
       {
         :'mobile_id_phone_number' => :'String',
         :'mobile_id_national_identity_number' => :'String',
-        :'mobile_id_language' => :'Language'
+        :'mobile_id_language' => :'MobileIdLanguage'
       }
     end