// third_party/blink/public/mojom/webid/federated_request.mojom.cc is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "third_party/blink/public/mojom/webid/federated_request.mojom.h"
#include <math.h>
#include <stdint.h>
#include <utility>
#include "base/debug/alias.h"
#include "base/notreached.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "third_party/blink/public/mojom/webid/federated_request.mojom-params-data.h"
#include "third_party/blink/public/mojom/webid/federated_request.mojom-shared-message-ids.h"

#include "third_party/blink/public/mojom/webid/federated_request.mojom-import-headers.h"
#include "third_party/blink/public/mojom/webid/federated_request.mojom-test-utils.h"


namespace blink::mojom {
IdentityProviderConfig::IdentityProviderConfig()
    : config_url(),
      from_idp_registration_api(),
      type(),
      client_id() {}

IdentityProviderConfig::IdentityProviderConfig(
    const ::GURL& config_url_in,
    bool from_idp_registration_api_in,
    const std::optional<std::string>& type_in,
    const std::string& client_id_in)
    : config_url(std::move(config_url_in)),
      from_idp_registration_api(std::move(from_idp_registration_api_in)),
      type(std::move(type_in)),
      client_id(std::move(client_id_in)) {}

IdentityProviderConfig::~IdentityProviderConfig() = default;

void IdentityProviderConfig::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "config_url"), this->config_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "from_idp_registration_api"), this->from_idp_registration_api,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "type"), this->type,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "client_id"), this->client_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool IdentityProviderConfig::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
RedirectGetParams::RedirectGetParams()
    : url() {}

RedirectGetParams::RedirectGetParams(
    const ::GURL& url_in)
    : url(std::move(url_in)) {}

RedirectGetParams::~RedirectGetParams() = default;

void RedirectGetParams::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "url"), this->url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool RedirectGetParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
RedirectPostParams::RedirectPostParams()
    : url(),
      request_body() {}

RedirectPostParams::RedirectPostParams(
    const ::GURL& url_in,
    const std::string& request_body_in)
    : url(std::move(url_in)),
      request_body(std::move(request_body_in)) {}

RedirectPostParams::~RedirectPostParams() = default;

void RedirectPostParams::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "url"), this->url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "request_body"), this->request_body,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool RedirectPostParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
IdentityProviderRequestOptions::IdentityProviderRequestOptions()
    : config(),
      nonce(),
      login_hint(),
      domain_hint(),
      fields(),
      params_json(),
      format() {}

IdentityProviderRequestOptions::IdentityProviderRequestOptions(
    IdentityProviderConfigPtr config_in,
    const std::string& nonce_in,
    const std::string& login_hint_in,
    const std::string& domain_hint_in,
    std::optional<std::vector<std::string>> fields_in,
    const std::optional<std::string>& params_json_in,
    std::optional<Format> format_in)
    : config(std::move(config_in)),
      nonce(std::move(nonce_in)),
      login_hint(std::move(login_hint_in)),
      domain_hint(std::move(domain_hint_in)),
      fields(std::move(fields_in)),
      params_json(std::move(params_json_in)),
      format(std::move(format_in)) {}

IdentityProviderRequestOptions::~IdentityProviderRequestOptions() = default;

void IdentityProviderRequestOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "config"), this->config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type IdentityProviderConfigPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "nonce"), this->nonce,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "login_hint"), this->login_hint,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "domain_hint"), this->domain_hint,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "fields"), this->fields,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::vector<std::string>>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "params_json"), this->params_json,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "format"), this->format,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<Format>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool IdentityProviderRequestOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
IdentityCredentialDisconnectOptions::IdentityCredentialDisconnectOptions()
    : config(),
      account_hint() {}

IdentityCredentialDisconnectOptions::IdentityCredentialDisconnectOptions(
    IdentityProviderConfigPtr config_in,
    const std::string& account_hint_in)
    : config(std::move(config_in)),
      account_hint(std::move(account_hint_in)) {}

IdentityCredentialDisconnectOptions::~IdentityCredentialDisconnectOptions() = default;

void IdentityCredentialDisconnectOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "config"), this->config,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type IdentityProviderConfigPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "account_hint"), this->account_hint,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool IdentityCredentialDisconnectOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
IdentityUserInfo::IdentityUserInfo()
    : email(),
      given_name(),
      name(),
      picture() {}

IdentityUserInfo::IdentityUserInfo(
    const std::string& email_in,
    const std::string& given_name_in,
    const std::string& name_in,
    const std::string& picture_in)
    : email(std::move(email_in)),
      given_name(std::move(given_name_in)),
      name(std::move(name_in)),
      picture(std::move(picture_in)) {}

IdentityUserInfo::~IdentityUserInfo() = default;
size_t IdentityUserInfo::Hash(size_t seed) const {
  seed = mojo::internal::Hash(seed, this->email);
  seed = mojo::internal::Hash(seed, this->given_name);
  seed = mojo::internal::Hash(seed, this->name);
  seed = mojo::internal::Hash(seed, this->picture);
  return seed;
}

void IdentityUserInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "email"), this->email,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "given_name"), this->given_name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "picture"), this->picture,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool IdentityUserInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
LoginStatusAccount::LoginStatusAccount()
    : id(),
      email(),
      name(),
      given_name(),
      picture() {}

LoginStatusAccount::LoginStatusAccount(
    const std::string& id_in,
    const std::string& email_in,
    const std::string& name_in,
    const std::optional<std::string>& given_name_in,
    const std::optional<::GURL>& picture_in)
    : id(std::move(id_in)),
      email(std::move(email_in)),
      name(std::move(name_in)),
      given_name(std::move(given_name_in)),
      picture(std::move(picture_in)) {}

LoginStatusAccount::~LoginStatusAccount() = default;

void LoginStatusAccount::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "id"), this->id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "email"), this->email,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "given_name"), this->given_name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "picture"), this->picture,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::GURL>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool LoginStatusAccount::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
LoginStatusOptions::LoginStatusOptions()
    : accounts(),
      expiration() {}

LoginStatusOptions::LoginStatusOptions(
    std::vector<::blink::common::webid::LoginStatusAccount> accounts_in,
    std::optional<::base::TimeDelta> expiration_in)
    : accounts(std::move(accounts_in)),
      expiration(std::move(expiration_in)) {}

LoginStatusOptions::~LoginStatusOptions() = default;

void LoginStatusOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "accounts"), this->accounts,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::vector<::blink::common::webid::LoginStatusAccount>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "expiration"), this->expiration,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<::base::TimeDelta>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool LoginStatusOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
IdentityProviderGetParameters::IdentityProviderGetParameters()
    : providers(),
      context(),
      mode() {}

IdentityProviderGetParameters::IdentityProviderGetParameters(
    std::vector<IdentityProviderRequestOptionsPtr> providers_in,
    RpContext context_in,
    RpMode mode_in)
    : providers(std::move(providers_in)),
      context(std::move(context_in)),
      mode(std::move(mode_in)) {}

IdentityProviderGetParameters::~IdentityProviderGetParameters() = default;

void IdentityProviderGetParameters::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "providers"), this->providers,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<IdentityProviderRequestOptionsPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "context"), this->context,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type RpContext>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "mode"), this->mode,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type RpMode>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool IdentityProviderGetParameters::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TokenError::TokenError()
    : code(),
      url() {}

TokenError::TokenError(
    const std::optional<std::string>& code_in,
    const std::optional<::GURL>& url_in)
    : code(std::move(code_in)),
      url(std::move(url_in)) {}

TokenError::~TokenError() = default;

void TokenError::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "code"), this->code,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "url"), this->url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::GURL>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool TokenError::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TokenRequestSuccess::TokenRequestSuccess()
    : selected_idp_config_url(),
      token(),
      is_auto_selected() {}

TokenRequestSuccess::TokenRequestSuccess(
    const ::GURL& selected_idp_config_url_in,
    std::optional<::base::Value> token_in,
    bool is_auto_selected_in)
    : selected_idp_config_url(std::move(selected_idp_config_url_in)),
      token(std::move(token_in)),
      is_auto_selected(std::move(is_auto_selected_in)) {}

TokenRequestSuccess::~TokenRequestSuccess() = default;

void TokenRequestSuccess::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "selected_idp_config_url"), this->selected_idp_config_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "token"), this->token,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<::base::Value>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_auto_selected"), this->is_auto_selected,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool TokenRequestSuccess::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
TokenRequestFailure::TokenRequestFailure()
    : status(),
      error() {}

TokenRequestFailure::TokenRequestFailure(
    RequestTokenStatus status_in,
    TokenErrorPtr error_in)
    : status(std::move(status_in)),
      error(std::move(error_in)) {}

TokenRequestFailure::~TokenRequestFailure() = default;

void TokenRequestFailure::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "status"), this->status,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type RequestTokenStatus>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "error"), this->error,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type TokenErrorPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool TokenRequestFailure::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
RedirectParamsPtr
RedirectParams::NewGet(
    RedirectGetParamsPtr value) {
  return RedirectParamsPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kGet)>,
      std::move(value));
}

RedirectParamsPtr
RedirectParams::NewPost(
    RedirectPostParamsPtr value) {
  return RedirectParamsPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kPost)>,
      std::move(value));
}

