text: """
      ORY Hydra
  
      Welcome to the ORY Hydra HTTP API documentation. You will find documentation for all HTTP APIs here.  # noqa: E501
  
      The version of the OpenAPI document: v1.10.5
      Generated by: https://openapi-generator.tech
  """
  
  
  import re  # noqa: F401
  import sys  # noqa: F401
  
  from ory_hydra_client.api_client import ApiClient, Endpoint as _Endpoint
  from ory_hydra_client.model_utils import (  # noqa: F401
      check_allowed_values,
      check_validations,
      date,
      datetime,
      file_type,
      none_type,
      validate_and_convert_types
  )
  from ory_hydra_client.model.health_not_ready_status import HealthNotReadyStatus
  from ory_hydra_client.model.health_status import HealthStatus
  from ory_hydra_client.model.json_web_key_set import JSONWebKeySet
  from ory_hydra_client.model.json_error import JsonError
  from ory_hydra_client.model.oauth2_token_response import Oauth2TokenResponse
  from ory_hydra_client.model.userinfo_response import UserinfoResponse
  from ory_hydra_client.model.well_known import WellKnown
  
  
  class PublicApi(object):
      """NOTE: This class is auto generated by OpenAPI Generator
      Ref: https://openapi-generator.tech
  
      Do not edit the class manually.
      """
  
      def __init__(self, api_client=None):
          if api_client is None:
              api_client = ApiClient()
          self.api_client = api_client
  
          def __disconnect_user(
              self,
              **kwargs
          ):
              """OpenID Connect Front-Backchannel Enabled Logout  # noqa: E501
  
              This endpoint initiates and completes user logout at ORY Hydra and initiates OpenID Connect Front-/Back-channel logout:  https://openid.net/specs/openid-connect-frontchannel-1_0.html https://openid.net/specs/openid-connect-backchannel-1_0.html  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.disconnect_user(async_req=True)
              >>> result = thread.get()
  
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  _check_input_type (bool): specifies if type checking
                      should be done one the data sent to the server.
                      Default is True.
                  _check_return_type (bool): specifies if type checking
                      should be done one the data received from the server.
                      Default is True.
                  _host_index (int/None): specifies the index of the server
                      that we want to use.
                      Default is read from the configuration.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  None
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['_check_input_type'] = kwargs.get(
                  '_check_input_type', True
              )
              kwargs['_check_return_type'] = kwargs.get(
                  '_check_return_type', True
              )
              kwargs['_host_index'] = kwargs.get('_host_index')
              return self.call_with_http_info(**kwargs)
  
          self.disconnect_user = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [],
                  'endpoint_path': '/oauth2/sessions/logout',
                  'operation_id': 'disconnect_user',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [],
                  'content_type': [],
              },
              api_client=api_client,
              callable=__disconnect_user
          )
  
          def __discover_open_id_configuration(
              self,
              **kwargs
          ):
              """OpenID Connect Discovery  # noqa: E501
  
              The well known endpoint an be used to retrieve information for OpenID Connect clients. We encourage you to not roll your own OpenID Connect client but to use an OpenID Connect client library instead. You can learn more on this flow at https://openid.net/specs/openid-connect-discovery-1_0.html .  Popular libraries for OpenID Connect clients include oidc-client-js (JavaScript), go-oidc (Golang), and others. For a full list of clients go here: https://openid.net/developers/certified/  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.discover_open_id_configuration(async_req=True)
              >>> result = thread.get()
  
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  _check_input_type (bool): specifies if type checking
                      should be done one the data sent to the server.
                      Default is True.
                  _check_return_type (bool): specifies if type checking
                      should be done one the data received from the server.
                      Default is True.
                  _host_index (int/None): specifies the index of the server
                      that we want to use.
                      Default is read from the configuration.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  WellKnown
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['_check_input_type'] = kwargs.get(
                  '_check_input_type', True
              )
              kwargs['_check_return_type'] = kwargs.get(
                  '_check_return_type', True
              )
              kwargs['_host_index'] = kwargs.get('_host_index')
              return self.call_with_http_info(**kwargs)
  
          self.discover_open_id_configuration = _Endpoint(
              settings={
                  'response_type': (WellKnown,),
                  'auth': [],
                  'endpoint_path': '/.well-known/openid-configuration',
                  'operation_id': 'discover_open_id_configuration',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [],
              },
              api_client=api_client,
              callable=__discover_open_id_configuration
          )
  
          def __is_instance_ready(
              self,
              **kwargs
          ):
              """Check Readiness Status  # noqa: E501
  
              This endpoint returns a 200 status code when the HTTP server is up running and the environment dependencies (e.g. the database) are responsive as well.  If the service supports TLS Edge Termination, this endpoint does not require the `X-Forwarded-Proto` header to be set.  Be aware that if you are running multiple nodes of this service, the health status will never refer to the cluster state, only to a single instance.  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.is_instance_ready(async_req=True)
              >>> result = thread.get()
  
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  _check_input_type (bool): specifies if type checking
                      should be done one the data sent to the server.
                      Default is True.
                  _check_return_type (bool): specifies if type checking
                      should be done one the data received from the server.
                      Default is True.
                  _host_index (int/None): specifies the index of the server
                      that we want to use.
                      Default is read from the configuration.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  HealthStatus
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['_check_input_type'] = kwargs.get(
                  '_check_input_type', True
              )
              kwargs['_check_return_type'] = kwargs.get(
                  '_check_return_type', True
              )
              kwargs['_host_index'] = kwargs.get('_host_index')
              return self.call_with_http_info(**kwargs)
  
          self.is_instance_ready = _Endpoint(
              settings={
                  'response_type': (HealthStatus,),
                  'auth': [],
                  'endpoint_path': '/health/ready',
                  'operation_id': 'is_instance_ready',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [],
              },
              api_client=api_client,
              callable=__is_instance_ready
          )
  
          def __oauth2_token(
              self,
              grant_type,
              **kwargs
          ):
              """The OAuth 2.0 Token Endpoint  # noqa: E501
  
              The client makes a request to the token endpoint by sending the following parameters using the \"application/x-www-form-urlencoded\" HTTP request entity-body.  > Do not implement a client for this endpoint yourself. Use a library. There are many libraries > available for any programming language. You can find a list of libraries here: https://oauth.net/code/ > > Do note that Hydra SDK does not implement this endpoint properly. Use one of the libraries listed above!  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.oauth2_token(grant_type, async_req=True)
              >>> result = thread.get()
  
              Args:
                  grant_type (str):
  
              Keyword Args:
                  code (str): [optional]
                  refresh_token (str): [optional]
                  redirect_uri (str): [optional]
                  client_id (str): [optional]
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  _check_input_type (bool): specifies if type checking
                      should be done one the data sent to the server.
                      Default is True.
                  _check_return_type (bool): specifies if type checking
                      should be done one the data received from the server.
                      Default is True.
                  _host_index (int/None): specifies the index of the server
                      that we want to use.
                      Default is read from the configuration.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  Oauth2TokenResponse
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['_check_input_type'] = kwargs.get(
                  '_check_input_type', True
              )
              kwargs['_check_return_type'] = kwargs.get(
                  '_check_return_type', True
              )
              kwargs['_host_index'] = kwargs.get('_host_index')
              kwargs['grant_type'] = \
                  grant_type
              return self.call_with_http_info(**kwargs)
  
          self.oauth2_token = _Endpoint(
              settings={
                  'response_type': (Oauth2TokenResponse,),
                  'auth': [
                      'basic',
                      'oauth2'
                  ],
                  'endpoint_path': '/oauth2/token',
                  'operation_id': 'oauth2_token',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'grant_type',
                      'code',
                      'refresh_token',
                      'redirect_uri',
                      'client_id',
                  ],
                  'required': [
                      'grant_type',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'grant_type':
                          (str,),
                      'code':
                          (str,),
                      'refresh_token':
                          (str,),
                      'redirect_uri':
                          (str,),
                      'client_id':
                          (str,),
                  },
                  'attribute_map': {
                      'grant_type': 'grant_type',
                      'code': 'code',
                      'refresh_token': 'refresh_token',
                      'redirect_uri': 'redirect_uri',
                      'client_id': 'client_id',
                  },
                  'location_map': {
                      'grant_type': 'form',
                      'code': 'form',
                      'refresh_token': 'form',
                      'redirect_uri': 'form',
                      'client_id': 'form',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/x-www-form-urlencoded'
                  ]
              },
              api_client=api_client,
              callable=__oauth2_token
          )
  
          def __oauth_auth(
              self,
              **kwargs
          ):
              """The OAuth 2.0 Authorize Endpoint  # noqa: E501
  
              This endpoint is not documented here because you should never use your own implementation to perform OAuth2 flows. OAuth2 is a very popular protocol and a library for your programming language will exists.  To learn more about this flow please refer to the specification: https://tools.ietf.org/html/rfc6749  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.oauth_auth(async_req=True)
              >>> result = thread.get()
  
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  _check_input_type (bool): specifies if type checking
                      should be done one the data sent to the server.
                      Default is True.
                  _check_return_type (bool): specifies if type checking
                      should be done one the data received from the server.
                      Default is True.
                  _host_index (int/None): specifies the index of the server
                      that we want to use.
                      Default is read from the configuration.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  None
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['_check_input_type'] = kwargs.get(
                  '_check_input_type', True
              )
              kwargs['_check_return_type'] = kwargs.get(
                  '_check_return_type', True
              )
              kwargs['_host_index'] = kwargs.get('_host_index')
              return self.call_with_http_info(**kwargs)
  
          self.oauth_auth = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [],
                  'endpoint_path': '/oauth2/auth',
                  'operation_id': 'oauth_auth',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [],
              },
              api_client=api_client,
              callable=__oauth_auth
          )
  
          def __revoke_o_auth2_token(
              self,
              token,
              **kwargs
          ):
              """Revoke OAuth2 Tokens  # noqa: E501
  
              Revoking a token (both access and refresh) means that the tokens will be invalid. A revoked access token can no longer be used to make access requests, and a revoked refresh token can no longer be used to refresh an access token. Revoking a refresh token also invalidates the access token that was created with it. A token may only be revoked by the client the token was generated for.  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.revoke_o_auth2_token(token, async_req=True)
              >>> result = thread.get()
  
              Args:
                  token (str):
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  _check_input_type (bool): specifies if type checking
                      should be done one the data sent to the server.
                      Default is True.
                  _check_return_type (bool): specifies if type checking
                      should be done one the data received from the server.
                      Default is True.
                  _host_index (int/None): specifies the index of the server
                      that we want to use.
                      Default is read from the configuration.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  None
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['_check_input_type'] = kwargs.get(
                  '_check_input_type', True
              )
              kwargs['_check_return_type'] = kwargs.get(
                  '_check_return_type', True
              )
              kwargs['_host_index'] = kwargs.get('_host_index')
              kwargs['token'] = \
                  token
              return self.call_with_http_info(**kwargs)
  
          self.revoke_o_auth2_token = _Endpoint(
              settings={
                  'response_type': None,
                  'auth': [
                      'basic',
                      'oauth2'
                  ],
                  'endpoint_path': '/oauth2/revoke',
                  'operation_id': 'revoke_o_auth2_token',
                  'http_method': 'POST',
                  'servers': None,
              },
              params_map={
                  'all': [
                      'token',
                  ],
                  'required': [
                      'token',
                  ],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                      'token':
                          (str,),
                  },
                  'attribute_map': {
                      'token': 'token',
                  },
                  'location_map': {
                      'token': 'form',
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [
                      'application/x-www-form-urlencoded'
                  ]
              },
              api_client=api_client,
              callable=__revoke_o_auth2_token
          )
  
          def __userinfo(
              self,
              **kwargs
          ):
              """OpenID Connect Userinfo  # noqa: E501
  
              This endpoint returns the payload of the ID Token, including the idTokenExtra values, of the provided OAuth 2.0 Access Token.  For more information please [refer to the spec](http://openid.net/specs/openid-connect-core-1_0.html#UserInfo).  In the case of authentication error, a WWW-Authenticate header might be set in the response with more information about the error. See [the spec](https://datatracker.ietf.org/doc/html/rfc6750#section-3) for more details about header format.  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.userinfo(async_req=True)
              >>> result = thread.get()
  
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  _check_input_type (bool): specifies if type checking
                      should be done one the data sent to the server.
                      Default is True.
                  _check_return_type (bool): specifies if type checking
                      should be done one the data received from the server.
                      Default is True.
                  _host_index (int/None): specifies the index of the server
                      that we want to use.
                      Default is read from the configuration.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  UserinfoResponse
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['_check_input_type'] = kwargs.get(
                  '_check_input_type', True
              )
              kwargs['_check_return_type'] = kwargs.get(
                  '_check_return_type', True
              )
              kwargs['_host_index'] = kwargs.get('_host_index')
              return self.call_with_http_info(**kwargs)
  
          self.userinfo = _Endpoint(
              settings={
                  'response_type': (UserinfoResponse,),
                  'auth': [
                      'oauth2'
                  ],
                  'endpoint_path': '/userinfo',
                  'operation_id': 'userinfo',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [],
              },
              api_client=api_client,
              callable=__userinfo
          )
  
          def __well_known(
              self,
              **kwargs
          ):
              """JSON Web Keys Discovery  # noqa: E501
  
              This endpoint returns JSON Web Keys to be used as public keys for verifying OpenID Connect ID Tokens and, if enabled, OAuth 2.0 JWT Access Tokens. This endpoint can be used with client libraries like [node-jwks-rsa](https://github.com/auth0/node-jwks-rsa) among others.  # noqa: E501
              This method makes a synchronous HTTP request by default. To make an
              asynchronous HTTP request, please pass async_req=True
  
              >>> thread = api.well_known(async_req=True)
              >>> result = thread.get()
  
  
              Keyword Args:
                  _return_http_data_only (bool): response data without head status
                      code and headers. Default is True.
                  _preload_content (bool): if False, the urllib3.HTTPResponse object
                      will be returned without reading/decoding response data.
                      Default is True.
                  _request_timeout (float/tuple): timeout setting for this request. If one
                      number provided, it will be total request timeout. It can also
                      be a pair (tuple) of (connection, read) timeouts.
                      Default is None.
                  _check_input_type (bool): specifies if type checking
                      should be done one the data sent to the server.
                      Default is True.
                  _check_return_type (bool): specifies if type checking
                      should be done one the data received from the server.
                      Default is True.
                  _host_index (int/None): specifies the index of the server
                      that we want to use.
                      Default is read from the configuration.
                  async_req (bool): execute request asynchronously
  
              Returns:
                  JSONWebKeySet
                      If the method is called asynchronously, returns the request
                      thread.
              """
              kwargs['async_req'] = kwargs.get(
                  'async_req', False
              )
              kwargs['_return_http_data_only'] = kwargs.get(
                  '_return_http_data_only', True
              )
              kwargs['_preload_content'] = kwargs.get(
                  '_preload_content', True
              )
              kwargs['_request_timeout'] = kwargs.get(
                  '_request_timeout', None
              )
              kwargs['_check_input_type'] = kwargs.get(
                  '_check_input_type', True
              )
              kwargs['_check_return_type'] = kwargs.get(
                  '_check_return_type', True
              )
              kwargs['_host_index'] = kwargs.get('_host_index')
              return self.call_with_http_info(**kwargs)
  
          self.well_known = _Endpoint(
              settings={
                  'response_type': (JSONWebKeySet,),
                  'auth': [],
                  'endpoint_path': '/.well-known/jwks.json',
                  'operation_id': 'well_known',
                  'http_method': 'GET',
                  'servers': None,
              },
              params_map={
                  'all': [
                  ],
                  'required': [],
                  'nullable': [
                  ],
                  'enum': [
                  ],
                  'validation': [
                  ]
              },
              root_map={
                  'validations': {
                  },
                  'allowed_values': {
                  },
                  'openapi_types': {
                  },
                  'attribute_map': {
                  },
                  'location_map': {
                  },
                  'collection_format_map': {
                  }
              },
              headers_map={
                  'accept': [
                      'application/json'
                  ],
                  'content_type': [],
              },
              api_client=api_client,
              callable=__well_known
          )
  