generated/googleapis/lib/identitytoolkit/v3.dart

// This is a generated file (see the discoveryapis_generator project).

library googleapis.identitytoolkit.v3;

import 'dart:core' as core;
import 'dart:collection' as collection;
import 'dart:async' as async;
import 'dart:convert' as convert;

import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;

export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
    show ApiRequestError, DetailedApiRequestError;

const core.String USER_AGENT = 'dart-api-client identitytoolkit/v3';

/// Help the third party sites to implement federated login.
class IdentitytoolkitApi {
  /// View and manage your data across Google Cloud Platform services
  static const CloudPlatformScope =
      "https://www.googleapis.com/auth/cloud-platform";

  /// View and administer all your Firebase data and settings
  static const FirebaseScope = "https://www.googleapis.com/auth/firebase";

  final commons.ApiRequester _requester;

  RelyingpartyResourceApi get relyingparty =>
      new RelyingpartyResourceApi(_requester);

  IdentitytoolkitApi(http.Client client,
      {core.String rootUrl: "https://www.googleapis.com/",
      core.String servicePath: "identitytoolkit/v3/relyingparty/"})
      : _requester =
            new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
}

class RelyingpartyResourceApi {
  final commons.ApiRequester _requester;

  RelyingpartyResourceApi(commons.ApiRequester client) : _requester = client;

  /// Creates the URI used by the IdP to authenticate the user.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [CreateAuthUriResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<CreateAuthUriResponse> createAuthUri(
      IdentitytoolkitRelyingpartyCreateAuthUriRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'createAuthUri';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new CreateAuthUriResponse.fromJson(data));
  }

  /// Delete user account.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [DeleteAccountResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<DeleteAccountResponse> deleteAccount(
      IdentitytoolkitRelyingpartyDeleteAccountRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'deleteAccount';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new DeleteAccountResponse.fromJson(data));
  }

  /// Batch download user accounts.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [DownloadAccountResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<DownloadAccountResponse> downloadAccount(
      IdentitytoolkitRelyingpartyDownloadAccountRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'downloadAccount';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new DownloadAccountResponse.fromJson(data));
  }

  /// Reset password for a user.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [EmailLinkSigninResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<EmailLinkSigninResponse> emailLinkSignin(
      IdentitytoolkitRelyingpartyEmailLinkSigninRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'emailLinkSignin';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new EmailLinkSigninResponse.fromJson(data));
  }

  /// Returns the account info.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [GetAccountInfoResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<GetAccountInfoResponse> getAccountInfo(
      IdentitytoolkitRelyingpartyGetAccountInfoRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'getAccountInfo';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new GetAccountInfoResponse.fromJson(data));
  }

  /// Get a code for user action confirmation.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [GetOobConfirmationCodeResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<GetOobConfirmationCodeResponse> getOobConfirmationCode(
      Relyingparty request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'getOobConfirmationCode';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response
        .then((data) => new GetOobConfirmationCodeResponse.fromJson(data));
  }

  /// Get project configuration.
  ///
  /// Request parameters:
  ///
  /// [delegatedProjectNumber] - Delegated GCP project number of the request.
  ///
  /// [projectNumber] - GCP project number of the request.
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [IdentitytoolkitRelyingpartyGetProjectConfigResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<IdentitytoolkitRelyingpartyGetProjectConfigResponse>
      getProjectConfig(
          {core.String delegatedProjectNumber,
          core.String projectNumber,
          core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (delegatedProjectNumber != null) {
      _queryParams["delegatedProjectNumber"] = [delegatedProjectNumber];
    }
    if (projectNumber != null) {
      _queryParams["projectNumber"] = [projectNumber];
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'getProjectConfig';

    var _response = _requester.request(_url, "GET",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) =>
        new IdentitytoolkitRelyingpartyGetProjectConfigResponse.fromJson(data));
  }

  /// Get token signing public key.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [IdentitytoolkitRelyingpartyGetPublicKeysResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<IdentitytoolkitRelyingpartyGetPublicKeysResponse> getPublicKeys(
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'publicKeys';

    var _response = _requester.request(_url, "GET",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) =>
        new IdentitytoolkitRelyingpartyGetPublicKeysResponse.fromJson(data));
  }

  /// Get recaptcha secure param.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [GetRecaptchaParamResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<GetRecaptchaParamResponse> getRecaptchaParam(
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'getRecaptchaParam';

    var _response = _requester.request(_url, "GET",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response
        .then((data) => new GetRecaptchaParamResponse.fromJson(data));
  }

  /// Reset password for a user.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [ResetPasswordResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<ResetPasswordResponse> resetPassword(
      IdentitytoolkitRelyingpartyResetPasswordRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'resetPassword';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new ResetPasswordResponse.fromJson(data));
  }

  /// Send SMS verification code.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a
  /// [IdentitytoolkitRelyingpartySendVerificationCodeResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<IdentitytoolkitRelyingpartySendVerificationCodeResponse>
      sendVerificationCode(
          IdentitytoolkitRelyingpartySendVerificationCodeRequest request,
          {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'sendVerificationCode';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) =>
        new IdentitytoolkitRelyingpartySendVerificationCodeResponse.fromJson(
            data));
  }

  /// Set account info for a user.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [SetAccountInfoResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<SetAccountInfoResponse> setAccountInfo(
      IdentitytoolkitRelyingpartySetAccountInfoRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'setAccountInfo';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new SetAccountInfoResponse.fromJson(data));
  }

  /// Set project configuration.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [IdentitytoolkitRelyingpartySetProjectConfigResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<IdentitytoolkitRelyingpartySetProjectConfigResponse>
      setProjectConfig(
          IdentitytoolkitRelyingpartySetProjectConfigRequest request,
          {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'setProjectConfig';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) =>
        new IdentitytoolkitRelyingpartySetProjectConfigResponse.fromJson(data));
  }

  /// Sign out user.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [IdentitytoolkitRelyingpartySignOutUserResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<IdentitytoolkitRelyingpartySignOutUserResponse> signOutUser(
      IdentitytoolkitRelyingpartySignOutUserRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'signOutUser';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) =>
        new IdentitytoolkitRelyingpartySignOutUserResponse.fromJson(data));
  }

  /// Signup new user.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [SignupNewUserResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<SignupNewUserResponse> signupNewUser(
      IdentitytoolkitRelyingpartySignupNewUserRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'signupNewUser';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new SignupNewUserResponse.fromJson(data));
  }

  /// Batch upload existing user accounts.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [UploadAccountResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<UploadAccountResponse> uploadAccount(
      IdentitytoolkitRelyingpartyUploadAccountRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'uploadAccount';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new UploadAccountResponse.fromJson(data));
  }

  /// Verifies the assertion returned by the IdP.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [VerifyAssertionResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<VerifyAssertionResponse> verifyAssertion(
      IdentitytoolkitRelyingpartyVerifyAssertionRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'verifyAssertion';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new VerifyAssertionResponse.fromJson(data));
  }

  /// Verifies the developer asserted ID token.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [VerifyCustomTokenResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<VerifyCustomTokenResponse> verifyCustomToken(
      IdentitytoolkitRelyingpartyVerifyCustomTokenRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'verifyCustomToken';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response
        .then((data) => new VerifyCustomTokenResponse.fromJson(data));
  }

  /// Verifies the user entered password.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [VerifyPasswordResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<VerifyPasswordResponse> verifyPassword(
      IdentitytoolkitRelyingpartyVerifyPasswordRequest request,
      {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'verifyPassword';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) => new VerifyPasswordResponse.fromJson(data));
  }

  /// Verifies ownership of a phone number and creates/updates the user account
  /// accordingly.
  ///
  /// [request] - The metadata request object.
  ///
  /// Request parameters:
  ///
  /// [$fields] - Selector specifying which fields to include in a partial
  /// response.
  ///
  /// Completes with a [IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse].
  ///
  /// Completes with a [commons.ApiRequestError] if the API endpoint returned an
  /// error.
  ///
  /// If the used [http.Client] completes with an error when making a REST call,
  /// this method will complete with the same error.
  async.Future<IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse>
      verifyPhoneNumber(
          IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest request,
          {core.String $fields}) {
    var _url = null;
    var _queryParams = new core.Map();
    var _uploadMedia = null;
    var _uploadOptions = null;
    var _downloadOptions = commons.DownloadOptions.Metadata;
    var _body = null;

    if (request != null) {
      _body = convert.JSON.encode((request).toJson());
    }
    if ($fields != null) {
      _queryParams["fields"] = [$fields];
    }

    _url = 'verifyPhoneNumber';

    var _response = _requester.request(_url, "POST",
        body: _body,
        queryParams: _queryParams,
        uploadOptions: _uploadOptions,
        uploadMedia: _uploadMedia,
        downloadOptions: _downloadOptions);
    return _response.then((data) =>
        new IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse.fromJson(
            data));
  }
}

/// Response of creating the IDP authentication URL.
class CreateAuthUriResponse {
  /// all providers the user has once used to do federated login
  core.List<core.String> allProviders;

  /// The URI used by the IDP to authenticate the user.
  core.String authUri;

  /// True if captcha is required.
  core.bool captchaRequired;

  /// True if the authUri is for user's existing provider.
  core.bool forExistingProvider;

  /// The fixed string identitytoolkit#CreateAuthUriResponse".
  core.String kind;

  /// The provider ID of the auth URI.
  core.String providerId;

  /// Whether the user is registered if the identifier is an email.
  core.bool registered;

  /// Session ID which should be passed in the following verifyAssertion
  /// request.
  core.String sessionId;

  /// All sign-in methods this user has used.
  core.List<core.String> signinMethods;

  CreateAuthUriResponse();