RedirectParams::RedirectParams(
    std::in_place_index_t<static_cast<size_t>(Tag::kGet)>,
    RedirectGetParamsPtr value)
    : tag_(Tag::kGet),
      data_(std::in_place_index<static_cast<size_t>(Tag::kGet)>,
            std::move(value)) {}

RedirectParams::RedirectParams(
    std::in_place_index_t<static_cast<size_t>(Tag::kPost)>,
    RedirectPostParamsPtr value)
    : tag_(Tag::kPost),
      data_(std::in_place_index<static_cast<size_t>(Tag::kPost)>,
            std::move(value)) {}
RedirectParams::~RedirectParams() {
  DestroyActive();
}

void RedirectParams::set_get(RedirectGetParamsPtr get) {
  if (tag_ == Tag::kGet) {
    data_.get = std::move(get);
  } else {
    DestroyActive();
    tag_ = Tag::kGet;
    new (&data_.get) RedirectGetParamsPtr(
        std::move(get));
  }
}

void RedirectParams::set_post(RedirectPostParamsPtr post) {
  if (tag_ == Tag::kPost) {
    data_.post = std::move(post);
  } else {
    DestroyActive();
    tag_ = Tag::kPost;
    new (&data_.post) RedirectPostParamsPtr(
        std::move(post));
  }
}


RedirectParams::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kGet)>,
    RedirectGetParamsPtr value)
    : get(std::move(value)) {}

RedirectParams::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kPost)>,
    RedirectPostParamsPtr value)
    : post(std::move(value)) {}

void RedirectParams::DestroyActive() {
  switch (tag_) {

    case Tag::kGet:
      std::destroy_at(&data_.get);
      break;
    case Tag::kPost:
      std::destroy_at(&data_.post);
      break;
  }
}

bool RedirectParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
ResolveTokenParamsPtr
ResolveTokenParams::NewToken(
    ::base::Value value) {
  return ResolveTokenParamsPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kToken)>,
      std::move(value));
}

ResolveTokenParamsPtr
ResolveTokenParams::NewRedirectTo(
    RedirectParamsPtr value) {
  return ResolveTokenParamsPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kRedirectTo)>,
      std::move(value));
}

ResolveTokenParams::ResolveTokenParams(
    std::in_place_index_t<static_cast<size_t>(Tag::kToken)>,
    ::base::Value value)
    : tag_(Tag::kToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kToken)>,
            std::move(value)) {}

ResolveTokenParams::ResolveTokenParams(
    std::in_place_index_t<static_cast<size_t>(Tag::kRedirectTo)>,
    RedirectParamsPtr value)
    : tag_(Tag::kRedirectTo),
      data_(std::in_place_index<static_cast<size_t>(Tag::kRedirectTo)>,
            std::move(value)) {}
ResolveTokenParams::~ResolveTokenParams() {
  DestroyActive();
}

void ResolveTokenParams::set_token(::base::Value token) {
  if (tag_ == Tag::kToken) {
    data_.token = std::move(token);
  } else {
    DestroyActive();
    tag_ = Tag::kToken;
    new (&data_.token) ::base::Value(
        std::move(token));
  }
}

void ResolveTokenParams::set_redirect_to(RedirectParamsPtr redirect_to) {
  if (tag_ == Tag::kRedirectTo) {
    data_.redirect_to = std::move(redirect_to);
  } else {
    DestroyActive();
    tag_ = Tag::kRedirectTo;
    new (&data_.redirect_to) RedirectParamsPtr(
        std::move(redirect_to));
  }
}


ResolveTokenParams::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kToken)>,
    ::base::Value value)
    : token(std::move(value)) {}

ResolveTokenParams::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kRedirectTo)>,
    RedirectParamsPtr value)
    : redirect_to(std::move(value)) {}

void ResolveTokenParams::DestroyActive() {
  switch (tag_) {

    case Tag::kToken:
      std::destroy_at(&data_.token);
      break;
    case Tag::kRedirectTo:
      std::destroy_at(&data_.redirect_to);
      break;
  }
}

bool ResolveTokenParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
RequestUserInfoResultPtr
RequestUserInfoResult::NewStatus(
    RequestUserInfoStatus value) {
  return RequestUserInfoResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kStatus)>,
      std::move(value));
}

RequestUserInfoResultPtr
RequestUserInfoResult::NewUserInfo(
    std::vector<IdentityUserInfoPtr> value) {
  return RequestUserInfoResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kUserInfo)>,
      std::move(value));
}

RequestUserInfoResult::RequestUserInfoResult(
    std::in_place_index_t<static_cast<size_t>(Tag::kStatus)>,
    RequestUserInfoStatus value)
    : tag_(Tag::kStatus),
      data_(std::in_place_index<static_cast<size_t>(Tag::kStatus)>,
            std::move(value)) {}

RequestUserInfoResult::RequestUserInfoResult(
    std::in_place_index_t<static_cast<size_t>(Tag::kUserInfo)>,
    std::vector<IdentityUserInfoPtr> value)
    : tag_(Tag::kUserInfo),
      data_(std::in_place_index<static_cast<size_t>(Tag::kUserInfo)>,
            std::move(value)) {}
RequestUserInfoResult::~RequestUserInfoResult() {
  DestroyActive();
}

void RequestUserInfoResult::set_status(RequestUserInfoStatus status) {
  if (tag_ != Tag::kStatus) {
    DestroyActive();
    tag_ = Tag::kStatus;
  }
  data_.status = status;
}

void RequestUserInfoResult::set_user_info(std::vector<IdentityUserInfoPtr> user_info) {
  if (tag_ == Tag::kUserInfo) {
    data_.user_info = std::move(user_info);
  } else {
    DestroyActive();
    tag_ = Tag::kUserInfo;
    new (&data_.user_info) std::vector<IdentityUserInfoPtr>(
        std::move(user_info));
  }
}


RequestUserInfoResult::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kStatus)>,
    RequestUserInfoStatus value)
    : status(std::move(value)) {}

RequestUserInfoResult::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kUserInfo)>,
    std::vector<IdentityUserInfoPtr> value)
    : user_info(std::move(value)) {}

void RequestUserInfoResult::DestroyActive() {
  switch (tag_) {

    case Tag::kStatus:
      std::destroy_at(&data_.status);
      break;
    case Tag::kUserInfo:
      std::destroy_at(&data_.user_info);
      break;
  }
}

bool RequestUserInfoResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr
FederatedRequestService_StartTokenRequest_ResponseParam_Result::NewSuccess(
    TokenRequestSuccessPtr value) {
  return FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr
FederatedRequestService_StartTokenRequest_ResponseParam_Result::NewFailure(
    TokenRequestFailurePtr value) {
  return FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

FederatedRequestService_StartTokenRequest_ResponseParam_Result::FederatedRequestService_StartTokenRequest_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    TokenRequestSuccessPtr value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

FederatedRequestService_StartTokenRequest_ResponseParam_Result::FederatedRequestService_StartTokenRequest_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    TokenRequestFailurePtr value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
FederatedRequestService_StartTokenRequest_ResponseParam_Result::~FederatedRequestService_StartTokenRequest_ResponseParam_Result() {
  DestroyActive();
}

void FederatedRequestService_StartTokenRequest_ResponseParam_Result::set_success(TokenRequestSuccessPtr success) {
  if (tag_ == Tag::kSuccess) {
    data_.success = std::move(success);
  } else {
    DestroyActive();
    tag_ = Tag::kSuccess;
    new (&data_.success) TokenRequestSuccessPtr(
        std::move(success));
  }
}

void FederatedRequestService_StartTokenRequest_ResponseParam_Result::set_failure(TokenRequestFailurePtr failure) {
  if (tag_ == Tag::kFailure) {
    data_.failure = std::move(failure);
  } else {
    DestroyActive();
    tag_ = Tag::kFailure;
    new (&data_.failure) TokenRequestFailurePtr(
        std::move(failure));
  }
}


FederatedRequestService_StartTokenRequest_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    TokenRequestSuccessPtr value)
    : success(std::move(value)) {}

FederatedRequestService_StartTokenRequest_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    TokenRequestFailurePtr value)
    : failure(std::move(value)) {}

void FederatedRequestService_StartTokenRequest_ResponseParam_Result::DestroyActive() {
  switch (tag_) {

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}

bool FederatedRequestService_StartTokenRequest_ResponseParam_Result::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
// The declaration includes the definition on other builds.

FederatedRequest::IPCStableHashFunction FederatedRequest::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::FederatedRequest>(message.name())) {
    case messages::FederatedRequest::kAbort: {
      return &FederatedRequest::Abort_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* FederatedRequest::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::FederatedRequest>(message.name())) {
      case messages::FederatedRequest::kAbort:
            return "Receive blink::mojom::FederatedRequest::Abort";
    }
  } else {
    switch (static_cast<messages::FederatedRequest>(message.name())) {
      case messages::FederatedRequest::kAbort:
            return "Receive reply blink::mojom::FederatedRequest::Abort";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t FederatedRequest::Abort_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x3ac9c351;  // IPCStableHash for blink::mojom::FederatedRequest::Abort
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

FederatedRequestProxy::FederatedRequestProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void FederatedRequestProxy::Abort(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send blink::mojom::FederatedRequest::Abort");
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequest::kAbort), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequest_Abort_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequest::Name_);
  message.set_method_name("Abort");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

// static
bool FederatedRequestStubDispatch::Accept(
    FederatedRequest* impl,
    mojo::Message* message) {
  switch (static_cast<messages::FederatedRequest>(message->header()->name)) {
    case messages::FederatedRequest::kAbort: {
      DCHECK(message->is_serialized());
      internal::FederatedRequest_Abort_Params_Data* params =
          reinterpret_cast<internal::FederatedRequest_Abort_Params_Data*>(
              message->mutable_payload());
      

      // Validation for FederatedRequest.0
      bool success = true;
      FederatedRequest_Abort_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequest::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->Abort(        );
      return true;
    }
  }
  return false;
}

// static
bool FederatedRequestStubDispatch::AcceptWithResponder(
    FederatedRequest* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::FederatedRequest>(message->header()->name)) {
    case messages::FederatedRequest::kAbort: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kFederatedRequestValidationInfo[] = {
    { &internal::FederatedRequest_Abort_Params_Data::Validate,
     nullptr /* no response */},
};

bool FederatedRequestRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::blink::mojom::FederatedRequest::Name_,
    kFederatedRequestValidationInfo);
}

