docs: def verify(self, **kwargs):
          """Authorization Request parameters that are OPTIONAL in the OAuth 2.0
          specification MAY be included in the OpenID Request Object without also
          passing them as OAuth 2.0 Authorization Request parameters, with one
          exception: The scope parameter MUST always be present in OAuth 2.0
          Authorization Request parameters.
          All parameter values that are present both in the OAuth 2.0
          Authorization Request and in the OpenID Request Object MUST exactly
          match."""
          super(AuthorizationRequest, self).verify(**kwargs)
  
          clear_verified_claims(self)
  
          args = {}
          for arg in ["keyjar", "opponent_id", "sender", "alg", "encalg",
                      "encenc"]:
              try:
                  args[arg] = kwargs[arg]
              except KeyError:
                  pass
  
          if "opponent_id" not in kwargs:
              args["opponent_id"] = self["client_id"]
  
          if "request" in self:
              if isinstance(self["request"], str):
                  # Try to decode the JWT, checks the signature
                  oidr = OpenIDRequest().from_jwt(str(self["request"]), **args)
  
                  # check if something is change in the original message
                  for key, val in oidr.items():
                      if key in self:
                          if self[key] != val:
                              # log but otherwise ignore
                              logger.warning('{} != {}'.format(self[key], val))
  
                  # remove all claims
                  _keys = list(self.keys())
                  for key in _keys:
                      if key not in oidr:
                          del self[key]
  
                  self.update(oidr)
  
                  # replace the JWT with the parsed and verified instance
                  self[verified_claim_name("request")] = oidr
  
          if "id_token_hint" in self:
              if isinstance(self["id_token_hint"], str):
                  idt = IdToken().from_jwt(str(self["id_token_hint"]), **args)
                  self["verified_id_token_hint"] = idt
  
          if "response_type" not in self:
              raise MissingRequiredAttribute("response_type missing", self)
  
          _rt = self["response_type"]
          if "id_token" in _rt:
              if "nonce" not in self:
                  raise MissingRequiredAttribute("Nonce missing", self)
              else:
                  try:
                      if self['nonce'] != kwargs['nonce']:
                          raise ValueError(
                              'Nonce in id_token not matching nonce in authz '
                              'request')
                  except KeyError:
                      pass
  
          if "openid" not in self.get("scope", []):
              raise MissingRequiredValue("openid not in scope", self)
  
          if "offline_access" in self.get("scope", []):
              if "prompt" not in self or "consent" not in self["prompt"]:
                  raise MissingRequiredValue("consent in prompt", self)
  
          if "prompt" in self:
              if "none" in self["prompt"] and len(self["prompt"]) > 1:
                  raise InvalidRequest("prompt none combined with other value",
                                       self)
  
          return True