  CreateAuthUriResponse.fromJson(core.Map _json) {
    if (_json.containsKey("allProviders")) {
      allProviders = _json["allProviders"];
    }
    if (_json.containsKey("authUri")) {
      authUri = _json["authUri"];
    }
    if (_json.containsKey("captchaRequired")) {
      captchaRequired = _json["captchaRequired"];
    }
    if (_json.containsKey("forExistingProvider")) {
      forExistingProvider = _json["forExistingProvider"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("providerId")) {
      providerId = _json["providerId"];
    }
    if (_json.containsKey("registered")) {
      registered = _json["registered"];
    }
    if (_json.containsKey("sessionId")) {
      sessionId = _json["sessionId"];
    }
    if (_json.containsKey("signinMethods")) {
      signinMethods = _json["signinMethods"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (allProviders != null) {
      _json["allProviders"] = allProviders;
    }
    if (authUri != null) {
      _json["authUri"] = authUri;
    }
    if (captchaRequired != null) {
      _json["captchaRequired"] = captchaRequired;
    }
    if (forExistingProvider != null) {
      _json["forExistingProvider"] = forExistingProvider;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (providerId != null) {
      _json["providerId"] = providerId;
    }
    if (registered != null) {
      _json["registered"] = registered;
    }
    if (sessionId != null) {
      _json["sessionId"] = sessionId;
    }
    if (signinMethods != null) {
      _json["signinMethods"] = signinMethods;
    }
    return _json;
  }
}

/// Respone of deleting account.
class DeleteAccountResponse {
  /// The fixed string "identitytoolkit#DeleteAccountResponse".
  core.String kind;

  DeleteAccountResponse();

  DeleteAccountResponse.fromJson(core.Map _json) {
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (kind != null) {
      _json["kind"] = kind;
    }
    return _json;
  }
}

/// Response of downloading accounts in batch.
class DownloadAccountResponse {
  /// The fixed string "identitytoolkit#DownloadAccountResponse".
  core.String kind;

  /// The next page token. To be used in a subsequent request to return the next
  /// page of results.
  core.String nextPageToken;

  /// The user accounts data.
  core.List<UserInfo> users;

  DownloadAccountResponse();

  DownloadAccountResponse.fromJson(core.Map _json) {
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("nextPageToken")) {
      nextPageToken = _json["nextPageToken"];
    }
    if (_json.containsKey("users")) {
      users =
          _json["users"].map((value) => new UserInfo.fromJson(value)).toList();
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (nextPageToken != null) {
      _json["nextPageToken"] = nextPageToken;
    }
    if (users != null) {
      _json["users"] = users.map((value) => (value).toJson()).toList();
    }
    return _json;
  }
}

/// Response of email signIn.
class EmailLinkSigninResponse {
  /// The user's email.
  core.String email;

  /// Expiration time of STS id token in seconds.
  core.String expiresIn;

  /// The STS id token to login the newly signed in user.
  core.String idToken;

  /// Whether the user is new.
  core.bool isNewUser;

  /// The fixed string "identitytoolkit#EmailLinkSigninResponse".
  core.String kind;

  /// The RP local ID of the user.
  core.String localId;

  /// The refresh token for the signed in user.
  core.String refreshToken;

  EmailLinkSigninResponse();

  EmailLinkSigninResponse.fromJson(core.Map _json) {
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("expiresIn")) {
      expiresIn = _json["expiresIn"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("isNewUser")) {
      isNewUser = _json["isNewUser"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("refreshToken")) {
      refreshToken = _json["refreshToken"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (email != null) {
      _json["email"] = email;
    }
    if (expiresIn != null) {
      _json["expiresIn"] = expiresIn;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (isNewUser != null) {
      _json["isNewUser"] = isNewUser;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (refreshToken != null) {
      _json["refreshToken"] = refreshToken;
    }
    return _json;
  }
}

/// Template for an email template.
class EmailTemplate {
  /// Email body.
  core.String body;

  /// Email body format.
  core.String format;

  /// From address of the email.
  core.String from;

  /// From display name.
  core.String fromDisplayName;

  /// Reply-to address.
  core.String replyTo;

  /// Subject of the email.
  core.String subject;

  EmailTemplate();

  EmailTemplate.fromJson(core.Map _json) {
    if (_json.containsKey("body")) {
      body = _json["body"];
    }
    if (_json.containsKey("format")) {
      format = _json["format"];
    }
    if (_json.containsKey("from")) {
      from = _json["from"];
    }
    if (_json.containsKey("fromDisplayName")) {
      fromDisplayName = _json["fromDisplayName"];
    }
    if (_json.containsKey("replyTo")) {
      replyTo = _json["replyTo"];
    }
    if (_json.containsKey("subject")) {
      subject = _json["subject"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (body != null) {
      _json["body"] = body;
    }
    if (format != null) {
      _json["format"] = format;
    }
    if (from != null) {
      _json["from"] = from;
    }
    if (fromDisplayName != null) {
      _json["fromDisplayName"] = fromDisplayName;
    }
    if (replyTo != null) {
      _json["replyTo"] = replyTo;
    }
    if (subject != null) {
      _json["subject"] = subject;
    }
    return _json;
  }
}

/// Response of getting account information.
class GetAccountInfoResponse {
  /// The fixed string "identitytoolkit#GetAccountInfoResponse".
  core.String kind;

  /// The info of the users.
  core.List<UserInfo> users;

  GetAccountInfoResponse();

  GetAccountInfoResponse.fromJson(core.Map _json) {
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("users")) {
      users =
          _json["users"].map((value) => new UserInfo.fromJson(value)).toList();
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (users != null) {
      _json["users"] = users.map((value) => (value).toJson()).toList();
    }
    return _json;
  }
}

/// Response of getting a code for user confirmation (reset password, change
/// email etc.).
class GetOobConfirmationCodeResponse {
  /// The email address that the email is sent to.
  core.String email;

  /// The fixed string "identitytoolkit#GetOobConfirmationCodeResponse".
  core.String kind;

  /// The code to be send to the user.
  core.String oobCode;

  GetOobConfirmationCodeResponse();

  GetOobConfirmationCodeResponse.fromJson(core.Map _json) {
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("oobCode")) {
      oobCode = _json["oobCode"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (email != null) {
      _json["email"] = email;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (oobCode != null) {
      _json["oobCode"] = oobCode;
    }
    return _json;
  }
}

/// Response of getting recaptcha param.
class GetRecaptchaParamResponse {
  /// The fixed string "identitytoolkit#GetRecaptchaParamResponse".
  core.String kind;

  /// Site key registered at recaptcha.
  core.String recaptchaSiteKey;

  /// The stoken field for the recaptcha widget, used to request captcha
  /// challenge.
  core.String recaptchaStoken;

  GetRecaptchaParamResponse();

  GetRecaptchaParamResponse.fromJson(core.Map _json) {
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("recaptchaSiteKey")) {
      recaptchaSiteKey = _json["recaptchaSiteKey"];
    }
    if (_json.containsKey("recaptchaStoken")) {
      recaptchaStoken = _json["recaptchaStoken"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (recaptchaSiteKey != null) {
      _json["recaptchaSiteKey"] = recaptchaSiteKey;
    }
    if (recaptchaStoken != null) {
      _json["recaptchaStoken"] = recaptchaStoken;
    }
    return _json;
  }
}

/// Request to get the IDP authentication URL.
class IdentitytoolkitRelyingpartyCreateAuthUriRequest {
  /// The app ID of the mobile app, base64(CERT_SHA1):PACKAGE_NAME for Android,
  /// BUNDLE_ID for iOS.
  core.String appId;

  /// Explicitly specify the auth flow type. Currently only support "CODE_FLOW"
  /// type. The field is only used for Google provider.
  core.String authFlowType;

  /// The relying party OAuth client ID.
  core.String clientId;

  /// The opaque value used by the client to maintain context info between the
  /// authentication request and the IDP callback.
  core.String context;

  /// The URI to which the IDP redirects the user after the federated login
  /// flow.
  core.String continueUri;

  /// The query parameter that client can customize by themselves in auth url.
  /// The following parameters are reserved for server so that they cannot be
  /// customized by clients: client_id, response_type, scope, redirect_uri,
  /// state, oauth_token.
  core.Map<core.String, core.String> customParameter;

  /// The hosted domain to restrict sign-in to accounts at that domain for
  /// Google Apps hosted accounts.
  core.String hostedDomain;

  /// The email or federated ID of the user.
  core.String identifier;

  /// The developer's consumer key for OpenId OAuth Extension
  core.String oauthConsumerKey;

  /// Additional oauth scopes, beyond the basid user profile, that the user
  /// would be prompted to grant
  core.String oauthScope;

  /// Optional realm for OpenID protocol. The sub string "scheme://domain:port"
  /// of the param "continueUri" is used if this is not set.
  core.String openidRealm;

  /// The native app package for OTA installation.
  core.String otaApp;

  /// The IdP ID. For white listed IdPs it's a short domain name e.g.
  /// google.com, aol.com, live.net and yahoo.com. For other OpenID IdPs it's
  /// the OP identifier.
  core.String providerId;

  /// The session_id passed by client.
  core.String sessionId;

  IdentitytoolkitRelyingpartyCreateAuthUriRequest();

  IdentitytoolkitRelyingpartyCreateAuthUriRequest.fromJson(core.Map _json) {
    if (_json.containsKey("appId")) {
      appId = _json["appId"];
    }
    if (_json.containsKey("authFlowType")) {
      authFlowType = _json["authFlowType"];
    }
    if (_json.containsKey("clientId")) {
      clientId = _json["clientId"];
    }
    if (_json.containsKey("context")) {
      context = _json["context"];
    }
    if (_json.containsKey("continueUri")) {
      continueUri = _json["continueUri"];
    }
    if (_json.containsKey("customParameter")) {
      customParameter = _json["customParameter"];
    }
    if (_json.containsKey("hostedDomain")) {
      hostedDomain = _json["hostedDomain"];
    }
    if (_json.containsKey("identifier")) {
      identifier = _json["identifier"];
    }
    if (_json.containsKey("oauthConsumerKey")) {
      oauthConsumerKey = _json["oauthConsumerKey"];
    }
    if (_json.containsKey("oauthScope")) {
      oauthScope = _json["oauthScope"];
    }
    if (_json.containsKey("openidRealm")) {
      openidRealm = _json["openidRealm"];
    }
    if (_json.containsKey("otaApp")) {
      otaApp = _json["otaApp"];
    }
    if (_json.containsKey("providerId")) {
      providerId = _json["providerId"];
    }
    if (_json.containsKey("sessionId")) {
      sessionId = _json["sessionId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (appId != null) {
      _json["appId"] = appId;
    }
    if (authFlowType != null) {
      _json["authFlowType"] = authFlowType;
    }
    if (clientId != null) {
      _json["clientId"] = clientId;
    }
    if (context != null) {
      _json["context"] = context;
    }
    if (continueUri != null) {
      _json["continueUri"] = continueUri;
    }
    if (customParameter != null) {
      _json["customParameter"] = customParameter;
    }
    if (hostedDomain != null) {
      _json["hostedDomain"] = hostedDomain;
    }
    if (identifier != null) {
      _json["identifier"] = identifier;
    }
    if (oauthConsumerKey != null) {
      _json["oauthConsumerKey"] = oauthConsumerKey;
    }
    if (oauthScope != null) {
      _json["oauthScope"] = oauthScope;
    }
    if (openidRealm != null) {
      _json["openidRealm"] = openidRealm;
    }
    if (otaApp != null) {
      _json["otaApp"] = otaApp;
    }
    if (providerId != null) {
      _json["providerId"] = providerId;
    }
    if (sessionId != null) {
      _json["sessionId"] = sessionId;
    }
    return _json;
  }
}

/// Request to delete account.
class IdentitytoolkitRelyingpartyDeleteAccountRequest {
  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;

  /// The GITKit token or STS id token of the authenticated user.
  core.String idToken;

  /// The local ID of the user.
  core.String localId;

  IdentitytoolkitRelyingpartyDeleteAccountRequest();

  IdentitytoolkitRelyingpartyDeleteAccountRequest.fromJson(core.Map _json) {
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    return _json;
  }
}

/// Request to download user account in batch.
class IdentitytoolkitRelyingpartyDownloadAccountRequest {
  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;

  /// The max number of results to return in the response.
  core.int maxResults;

  /// The token for the next page. This should be taken from the previous
  /// response.
  core.String nextPageToken;

  /// Specify which project (field value is actually project id) to operate.
  /// Only used when provided credential.
  core.String targetProjectId;

  IdentitytoolkitRelyingpartyDownloadAccountRequest();

  IdentitytoolkitRelyingpartyDownloadAccountRequest.fromJson(core.Map _json) {
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("maxResults")) {
      maxResults = _json["maxResults"];
    }
    if (_json.containsKey("nextPageToken")) {
      nextPageToken = _json["nextPageToken"];
    }
    if (_json.containsKey("targetProjectId")) {
      targetProjectId = _json["targetProjectId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (maxResults != null) {
      _json["maxResults"] = maxResults;
    }
    if (nextPageToken != null) {
      _json["nextPageToken"] = nextPageToken;
    }
    if (targetProjectId != null) {
      _json["targetProjectId"] = targetProjectId;
    }
    return _json;
  }
}

/// Request to sign in with email.
class IdentitytoolkitRelyingpartyEmailLinkSigninRequest {
  /// The email address of the user.
  core.String email;

  /// Token for linking flow.
  core.String idToken;

  /// The confirmation code.
  core.String oobCode;

  IdentitytoolkitRelyingpartyEmailLinkSigninRequest();

  IdentitytoolkitRelyingpartyEmailLinkSigninRequest.fromJson(core.Map _json) {
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("oobCode")) {
      oobCode = _json["oobCode"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (email != null) {
      _json["email"] = email;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (oobCode != null) {
      _json["oobCode"] = oobCode;
    }
    return _json;
  }
}

/// Request to get the account information.
class IdentitytoolkitRelyingpartyGetAccountInfoRequest {
  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;

  /// The list of emails of the users to inquiry.
  core.List<core.String> email;

  /// The GITKit token of the authenticated user.
  core.String idToken;

  /// The list of local ID's of the users to inquiry.
  core.List<core.String> localId;

  /// Privileged caller can query users by specified phone number.
  core.List<core.String> phoneNumber;

  IdentitytoolkitRelyingpartyGetAccountInfoRequest();

  IdentitytoolkitRelyingpartyGetAccountInfoRequest.fromJson(core.Map _json) {
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("phoneNumber")) {
      phoneNumber = _json["phoneNumber"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (phoneNumber != null) {
      _json["phoneNumber"] = phoneNumber;
    }
    return _json;
  }
}

/// Response of getting the project configuration.
class IdentitytoolkitRelyingpartyGetProjectConfigResponse {
  /// Whether to allow password user sign in or sign up.
  core.bool allowPasswordUser;

  /// Browser API key, needed when making http request to Apiary.
  core.String apiKey;

  /// Authorized domains.
  core.List<core.String> authorizedDomains;

  /// Change email template.
  EmailTemplate changeEmailTemplate;
  core.String dynamicLinksDomain;

  /// Whether anonymous user is enabled.
  core.bool enableAnonymousUser;

  /// OAuth2 provider configuration.
  core.List<IdpConfig> idpConfig;

  /// Legacy reset password email template.
  EmailTemplate legacyResetPasswordTemplate;

  /// Project ID of the relying party.
  core.String projectId;

  /// Reset password email template.
  EmailTemplate resetPasswordTemplate;

  /// Whether to use email sending provided by Firebear.
  core.bool useEmailSending;

  /// Verify email template.
  EmailTemplate verifyEmailTemplate;

  IdentitytoolkitRelyingpartyGetProjectConfigResponse();

  IdentitytoolkitRelyingpartyGetProjectConfigResponse.fromJson(core.Map _json) {
    if (_json.containsKey("allowPasswordUser")) {
      allowPasswordUser = _json["allowPasswordUser"];
    }
    if (_json.containsKey("apiKey")) {
      apiKey = _json["apiKey"];
    }
    if (_json.containsKey("authorizedDomains")) {
      authorizedDomains = _json["authorizedDomains"];
    }
    if (_json.containsKey("changeEmailTemplate")) {
      changeEmailTemplate =
          new EmailTemplate.fromJson(_json["changeEmailTemplate"]);
    }
    if (_json.containsKey("dynamicLinksDomain")) {
      dynamicLinksDomain = _json["dynamicLinksDomain"];
    }
    if (_json.containsKey("enableAnonymousUser")) {
      enableAnonymousUser = _json["enableAnonymousUser"];
    }
    if (_json.containsKey("idpConfig")) {
      idpConfig = _json["idpConfig"]
          .map((value) => new IdpConfig.fromJson(value))
          .toList();
    }
    if (_json.containsKey("legacyResetPasswordTemplate")) {
      legacyResetPasswordTemplate =
          new EmailTemplate.fromJson(_json["legacyResetPasswordTemplate"]);
    }
    if (_json.containsKey("projectId")) {
      projectId = _json["projectId"];
    }
    if (_json.containsKey("resetPasswordTemplate")) {
      resetPasswordTemplate =
          new EmailTemplate.fromJson(_json["resetPasswordTemplate"]);
    }
    if (_json.containsKey("useEmailSending")) {
      useEmailSending = _json["useEmailSending"];
    }
    if (_json.containsKey("verifyEmailTemplate")) {
      verifyEmailTemplate =
          new EmailTemplate.fromJson(_json["verifyEmailTemplate"]);
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (allowPasswordUser != null) {
      _json["allowPasswordUser"] = allowPasswordUser;
    }
    if (apiKey != null) {
      _json["apiKey"] = apiKey;
    }
    if (authorizedDomains != null) {
      _json["authorizedDomains"] = authorizedDomains;
    }
    if (changeEmailTemplate != null) {
      _json["changeEmailTemplate"] = (changeEmailTemplate).toJson();
    }
    if (dynamicLinksDomain != null) {
      _json["dynamicLinksDomain"] = dynamicLinksDomain;
    }
    if (enableAnonymousUser != null) {
      _json["enableAnonymousUser"] = enableAnonymousUser;
    }
    if (idpConfig != null) {
      _json["idpConfig"] = idpConfig.map((value) => (value).toJson()).toList();
    }
    if (legacyResetPasswordTemplate != null) {
      _json["legacyResetPasswordTemplate"] =
          (legacyResetPasswordTemplate).toJson();
    }
    if (projectId != null) {
      _json["projectId"] = projectId;
    }
    if (resetPasswordTemplate != null) {
      _json["resetPasswordTemplate"] = (resetPasswordTemplate).toJson();
    }
    if (useEmailSending != null) {
      _json["useEmailSending"] = useEmailSending;
    }
    if (verifyEmailTemplate != null) {
      _json["verifyEmailTemplate"] = (verifyEmailTemplate).toJson();
    }
    return _json;
  }
}

/// Respone of getting public keys.
class IdentitytoolkitRelyingpartyGetPublicKeysResponse
    extends collection.MapBase<core.String, core.String> {
  final core.Map _innerMap = {};

  IdentitytoolkitRelyingpartyGetPublicKeysResponse();

  IdentitytoolkitRelyingpartyGetPublicKeysResponse.fromJson(
      core.Map<core.String, core.dynamic> _json) {
    _json.forEach((core.String key, value) {
      this[key] = value;
    });
  }

  core.Map<core.String, core.String> toJson() {
    final core.Map<core.String, core.String> _json =
        <core.String, core.String>{};
    this.forEach((core.String key, value) {
      _json[key] = value;
    });
    return _json;
  }

  core.String operator [](core.Object key) => _innerMap[key];

  operator []=(core.String key, core.String value) {
    _innerMap[key] = value;
  }

  void clear() {
    _innerMap.clear();
  }

  core.Iterable<core.String> get keys => _innerMap.keys;

  core.String remove(core.Object key) => _innerMap.remove(key);
}

/// Request to reset the password.
class IdentitytoolkitRelyingpartyResetPasswordRequest {
  /// The email address of the user.
  core.String email;

  /// The new password inputted by the user.
  core.String newPassword;

  /// The old password inputted by the user.
  core.String oldPassword;

  /// The confirmation code.
  core.String oobCode;

  IdentitytoolkitRelyingpartyResetPasswordRequest();

  IdentitytoolkitRelyingpartyResetPasswordRequest.fromJson(core.Map _json) {
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("newPassword")) {
      newPassword = _json["newPassword"];
    }
    if (_json.containsKey("oldPassword")) {
      oldPassword = _json["oldPassword"];
    }
    if (_json.containsKey("oobCode")) {
      oobCode = _json["oobCode"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (email != null) {
      _json["email"] = email;
    }
    if (newPassword != null) {
      _json["newPassword"] = newPassword;
    }
    if (oldPassword != null) {
      _json["oldPassword"] = oldPassword;
    }
    if (oobCode != null) {
      _json["oobCode"] = oobCode;
    }
    return _json;
  }
}

/// Request for Identitytoolkit-SendVerificationCode
class IdentitytoolkitRelyingpartySendVerificationCodeRequest {
  /// Receipt of successful app token validation with APNS.
  core.String iosReceipt;

  /// Secret delivered to iOS app via APNS.
  core.String iosSecret;

  /// The phone number to send the verification code to in E.164 format.
  core.String phoneNumber;

  /// Recaptcha solution.
  core.String recaptchaToken;

  IdentitytoolkitRelyingpartySendVerificationCodeRequest();

  IdentitytoolkitRelyingpartySendVerificationCodeRequest.fromJson(
      core.Map _json) {
    if (_json.containsKey("iosReceipt")) {
      iosReceipt = _json["iosReceipt"];
    }
    if (_json.containsKey("iosSecret")) {
      iosSecret = _json["iosSecret"];
    }
    if (_json.containsKey("phoneNumber")) {
      phoneNumber = _json["phoneNumber"];
    }
    if (_json.containsKey("recaptchaToken")) {
      recaptchaToken = _json["recaptchaToken"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (iosReceipt != null) {
      _json["iosReceipt"] = iosReceipt;
    }
    if (iosSecret != null) {
      _json["iosSecret"] = iosSecret;
    }
    if (phoneNumber != null) {
      _json["phoneNumber"] = phoneNumber;
    }
    if (recaptchaToken != null) {
      _json["recaptchaToken"] = recaptchaToken;
    }
    return _json;
  }
}

/// Response for Identitytoolkit-SendVerificationCode
class IdentitytoolkitRelyingpartySendVerificationCodeResponse {
  /// Encrypted session information
  core.String sessionInfo;

  IdentitytoolkitRelyingpartySendVerificationCodeResponse();

  IdentitytoolkitRelyingpartySendVerificationCodeResponse.fromJson(
      core.Map _json) {
    if (_json.containsKey("sessionInfo")) {
      sessionInfo = _json["sessionInfo"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (sessionInfo != null) {
      _json["sessionInfo"] = sessionInfo;
    }
    return _json;
  }
}

/// Request to set the account information.
class IdentitytoolkitRelyingpartySetAccountInfoRequest {
  /// The captcha challenge.
  core.String captchaChallenge;

  /// Response to the captcha.
  core.String captchaResponse;

  /// The timestamp when the account is created.
  core.String createdAt;

  /// The custom attributes to be set in the user's id token.
  core.String customAttributes;

  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;

  /// The attributes users request to delete.
  core.List<core.String> deleteAttribute;

  /// The IDPs the user request to delete.
  core.List<core.String> deleteProvider;

  /// Whether to disable the user.
  core.bool disableUser;

  /// The name of the user.
  core.String displayName;

  /// The email of the user.
  core.String email;

  /// Mark the email as verified or not.
  core.bool emailVerified;

  /// The GITKit token of the authenticated user.
  core.String idToken;

  /// Instance id token of the app.
  core.String instanceId;

  /// Last login timestamp.
  core.String lastLoginAt;

  /// The local ID of the user.
  core.String localId;

  /// The out-of-band code of the change email request.
  core.String oobCode;

  /// The new password of the user.
  core.String password;

  /// Privileged caller can update user with specified phone number.
  core.String phoneNumber;

  /// The photo url of the user.
  core.String photoUrl;

  /// The associated IDPs of the user.
  core.List<core.String> provider;

  /// Whether return sts id token and refresh token instead of gitkit token.
  core.bool returnSecureToken;

  /// Mark the user to upgrade to federated login.
  core.bool upgradeToFederatedLogin;

  /// Timestamp in seconds for valid login token.
  core.String validSince;

  IdentitytoolkitRelyingpartySetAccountInfoRequest();

  IdentitytoolkitRelyingpartySetAccountInfoRequest.fromJson(core.Map _json) {
    if (_json.containsKey("captchaChallenge")) {
      captchaChallenge = _json["captchaChallenge"];
    }
    if (_json.containsKey("captchaResponse")) {
      captchaResponse = _json["captchaResponse"];
    }
    if (_json.containsKey("createdAt")) {
      createdAt = _json["createdAt"];
    }
    if (_json.containsKey("customAttributes")) {
      customAttributes = _json["customAttributes"];
    }
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("deleteAttribute")) {
      deleteAttribute = _json["deleteAttribute"];
    }
    if (_json.containsKey("deleteProvider")) {
      deleteProvider = _json["deleteProvider"];
    }
    if (_json.containsKey("disableUser")) {
      disableUser = _json["disableUser"];
    }
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("emailVerified")) {
      emailVerified = _json["emailVerified"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("instanceId")) {
      instanceId = _json["instanceId"];
    }
    if (_json.containsKey("lastLoginAt")) {
      lastLoginAt = _json["lastLoginAt"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("oobCode")) {
      oobCode = _json["oobCode"];
    }
    if (_json.containsKey("password")) {
      password = _json["password"];
    }
    if (_json.containsKey("phoneNumber")) {
      phoneNumber = _json["phoneNumber"];
    }
    if (_json.containsKey("photoUrl")) {
      photoUrl = _json["photoUrl"];
    }
    if (_json.containsKey("provider")) {
      provider = _json["provider"];
    }
    if (_json.containsKey("returnSecureToken")) {
      returnSecureToken = _json["returnSecureToken"];
    }
    if (_json.containsKey("upgradeToFederatedLogin")) {
      upgradeToFederatedLogin = _json["upgradeToFederatedLogin"];
    }
    if (_json.containsKey("validSince")) {
      validSince = _json["validSince"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (captchaChallenge != null) {
      _json["captchaChallenge"] = captchaChallenge;
    }
    if (captchaResponse != null) {
      _json["captchaResponse"] = captchaResponse;
    }
    if (createdAt != null) {
      _json["createdAt"] = createdAt;
    }
    if (customAttributes != null) {
      _json["customAttributes"] = customAttributes;
    }
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (deleteAttribute != null) {
      _json["deleteAttribute"] = deleteAttribute;
    }
    if (deleteProvider != null) {
      _json["deleteProvider"] = deleteProvider;
    }
    if (disableUser != null) {
      _json["disableUser"] = disableUser;
    }
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (emailVerified != null) {
      _json["emailVerified"] = emailVerified;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (instanceId != null) {
      _json["instanceId"] = instanceId;
    }
    if (lastLoginAt != null) {
      _json["lastLoginAt"] = lastLoginAt;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (oobCode != null) {
      _json["oobCode"] = oobCode;
    }
    if (password != null) {
      _json["password"] = password;
    }
    if (phoneNumber != null) {
      _json["phoneNumber"] = phoneNumber;
    }
    if (photoUrl != null) {
      _json["photoUrl"] = photoUrl;
    }
    if (provider != null) {
      _json["provider"] = provider;
    }
    if (returnSecureToken != null) {
      _json["returnSecureToken"] = returnSecureToken;
    }
    if (upgradeToFederatedLogin != null) {
      _json["upgradeToFederatedLogin"] = upgradeToFederatedLogin;
    }
    if (validSince != null) {
      _json["validSince"] = validSince;
    }
    return _json;
  }
}

/// Request to set the project configuration.
class IdentitytoolkitRelyingpartySetProjectConfigRequest {
  /// Whether to allow password user sign in or sign up.
  core.bool allowPasswordUser;

  /// Browser API key, needed when making http request to Apiary.
  core.String apiKey;

  /// Authorized domains for widget redirect.
  core.List<core.String> authorizedDomains;

  /// Change email template.
  EmailTemplate changeEmailTemplate;

  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;

  /// Whether to enable anonymous user.
  core.bool enableAnonymousUser;

  /// Oauth2 provider configuration.
  core.List<IdpConfig> idpConfig;

  /// Legacy reset password email template.
  EmailTemplate legacyResetPasswordTemplate;

  /// Reset password email template.
  EmailTemplate resetPasswordTemplate;

  /// Whether to use email sending provided by Firebear.
  core.bool useEmailSending;

  /// Verify email template.
  EmailTemplate verifyEmailTemplate;

  IdentitytoolkitRelyingpartySetProjectConfigRequest();

  IdentitytoolkitRelyingpartySetProjectConfigRequest.fromJson(core.Map _json) {
    if (_json.containsKey("allowPasswordUser")) {
      allowPasswordUser = _json["allowPasswordUser"];
    }
    if (_json.containsKey("apiKey")) {
      apiKey = _json["apiKey"];
    }
    if (_json.containsKey("authorizedDomains")) {
      authorizedDomains = _json["authorizedDomains"];
    }
    if (_json.containsKey("changeEmailTemplate")) {
      changeEmailTemplate =
          new EmailTemplate.fromJson(_json["changeEmailTemplate"]);
    }
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("enableAnonymousUser")) {
      enableAnonymousUser = _json["enableAnonymousUser"];
    }
    if (_json.containsKey("idpConfig")) {
      idpConfig = _json["idpConfig"]
          .map((value) => new IdpConfig.fromJson(value))
          .toList();
    }
    if (_json.containsKey("legacyResetPasswordTemplate")) {
      legacyResetPasswordTemplate =
          new EmailTemplate.fromJson(_json["legacyResetPasswordTemplate"]);
    }
    if (_json.containsKey("resetPasswordTemplate")) {
      resetPasswordTemplate =
          new EmailTemplate.fromJson(_json["resetPasswordTemplate"]);
    }
    if (_json.containsKey("useEmailSending")) {
      useEmailSending = _json["useEmailSending"];
    }
    if (_json.containsKey("verifyEmailTemplate")) {
      verifyEmailTemplate =
          new EmailTemplate.fromJson(_json["verifyEmailTemplate"]);
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (allowPasswordUser != null) {
      _json["allowPasswordUser"] = allowPasswordUser;
    }
    if (apiKey != null) {
      _json["apiKey"] = apiKey;
    }
    if (authorizedDomains != null) {
      _json["authorizedDomains"] = authorizedDomains;
    }
    if (changeEmailTemplate != null) {
      _json["changeEmailTemplate"] = (changeEmailTemplate).toJson();
    }
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (enableAnonymousUser != null) {
      _json["enableAnonymousUser"] = enableAnonymousUser;
    }
    if (idpConfig != null) {
      _json["idpConfig"] = idpConfig.map((value) => (value).toJson()).toList();
    }
    if (legacyResetPasswordTemplate != null) {
      _json["legacyResetPasswordTemplate"] =
          (legacyResetPasswordTemplate).toJson();
    }
    if (resetPasswordTemplate != null) {
      _json["resetPasswordTemplate"] = (resetPasswordTemplate).toJson();
    }
    if (useEmailSending != null) {
      _json["useEmailSending"] = useEmailSending;
    }
    if (verifyEmailTemplate != null) {
      _json["verifyEmailTemplate"] = (verifyEmailTemplate).toJson();
    }
    return _json;
  }
}

/// Response of setting the project configuration.
class IdentitytoolkitRelyingpartySetProjectConfigResponse {
  /// Project ID of the relying party.
  core.String projectId;

  IdentitytoolkitRelyingpartySetProjectConfigResponse();

  IdentitytoolkitRelyingpartySetProjectConfigResponse.fromJson(core.Map _json) {
    if (_json.containsKey("projectId")) {
      projectId = _json["projectId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (projectId != null) {
      _json["projectId"] = projectId;
    }
    return _json;
  }
}

/// Request to sign out user.
class IdentitytoolkitRelyingpartySignOutUserRequest {
  /// Instance id token of the app.
  core.String instanceId;

  /// The local ID of the user.
  core.String localId;

  IdentitytoolkitRelyingpartySignOutUserRequest();

  IdentitytoolkitRelyingpartySignOutUserRequest.fromJson(core.Map _json) {
    if (_json.containsKey("instanceId")) {
      instanceId = _json["instanceId"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (instanceId != null) {
      _json["instanceId"] = instanceId;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    return _json;
  }
}

/// Response of signing out user.
class IdentitytoolkitRelyingpartySignOutUserResponse {
  /// The local ID of the user.
  core.String localId;

  IdentitytoolkitRelyingpartySignOutUserResponse();

  IdentitytoolkitRelyingpartySignOutUserResponse.fromJson(core.Map _json) {
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (localId != null) {
      _json["localId"] = localId;
    }
    return _json;
  }
}

/// Request to signup new user, create anonymous user or anonymous user reauth.
class IdentitytoolkitRelyingpartySignupNewUserRequest {
  /// The captcha challenge.
  core.String captchaChallenge;

  /// Response to the captcha.
  core.String captchaResponse;

  /// Whether to disable the user. Only can be used by service account.
  core.bool disabled;

  /// The name of the user.
  core.String displayName;

  /// The email of the user.
  core.String email;

  /// Mark the email as verified or not. Only can be used by service account.
  core.bool emailVerified;

  /// The GITKit token of the authenticated user.
  core.String idToken;

  /// Instance id token of the app.
  core.String instanceId;

  /// Privileged caller can create user with specified user id.
  core.String localId;

  /// The new password of the user.
  core.String password;

  /// Privileged caller can create user with specified phone number.
  core.String phoneNumber;

  /// The photo url of the user.
  core.String photoUrl;

  IdentitytoolkitRelyingpartySignupNewUserRequest();

  IdentitytoolkitRelyingpartySignupNewUserRequest.fromJson(core.Map _json) {
    if (_json.containsKey("captchaChallenge")) {
      captchaChallenge = _json["captchaChallenge"];
    }
    if (_json.containsKey("captchaResponse")) {
      captchaResponse = _json["captchaResponse"];
    }
    if (_json.containsKey("disabled")) {
      disabled = _json["disabled"];
    }
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("emailVerified")) {
      emailVerified = _json["emailVerified"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("instanceId")) {
      instanceId = _json["instanceId"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("password")) {
      password = _json["password"];
    }
    if (_json.containsKey("phoneNumber")) {
      phoneNumber = _json["phoneNumber"];
    }
    if (_json.containsKey("photoUrl")) {
      photoUrl = _json["photoUrl"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (captchaChallenge != null) {
      _json["captchaChallenge"] = captchaChallenge;
    }
    if (captchaResponse != null) {
      _json["captchaResponse"] = captchaResponse;
    }
    if (disabled != null) {
      _json["disabled"] = disabled;
    }
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (emailVerified != null) {
      _json["emailVerified"] = emailVerified;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (instanceId != null) {
      _json["instanceId"] = instanceId;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (password != null) {
      _json["password"] = password;
    }
    if (phoneNumber != null) {
      _json["phoneNumber"] = phoneNumber;
    }
    if (photoUrl != null) {
      _json["photoUrl"] = photoUrl;
    }
    return _json;
  }
}

/// Request to upload user account in batch.
class IdentitytoolkitRelyingpartyUploadAccountRequest {
  /// Whether allow overwrite existing account when user local_id exists.
  core.bool allowOverwrite;
  core.int blockSize;

  /// The following 4 fields are for standard scrypt algorithm.
  core.int cpuMemCost;

  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;
  core.int dkLen;

  /// The password hash algorithm.
  core.String hashAlgorithm;

  /// Memory cost for hash calculation. Used by scrypt similar algorithms.
  core.int memoryCost;
  core.int parallelization;

  /// Rounds for hash calculation. Used by scrypt and similar algorithms.
  core.int rounds;

  /// The salt separator.
  core.String saltSeparator;
  core.List<core.int> get saltSeparatorAsBytes {
    return convert.BASE64.decode(saltSeparator);
  }

  void set saltSeparatorAsBytes(core.List<core.int> _bytes) {
    saltSeparator =
        convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
  }

  /// If true, backend will do sanity check(including duplicate email and
  /// federated id) when uploading account.
  core.bool sanityCheck;

  /// The key for to hash the password.
  core.String signerKey;
  core.List<core.int> get signerKeyAsBytes {
    return convert.BASE64.decode(signerKey);
  }

  void set signerKeyAsBytes(core.List<core.int> _bytes) {
    signerKey =
        convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
  }

  /// Specify which project (field value is actually project id) to operate.
  /// Only used when provided credential.
  core.String targetProjectId;

  /// The account info to be stored.
  core.List<UserInfo> users;

  IdentitytoolkitRelyingpartyUploadAccountRequest();

  IdentitytoolkitRelyingpartyUploadAccountRequest.fromJson(core.Map _json) {
    if (_json.containsKey("allowOverwrite")) {
      allowOverwrite = _json["allowOverwrite"];
    }
    if (_json.containsKey("blockSize")) {
      blockSize = _json["blockSize"];
    }
    if (_json.containsKey("cpuMemCost")) {
      cpuMemCost = _json["cpuMemCost"];
    }
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("dkLen")) {
      dkLen = _json["dkLen"];
    }
    if (_json.containsKey("hashAlgorithm")) {
      hashAlgorithm = _json["hashAlgorithm"];
    }
    if (_json.containsKey("memoryCost")) {
      memoryCost = _json["memoryCost"];
    }
    if (_json.containsKey("parallelization")) {
      parallelization = _json["parallelization"];
    }
    if (_json.containsKey("rounds")) {
      rounds = _json["rounds"];
    }
    if (_json.containsKey("saltSeparator")) {
      saltSeparator = _json["saltSeparator"];
    }
    if (_json.containsKey("sanityCheck")) {
      sanityCheck = _json["sanityCheck"];
    }
    if (_json.containsKey("signerKey")) {
      signerKey = _json["signerKey"];
    }
    if (_json.containsKey("targetProjectId")) {
      targetProjectId = _json["targetProjectId"];
    }
    if (_json.containsKey("users")) {
      users =
          _json["users"].map((value) => new UserInfo.fromJson(value)).toList();
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (allowOverwrite != null) {
      _json["allowOverwrite"] = allowOverwrite;
    }
    if (blockSize != null) {
      _json["blockSize"] = blockSize;
    }
    if (cpuMemCost != null) {
      _json["cpuMemCost"] = cpuMemCost;
    }
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (dkLen != null) {
      _json["dkLen"] = dkLen;
    }
    if (hashAlgorithm != null) {
      _json["hashAlgorithm"] = hashAlgorithm;
    }
    if (memoryCost != null) {
      _json["memoryCost"] = memoryCost;
    }
    if (parallelization != null) {
      _json["parallelization"] = parallelization;
    }
    if (rounds != null) {
      _json["rounds"] = rounds;
    }
    if (saltSeparator != null) {
      _json["saltSeparator"] = saltSeparator;
    }
    if (sanityCheck != null) {
      _json["sanityCheck"] = sanityCheck;
    }
    if (signerKey != null) {
      _json["signerKey"] = signerKey;
    }
    if (targetProjectId != null) {
      _json["targetProjectId"] = targetProjectId;
    }
    if (users != null) {
      _json["users"] = users.map((value) => (value).toJson()).toList();
    }
    return _json;
  }
}

/// Request to verify the IDP assertion.
class IdentitytoolkitRelyingpartyVerifyAssertionRequest {
  /// When it's true, automatically creates a new account if the user doesn't
  /// exist. When it's false, allows existing user to sign in normally and
  /// throws exception if the user doesn't exist.
  core.bool autoCreate;

  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;

  /// The GITKit token of the authenticated user.
  core.String idToken;

  /// Instance id token of the app.
  core.String instanceId;

  /// The GITKit token for the non-trusted IDP pending to be confirmed by the
  /// user.
  core.String pendingIdToken;

  /// The post body if the request is a HTTP POST.
  core.String postBody;

  /// The URI to which the IDP redirects the user back. It may contain federated
  /// login result params added by the IDP.
  core.String requestUri;

  /// Whether return 200 and IDP credential rather than throw exception when
  /// federated id is already linked.
  core.bool returnIdpCredential;

  /// Whether to return refresh tokens.
  core.bool returnRefreshToken;

  /// Whether return sts id token and refresh token instead of gitkit token.
  core.bool returnSecureToken;

  /// Session ID, which should match the one in previous createAuthUri request.
  core.String sessionId;

  IdentitytoolkitRelyingpartyVerifyAssertionRequest();

  IdentitytoolkitRelyingpartyVerifyAssertionRequest.fromJson(core.Map _json) {
    if (_json.containsKey("autoCreate")) {
      autoCreate = _json["autoCreate"];
    }
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("instanceId")) {
      instanceId = _json["instanceId"];
    }
    if (_json.containsKey("pendingIdToken")) {
      pendingIdToken = _json["pendingIdToken"];
    }
    if (_json.containsKey("postBody")) {
      postBody = _json["postBody"];
    }
    if (_json.containsKey("requestUri")) {
      requestUri = _json["requestUri"];
    }
    if (_json.containsKey("returnIdpCredential")) {
      returnIdpCredential = _json["returnIdpCredential"];
    }
    if (_json.containsKey("returnRefreshToken")) {
      returnRefreshToken = _json["returnRefreshToken"];
    }
    if (_json.containsKey("returnSecureToken")) {
      returnSecureToken = _json["returnSecureToken"];
    }
    if (_json.containsKey("sessionId")) {
      sessionId = _json["sessionId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (autoCreate != null) {
      _json["autoCreate"] = autoCreate;
    }
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (instanceId != null) {
      _json["instanceId"] = instanceId;
    }
    if (pendingIdToken != null) {
      _json["pendingIdToken"] = pendingIdToken;
    }
    if (postBody != null) {
      _json["postBody"] = postBody;
    }
    if (requestUri != null) {
      _json["requestUri"] = requestUri;
    }
    if (returnIdpCredential != null) {
      _json["returnIdpCredential"] = returnIdpCredential;
    }
    if (returnRefreshToken != null) {
      _json["returnRefreshToken"] = returnRefreshToken;
    }
    if (returnSecureToken != null) {
      _json["returnSecureToken"] = returnSecureToken;
    }
    if (sessionId != null) {
      _json["sessionId"] = sessionId;
    }
    return _json;
  }
}

/// Request to verify a custom token
class IdentitytoolkitRelyingpartyVerifyCustomTokenRequest {
  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;

  /// Instance id token of the app.
  core.String instanceId;

  /// Whether return sts id token and refresh token instead of gitkit token.
  core.bool returnSecureToken;

  /// The custom token to verify
  core.String token;

  IdentitytoolkitRelyingpartyVerifyCustomTokenRequest();

  IdentitytoolkitRelyingpartyVerifyCustomTokenRequest.fromJson(core.Map _json) {
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("instanceId")) {
      instanceId = _json["instanceId"];
    }
    if (_json.containsKey("returnSecureToken")) {
      returnSecureToken = _json["returnSecureToken"];
    }
    if (_json.containsKey("token")) {
      token = _json["token"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (instanceId != null) {
      _json["instanceId"] = instanceId;
    }
    if (returnSecureToken != null) {
      _json["returnSecureToken"] = returnSecureToken;
    }
    if (token != null) {
      _json["token"] = token;
    }
    return _json;
  }
}

/// Request to verify the password.
class IdentitytoolkitRelyingpartyVerifyPasswordRequest {
  /// The captcha challenge.
  core.String captchaChallenge;

  /// Response to the captcha.
  core.String captchaResponse;

  /// GCP project number of the requesting delegated app. Currently only
  /// intended for Firebase V1 migration.
  core.String delegatedProjectNumber;

  /// The email of the user.
  core.String email;

  /// The GITKit token of the authenticated user.
  core.String idToken;

  /// Instance id token of the app.
  core.String instanceId;

  /// The password inputed by the user.
  core.String password;

  /// The GITKit token for the non-trusted IDP, which is to be confirmed by the
  /// user.
  core.String pendingIdToken;

  /// Whether return sts id token and refresh token instead of gitkit token.
  core.bool returnSecureToken;

  IdentitytoolkitRelyingpartyVerifyPasswordRequest();

  IdentitytoolkitRelyingpartyVerifyPasswordRequest.fromJson(core.Map _json) {
    if (_json.containsKey("captchaChallenge")) {
      captchaChallenge = _json["captchaChallenge"];
    }
    if (_json.containsKey("captchaResponse")) {
      captchaResponse = _json["captchaResponse"];
    }
    if (_json.containsKey("delegatedProjectNumber")) {
      delegatedProjectNumber = _json["delegatedProjectNumber"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("instanceId")) {
      instanceId = _json["instanceId"];
    }
    if (_json.containsKey("password")) {
      password = _json["password"];
    }
    if (_json.containsKey("pendingIdToken")) {
      pendingIdToken = _json["pendingIdToken"];
    }
    if (_json.containsKey("returnSecureToken")) {
      returnSecureToken = _json["returnSecureToken"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (captchaChallenge != null) {
      _json["captchaChallenge"] = captchaChallenge;
    }
    if (captchaResponse != null) {
      _json["captchaResponse"] = captchaResponse;
    }
    if (delegatedProjectNumber != null) {
      _json["delegatedProjectNumber"] = delegatedProjectNumber;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (instanceId != null) {
      _json["instanceId"] = instanceId;
    }
    if (password != null) {
      _json["password"] = password;
    }
    if (pendingIdToken != null) {
      _json["pendingIdToken"] = pendingIdToken;
    }
    if (returnSecureToken != null) {
      _json["returnSecureToken"] = returnSecureToken;
    }
    return _json;
  }
}

/// Request for Identitytoolkit-VerifyPhoneNumber
class IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest {
  core.String code;
  core.String idToken;
  core.String operation;
  core.String phoneNumber;

  /// The session info previously returned by
  /// IdentityToolkit-SendVerificationCode.
  core.String sessionInfo;
  core.String temporaryProof;
  core.String verificationProof;

  IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest();

  IdentitytoolkitRelyingpartyVerifyPhoneNumberRequest.fromJson(core.Map _json) {
    if (_json.containsKey("code")) {
      code = _json["code"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("operation")) {
      operation = _json["operation"];
    }
    if (_json.containsKey("phoneNumber")) {
      phoneNumber = _json["phoneNumber"];
    }
    if (_json.containsKey("sessionInfo")) {
      sessionInfo = _json["sessionInfo"];
    }
    if (_json.containsKey("temporaryProof")) {
      temporaryProof = _json["temporaryProof"];
    }
    if (_json.containsKey("verificationProof")) {
      verificationProof = _json["verificationProof"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (code != null) {
      _json["code"] = code;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (operation != null) {
      _json["operation"] = operation;
    }
    if (phoneNumber != null) {
      _json["phoneNumber"] = phoneNumber;
    }
    if (sessionInfo != null) {
      _json["sessionInfo"] = sessionInfo;
    }
    if (temporaryProof != null) {
      _json["temporaryProof"] = temporaryProof;
    }
    if (verificationProof != null) {
      _json["verificationProof"] = verificationProof;
    }
    return _json;
  }
}

/// Response for Identitytoolkit-VerifyPhoneNumber
class IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse {
  core.String expiresIn;
  core.String idToken;
  core.bool isNewUser;
  core.String localId;
  core.String phoneNumber;
  core.String refreshToken;
  core.String temporaryProof;
  core.String temporaryProofExpiresIn;
  core.String verificationProof;
  core.String verificationProofExpiresIn;

  IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse();

  IdentitytoolkitRelyingpartyVerifyPhoneNumberResponse.fromJson(
      core.Map _json) {
    if (_json.containsKey("expiresIn")) {
      expiresIn = _json["expiresIn"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("isNewUser")) {
      isNewUser = _json["isNewUser"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("phoneNumber")) {
      phoneNumber = _json["phoneNumber"];
    }
    if (_json.containsKey("refreshToken")) {
      refreshToken = _json["refreshToken"];
    }
    if (_json.containsKey("temporaryProof")) {
      temporaryProof = _json["temporaryProof"];
    }
    if (_json.containsKey("temporaryProofExpiresIn")) {
      temporaryProofExpiresIn = _json["temporaryProofExpiresIn"];
    }
    if (_json.containsKey("verificationProof")) {
      verificationProof = _json["verificationProof"];
    }
    if (_json.containsKey("verificationProofExpiresIn")) {
      verificationProofExpiresIn = _json["verificationProofExpiresIn"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (expiresIn != null) {
      _json["expiresIn"] = expiresIn;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (isNewUser != null) {
      _json["isNewUser"] = isNewUser;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (phoneNumber != null) {
      _json["phoneNumber"] = phoneNumber;
    }
    if (refreshToken != null) {
      _json["refreshToken"] = refreshToken;
    }
    if (temporaryProof != null) {
      _json["temporaryProof"] = temporaryProof;
    }
    if (temporaryProofExpiresIn != null) {
      _json["temporaryProofExpiresIn"] = temporaryProofExpiresIn;
    }
    if (verificationProof != null) {
      _json["verificationProof"] = verificationProof;
    }
    if (verificationProofExpiresIn != null) {
      _json["verificationProofExpiresIn"] = verificationProofExpiresIn;
    }
    return _json;
  }
}

/// Template for a single idp configuration.
class IdpConfig {
  /// OAuth2 client ID.
  core.String clientId;

  /// Whether this IDP is enabled.
  core.bool enabled;

  /// Percent of users who will be prompted/redirected federated login for this
  /// IDP.
  core.int experimentPercent;

  /// OAuth2 provider.
  core.String provider;

  /// OAuth2 client secret.
  core.String secret;

  /// Whitelisted client IDs for audience check.
  core.List<core.String> whitelistedAudiences;

  IdpConfig();

  IdpConfig.fromJson(core.Map _json) {
    if (_json.containsKey("clientId")) {
      clientId = _json["clientId"];
    }
    if (_json.containsKey("enabled")) {
      enabled = _json["enabled"];
    }
    if (_json.containsKey("experimentPercent")) {
      experimentPercent = _json["experimentPercent"];
    }
    if (_json.containsKey("provider")) {
      provider = _json["provider"];
    }
    if (_json.containsKey("secret")) {
      secret = _json["secret"];
    }
    if (_json.containsKey("whitelistedAudiences")) {
      whitelistedAudiences = _json["whitelistedAudiences"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (clientId != null) {
      _json["clientId"] = clientId;
    }
    if (enabled != null) {
      _json["enabled"] = enabled;
    }
    if (experimentPercent != null) {
      _json["experimentPercent"] = experimentPercent;
    }
    if (provider != null) {
      _json["provider"] = provider;
    }
    if (secret != null) {
      _json["secret"] = secret;
    }
    if (whitelistedAudiences != null) {
      _json["whitelistedAudiences"] = whitelistedAudiences;
    }
    return _json;
  }
}

/// Request of getting a code for user confirmation (reset password, change
/// email etc.)
class Relyingparty {
  /// whether or not to install the android app on the device where the link is
  /// opened
  core.bool androidInstallApp;

  /// minimum version of the app. if the version on the device is lower than
  /// this version then the user is taken to the play store to upgrade the app
  core.String androidMinimumVersion;

  /// android package name of the android app to handle the action code
  core.String androidPackageName;

  /// whether or not the app can handle the oob code without first going to web
  core.bool canHandleCodeInApp;

  /// The recaptcha response from the user.
  core.String captchaResp;

  /// The recaptcha challenge presented to the user.
  core.String challenge;

  /// The url to continue to the Gitkit app
  core.String continueUrl;

  /// The email of the user.
  core.String email;

  /// iOS app store id to download the app if it's not already installed
  core.String iOSAppStoreId;

  /// the iOS bundle id of iOS app to handle the action code
  core.String iOSBundleId;

  /// The user's Gitkit login token for email change.
  core.String idToken;

  /// The fixed string "identitytoolkit#relyingparty".
  core.String kind;

  /// The new email if the code is for email change.
  core.String newEmail;

  /// The request type.
  core.String requestType;

  /// The IP address of the user.
  core.String userIp;

  Relyingparty();

  Relyingparty.fromJson(core.Map _json) {
    if (_json.containsKey("androidInstallApp")) {
      androidInstallApp = _json["androidInstallApp"];
    }
    if (_json.containsKey("androidMinimumVersion")) {
      androidMinimumVersion = _json["androidMinimumVersion"];
    }
    if (_json.containsKey("androidPackageName")) {
      androidPackageName = _json["androidPackageName"];
    }
    if (_json.containsKey("canHandleCodeInApp")) {
      canHandleCodeInApp = _json["canHandleCodeInApp"];
    }
    if (_json.containsKey("captchaResp")) {
      captchaResp = _json["captchaResp"];
    }
    if (_json.containsKey("challenge")) {
      challenge = _json["challenge"];
    }
    if (_json.containsKey("continueUrl")) {
      continueUrl = _json["continueUrl"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("iOSAppStoreId")) {
      iOSAppStoreId = _json["iOSAppStoreId"];
    }
    if (_json.containsKey("iOSBundleId")) {
      iOSBundleId = _json["iOSBundleId"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("newEmail")) {
      newEmail = _json["newEmail"];
    }
    if (_json.containsKey("requestType")) {
      requestType = _json["requestType"];
    }
    if (_json.containsKey("userIp")) {
      userIp = _json["userIp"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (androidInstallApp != null) {
      _json["androidInstallApp"] = androidInstallApp;
    }
    if (androidMinimumVersion != null) {
      _json["androidMinimumVersion"] = androidMinimumVersion;
    }
    if (androidPackageName != null) {
      _json["androidPackageName"] = androidPackageName;
    }
    if (canHandleCodeInApp != null) {
      _json["canHandleCodeInApp"] = canHandleCodeInApp;
    }
    if (captchaResp != null) {
      _json["captchaResp"] = captchaResp;
    }
    if (challenge != null) {
      _json["challenge"] = challenge;
    }
    if (continueUrl != null) {
      _json["continueUrl"] = continueUrl;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (iOSAppStoreId != null) {
      _json["iOSAppStoreId"] = iOSAppStoreId;
    }
    if (iOSBundleId != null) {
      _json["iOSBundleId"] = iOSBundleId;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (newEmail != null) {
      _json["newEmail"] = newEmail;
    }
    if (requestType != null) {
      _json["requestType"] = requestType;
    }
    if (userIp != null) {
      _json["userIp"] = userIp;
    }
    return _json;
  }
}

/// Response of resetting the password.
class ResetPasswordResponse {
  /// The user's email. If the out-of-band code is for email recovery, the
  /// user's original email.
  core.String email;

  /// The fixed string "identitytoolkit#ResetPasswordResponse".
  core.String kind;

  /// If the out-of-band code is for email recovery, the user's new email.
  core.String newEmail;

  /// The request type.
  core.String requestType;

  ResetPasswordResponse();

  ResetPasswordResponse.fromJson(core.Map _json) {
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("newEmail")) {
      newEmail = _json["newEmail"];
    }
    if (_json.containsKey("requestType")) {
      requestType = _json["requestType"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (email != null) {
      _json["email"] = email;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (newEmail != null) {
      _json["newEmail"] = newEmail;
    }
    if (requestType != null) {
      _json["requestType"] = requestType;
    }
    return _json;
  }
}

class SetAccountInfoResponseProviderUserInfo {
  /// The user's display name at the IDP.
  core.String displayName;

  /// User's identifier at IDP.
  core.String federatedId;

  /// The user's photo url at the IDP.
  core.String photoUrl;

  /// The IdP ID. For whitelisted IdPs it's a short domain name, e.g.,
  /// google.com, aol.com, live.net and yahoo.com. For other OpenID IdPs it's
  /// the OP identifier.
  core.String providerId;

  SetAccountInfoResponseProviderUserInfo();

  SetAccountInfoResponseProviderUserInfo.fromJson(core.Map _json) {
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("federatedId")) {
      federatedId = _json["federatedId"];
    }
    if (_json.containsKey("photoUrl")) {
      photoUrl = _json["photoUrl"];
    }
    if (_json.containsKey("providerId")) {
      providerId = _json["providerId"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (federatedId != null) {
      _json["federatedId"] = federatedId;
    }
    if (photoUrl != null) {
      _json["photoUrl"] = photoUrl;
    }
    if (providerId != null) {
      _json["providerId"] = providerId;
    }
    return _json;
  }
}

/// Respone of setting the account information.
class SetAccountInfoResponse {
  /// The name of the user.
  core.String displayName;

  /// The email of the user.
  core.String email;

  /// If email has been verified.
  core.bool emailVerified;

  /// If idToken is STS id token, then this field will be expiration time of STS
  /// id token in seconds.
  core.String expiresIn;

  /// The Gitkit id token to login the newly sign up user.
  core.String idToken;

  /// The fixed string "identitytoolkit#SetAccountInfoResponse".
  core.String kind;

  /// The local ID of the user.
  core.String localId;

  /// The new email the user attempts to change to.
  core.String newEmail;

  /// The user's hashed password.
  core.String passwordHash;
  core.List<core.int> get passwordHashAsBytes {
    return convert.BASE64.decode(passwordHash);
  }

  void set passwordHashAsBytes(core.List<core.int> _bytes) {
    passwordHash =
        convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
  }

  /// The photo url of the user.
  core.String photoUrl;

  /// The user's profiles at the associated IdPs.
  core.List<SetAccountInfoResponseProviderUserInfo> providerUserInfo;

  /// If idToken is STS id token, then this field will be refresh token.
  core.String refreshToken;

  SetAccountInfoResponse();

  SetAccountInfoResponse.fromJson(core.Map _json) {
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("emailVerified")) {
      emailVerified = _json["emailVerified"];
    }
    if (_json.containsKey("expiresIn")) {
      expiresIn = _json["expiresIn"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("newEmail")) {
      newEmail = _json["newEmail"];
    }
    if (_json.containsKey("passwordHash")) {
      passwordHash = _json["passwordHash"];
    }
    if (_json.containsKey("photoUrl")) {
      photoUrl = _json["photoUrl"];
    }
    if (_json.containsKey("providerUserInfo")) {
      providerUserInfo = _json["providerUserInfo"]
          .map((value) =>
              new SetAccountInfoResponseProviderUserInfo.fromJson(value))
          .toList();
    }
    if (_json.containsKey("refreshToken")) {
      refreshToken = _json["refreshToken"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (emailVerified != null) {
      _json["emailVerified"] = emailVerified;
    }
    if (expiresIn != null) {
      _json["expiresIn"] = expiresIn;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (newEmail != null) {
      _json["newEmail"] = newEmail;
    }
    if (passwordHash != null) {
      _json["passwordHash"] = passwordHash;
    }
    if (photoUrl != null) {
      _json["photoUrl"] = photoUrl;
    }
    if (providerUserInfo != null) {
      _json["providerUserInfo"] =
          providerUserInfo.map((value) => (value).toJson()).toList();
    }
    if (refreshToken != null) {
      _json["refreshToken"] = refreshToken;
    }
    return _json;
  }
}

/// Response of signing up new user, creating anonymous user or anonymous user
/// reauth.
class SignupNewUserResponse {
  /// The name of the user.
  core.String displayName;

  /// The email of the user.
  core.String email;

  /// If idToken is STS id token, then this field will be expiration time of STS
  /// id token in seconds.
  core.String expiresIn;

  /// The Gitkit id token to login the newly sign up user.
  core.String idToken;

  /// The fixed string "identitytoolkit#SignupNewUserResponse".
  core.String kind;

  /// The RP local ID of the user.
  core.String localId;

  /// If idToken is STS id token, then this field will be refresh token.
  core.String refreshToken;

  SignupNewUserResponse();

  SignupNewUserResponse.fromJson(core.Map _json) {
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("expiresIn")) {
      expiresIn = _json["expiresIn"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("refreshToken")) {
      refreshToken = _json["refreshToken"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (expiresIn != null) {
      _json["expiresIn"] = expiresIn;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (refreshToken != null) {
      _json["refreshToken"] = refreshToken;
    }
    return _json;
  }
}

class UploadAccountResponseError {
  /// The index of the malformed account, starting from 0.
  core.int index;

  /// Detailed error message for the account info.
  core.String message;

  UploadAccountResponseError();

  UploadAccountResponseError.fromJson(core.Map _json) {
    if (_json.containsKey("index")) {
      index = _json["index"];
    }
    if (_json.containsKey("message")) {
      message = _json["message"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (index != null) {
      _json["index"] = index;
    }
    if (message != null) {
      _json["message"] = message;
    }
    return _json;
  }
}

/// Respone of uploading accounts in batch.
class UploadAccountResponse {
  /// The error encountered while processing the account info.
  core.List<UploadAccountResponseError> error;

  /// The fixed string "identitytoolkit#UploadAccountResponse".
  core.String kind;

  UploadAccountResponse();

  UploadAccountResponse.fromJson(core.Map _json) {
    if (_json.containsKey("error")) {
      error = _json["error"]
          .map((value) => new UploadAccountResponseError.fromJson(value))
          .toList();
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (error != null) {
      _json["error"] = error.map((value) => (value).toJson()).toList();
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    return _json;
  }
}

class UserInfoProviderUserInfo {
  /// The user's display name at the IDP.
  core.String displayName;

  /// User's email at IDP.
  core.String email;

  /// User's identifier at IDP.
  core.String federatedId;

  /// User's phone number.
  core.String phoneNumber;

  /// The user's photo url at the IDP.
  core.String photoUrl;

  /// The IdP ID. For white listed IdPs it's a short domain name, e.g.,
  /// google.com, aol.com, live.net and yahoo.com. For other OpenID IdPs it's
  /// the OP identifier.
  core.String providerId;

  /// User's raw identifier directly returned from IDP.
  core.String rawId;

  /// User's screen name at Twitter or login name at Github.
  core.String screenName;

  UserInfoProviderUserInfo();

  UserInfoProviderUserInfo.fromJson(core.Map _json) {
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("federatedId")) {
      federatedId = _json["federatedId"];
    }
    if (_json.containsKey("phoneNumber")) {
      phoneNumber = _json["phoneNumber"];
    }
    if (_json.containsKey("photoUrl")) {
      photoUrl = _json["photoUrl"];
    }
    if (_json.containsKey("providerId")) {
      providerId = _json["providerId"];
    }
    if (_json.containsKey("rawId")) {
      rawId = _json["rawId"];
    }
    if (_json.containsKey("screenName")) {
      screenName = _json["screenName"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (federatedId != null) {
      _json["federatedId"] = federatedId;
    }
    if (phoneNumber != null) {
      _json["phoneNumber"] = phoneNumber;
    }
    if (photoUrl != null) {
      _json["photoUrl"] = photoUrl;
    }
    if (providerId != null) {
      _json["providerId"] = providerId;
    }
    if (rawId != null) {
      _json["rawId"] = rawId;
    }
    if (screenName != null) {
      _json["screenName"] = screenName;
    }
    return _json;
  }
}

/// Template for an individual account info.
class UserInfo {
  /// User creation timestamp.
  core.String createdAt;

  /// The custom attributes to be set in the user's id token.
  core.String customAttributes;

  /// Whether the user is authenticated by the developer.
  core.bool customAuth;

  /// Whether the user is disabled.
  core.bool disabled;

  /// The name of the user.
  core.String displayName;

  /// The email of the user.
  core.String email;

  /// Whether the email has been verified.
  core.bool emailVerified;

  /// last login timestamp.
  core.String lastLoginAt;

  /// The local ID of the user.
  core.String localId;

  /// The user's hashed password.
  core.String passwordHash;
  core.List<core.int> get passwordHashAsBytes {
    return convert.BASE64.decode(passwordHash);
  }

  void set passwordHashAsBytes(core.List<core.int> _bytes) {
    passwordHash =
        convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
  }

  /// The timestamp when the password was last updated.
  core.double passwordUpdatedAt;

  /// User's phone number.
  core.String phoneNumber;

  /// The URL of the user profile photo.
  core.String photoUrl;

  /// The IDP of the user.
  core.List<UserInfoProviderUserInfo> providerUserInfo;

  /// The user's plain text password.
  core.String rawPassword;

  /// The user's password salt.
  core.String salt;
  core.List<core.int> get saltAsBytes {
    return convert.BASE64.decode(salt);
  }

  void set saltAsBytes(core.List<core.int> _bytes) {
    salt =
        convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
  }

  /// User's screen name at Twitter or login name at Github.
  core.String screenName;

  /// Timestamp in seconds for valid login token.
  core.String validSince;

  /// Version of the user's password.
  core.int version;

  UserInfo();

  UserInfo.fromJson(core.Map _json) {
    if (_json.containsKey("createdAt")) {
      createdAt = _json["createdAt"];
    }
    if (_json.containsKey("customAttributes")) {
      customAttributes = _json["customAttributes"];
    }
    if (_json.containsKey("customAuth")) {
      customAuth = _json["customAuth"];
    }
    if (_json.containsKey("disabled")) {
      disabled = _json["disabled"];
    }
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("emailVerified")) {
      emailVerified = _json["emailVerified"];
    }
    if (_json.containsKey("lastLoginAt")) {
      lastLoginAt = _json["lastLoginAt"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("passwordHash")) {
      passwordHash = _json["passwordHash"];
    }
    if (_json.containsKey("passwordUpdatedAt")) {
      passwordUpdatedAt = _json["passwordUpdatedAt"];
    }
    if (_json.containsKey("phoneNumber")) {
      phoneNumber = _json["phoneNumber"];
    }
    if (_json.containsKey("photoUrl")) {
      photoUrl = _json["photoUrl"];
    }
    if (_json.containsKey("providerUserInfo")) {
      providerUserInfo = _json["providerUserInfo"]
          .map((value) => new UserInfoProviderUserInfo.fromJson(value))
          .toList();
    }
    if (_json.containsKey("rawPassword")) {
      rawPassword = _json["rawPassword"];
    }
    if (_json.containsKey("salt")) {
      salt = _json["salt"];
    }
    if (_json.containsKey("screenName")) {
      screenName = _json["screenName"];
    }
    if (_json.containsKey("validSince")) {
      validSince = _json["validSince"];
    }
    if (_json.containsKey("version")) {
      version = _json["version"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (createdAt != null) {
      _json["createdAt"] = createdAt;
    }
    if (customAttributes != null) {
      _json["customAttributes"] = customAttributes;
    }
    if (customAuth != null) {
      _json["customAuth"] = customAuth;
    }
    if (disabled != null) {
      _json["disabled"] = disabled;
    }
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (emailVerified != null) {
      _json["emailVerified"] = emailVerified;
    }
    if (lastLoginAt != null) {
      _json["lastLoginAt"] = lastLoginAt;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (passwordHash != null) {
      _json["passwordHash"] = passwordHash;
    }
    if (passwordUpdatedAt != null) {
      _json["passwordUpdatedAt"] = passwordUpdatedAt;
    }
    if (phoneNumber != null) {
      _json["phoneNumber"] = phoneNumber;
    }
    if (photoUrl != null) {
      _json["photoUrl"] = photoUrl;
    }
    if (providerUserInfo != null) {
      _json["providerUserInfo"] =
          providerUserInfo.map((value) => (value).toJson()).toList();
    }
    if (rawPassword != null) {
      _json["rawPassword"] = rawPassword;
    }
    if (salt != null) {
      _json["salt"] = salt;
    }
    if (screenName != null) {
      _json["screenName"] = screenName;
    }
    if (validSince != null) {
      _json["validSince"] = validSince;
    }
    if (version != null) {
      _json["version"] = version;
    }
    return _json;
  }
}

/// Response of verifying the IDP assertion.
class VerifyAssertionResponse {
  /// The action code.
  core.String action;

  /// URL for OTA app installation.
  core.String appInstallationUrl;

  /// The custom scheme used by mobile app.
  core.String appScheme;

  /// The opaque value used by the client to maintain context info between the
  /// authentication request and the IDP callback.
  core.String context;

  /// The birth date of the IdP account.
  core.String dateOfBirth;

  /// The display name of the user.
  core.String displayName;

  /// The email returned by the IdP. NOTE: The federated login user may not own
  /// the email.
  core.String email;

  /// It's true if the email is recycled.
  core.bool emailRecycled;

  /// The value is true if the IDP is also the email provider. It means the user
  /// owns the email.
  core.bool emailVerified;

  /// Client error code.
  core.String errorMessage;

  /// If idToken is STS id token, then this field will be expiration time of STS
  /// id token in seconds.
  core.String expiresIn;

  /// The unique ID identifies the IdP account.
  core.String federatedId;

  /// The first name of the user.
  core.String firstName;

  /// The full name of the user.
  core.String fullName;

  /// The ID token.
  core.String idToken;

  /// It's the identifier param in the createAuthUri request if the identifier
  /// is an email. It can be used to check whether the user input email is
  /// different from the asserted email.
  core.String inputEmail;

  /// True if it's a new user sign-in, false if it's a returning user.
  core.bool isNewUser;

  /// The fixed string "identitytoolkit#VerifyAssertionResponse".
  core.String kind;

  /// The language preference of the user.
  core.String language;

  /// The last name of the user.
  core.String lastName;

  /// The RP local ID if it's already been mapped to the IdP account identified
  /// by the federated ID.
  core.String localId;

  /// Whether the assertion is from a non-trusted IDP and need account linking
  /// confirmation.
  core.bool needConfirmation;

  /// Whether need client to supply email to complete the federated login flow.
  core.bool needEmail;

  /// The nick name of the user.
  core.String nickName;

  /// The OAuth2 access token.
  core.String oauthAccessToken;

  /// The OAuth2 authorization code.
  core.String oauthAuthorizationCode;

  /// The lifetime in seconds of the OAuth2 access token.
  core.int oauthExpireIn;

  /// The OIDC id token.
  core.String oauthIdToken;

  /// The user approved request token for the OpenID OAuth extension.
  core.String oauthRequestToken;

  /// The scope for the OpenID OAuth extension.
  core.String oauthScope;

  /// The OAuth1 access token secret.
  core.String oauthTokenSecret;

  /// The original email stored in the mapping storage. It's returned when the
  /// federated ID is associated to a different email.
  core.String originalEmail;

  /// The URI of the public accessible profiel picture.
  core.String photoUrl;

  /// The IdP ID. For white listed IdPs it's a short domain name e.g.
  /// google.com, aol.com, live.net and yahoo.com. If the "providerId" param is
  /// set to OpenID OP identifer other than the whilte listed IdPs the OP
  /// identifier is returned. If the "identifier" param is federated ID in the
  /// createAuthUri request. The domain part of the federated ID is returned.
  core.String providerId;

  /// Raw IDP-returned user info.
  core.String rawUserInfo;

  /// If idToken is STS id token, then this field will be refresh token.
  core.String refreshToken;

  /// The screen_name of a Twitter user or the login name at Github.
  core.String screenName;

  /// The timezone of the user.
  core.String timeZone;

  /// When action is 'map', contains the idps which can be used for
  /// confirmation.
  core.List<core.String> verifiedProvider;

  VerifyAssertionResponse();

  VerifyAssertionResponse.fromJson(core.Map _json) {
    if (_json.containsKey("action")) {
      action = _json["action"];
    }
    if (_json.containsKey("appInstallationUrl")) {
      appInstallationUrl = _json["appInstallationUrl"];
    }
    if (_json.containsKey("appScheme")) {
      appScheme = _json["appScheme"];
    }
    if (_json.containsKey("context")) {
      context = _json["context"];
    }
    if (_json.containsKey("dateOfBirth")) {
      dateOfBirth = _json["dateOfBirth"];
    }
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("emailRecycled")) {
      emailRecycled = _json["emailRecycled"];
    }
    if (_json.containsKey("emailVerified")) {
      emailVerified = _json["emailVerified"];
    }
    if (_json.containsKey("errorMessage")) {
      errorMessage = _json["errorMessage"];
    }
    if (_json.containsKey("expiresIn")) {
      expiresIn = _json["expiresIn"];
    }
    if (_json.containsKey("federatedId")) {
      federatedId = _json["federatedId"];
    }
    if (_json.containsKey("firstName")) {
      firstName = _json["firstName"];
    }
    if (_json.containsKey("fullName")) {
      fullName = _json["fullName"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("inputEmail")) {
      inputEmail = _json["inputEmail"];
    }
    if (_json.containsKey("isNewUser")) {
      isNewUser = _json["isNewUser"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("language")) {
      language = _json["language"];
    }
    if (_json.containsKey("lastName")) {
      lastName = _json["lastName"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("needConfirmation")) {
      needConfirmation = _json["needConfirmation"];
    }
    if (_json.containsKey("needEmail")) {
      needEmail = _json["needEmail"];
    }
    if (_json.containsKey("nickName")) {
      nickName = _json["nickName"];
    }
    if (_json.containsKey("oauthAccessToken")) {
      oauthAccessToken = _json["oauthAccessToken"];
    }
    if (_json.containsKey("oauthAuthorizationCode")) {
      oauthAuthorizationCode = _json["oauthAuthorizationCode"];
    }
    if (_json.containsKey("oauthExpireIn")) {
      oauthExpireIn = _json["oauthExpireIn"];
    }
    if (_json.containsKey("oauthIdToken")) {
      oauthIdToken = _json["oauthIdToken"];
    }
    if (_json.containsKey("oauthRequestToken")) {
      oauthRequestToken = _json["oauthRequestToken"];
    }
    if (_json.containsKey("oauthScope")) {
      oauthScope = _json["oauthScope"];
    }
    if (_json.containsKey("oauthTokenSecret")) {
      oauthTokenSecret = _json["oauthTokenSecret"];
    }
    if (_json.containsKey("originalEmail")) {
      originalEmail = _json["originalEmail"];
    }
    if (_json.containsKey("photoUrl")) {
      photoUrl = _json["photoUrl"];
    }
    if (_json.containsKey("providerId")) {
      providerId = _json["providerId"];
    }
    if (_json.containsKey("rawUserInfo")) {
      rawUserInfo = _json["rawUserInfo"];
    }
    if (_json.containsKey("refreshToken")) {
      refreshToken = _json["refreshToken"];
    }
    if (_json.containsKey("screenName")) {
      screenName = _json["screenName"];
    }
    if (_json.containsKey("timeZone")) {
      timeZone = _json["timeZone"];
    }
    if (_json.containsKey("verifiedProvider")) {
      verifiedProvider = _json["verifiedProvider"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (action != null) {
      _json["action"] = action;
    }
    if (appInstallationUrl != null) {
      _json["appInstallationUrl"] = appInstallationUrl;
    }
    if (appScheme != null) {
      _json["appScheme"] = appScheme;
    }
    if (context != null) {
      _json["context"] = context;
    }
    if (dateOfBirth != null) {
      _json["dateOfBirth"] = dateOfBirth;
    }
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (emailRecycled != null) {
      _json["emailRecycled"] = emailRecycled;
    }
    if (emailVerified != null) {
      _json["emailVerified"] = emailVerified;
    }
    if (errorMessage != null) {
      _json["errorMessage"] = errorMessage;
    }
    if (expiresIn != null) {
      _json["expiresIn"] = expiresIn;
    }
    if (federatedId != null) {
      _json["federatedId"] = federatedId;
    }
    if (firstName != null) {
      _json["firstName"] = firstName;
    }
    if (fullName != null) {
      _json["fullName"] = fullName;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (inputEmail != null) {
      _json["inputEmail"] = inputEmail;
    }
    if (isNewUser != null) {
      _json["isNewUser"] = isNewUser;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (language != null) {
      _json["language"] = language;
    }
    if (lastName != null) {
      _json["lastName"] = lastName;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (needConfirmation != null) {
      _json["needConfirmation"] = needConfirmation;
    }
    if (needEmail != null) {
      _json["needEmail"] = needEmail;
    }
    if (nickName != null) {
      _json["nickName"] = nickName;
    }
    if (oauthAccessToken != null) {
      _json["oauthAccessToken"] = oauthAccessToken;
    }
    if (oauthAuthorizationCode != null) {
      _json["oauthAuthorizationCode"] = oauthAuthorizationCode;
    }
    if (oauthExpireIn != null) {
      _json["oauthExpireIn"] = oauthExpireIn;
    }
    if (oauthIdToken != null) {
      _json["oauthIdToken"] = oauthIdToken;
    }
    if (oauthRequestToken != null) {
      _json["oauthRequestToken"] = oauthRequestToken;
    }
    if (oauthScope != null) {
      _json["oauthScope"] = oauthScope;
    }
    if (oauthTokenSecret != null) {
      _json["oauthTokenSecret"] = oauthTokenSecret;
    }
    if (originalEmail != null) {
      _json["originalEmail"] = originalEmail;
    }
    if (photoUrl != null) {
      _json["photoUrl"] = photoUrl;
    }
    if (providerId != null) {
      _json["providerId"] = providerId;
    }
    if (rawUserInfo != null) {
      _json["rawUserInfo"] = rawUserInfo;
    }
    if (refreshToken != null) {
      _json["refreshToken"] = refreshToken;
    }
    if (screenName != null) {
      _json["screenName"] = screenName;
    }
    if (timeZone != null) {
      _json["timeZone"] = timeZone;
    }
    if (verifiedProvider != null) {
      _json["verifiedProvider"] = verifiedProvider;
    }
    return _json;
  }
}

/// Response from verifying a custom token
class VerifyCustomTokenResponse {
  /// If idToken is STS id token, then this field will be expiration time of STS
  /// id token in seconds.
  core.String expiresIn;

  /// The GITKit token for authenticated user.
  core.String idToken;

  /// True if it's a new user sign-in, false if it's a returning user.
  core.bool isNewUser;

  /// The fixed string "identitytoolkit#VerifyCustomTokenResponse".
  core.String kind;

  /// If idToken is STS id token, then this field will be refresh token.
  core.String refreshToken;

  VerifyCustomTokenResponse();

  VerifyCustomTokenResponse.fromJson(core.Map _json) {
    if (_json.containsKey("expiresIn")) {
      expiresIn = _json["expiresIn"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("isNewUser")) {
      isNewUser = _json["isNewUser"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("refreshToken")) {
      refreshToken = _json["refreshToken"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (expiresIn != null) {
      _json["expiresIn"] = expiresIn;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (isNewUser != null) {
      _json["isNewUser"] = isNewUser;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (refreshToken != null) {
      _json["refreshToken"] = refreshToken;
    }
    return _json;
  }
}

/// Request of verifying the password.
class VerifyPasswordResponse {
  /// The name of the user.
  core.String displayName;

  /// The email returned by the IdP. NOTE: The federated login user may not own
  /// the email.
  core.String email;

  /// If idToken is STS id token, then this field will be expiration time of STS
  /// id token in seconds.
  core.String expiresIn;

  /// The GITKit token for authenticated user.
  core.String idToken;

  /// The fixed string "identitytoolkit#VerifyPasswordResponse".
  core.String kind;

  /// The RP local ID if it's already been mapped to the IdP account identified
  /// by the federated ID.
  core.String localId;

  /// The OAuth2 access token.
  core.String oauthAccessToken;

  /// The OAuth2 authorization code.
  core.String oauthAuthorizationCode;

  /// The lifetime in seconds of the OAuth2 access token.
  core.int oauthExpireIn;

  /// The URI of the user's photo at IdP
  core.String photoUrl;

  /// If idToken is STS id token, then this field will be refresh token.
  core.String refreshToken;

  /// Whether the email is registered.
  core.bool registered;

  VerifyPasswordResponse();

  VerifyPasswordResponse.fromJson(core.Map _json) {
    if (_json.containsKey("displayName")) {
      displayName = _json["displayName"];
    }
    if (_json.containsKey("email")) {
      email = _json["email"];
    }
    if (_json.containsKey("expiresIn")) {
      expiresIn = _json["expiresIn"];
    }
    if (_json.containsKey("idToken")) {
      idToken = _json["idToken"];
    }
    if (_json.containsKey("kind")) {
      kind = _json["kind"];
    }
    if (_json.containsKey("localId")) {
      localId = _json["localId"];
    }
    if (_json.containsKey("oauthAccessToken")) {
      oauthAccessToken = _json["oauthAccessToken"];
    }
    if (_json.containsKey("oauthAuthorizationCode")) {
      oauthAuthorizationCode = _json["oauthAuthorizationCode"];
    }
    if (_json.containsKey("oauthExpireIn")) {
      oauthExpireIn = _json["oauthExpireIn"];
    }
    if (_json.containsKey("photoUrl")) {
      photoUrl = _json["photoUrl"];
    }
    if (_json.containsKey("refreshToken")) {
      refreshToken = _json["refreshToken"];
    }
    if (_json.containsKey("registered")) {
      registered = _json["registered"];
    }
  }

  core.Map<core.String, core.Object> toJson() {
    final core.Map<core.String, core.Object> _json =
        new core.Map<core.String, core.Object>();
    if (displayName != null) {
      _json["displayName"] = displayName;
    }
    if (email != null) {
      _json["email"] = email;
    }
    if (expiresIn != null) {
      _json["expiresIn"] = expiresIn;
    }
    if (idToken != null) {
      _json["idToken"] = idToken;
    }
    if (kind != null) {
      _json["kind"] = kind;
    }
    if (localId != null) {
      _json["localId"] = localId;
    }
    if (oauthAccessToken != null) {
      _json["oauthAccessToken"] = oauthAccessToken;
    }
    if (oauthAuthorizationCode != null) {
      _json["oauthAuthorizationCode"] = oauthAuthorizationCode;
    }
    if (oauthExpireIn != null) {
      _json["oauthExpireIn"] = oauthExpireIn;
    }
    if (photoUrl != null) {
      _json["photoUrl"] = photoUrl;
    }
    if (refreshToken != null) {
      _json["refreshToken"] = refreshToken;
    }
    if (registered != null) {
      _json["registered"] = registered;
    }
    return _json;
  }
}