// The declaration includes the definition on other builds.

FederatedRequestService::IPCStableHashFunction FederatedRequestService::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::FederatedRequestService>(message.name())) {
    case messages::FederatedRequestService::kStartTokenRequest: {
      return &FederatedRequestService::StartTokenRequest_Sym::IPCStableHash;
    }
    case messages::FederatedRequestService::kRegisterIdP: {
      return &FederatedRequestService::RegisterIdP_Sym::IPCStableHash;
    }
    case messages::FederatedRequestService::kUnregisterIdP: {
      return &FederatedRequestService::UnregisterIdP_Sym::IPCStableHash;
    }
    case messages::FederatedRequestService::kCloseModalDialogView: {
      return &FederatedRequestService::CloseModalDialogView_Sym::IPCStableHash;
    }
    case messages::FederatedRequestService::kPreventSilentAccess: {
      return &FederatedRequestService::PreventSilentAccess_Sym::IPCStableHash;
    }
    case messages::FederatedRequestService::kRequestUserInfo: {
      return &FederatedRequestService::RequestUserInfo_Sym::IPCStableHash;
    }
    case messages::FederatedRequestService::kDisconnect: {
      return &FederatedRequestService::Disconnect_Sym::IPCStableHash;
    }
    case messages::FederatedRequestService::kResolveTokenRequest: {
      return &FederatedRequestService::ResolveTokenRequest_Sym::IPCStableHash;
    }
    case messages::FederatedRequestService::kSetIdpSigninStatus: {
      return &FederatedRequestService::SetIdpSigninStatus_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* FederatedRequestService::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::FederatedRequestService>(message.name())) {
      case messages::FederatedRequestService::kStartTokenRequest:
            return "Receive blink::mojom::FederatedRequestService::StartTokenRequest";
      case messages::FederatedRequestService::kRegisterIdP:
            return "Receive blink::mojom::FederatedRequestService::RegisterIdP";
      case messages::FederatedRequestService::kUnregisterIdP:
            return "Receive blink::mojom::FederatedRequestService::UnregisterIdP";
      case messages::FederatedRequestService::kCloseModalDialogView:
            return "Receive blink::mojom::FederatedRequestService::CloseModalDialogView";
      case messages::FederatedRequestService::kPreventSilentAccess:
            return "Receive blink::mojom::FederatedRequestService::PreventSilentAccess";
      case messages::FederatedRequestService::kRequestUserInfo:
            return "Receive blink::mojom::FederatedRequestService::RequestUserInfo";
      case messages::FederatedRequestService::kDisconnect:
            return "Receive blink::mojom::FederatedRequestService::Disconnect";
      case messages::FederatedRequestService::kResolveTokenRequest:
            return "Receive blink::mojom::FederatedRequestService::ResolveTokenRequest";
      case messages::FederatedRequestService::kSetIdpSigninStatus:
            return "Receive blink::mojom::FederatedRequestService::SetIdpSigninStatus";
    }
  } else {
    switch (static_cast<messages::FederatedRequestService>(message.name())) {
      case messages::FederatedRequestService::kStartTokenRequest:
            return "Receive reply blink::mojom::FederatedRequestService::StartTokenRequest";
      case messages::FederatedRequestService::kRegisterIdP:
            return "Receive reply blink::mojom::FederatedRequestService::RegisterIdP";
      case messages::FederatedRequestService::kUnregisterIdP:
            return "Receive reply blink::mojom::FederatedRequestService::UnregisterIdP";
      case messages::FederatedRequestService::kCloseModalDialogView:
            return "Receive reply blink::mojom::FederatedRequestService::CloseModalDialogView";
      case messages::FederatedRequestService::kPreventSilentAccess:
            return "Receive reply blink::mojom::FederatedRequestService::PreventSilentAccess";
      case messages::FederatedRequestService::kRequestUserInfo:
            return "Receive reply blink::mojom::FederatedRequestService::RequestUserInfo";
      case messages::FederatedRequestService::kDisconnect:
            return "Receive reply blink::mojom::FederatedRequestService::Disconnect";
      case messages::FederatedRequestService::kResolveTokenRequest:
            return "Receive reply blink::mojom::FederatedRequestService::ResolveTokenRequest";
      case messages::FederatedRequestService::kSetIdpSigninStatus:
            return "Receive reply blink::mojom::FederatedRequestService::SetIdpSigninStatus";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t FederatedRequestService::StartTokenRequest_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x14d56d74;  // IPCStableHash for blink::mojom::FederatedRequestService::StartTokenRequest
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t FederatedRequestService::RegisterIdP_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x4ba9ea20;  // IPCStableHash for blink::mojom::FederatedRequestService::RegisterIdP
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t FederatedRequestService::UnregisterIdP_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x6f5f4da8;  // IPCStableHash for blink::mojom::FederatedRequestService::UnregisterIdP
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t FederatedRequestService::CloseModalDialogView_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x74fa6fa1;  // IPCStableHash for blink::mojom::FederatedRequestService::CloseModalDialogView
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t FederatedRequestService::PreventSilentAccess_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x2287792c;  // IPCStableHash for blink::mojom::FederatedRequestService::PreventSilentAccess
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t FederatedRequestService::RequestUserInfo_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xcc8ef971;  // IPCStableHash for blink::mojom::FederatedRequestService::RequestUserInfo
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t FederatedRequestService::Disconnect_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x1e09f1e0;  // IPCStableHash for blink::mojom::FederatedRequestService::Disconnect
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t FederatedRequestService::ResolveTokenRequest_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x46a17f33;  // IPCStableHash for blink::mojom::FederatedRequestService::ResolveTokenRequest
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t FederatedRequestService::SetIdpSigninStatus_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x79bceb90;  // IPCStableHash for blink::mojom::FederatedRequestService::SetIdpSigninStatus
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class FederatedRequestService_StartTokenRequest_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  FederatedRequestService_StartTokenRequest_ForwardToCallback(
      FederatedRequestService::StartTokenRequestCallback callback
      ) : callback_(std::move(callback)) {
  }

  FederatedRequestService_StartTokenRequest_ForwardToCallback(const FederatedRequestService_StartTokenRequest_ForwardToCallback&) = delete;
  FederatedRequestService_StartTokenRequest_ForwardToCallback& operator=(const FederatedRequestService_StartTokenRequest_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  FederatedRequestService::StartTokenRequestCallback callback_;
};

class FederatedRequestService_RegisterIdP_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  FederatedRequestService_RegisterIdP_ForwardToCallback(
      FederatedRequestService::RegisterIdPCallback callback
      ) : callback_(std::move(callback)) {
  }

  FederatedRequestService_RegisterIdP_ForwardToCallback(const FederatedRequestService_RegisterIdP_ForwardToCallback&) = delete;
  FederatedRequestService_RegisterIdP_ForwardToCallback& operator=(const FederatedRequestService_RegisterIdP_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  FederatedRequestService::RegisterIdPCallback callback_;
};

class FederatedRequestService_UnregisterIdP_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  FederatedRequestService_UnregisterIdP_ForwardToCallback(
      FederatedRequestService::UnregisterIdPCallback callback
      ) : callback_(std::move(callback)) {
  }

  FederatedRequestService_UnregisterIdP_ForwardToCallback(const FederatedRequestService_UnregisterIdP_ForwardToCallback&) = delete;
  FederatedRequestService_UnregisterIdP_ForwardToCallback& operator=(const FederatedRequestService_UnregisterIdP_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  FederatedRequestService::UnregisterIdPCallback callback_;
};

class FederatedRequestService_PreventSilentAccess_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  FederatedRequestService_PreventSilentAccess_ForwardToCallback(
      FederatedRequestService::PreventSilentAccessCallback callback
      ) : callback_(std::move(callback)) {
  }

  FederatedRequestService_PreventSilentAccess_ForwardToCallback(const FederatedRequestService_PreventSilentAccess_ForwardToCallback&) = delete;
  FederatedRequestService_PreventSilentAccess_ForwardToCallback& operator=(const FederatedRequestService_PreventSilentAccess_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  FederatedRequestService::PreventSilentAccessCallback callback_;
};

class FederatedRequestService_RequestUserInfo_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  FederatedRequestService_RequestUserInfo_ForwardToCallback(
      FederatedRequestService::RequestUserInfoCallback callback
      ) : callback_(std::move(callback)) {
  }

  FederatedRequestService_RequestUserInfo_ForwardToCallback(const FederatedRequestService_RequestUserInfo_ForwardToCallback&) = delete;
  FederatedRequestService_RequestUserInfo_ForwardToCallback& operator=(const FederatedRequestService_RequestUserInfo_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  FederatedRequestService::RequestUserInfoCallback callback_;
};

class FederatedRequestService_Disconnect_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  FederatedRequestService_Disconnect_ForwardToCallback(
      FederatedRequestService::DisconnectCallback callback
      ) : callback_(std::move(callback)) {
  }

  FederatedRequestService_Disconnect_ForwardToCallback(const FederatedRequestService_Disconnect_ForwardToCallback&) = delete;
  FederatedRequestService_Disconnect_ForwardToCallback& operator=(const FederatedRequestService_Disconnect_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  FederatedRequestService::DisconnectCallback callback_;
};

class FederatedRequestService_ResolveTokenRequest_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  FederatedRequestService_ResolveTokenRequest_ForwardToCallback(
      FederatedRequestService::ResolveTokenRequestCallback callback
      ) : callback_(std::move(callback)) {
  }

  FederatedRequestService_ResolveTokenRequest_ForwardToCallback(const FederatedRequestService_ResolveTokenRequest_ForwardToCallback&) = delete;
  FederatedRequestService_ResolveTokenRequest_ForwardToCallback& operator=(const FederatedRequestService_ResolveTokenRequest_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  FederatedRequestService::ResolveTokenRequestCallback callback_;
};

class FederatedRequestService_SetIdpSigninStatus_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  FederatedRequestService_SetIdpSigninStatus_ForwardToCallback(
      FederatedRequestService::SetIdpSigninStatusCallback callback
      ) : callback_(std::move(callback)) {
  }

  FederatedRequestService_SetIdpSigninStatus_ForwardToCallback(const FederatedRequestService_SetIdpSigninStatus_ForwardToCallback&) = delete;
  FederatedRequestService_SetIdpSigninStatus_ForwardToCallback& operator=(const FederatedRequestService_SetIdpSigninStatus_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  FederatedRequestService::SetIdpSigninStatusCallback callback_;
};

FederatedRequestServiceProxy::FederatedRequestServiceProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void FederatedRequestServiceProxy::StartTokenRequest(
    std::vector<IdentityProviderGetParametersPtr> in_idp_get_params, ::password_manager::CredentialMediationRequirement in_requirement, ::mojo::PendingReceiver<FederatedRequest> in_request_receiver, StartTokenRequestCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send blink::mojom::FederatedRequestService::StartTokenRequest", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("idp_get_params"), in_idp_get_params,
                        "<value of type std::vector<IdentityProviderGetParametersPtr>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("requirement"), in_requirement,
                        "<value of type ::password_manager::CredentialMediationRequirement>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("request_receiver"), in_request_receiver,
                        "<value of type ::mojo::PendingReceiver<FederatedRequest>>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kStartTokenRequest), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_StartTokenRequest_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->idp_get_params)::BaseType>
      idp_get_params_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& idp_get_params_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::IdentityProviderGetParametersDataView>>(
    in_idp_get_params,
    idp_get_params_fragment,
    &idp_get_params_validate_params);

  params->idp_get_params.Set(
      idp_get_params_fragment.is_null() ? nullptr : idp_get_params_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->idp_get_params.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null idp_get_params in FederatedRequestService.StartTokenRequest request");

  
  mojo::internal::Serialize<::blink::mojom::CredentialMediationRequirement>(
    in_requirement,
    &params->requirement);

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::blink::mojom::FederatedRequestInterfaceBase>>(
    in_request_receiver,
    &params->request_receiver,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->request_receiver)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid request_receiver in FederatedRequestService.StartTokenRequest request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("StartTokenRequest");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new FederatedRequestService_StartTokenRequest_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void FederatedRequestServiceProxy::RegisterIdP(
    const ::GURL& in_url, RegisterIdPCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send blink::mojom::FederatedRequestService::RegisterIdP", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kRegisterIdP), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_RegisterIdP_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

  params->url.Set(
      url_fragment.is_null() ? nullptr : url_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->url.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null url in FederatedRequestService.RegisterIdP request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("RegisterIdP");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new FederatedRequestService_RegisterIdP_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void FederatedRequestServiceProxy::UnregisterIdP(
    const ::GURL& in_url, UnregisterIdPCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send blink::mojom::FederatedRequestService::UnregisterIdP", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::GURL&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kUnregisterIdP), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_UnregisterIdP_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

  params->url.Set(
      url_fragment.is_null() ? nullptr : url_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->url.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null url in FederatedRequestService.UnregisterIdP request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("UnregisterIdP");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new FederatedRequestService_UnregisterIdP_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void FederatedRequestServiceProxy::CloseModalDialogView(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send blink::mojom::FederatedRequestService::CloseModalDialogView");
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kCloseModalDialogView), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_CloseModalDialogView_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("CloseModalDialogView");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void FederatedRequestServiceProxy::PreventSilentAccess(
    PreventSilentAccessCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send blink::mojom::FederatedRequestService::PreventSilentAccess");
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kPreventSilentAccess), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_PreventSilentAccess_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("PreventSilentAccess");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new FederatedRequestService_PreventSilentAccess_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void FederatedRequestServiceProxy::RequestUserInfo(
    IdentityProviderConfigPtr in_provider, RequestUserInfoCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send blink::mojom::FederatedRequestService::RequestUserInfo", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("provider"), in_provider,
                        "<value of type IdentityProviderConfigPtr>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kRequestUserInfo), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_RequestUserInfo_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->provider)::BaseType> provider_fragment(
          params.message());
  
  mojo::internal::Serialize<::blink::mojom::IdentityProviderConfigDataView>(
    in_provider,
    provider_fragment);

  params->provider.Set(
      provider_fragment.is_null() ? nullptr : provider_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->provider.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null provider in FederatedRequestService.RequestUserInfo request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("RequestUserInfo");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new FederatedRequestService_RequestUserInfo_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void FederatedRequestServiceProxy::Disconnect(
    IdentityCredentialDisconnectOptionsPtr in_options, DisconnectCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send blink::mojom::FederatedRequestService::Disconnect", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type IdentityCredentialDisconnectOptionsPtr>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kDisconnect), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_Disconnect_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::blink::mojom::IdentityCredentialDisconnectOptionsDataView>(
    in_options,
    options_fragment);

  params->options.Set(
      options_fragment.is_null() ? nullptr : options_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->options.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null options in FederatedRequestService.Disconnect request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("Disconnect");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new FederatedRequestService_Disconnect_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void FederatedRequestServiceProxy::ResolveTokenRequest(
    const std::optional<std::string>& in_account_id, ResolveTokenParamsPtr in_params, ResolveTokenRequestCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send blink::mojom::FederatedRequestService::ResolveTokenRequest", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("account_id"), in_account_id,
                        "<value of type const std::optional<std::string>&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("params"), in_params,
                        "<value of type ResolveTokenParamsPtr>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kResolveTokenRequest), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_ResolveTokenRequest_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->account_id)::BaseType> account_id_fragment(
          params.message());
  
  mojo::internal::Serialize<mojo::StringDataView>(
    in_account_id,
    account_id_fragment);

  params->account_id.Set(
      account_id_fragment.is_null() ? nullptr : account_id_fragment.data());
  mojo::internal::MessageFragment<decltype(params->params)>
      params_fragment(params.message());
  params_fragment.Claim(&params->params);
  
  mojo::internal::Serialize<::blink::mojom::ResolveTokenParamsDataView>(
    in_params,
    params_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->params.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null params in FederatedRequestService.ResolveTokenRequest request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("ResolveTokenRequest");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new FederatedRequestService_ResolveTokenRequest_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void FederatedRequestServiceProxy::SetIdpSigninStatus(
    const ::url::Origin& in_origin, IdpSigninStatus in_status, const std::optional<::blink::common::webid::LoginStatusOptions>& in_options, SetIdpSigninStatusCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send blink::mojom::FederatedRequestService::SetIdpSigninStatus", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("origin"), in_origin,
                        "<value of type const ::url::Origin&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("status"), in_status,
                        "<value of type IdpSigninStatus>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("options"), in_options,
                        "<value of type const std::optional<::blink::common::webid::LoginStatusOptions>&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kSetIdpSigninStatus), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_SetIdpSigninStatus_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->origin)::BaseType> origin_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::OriginDataView>(
    in_origin,
    origin_fragment);

  params->origin.Set(
      origin_fragment.is_null() ? nullptr : origin_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->origin.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null origin in FederatedRequestService.SetIdpSigninStatus request");

  
  mojo::internal::Serialize<::blink::mojom::IdpSigninStatus>(
    in_status,
    &params->status);
  mojo::internal::MessageFragment<
      typename decltype(params->options)::BaseType> options_fragment(
          params.message());
  
  mojo::internal::Serialize<::blink::mojom::LoginStatusOptionsDataView>(
    in_options,
    options_fragment);

  params->options.Set(
      options_fragment.is_null() ? nullptr : options_fragment.data());

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("SetIdpSigninStatus");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new FederatedRequestService_SetIdpSigninStatus_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}
class FederatedRequestService_StartTokenRequest_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static FederatedRequestService::StartTokenRequestCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<FederatedRequestService_StartTokenRequest_ProxyToResponder> proxy(
        new FederatedRequestService_StartTokenRequest_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&FederatedRequestService_StartTokenRequest_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr Transform(base::expected<
  TokenRequestSuccessPtr,
  TokenRequestFailurePtr> in) {
    return in.has_value() ? ::blink::mojom::FederatedRequestService_StartTokenRequest_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::blink::mojom::FederatedRequestService_StartTokenRequest_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~FederatedRequestService_StartTokenRequest_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  FederatedRequestService_StartTokenRequest_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "FederatedRequestService::StartTokenRequestCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr in_result);
};

bool FederatedRequestService_StartTokenRequest_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::FederatedRequestService_StartTokenRequest_ResponseParams_Data* params =
      reinterpret_cast<
          internal::FederatedRequestService_StartTokenRequest_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for FederatedRequestService.0
  bool success = true;
  FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr p_result{};
  FederatedRequestService_StartTokenRequest_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        FederatedRequestService::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void FederatedRequestService_StartTokenRequest_ProxyToResponder::Run(
    FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply blink::mojom::FederatedRequestService::StartTokenRequest", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kStartTokenRequest), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_StartTokenRequest_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::blink::mojom::FederatedRequestService_StartTokenRequest_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->result.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null result in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("StartTokenRequest");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class FederatedRequestService_RegisterIdP_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static FederatedRequestService::RegisterIdPCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<FederatedRequestService_RegisterIdP_ProxyToResponder> proxy(
        new FederatedRequestService_RegisterIdP_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&FederatedRequestService_RegisterIdP_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~FederatedRequestService_RegisterIdP_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  FederatedRequestService_RegisterIdP_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "FederatedRequestService::RegisterIdPCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      RegisterIdpStatus in_status);
};

bool FederatedRequestService_RegisterIdP_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::FederatedRequestService_RegisterIdP_ResponseParams_Data* params =
      reinterpret_cast<
          internal::FederatedRequestService_RegisterIdP_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for FederatedRequestService.1
  bool success = true;
  RegisterIdpStatus p_status{};
  FederatedRequestService_RegisterIdP_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadStatus(&p_status))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        FederatedRequestService::Name_, 1, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_status));
  }
  return true;
}

void FederatedRequestService_RegisterIdP_ProxyToResponder::Run(
    RegisterIdpStatus in_status) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply blink::mojom::FederatedRequestService::RegisterIdP", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("status"), in_status,
                        "<value of type RegisterIdpStatus>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kRegisterIdP), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_RegisterIdP_ResponseParams_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::blink::mojom::RegisterIdpStatus>(
    in_status,
    &params->status);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("RegisterIdP");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class FederatedRequestService_UnregisterIdP_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static FederatedRequestService::UnregisterIdPCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<FederatedRequestService_UnregisterIdP_ProxyToResponder> proxy(
        new FederatedRequestService_UnregisterIdP_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&FederatedRequestService_UnregisterIdP_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~FederatedRequestService_UnregisterIdP_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  FederatedRequestService_UnregisterIdP_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "FederatedRequestService::UnregisterIdPCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_success);
};

bool FederatedRequestService_UnregisterIdP_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::FederatedRequestService_UnregisterIdP_ResponseParams_Data* params =
      reinterpret_cast<
          internal::FederatedRequestService_UnregisterIdP_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for FederatedRequestService.2
  bool success = true;
  bool p_success{};
  FederatedRequestService_UnregisterIdP_ResponseParamsDataView input_data_view(params, message);
  
  if (success)
    p_success = input_data_view.success();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        FederatedRequestService::Name_, 2, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_success));
  }
  return true;
}

void FederatedRequestService_UnregisterIdP_ProxyToResponder::Run(
    bool in_success) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply blink::mojom::FederatedRequestService::UnregisterIdP", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kUnregisterIdP), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_UnregisterIdP_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("UnregisterIdP");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class FederatedRequestService_PreventSilentAccess_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static FederatedRequestService::PreventSilentAccessCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<FederatedRequestService_PreventSilentAccess_ProxyToResponder> proxy(
        new FederatedRequestService_PreventSilentAccess_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&FederatedRequestService_PreventSilentAccess_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~FederatedRequestService_PreventSilentAccess_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  FederatedRequestService_PreventSilentAccess_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "FederatedRequestService::PreventSilentAccessCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      );
};

bool FederatedRequestService_PreventSilentAccess_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::FederatedRequestService_PreventSilentAccess_ResponseParams_Data* params =
      reinterpret_cast<
          internal::FederatedRequestService_PreventSilentAccess_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for FederatedRequestService.4
  bool success = true;
  FederatedRequestService_PreventSilentAccess_ResponseParamsDataView input_data_view(params, message);
  
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        FederatedRequestService::Name_, 4, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run();
  }
  return true;
}

