docs: def create(self, email, device_name, passphrase=None,
                 api_token=None, redirect_uri=None, **kwargs):
          """Create a new User object and add it to this Users collection.
  
          In addition to creating a user, this call will create a device for that
          user, whose device_token will be returned from this call. Store the
          device_token, as it's required to complete Gem-Device authentication
          after the user approves the device at the end of their signup flow.
  
          If you lose the device_token returned from users.create, you'll have to
          create a new device for the user to gain access to their account again.
  
          Also, after this call, be sure to redirect the user to the location in
          `mfa_uri` (second return value of this function) to complete their
          account.
  
          If you get a 409 Conflict error, then the user already exists in the Gem
          system and you'll want to do a
          `client.user(email).devices.create(device_name)`
  
          Args:
            email (str)
            device_name (str): Human-readable name for the device through which
              your Application will be authorized to access the new User's account.
            passphrase (str, optional): A passphrase with which to encrypt a user
              wallet. If not provided, a default_wallet parameter must be passed in
              kwargs.
            api_token (str, optional): Your app's API token. This is optional if
              and only if the Client which will be calling this function already
              has Gem-Application or Gem-Identify authentication.
            redirect_uri (str, optional): A URI to which to redirect the User after
              they confirm their Gem account.
            **kwargs
  
          Returns: device_token
          """
  
          if not passphrase and u'default_wallet' not in kwargs:
              raise ValueError("Usage: users.create(email, passphrase, device_name"
                               ", api_token, redirect_uri)")
          elif passphrase:
              default_wallet = generate(passphrase, ['primary'])['primary']
          else:
              default_wallet = kwargs['default_wallet']
  
          default_wallet['name'] = 'default'
          default_wallet['primary_private_seed'] = default_wallet['encrypted_seed']
          default_wallet['primary_public_seed'] = default_wallet['public_seed']
          del default_wallet['encrypted_seed']
          del default_wallet['public_seed']
          del default_wallet['private_seed']
  
          # If not supplied, we assume the client already has an api_token param.
          if api_token:
              self.client.authenticate_identify(api_token)
  
          user_data = dict(email=email,
                           default_wallet=default_wallet,
                           device_name=device_name)
  
          if redirect_uri:
              user_data['redirect_uri'] = redirect_uri
          if 'first_name' in kwargs:
              user_data['first_name'] = kwargs['first_name']
          if 'last_name' in kwargs:
              user_data['last_name'] = kwargs['last_name']
  
          try:
              resource = self.resource.create(user_data)
          except ResponseError as e:
              if "conflict" in e.message:
                  raise ConflictError(
                      "This user already exists. Use "
                      "client.user(email).devices.create(name) to request "
                      "authorization from the user.")
              raise e
  
          return resource.attributes['metadata']['device_token']