void FederatedRequestService_PreventSilentAccess_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply blink::mojom::FederatedRequestService::PreventSilentAccess");
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kPreventSilentAccess), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_PreventSilentAccess_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("PreventSilentAccess");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class FederatedRequestService_RequestUserInfo_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static FederatedRequestService::RequestUserInfoCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<FederatedRequestService_RequestUserInfo_ProxyToResponder> proxy(
        new FederatedRequestService_RequestUserInfo_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&FederatedRequestService_RequestUserInfo_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~FederatedRequestService_RequestUserInfo_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  FederatedRequestService_RequestUserInfo_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "FederatedRequestService::RequestUserInfoCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      RequestUserInfoResultPtr in_result);
};

bool FederatedRequestService_RequestUserInfo_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::FederatedRequestService_RequestUserInfo_ResponseParams_Data* params =
      reinterpret_cast<
          internal::FederatedRequestService_RequestUserInfo_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for FederatedRequestService.5
  bool success = true;
  RequestUserInfoResultPtr p_result{};
  FederatedRequestService_RequestUserInfo_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        FederatedRequestService::Name_, 5, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_result));
  }
  return true;
}

void FederatedRequestService_RequestUserInfo_ProxyToResponder::Run(
    RequestUserInfoResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply blink::mojom::FederatedRequestService::RequestUserInfo", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type RequestUserInfoResultPtr>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kRequestUserInfo), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_RequestUserInfo_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::blink::mojom::RequestUserInfoResultDataView>(
    in_result,
    result_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->result.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null result in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("RequestUserInfo");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class FederatedRequestService_Disconnect_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static FederatedRequestService::DisconnectCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<FederatedRequestService_Disconnect_ProxyToResponder> proxy(
        new FederatedRequestService_Disconnect_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&FederatedRequestService_Disconnect_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~FederatedRequestService_Disconnect_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  FederatedRequestService_Disconnect_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "FederatedRequestService::DisconnectCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      DisconnectStatus in_status);
};

bool FederatedRequestService_Disconnect_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::FederatedRequestService_Disconnect_ResponseParams_Data* params =
      reinterpret_cast<
          internal::FederatedRequestService_Disconnect_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for FederatedRequestService.6
  bool success = true;
  DisconnectStatus p_status{};
  FederatedRequestService_Disconnect_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadStatus(&p_status))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        FederatedRequestService::Name_, 6, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_status));
  }
  return true;
}

void FederatedRequestService_Disconnect_ProxyToResponder::Run(
    DisconnectStatus in_status) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply blink::mojom::FederatedRequestService::Disconnect", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("status"), in_status,
                        "<value of type DisconnectStatus>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kDisconnect), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_Disconnect_ResponseParams_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::blink::mojom::DisconnectStatus>(
    in_status,
    &params->status);

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("Disconnect");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class FederatedRequestService_ResolveTokenRequest_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static FederatedRequestService::ResolveTokenRequestCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<FederatedRequestService_ResolveTokenRequest_ProxyToResponder> proxy(
        new FederatedRequestService_ResolveTokenRequest_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&FederatedRequestService_ResolveTokenRequest_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~FederatedRequestService_ResolveTokenRequest_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  FederatedRequestService_ResolveTokenRequest_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "FederatedRequestService::ResolveTokenRequestCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      bool in_success);
};

bool FederatedRequestService_ResolveTokenRequest_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::FederatedRequestService_ResolveTokenRequest_ResponseParams_Data* params =
      reinterpret_cast<
          internal::FederatedRequestService_ResolveTokenRequest_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for FederatedRequestService.7
  bool success = true;
  bool p_success{};
  FederatedRequestService_ResolveTokenRequest_ResponseParamsDataView input_data_view(params, message);
  
  if (success)
    p_success = input_data_view.success();
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        FederatedRequestService::Name_, 7, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_success));
  }
  return true;
}

void FederatedRequestService_ResolveTokenRequest_ProxyToResponder::Run(
    bool in_success) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply blink::mojom::FederatedRequestService::ResolveTokenRequest", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("success"), in_success,
                        "<value of type bool>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kResolveTokenRequest), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_ResolveTokenRequest_ResponseParams_Data> params(
          message);
  params.Allocate();

  params->success = in_success;

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("ResolveTokenRequest");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class FederatedRequestService_SetIdpSigninStatus_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static FederatedRequestService::SetIdpSigninStatusCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<FederatedRequestService_SetIdpSigninStatus_ProxyToResponder> proxy(
        new FederatedRequestService_SetIdpSigninStatus_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&FederatedRequestService_SetIdpSigninStatus_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~FederatedRequestService_SetIdpSigninStatus_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  FederatedRequestService_SetIdpSigninStatus_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "FederatedRequestService::SetIdpSigninStatusCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      );
};

bool FederatedRequestService_SetIdpSigninStatus_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::FederatedRequestService_SetIdpSigninStatus_ResponseParams_Data* params =
      reinterpret_cast<
          internal::FederatedRequestService_SetIdpSigninStatus_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for FederatedRequestService.8
  bool success = true;
  FederatedRequestService_SetIdpSigninStatus_ResponseParamsDataView input_data_view(params, message);
  
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        FederatedRequestService::Name_, 8, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run();
  }
  return true;
}

void FederatedRequestService_SetIdpSigninStatus_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply blink::mojom::FederatedRequestService::SetIdpSigninStatus");
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::FederatedRequestService::kSetIdpSigninStatus), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::blink::mojom::internal::FederatedRequestService_SetIdpSigninStatus_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(FederatedRequestService::Name_);
  message.set_method_name("SetIdpSigninStatus");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool FederatedRequestServiceStubDispatch::Accept(
    FederatedRequestService* impl,
    mojo::Message* message) {
  switch (static_cast<messages::FederatedRequestService>(message->header()->name)) {
    case messages::FederatedRequestService::kStartTokenRequest: {
      break;
    }
    case messages::FederatedRequestService::kRegisterIdP: {
      break;
    }
    case messages::FederatedRequestService::kUnregisterIdP: {
      break;
    }
    case messages::FederatedRequestService::kCloseModalDialogView: {
      DCHECK(message->is_serialized());
      internal::FederatedRequestService_CloseModalDialogView_Params_Data* params =
          reinterpret_cast<internal::FederatedRequestService_CloseModalDialogView_Params_Data*>(
              message->mutable_payload());
      

      // Validation for FederatedRequestService.3
      bool success = true;
      FederatedRequestService_CloseModalDialogView_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CloseModalDialogView(        );
      return true;
    }
    case messages::FederatedRequestService::kPreventSilentAccess: {
      break;
    }
    case messages::FederatedRequestService::kRequestUserInfo: {
      break;
    }
    case messages::FederatedRequestService::kDisconnect: {
      break;
    }
    case messages::FederatedRequestService::kResolveTokenRequest: {
      break;
    }
    case messages::FederatedRequestService::kSetIdpSigninStatus: {
      break;
    }
  }
  return false;
}

// static
bool FederatedRequestServiceStubDispatch::AcceptWithResponder(
    FederatedRequestService* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::FederatedRequestService>(message->header()->name)) {
    case messages::FederatedRequestService::kStartTokenRequest: {
      internal::FederatedRequestService_StartTokenRequest_Params_Data* params =
          reinterpret_cast<
              internal::FederatedRequestService_StartTokenRequest_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for FederatedRequestService.0
      bool success = true;
      std::vector<IdentityProviderGetParametersPtr> p_idp_get_params{};
      ::password_manager::CredentialMediationRequirement p_requirement{};
      ::mojo::PendingReceiver<FederatedRequest> p_request_receiver{};
      FederatedRequestService_StartTokenRequest_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadIdpGetParams(&p_idp_get_params))
        success = false;
      if (success && !input_data_view.ReadRequirement(&p_requirement))
        success = false;
      if (success) {
        p_request_receiver =
            input_data_view.TakeRequestReceiver<decltype(p_request_receiver)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 0, false);
        return false;
      }
      auto callback =
          FederatedRequestService_StartTokenRequest_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->StartTokenRequest(        
        std::move(p_idp_get_params), 
        std::move(p_requirement), 
        std::move(p_request_receiver), std::move(callback));
      return true;
    }
    case messages::FederatedRequestService::kRegisterIdP: {
      internal::FederatedRequestService_RegisterIdP_Params_Data* params =
          reinterpret_cast<
              internal::FederatedRequestService_RegisterIdP_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for FederatedRequestService.1
      bool success = true;
      ::GURL p_url{};
      FederatedRequestService_RegisterIdP_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 1, false);
        return false;
      }
      auto callback =
          FederatedRequestService_RegisterIdP_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RegisterIdP(        
        std::move(p_url), std::move(callback));
      return true;
    }
    case messages::FederatedRequestService::kUnregisterIdP: {
      internal::FederatedRequestService_UnregisterIdP_Params_Data* params =
          reinterpret_cast<
              internal::FederatedRequestService_UnregisterIdP_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for FederatedRequestService.2
      bool success = true;
      ::GURL p_url{};
      FederatedRequestService_UnregisterIdP_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 2, false);
        return false;
      }
      auto callback =
          FederatedRequestService_UnregisterIdP_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UnregisterIdP(        
        std::move(p_url), std::move(callback));
      return true;
    }
    case messages::FederatedRequestService::kCloseModalDialogView: {
      break;
    }
    case messages::FederatedRequestService::kPreventSilentAccess: {
      internal::FederatedRequestService_PreventSilentAccess_Params_Data* params =
          reinterpret_cast<
              internal::FederatedRequestService_PreventSilentAccess_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for FederatedRequestService.4
      bool success = true;
      FederatedRequestService_PreventSilentAccess_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 4, false);
        return false;
      }
      auto callback =
          FederatedRequestService_PreventSilentAccess_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->PreventSilentAccess(std::move(callback));
      return true;
    }
    case messages::FederatedRequestService::kRequestUserInfo: {
      internal::FederatedRequestService_RequestUserInfo_Params_Data* params =
          reinterpret_cast<
              internal::FederatedRequestService_RequestUserInfo_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for FederatedRequestService.5
      bool success = true;
      IdentityProviderConfigPtr p_provider{};
      FederatedRequestService_RequestUserInfo_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadProvider(&p_provider))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 5, false);
        return false;
      }
      auto callback =
          FederatedRequestService_RequestUserInfo_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->RequestUserInfo(        
        std::move(p_provider), std::move(callback));
      return true;
    }
    case messages::FederatedRequestService::kDisconnect: {
      internal::FederatedRequestService_Disconnect_Params_Data* params =
          reinterpret_cast<
              internal::FederatedRequestService_Disconnect_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for FederatedRequestService.6
      bool success = true;
      IdentityCredentialDisconnectOptionsPtr p_options{};
      FederatedRequestService_Disconnect_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 6, false);
        return false;
      }
      auto callback =
          FederatedRequestService_Disconnect_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->Disconnect(        
        std::move(p_options), std::move(callback));
      return true;
    }
    case messages::FederatedRequestService::kResolveTokenRequest: {
      internal::FederatedRequestService_ResolveTokenRequest_Params_Data* params =
          reinterpret_cast<
              internal::FederatedRequestService_ResolveTokenRequest_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for FederatedRequestService.7
      bool success = true;
      std::optional<std::string> p_account_id{};
      ResolveTokenParamsPtr p_params{};
      FederatedRequestService_ResolveTokenRequest_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadAccountId(&p_account_id))
        success = false;
      if (success && !input_data_view.ReadParams(&p_params))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 7, false);
        return false;
      }
      auto callback =
          FederatedRequestService_ResolveTokenRequest_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->ResolveTokenRequest(        
        std::move(p_account_id), 
        std::move(p_params), std::move(callback));
      return true;
    }
    case messages::FederatedRequestService::kSetIdpSigninStatus: {
      internal::FederatedRequestService_SetIdpSigninStatus_Params_Data* params =
          reinterpret_cast<
              internal::FederatedRequestService_SetIdpSigninStatus_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for FederatedRequestService.8
      bool success = true;
      ::url::Origin p_origin{};
      IdpSigninStatus p_status{};
      std::optional<::blink::common::webid::LoginStatusOptions> p_options{};
      FederatedRequestService_SetIdpSigninStatus_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadOrigin(&p_origin))
        success = false;
      if (success && !input_data_view.ReadStatus(&p_status))
        success = false;
      if (success && !input_data_view.ReadOptions(&p_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            FederatedRequestService::Name_, 8, false);
        return false;
      }
      auto callback =
          FederatedRequestService_SetIdpSigninStatus_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->SetIdpSigninStatus(        
        std::move(p_origin), 
        std::move(p_status), 
        std::move(p_options), std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kFederatedRequestServiceValidationInfo[] = {
    { &internal::FederatedRequestService_StartTokenRequest_Params_Data::Validate,
     &internal::FederatedRequestService_StartTokenRequest_ResponseParams_Data::Validate},
    { &internal::FederatedRequestService_RegisterIdP_Params_Data::Validate,
     &internal::FederatedRequestService_RegisterIdP_ResponseParams_Data::Validate},
    { &internal::FederatedRequestService_UnregisterIdP_Params_Data::Validate,
     &internal::FederatedRequestService_UnregisterIdP_ResponseParams_Data::Validate},
    { &internal::FederatedRequestService_CloseModalDialogView_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::FederatedRequestService_PreventSilentAccess_Params_Data::Validate,
     &internal::FederatedRequestService_PreventSilentAccess_ResponseParams_Data::Validate},
    { &internal::FederatedRequestService_RequestUserInfo_Params_Data::Validate,
     &internal::FederatedRequestService_RequestUserInfo_ResponseParams_Data::Validate},
    { &internal::FederatedRequestService_Disconnect_Params_Data::Validate,
     &internal::FederatedRequestService_Disconnect_ResponseParams_Data::Validate},
    { &internal::FederatedRequestService_ResolveTokenRequest_Params_Data::Validate,
     &internal::FederatedRequestService_ResolveTokenRequest_ResponseParams_Data::Validate},
    { &internal::FederatedRequestService_SetIdpSigninStatus_Params_Data::Validate,
     &internal::FederatedRequestService_SetIdpSigninStatus_ResponseParams_Data::Validate},
};

bool FederatedRequestServiceRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::blink::mojom::FederatedRequestService::Name_,
    kFederatedRequestServiceValidationInfo);
}

bool FederatedRequestServiceResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::blink::mojom::FederatedRequestService::Name_,
    kFederatedRequestServiceValidationInfo);
}


}  // blink::mojom


namespace mojo {


// static
bool StructTraits<::blink::mojom::IdentityProviderConfig::DataView, ::blink::mojom::IdentityProviderConfigPtr>::Read(
    ::blink::mojom::IdentityProviderConfig::DataView input,
    ::blink::mojom::IdentityProviderConfigPtr* output) {
  bool success = true;
  ::blink::mojom::IdentityProviderConfigPtr result(::blink::mojom::IdentityProviderConfig::New());
  
      if (success && !input.ReadConfigUrl(&result->config_url))
        success = false;
      if (success)
        result->from_idp_registration_api = input.from_idp_registration_api();
      if (success && !input.ReadType(&result->type))
        success = false;
      if (success && !input.ReadClientId(&result->client_id))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::RedirectGetParams::DataView, ::blink::mojom::RedirectGetParamsPtr>::Read(
    ::blink::mojom::RedirectGetParams::DataView input,
    ::blink::mojom::RedirectGetParamsPtr* output) {
  bool success = true;
  ::blink::mojom::RedirectGetParamsPtr result(::blink::mojom::RedirectGetParams::New());
  
      if (success && !input.ReadUrl(&result->url))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::RedirectPostParams::DataView, ::blink::mojom::RedirectPostParamsPtr>::Read(
    ::blink::mojom::RedirectPostParams::DataView input,
    ::blink::mojom::RedirectPostParamsPtr* output) {
  bool success = true;
  ::blink::mojom::RedirectPostParamsPtr result(::blink::mojom::RedirectPostParams::New());
  
      if (success && !input.ReadUrl(&result->url))
        success = false;
      if (success && !input.ReadRequestBody(&result->request_body))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::IdentityProviderRequestOptions::DataView, ::blink::mojom::IdentityProviderRequestOptionsPtr>::Read(
    ::blink::mojom::IdentityProviderRequestOptions::DataView input,
    ::blink::mojom::IdentityProviderRequestOptionsPtr* output) {
  bool success = true;
  ::blink::mojom::IdentityProviderRequestOptionsPtr result(::blink::mojom::IdentityProviderRequestOptions::New());
  
      if (success && !input.ReadConfig(&result->config))
        success = false;
      if (success && !input.ReadNonce(&result->nonce))
        success = false;
      if (success && !input.ReadLoginHint(&result->login_hint))
        success = false;
      if (success && !input.ReadDomainHint(&result->domain_hint))
        success = false;
      if (success && !input.ReadFields(&result->fields))
        success = false;
      if (success && !input.ReadParamsJson(&result->params_json))
        success = false;
      if (success && !input.ReadFormat(&result->format)) {
        success = false;
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::IdentityCredentialDisconnectOptions::DataView, ::blink::mojom::IdentityCredentialDisconnectOptionsPtr>::Read(
    ::blink::mojom::IdentityCredentialDisconnectOptions::DataView input,
    ::blink::mojom::IdentityCredentialDisconnectOptionsPtr* output) {
  bool success = true;
  ::blink::mojom::IdentityCredentialDisconnectOptionsPtr result(::blink::mojom::IdentityCredentialDisconnectOptions::New());
  
      if (success && !input.ReadConfig(&result->config))
        success = false;
      if (success && !input.ReadAccountHint(&result->account_hint))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::IdentityUserInfo::DataView, ::blink::mojom::IdentityUserInfoPtr>::Read(
    ::blink::mojom::IdentityUserInfo::DataView input,
    ::blink::mojom::IdentityUserInfoPtr* output) {
  bool success = true;
  ::blink::mojom::IdentityUserInfoPtr result(::blink::mojom::IdentityUserInfo::New());
  
      if (success && !input.ReadEmail(&result->email))
        success = false;
      if (success && !input.ReadGivenName(&result->given_name))
        success = false;
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success && !input.ReadPicture(&result->picture))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::LoginStatusAccount::DataView, ::blink::mojom::LoginStatusAccountPtr>::Read(
    ::blink::mojom::LoginStatusAccount::DataView input,
    ::blink::mojom::LoginStatusAccountPtr* output) {
  bool success = true;
  ::blink::mojom::LoginStatusAccountPtr result(::blink::mojom::LoginStatusAccount::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
      if (success && !input.ReadEmail(&result->email))
        success = false;
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success && !input.ReadGivenName(&result->given_name))
        success = false;
      if (success && !input.ReadPicture(&result->picture))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::LoginStatusOptions::DataView, ::blink::mojom::LoginStatusOptionsPtr>::Read(
    ::blink::mojom::LoginStatusOptions::DataView input,
    ::blink::mojom::LoginStatusOptionsPtr* output) {
  bool success = true;
  ::blink::mojom::LoginStatusOptionsPtr result(::blink::mojom::LoginStatusOptions::New());
  
      if (success && !input.ReadAccounts(&result->accounts))
        success = false;
      if (success && !input.ReadExpiration(&result->expiration))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::IdentityProviderGetParameters::DataView, ::blink::mojom::IdentityProviderGetParametersPtr>::Read(
    ::blink::mojom::IdentityProviderGetParameters::DataView input,
    ::blink::mojom::IdentityProviderGetParametersPtr* output) {
  bool success = true;
  ::blink::mojom::IdentityProviderGetParametersPtr result(::blink::mojom::IdentityProviderGetParameters::New());
  
      if (success && !input.ReadProviders(&result->providers))
        success = false;
      if (success && !input.ReadContext(&result->context))
        success = false;
      if (success && !input.ReadMode(&result->mode))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::TokenError::DataView, ::blink::mojom::TokenErrorPtr>::Read(
    ::blink::mojom::TokenError::DataView input,
    ::blink::mojom::TokenErrorPtr* output) {
  bool success = true;
  ::blink::mojom::TokenErrorPtr result(::blink::mojom::TokenError::New());
  
      if (success && !input.ReadCode(&result->code))
        success = false;
      if (success && !input.ReadUrl(&result->url))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::TokenRequestSuccess::DataView, ::blink::mojom::TokenRequestSuccessPtr>::Read(
    ::blink::mojom::TokenRequestSuccess::DataView input,
    ::blink::mojom::TokenRequestSuccessPtr* output) {
  bool success = true;
  ::blink::mojom::TokenRequestSuccessPtr result(::blink::mojom::TokenRequestSuccess::New());
  
      if (success && !input.ReadSelectedIdpConfigUrl(&result->selected_idp_config_url))
        success = false;
      if (success && !input.ReadToken(&result->token))
        success = false;
      if (success)
        result->is_auto_selected = input.is_auto_selected();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::TokenRequestFailure::DataView, ::blink::mojom::TokenRequestFailurePtr>::Read(
    ::blink::mojom::TokenRequestFailure::DataView input,
    ::blink::mojom::TokenRequestFailurePtr* output) {
  bool success = true;
  ::blink::mojom::TokenRequestFailurePtr result(::blink::mojom::TokenRequestFailure::New());
  
      if (success && !input.ReadStatus(&result->status))
        success = false;
      if (success && !input.ReadError(&result->error))
        success = false;
  *output = std::move(result);
  return success;
}

// static
bool UnionTraits<::blink::mojom::RedirectParams::DataView, ::blink::mojom::RedirectParamsPtr>::Read(
    ::blink::mojom::RedirectParams::DataView input,
    ::blink::mojom::RedirectParamsPtr* output) {
  using UnionType = ::blink::mojom::RedirectParams;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kGet: {
      ::blink::mojom::RedirectGetParamsPtr result_get{};
      if (!input.ReadGet(&result_get))
        return false;

      *output = UnionType::NewGet(
          std::move(result_get));
      break;
    }
    case Tag::kPost: {
      ::blink::mojom::RedirectPostParamsPtr result_post{};
      if (!input.ReadPost(&result_post))
        return false;

      *output = UnionType::NewPost(
          std::move(result_post));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::blink::mojom::ResolveTokenParams::DataView, ::blink::mojom::ResolveTokenParamsPtr>::Read(
    ::blink::mojom::ResolveTokenParams::DataView input,
    ::blink::mojom::ResolveTokenParamsPtr* output) {
  using UnionType = ::blink::mojom::ResolveTokenParams;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kToken: {
      ::base::Value result_token{};
      if (!input.ReadToken(&result_token))
        return false;

      *output = UnionType::NewToken(
          std::move(result_token));
      break;
    }
    case Tag::kRedirectTo: {
      ::blink::mojom::RedirectParamsPtr result_redirect_to{};
      if (!input.ReadRedirectTo(&result_redirect_to))
        return false;

      *output = UnionType::NewRedirectTo(
          std::move(result_redirect_to));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::blink::mojom::RequestUserInfoResult::DataView, ::blink::mojom::RequestUserInfoResultPtr>::Read(
    ::blink::mojom::RequestUserInfoResult::DataView input,
    ::blink::mojom::RequestUserInfoResultPtr* output) {
  using UnionType = ::blink::mojom::RequestUserInfoResult;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kStatus: {
      ::blink::mojom::RequestUserInfoStatus result_status;
      if (!input.ReadStatus(&result_status))
        return false;

      *output = UnionType::NewStatus(result_status);
      break;
    }
    case Tag::kUserInfo: {
      std::vector<::blink::mojom::IdentityUserInfoPtr> result_user_info{};
      if (!input.ReadUserInfo(&result_user_info))
        return false;

      *output = UnionType::NewUserInfo(
          std::move(result_user_info));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::blink::mojom::FederatedRequestService_StartTokenRequest_ResponseParam_Result::DataView, ::blink::mojom::FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr>::Read(
    ::blink::mojom::FederatedRequestService_StartTokenRequest_ResponseParam_Result::DataView input,
    ::blink::mojom::FederatedRequestService_StartTokenRequest_ResponseParam_ResultPtr* output) {
  using UnionType = ::blink::mojom::FederatedRequestService_StartTokenRequest_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      ::blink::mojom::TokenRequestSuccessPtr result_success{};
      if (!input.ReadSuccess(&result_success))
        return false;

      *output = UnionType::NewSuccess(
          std::move(result_success));
      break;
    }
    case Tag::kFailure: {
      ::blink::mojom::TokenRequestFailurePtr result_failure{};
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(
          std::move(result_failure));
      break;
    }
    default:

      return false;
  }
  return true;
}

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace blink::mojom {


void FederatedRequestInterceptorForTesting::Abort() {
  GetForwardingInterface()->Abort();
}
FederatedRequestAsyncWaiter::FederatedRequestAsyncWaiter(
    FederatedRequest* proxy) : proxy_(proxy) {}

FederatedRequestAsyncWaiter::~FederatedRequestAsyncWaiter() = default;





void FederatedRequestServiceInterceptorForTesting::StartTokenRequest(std::vector<IdentityProviderGetParametersPtr> idp_get_params, ::password_manager::CredentialMediationRequirement requirement, ::mojo::PendingReceiver<FederatedRequest> request_receiver, StartTokenRequestCallback callback) {
  GetForwardingInterface()->StartTokenRequest(
    std::move(idp_get_params)
    , 
    std::move(requirement)
    , 
    std::move(request_receiver)
    , std::move(callback));
}
void FederatedRequestServiceInterceptorForTesting::RegisterIdP(const ::GURL& url, RegisterIdPCallback callback) {
  GetForwardingInterface()->RegisterIdP(
    std::move(url)
    , std::move(callback));
}
void FederatedRequestServiceInterceptorForTesting::UnregisterIdP(const ::GURL& url, UnregisterIdPCallback callback) {
  GetForwardingInterface()->UnregisterIdP(
    std::move(url)
    , std::move(callback));
}
void FederatedRequestServiceInterceptorForTesting::CloseModalDialogView() {
  GetForwardingInterface()->CloseModalDialogView();
}
void FederatedRequestServiceInterceptorForTesting::PreventSilentAccess(PreventSilentAccessCallback callback) {
  GetForwardingInterface()->PreventSilentAccess(std::move(callback));
}
void FederatedRequestServiceInterceptorForTesting::RequestUserInfo(IdentityProviderConfigPtr provider, RequestUserInfoCallback callback) {
  GetForwardingInterface()->RequestUserInfo(
    std::move(provider)
    , std::move(callback));
}
void FederatedRequestServiceInterceptorForTesting::Disconnect(IdentityCredentialDisconnectOptionsPtr options, DisconnectCallback callback) {
  GetForwardingInterface()->Disconnect(
    std::move(options)
    , std::move(callback));
}
void FederatedRequestServiceInterceptorForTesting::ResolveTokenRequest(const std::optional<std::string>& account_id, ResolveTokenParamsPtr params, ResolveTokenRequestCallback callback) {
  GetForwardingInterface()->ResolveTokenRequest(
    std::move(account_id)
    , 
    std::move(params)
    , std::move(callback));
}
void FederatedRequestServiceInterceptorForTesting::SetIdpSigninStatus(const ::url::Origin& origin, IdpSigninStatus status, const std::optional<::blink::common::webid::LoginStatusOptions>& options, SetIdpSigninStatusCallback callback) {
  GetForwardingInterface()->SetIdpSigninStatus(
    std::move(origin)
    , 
    std::move(status)
    , 
    std::move(options)
    , std::move(callback));
}
FederatedRequestServiceAsyncWaiter::FederatedRequestServiceAsyncWaiter(
    FederatedRequestService* proxy) : proxy_(proxy) {}

FederatedRequestServiceAsyncWaiter::~FederatedRequestServiceAsyncWaiter() = default;


void FederatedRequestServiceAsyncWaiter::RegisterIdP(
    const ::GURL& url, RegisterIdpStatus* out_status) {
  base::RunLoop loop;
  proxy_->RegisterIdP(
      std::move(url),
      base::BindOnce(
          [](base::RunLoop* loop,
             RegisterIdpStatus* out_status
,
             RegisterIdpStatus status) {*out_status = std::move(status);
            loop->Quit();
          },
          &loop,
          out_status));
  loop.Run();
}

RegisterIdpStatus FederatedRequestServiceAsyncWaiter::RegisterIdP(
    const ::GURL& url) {
  RegisterIdpStatus async_wait_result;
  RegisterIdP(std::move(url),&async_wait_result);
  return async_wait_result;
}

void FederatedRequestServiceAsyncWaiter::UnregisterIdP(
    const ::GURL& url, bool* out_success) {
  base::RunLoop loop;
  proxy_->UnregisterIdP(
      std::move(url),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             bool success) {*out_success = std::move(success);
            loop->Quit();
          },
          &loop,
          out_success));
  loop.Run();
}

bool FederatedRequestServiceAsyncWaiter::UnregisterIdP(
    const ::GURL& url) {
  bool async_wait_result;
  UnregisterIdP(std::move(url),&async_wait_result);
  return async_wait_result;
}

void FederatedRequestServiceAsyncWaiter::PreventSilentAccess(
    ) {
  base::RunLoop loop;
  proxy_->PreventSilentAccess(
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void FederatedRequestServiceAsyncWaiter::RequestUserInfo(
    IdentityProviderConfigPtr provider, RequestUserInfoResultPtr* out_result) {
  base::RunLoop loop;
  proxy_->RequestUserInfo(
      std::move(provider),
      base::BindOnce(
          [](base::RunLoop* loop,
             RequestUserInfoResultPtr* out_result
,
             RequestUserInfoResultPtr result) {*out_result = std::move(result);
            loop->Quit();
          },
          &loop,
          out_result));
  loop.Run();
}

RequestUserInfoResultPtr FederatedRequestServiceAsyncWaiter::RequestUserInfo(
    IdentityProviderConfigPtr provider) {
  RequestUserInfoResultPtr async_wait_result;
  RequestUserInfo(std::move(provider),&async_wait_result);
  return async_wait_result;
}

void FederatedRequestServiceAsyncWaiter::Disconnect(
    IdentityCredentialDisconnectOptionsPtr options, DisconnectStatus* out_status) {
  base::RunLoop loop;
  proxy_->Disconnect(
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop,
             DisconnectStatus* out_status
,
             DisconnectStatus status) {*out_status = std::move(status);
            loop->Quit();
          },
          &loop,
          out_status));
  loop.Run();
}

DisconnectStatus FederatedRequestServiceAsyncWaiter::Disconnect(
    IdentityCredentialDisconnectOptionsPtr options) {
  DisconnectStatus async_wait_result;
  Disconnect(std::move(options),&async_wait_result);
  return async_wait_result;
}

void FederatedRequestServiceAsyncWaiter::ResolveTokenRequest(
    const std::optional<std::string>& account_id, ResolveTokenParamsPtr params, bool* out_success) {
  base::RunLoop loop;
  proxy_->ResolveTokenRequest(
      std::move(account_id),
      std::move(params),
      base::BindOnce(
          [](base::RunLoop* loop,
             bool* out_success
,
             bool success) {*out_success = std::move(success);
            loop->Quit();
          },
          &loop,
          out_success));
  loop.Run();
}

bool FederatedRequestServiceAsyncWaiter::ResolveTokenRequest(
    const std::optional<std::string>& account_id, ResolveTokenParamsPtr params) {
  bool async_wait_result;
  ResolveTokenRequest(std::move(account_id),std::move(params),&async_wait_result);
  return async_wait_result;
}

void FederatedRequestServiceAsyncWaiter::SetIdpSigninStatus(
    const ::url::Origin& origin, IdpSigninStatus status, const std::optional<::blink::common::webid::LoginStatusOptions>& options) {
  base::RunLoop loop;
  proxy_->SetIdpSigninStatus(
      std::move(origin),
      std::move(status),
      std::move(options),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}








}  // blink::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif