// services/network/public/mojom/device_bound_sessions.mojom-shared.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef SERVICES_NETWORK_PUBLIC_MOJOM_DEVICE_BOUND_SESSIONS_MOJOM_SHARED_H_
#define SERVICES_NETWORK_PUBLIC_MOJOM_DEVICE_BOUND_SESSIONS_MOJOM_SHARED_H_

#include <stdint.h>

#include <functional>
#include <iosfwd>
#include <type_traits>
#include <utility>
#include "mojo/public/cpp/bindings/array_data_view.h"
#include "mojo/public/cpp/bindings/map_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"
#include "mojo/public/cpp/system/message_pipe.h"

#include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "services/network/public/mojom/device_bound_sessions.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-shared.h"
#include "sandbox/policy/mojom/context.mojom-shared.h"
#include "services/network/public/mojom/clear_data_filter.mojom-shared.h"
#include "services/network/public/mojom/cookie_manager.mojom-shared.h"
#include "services/network/public/mojom/schemeful_site.mojom-shared.h"
#include "url/mojom/url.mojom-shared.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization.h"
#include "mojo/public/cpp/system/data_pipe.h"



#include "services/network/public/mojom/device_bound_sessions.mojom-data-view.h"  // IWYU pragma: export




namespace std {

template <>
struct hash<::network::mojom::DeviceBoundSessionAccessType>
    : public mojo::internal::EnumHashImpl<::network::mojom::DeviceBoundSessionAccessType> {};

template <>
struct hash<::network::mojom::DeviceBoundSessionUsage>
    : public mojo::internal::EnumHashImpl<::network::mojom::DeviceBoundSessionUsage> {};

template <>
struct hash<::network::mojom::DeviceBoundSessionDeletionReason>
    : public mojo::internal::EnumHashImpl<::network::mojom::DeviceBoundSessionDeletionReason> {};

template <>
struct hash<::network::mojom::DeviceBoundSessionScopeSpecificationType>
    : public mojo::internal::EnumHashImpl<::network::mojom::DeviceBoundSessionScopeSpecificationType> {};

template <>
struct hash<::network::mojom::DeviceBoundSessionError>
    : public mojo::internal::EnumHashImpl<::network::mojom::DeviceBoundSessionError> {};

template <>
struct hash<::network::mojom::DeviceBoundSessionRefreshResult>
    : public mojo::internal::EnumHashImpl<::network::mojom::DeviceBoundSessionRefreshResult> {};

template <>
struct hash<::network::mojom::DeviceBoundSessionChallengeResult>
    : public mojo::internal::EnumHashImpl<::network::mojom::DeviceBoundSessionChallengeResult> {};

template <>
struct hash<::network::mojom::DeviceBoundSessionInclusionResult>
    : public mojo::internal::EnumHashImpl<::network::mojom::DeviceBoundSessionInclusionResult> {};

}  // namespace std

namespace mojo {


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionAccessType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::network::mojom::DeviceBoundSessionAccessType, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::network::mojom::DeviceBoundSessionAccessType>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::network::mojom::DeviceBoundSessionAccessType, UserType> ||
                        HasInfallibleConversion(::network::mojom::DeviceBoundSessionAccessType()),
                    "::network::mojom::DeviceBoundSessionAccessType does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionUsage, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::network::mojom::DeviceBoundSessionUsage, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::network::mojom::DeviceBoundSessionUsage>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::network::mojom::DeviceBoundSessionUsage, UserType> ||
                        HasInfallibleConversion(::network::mojom::DeviceBoundSessionUsage()),
                    "::network::mojom::DeviceBoundSessionUsage does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionDeletionReason, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::network::mojom::DeviceBoundSessionDeletionReason, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::network::mojom::DeviceBoundSessionDeletionReason>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::network::mojom::DeviceBoundSessionDeletionReason, UserType> ||
                        HasInfallibleConversion(::network::mojom::DeviceBoundSessionDeletionReason()),
                    "::network::mojom::DeviceBoundSessionDeletionReason does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionScopeSpecificationType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::network::mojom::DeviceBoundSessionScopeSpecificationType, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::network::mojom::DeviceBoundSessionScopeSpecificationType>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::network::mojom::DeviceBoundSessionScopeSpecificationType, UserType> ||
                        HasInfallibleConversion(::network::mojom::DeviceBoundSessionScopeSpecificationType()),
                    "::network::mojom::DeviceBoundSessionScopeSpecificationType does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionError, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::network::mojom::DeviceBoundSessionError, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::network::mojom::DeviceBoundSessionError>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::network::mojom::DeviceBoundSessionError, UserType> ||
                        HasInfallibleConversion(::network::mojom::DeviceBoundSessionError()),
                    "::network::mojom::DeviceBoundSessionError does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionRefreshResult, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::network::mojom::DeviceBoundSessionRefreshResult, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::network::mojom::DeviceBoundSessionRefreshResult>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::network::mojom::DeviceBoundSessionRefreshResult, UserType> ||
                        HasInfallibleConversion(::network::mojom::DeviceBoundSessionRefreshResult()),
                    "::network::mojom::DeviceBoundSessionRefreshResult does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionChallengeResult, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::network::mojom::DeviceBoundSessionChallengeResult, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::network::mojom::DeviceBoundSessionChallengeResult>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::network::mojom::DeviceBoundSessionChallengeResult, UserType> ||
                        HasInfallibleConversion(::network::mojom::DeviceBoundSessionChallengeResult()),
                    "::network::mojom::DeviceBoundSessionChallengeResult does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionInclusionResult, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::network::mojom::DeviceBoundSessionInclusionResult, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::network::mojom::DeviceBoundSessionInclusionResult>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::network::mojom::DeviceBoundSessionInclusionResult, UserType> ||
                        HasInfallibleConversion(::network::mojom::DeviceBoundSessionInclusionResult()),
                    "::network::mojom::DeviceBoundSessionInclusionResult does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionKeyDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionKeyDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionKey_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::site(input)) in_site = Traits::site(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->site)::BaseType> site_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::SchemefulSiteDataView>(
      in_site,
      site_fragment);

    fragment->site.Set(
        site_fragment.is_null() ? nullptr : site_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->site.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null site in DeviceBoundSessionKey struct");

    decltype(Traits::id(input)) in_id = Traits::id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->id)::BaseType> id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_id,
      id_fragment);

    fragment->id.Set(
        id_fragment.is_null() ? nullptr : id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null id in DeviceBoundSessionKey struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionKey_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionKeyDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionAccessDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionAccessDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionAccess_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionAccessType>(
      Traits::access_type(input),
      &fragment->access_type);

    decltype(Traits::session_key(input)) in_session_key = Traits::session_key(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->session_key)::BaseType> session_key_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionKeyDataView>(
      in_session_key,
      session_key_fragment);

    fragment->session_key.Set(
        session_key_fragment.is_null() ? nullptr : session_key_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->session_key.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null session_key in DeviceBoundSessionAccess struct");

    decltype(Traits::cookies(input)) in_cookies = Traits::cookies(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->cookies)::BaseType>
        cookies_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& cookies_validate_params =
        mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
      in_cookies,
      cookies_fragment,
      &cookies_validate_params);

    fragment->cookies.Set(
        cookies_fragment.is_null() ? nullptr : cookies_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->cookies.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null cookies in DeviceBoundSessionAccess struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionAccess_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionAccessDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionWithUsageDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionWithUsageDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionWithUsage_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::session_key(input)) in_session_key = Traits::session_key(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->session_key)::BaseType> session_key_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionKeyDataView>(
      in_session_key,
      session_key_fragment);

    fragment->session_key.Set(
        session_key_fragment.is_null() ? nullptr : session_key_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->session_key.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null session_key in DeviceBoundSessionWithUsage struct");

    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionUsage>(
      Traits::usage(input),
      &fragment->usage);
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionWithUsage_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionWithUsageDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionScopeSpecificationDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionScopeSpecificationDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionScopeSpecification_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionScopeSpecificationType>(
      Traits::type(input),
      &fragment->type);

    decltype(Traits::domain(input)) in_domain = Traits::domain(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->domain)::BaseType> domain_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_domain,
      domain_fragment);

    fragment->domain.Set(
        domain_fragment.is_null() ? nullptr : domain_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->domain.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null domain in DeviceBoundSessionScopeSpecification struct");

    decltype(Traits::path(input)) in_path = Traits::path(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->path)::BaseType> path_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_path,
      path_fragment);

    fragment->path.Set(
        path_fragment.is_null() ? nullptr : path_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->path.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null path in DeviceBoundSessionScopeSpecification struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionScopeSpecification_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionScopeSpecificationDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionScopeDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionScopeDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionScope_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    fragment->include_site = Traits::include_site(input);

    decltype(Traits::specifications(input)) in_specifications = Traits::specifications(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->specifications)::BaseType>
        specifications_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& specifications_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionScopeSpecificationDataView>>(
      in_specifications,
      specifications_fragment,
      &specifications_validate_params);

    fragment->specifications.Set(
        specifications_fragment.is_null() ? nullptr : specifications_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->specifications.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null specifications in DeviceBoundSessionScope struct");

    decltype(Traits::origin(input)) in_origin = Traits::origin(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->origin)::BaseType> origin_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_origin,
      origin_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->origin.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null origin in DeviceBoundSessionScope struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionScope_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionScopeDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionCredentialDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionCredentialDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionCredential_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::name(input)) in_name = Traits::name(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->name)::BaseType> name_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_name,
      name_fragment);

    fragment->name.Set(
        name_fragment.is_null() ? nullptr : name_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->name.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null name in DeviceBoundSessionCredential struct");

    decltype(Traits::attributes(input)) in_attributes = Traits::attributes(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->attributes)::BaseType> attributes_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_attributes,
      attributes_fragment);

    fragment->attributes.Set(
        attributes_fragment.is_null() ? nullptr : attributes_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->attributes.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null attributes in DeviceBoundSessionCredential struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionCredential_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionCredentialDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionParamsDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionParamsDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionParams_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::session_id(input)) in_session_id = Traits::session_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->session_id)::BaseType> session_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_session_id,
      session_id_fragment);

    fragment->session_id.Set(
        session_id_fragment.is_null() ? nullptr : session_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->session_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null session_id in DeviceBoundSessionParams struct");

    decltype(Traits::fetcher_url(input)) in_fetcher_url = Traits::fetcher_url(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->fetcher_url)::BaseType> fetcher_url_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::url::mojom::UrlDataView>(
      in_fetcher_url,
      fetcher_url_fragment);

    fragment->fetcher_url.Set(
        fetcher_url_fragment.is_null() ? nullptr : fetcher_url_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->fetcher_url.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null fetcher_url in DeviceBoundSessionParams struct");

    decltype(Traits::refresh_url(input)) in_refresh_url = Traits::refresh_url(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->refresh_url)::BaseType> refresh_url_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_refresh_url,
      refresh_url_fragment);

    fragment->refresh_url.Set(
        refresh_url_fragment.is_null() ? nullptr : refresh_url_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->refresh_url.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null refresh_url in DeviceBoundSessionParams struct");

    decltype(Traits::scope(input)) in_scope = Traits::scope(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->scope)::BaseType> scope_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionScopeDataView>(
      in_scope,
      scope_fragment);

    fragment->scope.Set(
        scope_fragment.is_null() ? nullptr : scope_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->scope.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null scope in DeviceBoundSessionParams struct");

    decltype(Traits::credentials(input)) in_credentials = Traits::credentials(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->credentials)::BaseType>
        credentials_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& credentials_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionCredentialDataView>>(
      in_credentials,
      credentials_fragment,
      &credentials_validate_params);

    fragment->credentials.Set(
        credentials_fragment.is_null() ? nullptr : credentials_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->credentials.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null credentials in DeviceBoundSessionParams struct");

    decltype(Traits::allowed_refresh_initiators(input)) in_allowed_refresh_initiators = Traits::allowed_refresh_initiators(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->allowed_refresh_initiators)::BaseType>
        allowed_refresh_initiators_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& allowed_refresh_initiators_validate_params =
        mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
      in_allowed_refresh_initiators,
      allowed_refresh_initiators_fragment,
      &allowed_refresh_initiators_validate_params);

    fragment->allowed_refresh_initiators.Set(
        allowed_refresh_initiators_fragment.is_null() ? nullptr : allowed_refresh_initiators_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->allowed_refresh_initiators.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null allowed_refresh_initiators in DeviceBoundSessionParams struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionParams_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionParamsDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionCookieCravingDisplayDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionCookieCravingDisplayDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionCookieCravingDisplay_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::name(input)) in_name = Traits::name(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->name)::BaseType> name_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_name,
      name_fragment);

    fragment->name.Set(
        name_fragment.is_null() ? nullptr : name_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->name.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null name in DeviceBoundSessionCookieCravingDisplay struct");

    decltype(Traits::domain(input)) in_domain = Traits::domain(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->domain)::BaseType> domain_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_domain,
      domain_fragment);

    fragment->domain.Set(
        domain_fragment.is_null() ? nullptr : domain_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->domain.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null domain in DeviceBoundSessionCookieCravingDisplay struct");

    decltype(Traits::path(input)) in_path = Traits::path(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->path)::BaseType> path_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_path,
      path_fragment);

    fragment->path.Set(
        path_fragment.is_null() ? nullptr : path_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->path.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null path in DeviceBoundSessionCookieCravingDisplay struct");

    fragment->secure = Traits::secure(input);

    fragment->http_only = Traits::http_only(input);

    
    mojo::internal::Serialize<::network::mojom::CookieSameSite>(
      Traits::same_site(input),
      &fragment->same_site);
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionCookieCravingDisplay_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionCookieCravingDisplayDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionUrlRuleDisplayDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionUrlRuleDisplayDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionUrlRuleDisplay_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionInclusionResult>(
      Traits::rule_type(input),
      &fragment->rule_type);

    decltype(Traits::host_pattern(input)) in_host_pattern = Traits::host_pattern(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->host_pattern)::BaseType> host_pattern_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_host_pattern,
      host_pattern_fragment);

    fragment->host_pattern.Set(
        host_pattern_fragment.is_null() ? nullptr : host_pattern_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->host_pattern.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null host_pattern in DeviceBoundSessionUrlRuleDisplay struct");

    decltype(Traits::path_prefix(input)) in_path_prefix = Traits::path_prefix(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->path_prefix)::BaseType> path_prefix_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_path_prefix,
      path_prefix_fragment);

    fragment->path_prefix.Set(
        path_prefix_fragment.is_null() ? nullptr : path_prefix_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->path_prefix.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null path_prefix in DeviceBoundSessionUrlRuleDisplay struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionUrlRuleDisplay_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionUrlRuleDisplayDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionInclusionRulesDisplayDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionInclusionRulesDisplayDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionInclusionRulesDisplay_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::origin(input)) in_origin = Traits::origin(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->origin)::BaseType> origin_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_origin,
      origin_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->origin.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null origin in DeviceBoundSessionInclusionRulesDisplay struct");

    fragment->include_site = Traits::include_site(input);

    decltype(Traits::url_rules(input)) in_url_rules = Traits::url_rules(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->url_rules)::BaseType>
        url_rules_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& url_rules_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionUrlRuleDisplayDataView>>(
      in_url_rules,
      url_rules_fragment,
      &url_rules_validate_params);

    fragment->url_rules.Set(
        url_rules_fragment.is_null() ? nullptr : url_rules_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->url_rules.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null url_rules in DeviceBoundSessionInclusionRulesDisplay struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionInclusionRulesDisplay_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionInclusionRulesDisplayDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionDisplayDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionDisplayDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionDisplay_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::key(input)) in_key = Traits::key(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->key)::BaseType> key_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionKeyDataView>(
      in_key,
      key_fragment);

    fragment->key.Set(
        key_fragment.is_null() ? nullptr : key_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->key.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null key in DeviceBoundSessionDisplay struct");

    decltype(Traits::refresh_url(input)) in_refresh_url = Traits::refresh_url(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->refresh_url)::BaseType> refresh_url_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::url::mojom::UrlDataView>(
      in_refresh_url,
      refresh_url_fragment);

    fragment->refresh_url.Set(
        refresh_url_fragment.is_null() ? nullptr : refresh_url_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->refresh_url.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null refresh_url in DeviceBoundSessionDisplay struct");

    decltype(Traits::inclusion_rules(input)) in_inclusion_rules = Traits::inclusion_rules(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->inclusion_rules)::BaseType> inclusion_rules_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionInclusionRulesDisplayDataView>(
      in_inclusion_rules,
      inclusion_rules_fragment);

    fragment->inclusion_rules.Set(
        inclusion_rules_fragment.is_null() ? nullptr : inclusion_rules_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->inclusion_rules.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null inclusion_rules in DeviceBoundSessionDisplay struct");

    decltype(Traits::cookie_cravings(input)) in_cookie_cravings = Traits::cookie_cravings(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->cookie_cravings)::BaseType>
        cookie_cravings_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& cookie_cravings_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionCookieCravingDisplayDataView>>(
      in_cookie_cravings,
      cookie_cravings_fragment,
      &cookie_cravings_validate_params);

    fragment->cookie_cravings.Set(
        cookie_cravings_fragment.is_null() ? nullptr : cookie_cravings_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->cookie_cravings.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null cookie_cravings in DeviceBoundSessionDisplay struct");

    decltype(Traits::expiry_date(input)) in_expiry_date = Traits::expiry_date(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->expiry_date)::BaseType> expiry_date_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::TimeDataView>(
      in_expiry_date,
      expiry_date_fragment);

    fragment->expiry_date.Set(
        expiry_date_fragment.is_null() ? nullptr : expiry_date_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->expiry_date.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null expiry_date in DeviceBoundSessionDisplay struct");

    decltype(Traits::cached_challenge(input)) in_cached_challenge = Traits::cached_challenge(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->cached_challenge)::BaseType> cached_challenge_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_cached_challenge,
      cached_challenge_fragment);

    fragment->cached_challenge.Set(
        cached_challenge_fragment.is_null() ? nullptr : cached_challenge_fragment.data());

    decltype(Traits::allowed_refresh_initiators(input)) in_allowed_refresh_initiators = Traits::allowed_refresh_initiators(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->allowed_refresh_initiators)::BaseType>
        allowed_refresh_initiators_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& allowed_refresh_initiators_validate_params =
        mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>>(
      in_allowed_refresh_initiators,
      allowed_refresh_initiators_fragment,
      &allowed_refresh_initiators_validate_params);

    fragment->allowed_refresh_initiators.Set(
        allowed_refresh_initiators_fragment.is_null() ? nullptr : allowed_refresh_initiators_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->allowed_refresh_initiators.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null allowed_refresh_initiators in DeviceBoundSessionDisplay struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionDisplay_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionDisplayDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionFailedRequestDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionFailedRequestDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionFailedRequest_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::request_url(input)) in_request_url = Traits::request_url(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->request_url)::BaseType> request_url_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::url::mojom::UrlDataView>(
      in_request_url,
      request_url_fragment);

    fragment->request_url.Set(
        request_url_fragment.is_null() ? nullptr : request_url_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->request_url.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null request_url in DeviceBoundSessionFailedRequest struct");
    fragment->net_error_$flag = Traits::net_error(input).has_value();
    if (Traits::net_error(input).has_value()) {
      fragment->net_error_$value = Traits::net_error(input).value();
    }
    fragment->response_error_$flag = Traits::response_error(input).has_value();
    if (Traits::response_error(input).has_value()) {
      fragment->response_error_$value = Traits::response_error(input).value();
    }

    decltype(Traits::response_error_body(input)) in_response_error_body = Traits::response_error_body(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->response_error_body)::BaseType> response_error_body_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_response_error_body,
      response_error_body_fragment);

    fragment->response_error_body.Set(
        response_error_body_fragment.is_null() ? nullptr : response_error_body_fragment.data());
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionFailedRequest_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionFailedRequestDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionCreationDetailsDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionCreationDetailsDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionCreationDetails_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionError>(
      Traits::fetch_error(input),
      &fragment->fetch_error);

    decltype(Traits::new_session_display(input)) in_new_session_display = Traits::new_session_display(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->new_session_display)::BaseType> new_session_display_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionDisplayDataView>(
      in_new_session_display,
      new_session_display_fragment);

    fragment->new_session_display.Set(
        new_session_display_fragment.is_null() ? nullptr : new_session_display_fragment.data());

    decltype(Traits::failed_request(input)) in_failed_request = Traits::failed_request(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->failed_request)::BaseType> failed_request_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionFailedRequestDataView>(
      in_failed_request,
      failed_request_fragment);

    fragment->failed_request.Set(
        failed_request_fragment.is_null() ? nullptr : failed_request_fragment.data());
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionCreationDetails_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionCreationDetailsDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionRefreshDetailsDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionRefreshDetailsDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionRefreshDetails_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionRefreshResult>(
      Traits::refresh_result(input),
      &fragment->refresh_result);
    fragment->fetch_error_$flag = Traits::fetch_error(input).has_value();
    if (Traits::fetch_error(input).has_value()) {
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionError>(
        Traits::fetch_error(input).value(),
        &fragment->fetch_error_$value);
    } else {
      fragment->fetch_error_$value =
          static_cast<int32_t>(::network::mojom::DeviceBoundSessionError::kMinValue);
    }

    decltype(Traits::new_session_display(input)) in_new_session_display = Traits::new_session_display(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->new_session_display)::BaseType> new_session_display_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionDisplayDataView>(
      in_new_session_display,
      new_session_display_fragment);

    fragment->new_session_display.Set(
        new_session_display_fragment.is_null() ? nullptr : new_session_display_fragment.data());

    fragment->was_fully_proactive_refresh = Traits::was_fully_proactive_refresh(input);

    decltype(Traits::failed_request(input)) in_failed_request = Traits::failed_request(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->failed_request)::BaseType> failed_request_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionFailedRequestDataView>(
      in_failed_request,
      failed_request_fragment);

    fragment->failed_request.Set(
        failed_request_fragment.is_null() ? nullptr : failed_request_fragment.data());
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionRefreshDetails_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionRefreshDetailsDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionTerminationDetailsDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionTerminationDetailsDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionTerminationDetails_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionDeletionReason>(
      Traits::deletion_reason(input),
      &fragment->deletion_reason);
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionTerminationDetails_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionTerminationDetailsDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionChallengeDetailsDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionChallengeDetailsDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionChallengeDetails_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionChallengeResult>(
      Traits::challenge_result(input),
      &fragment->challenge_result);

    decltype(Traits::challenge(input)) in_challenge = Traits::challenge(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->challenge)::BaseType> challenge_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_challenge,
      challenge_fragment);

    fragment->challenge.Set(
        challenge_fragment.is_null() ? nullptr : challenge_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->challenge.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null challenge in DeviceBoundSessionChallengeDetails struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionChallengeDetails_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionChallengeDetailsDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionEventDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionEventDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionEvent_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::event_id(input)) in_event_id = Traits::event_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->event_id)::BaseType> event_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UnguessableTokenDataView>(
      in_event_id,
      event_id_fragment);

    fragment->event_id.Set(
        event_id_fragment.is_null() ? nullptr : event_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->event_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null event_id in DeviceBoundSessionEvent struct");

    decltype(Traits::site(input)) in_site = Traits::site(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->site)::BaseType> site_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::network::mojom::SchemefulSiteDataView>(
      in_site,
      site_fragment);

    fragment->site.Set(
        site_fragment.is_null() ? nullptr : site_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->site.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null site in DeviceBoundSessionEvent struct");

    decltype(Traits::session_id(input)) in_session_id = Traits::session_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->session_id)::BaseType> session_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_session_id,
      session_id_fragment);

    fragment->session_id.Set(
        session_id_fragment.is_null() ? nullptr : session_id_fragment.data());

    fragment->succeeded = Traits::succeeded(input);

    decltype(Traits::event_type_details(input)) in_event_type_details = Traits::event_type_details(input);
    mojo::internal::MessageFragment<decltype(fragment->event_type_details)>
        event_type_details_fragment(fragment.message());
    event_type_details_fragment.Claim(&fragment->event_type_details);
    
    mojo::internal::Serialize<::network::mojom::DeviceBoundSessionEventTypeDetailsDataView>(
      in_event_type_details,
      event_type_details_fragment,
      true);

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->event_type_details.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null event_type_details in DeviceBoundSessionEvent struct");
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionEvent_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionEventDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::network::mojom::DeviceBoundSessionEventTypeDetailsDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::network::mojom::DeviceBoundSessionEventTypeDetailsDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::network::mojom::internal::DeviceBoundSessionEventTypeDetails_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView::Tag::kCreation: {
    decltype(Traits::creation(input))
    in_creation = Traits::creation(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_creation)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::network::mojom::DeviceBoundSessionCreationDetailsDataView>(
  in_creation,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null creation in DeviceBoundSessionEventTypeDetails union");
    fragment->data.f_creation.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView::Tag::kRefresh: {
    decltype(Traits::refresh(input))
    in_refresh = Traits::refresh(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_refresh)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::network::mojom::DeviceBoundSessionRefreshDetailsDataView>(
  in_refresh,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null refresh in DeviceBoundSessionEventTypeDetails union");
    fragment->data.f_refresh.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView::Tag::kTermination: {
    decltype(Traits::termination(input))
    in_termination = Traits::termination(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_termination)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::network::mojom::DeviceBoundSessionTerminationDetailsDataView>(
  in_termination,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null termination in DeviceBoundSessionEventTypeDetails union");
    fragment->data.f_termination.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView::Tag::kChallenge: {
    decltype(Traits::challenge(input))
    in_challenge = Traits::challenge(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_challenge)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::network::mojom::DeviceBoundSessionChallengeDetailsDataView>(
  in_challenge,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null challenge in DeviceBoundSessionEventTypeDetails union");
    fragment->data.f_challenge.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::network::mojom::internal::DeviceBoundSessionEventTypeDetails_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal

}  // namespace mojo


namespace network::mojom {

inline void DeviceBoundSessionKeyDataView::GetSiteDataView(
    ::network::mojom::SchemefulSiteDataView* output) {
  auto pointer = data_->site.Get();
  *output = ::network::mojom::SchemefulSiteDataView(pointer, message_);
}
inline void DeviceBoundSessionKeyDataView::GetIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->id.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void DeviceBoundSessionAccessDataView::GetSessionKeyDataView(
    DeviceBoundSessionKeyDataView* output) {
  auto pointer = data_->session_key.Get();
  *output = DeviceBoundSessionKeyDataView(pointer, message_);
}
inline void DeviceBoundSessionAccessDataView::GetCookiesDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->cookies.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, message_);
}


inline void DeviceBoundSessionWithUsageDataView::GetSessionKeyDataView(
    DeviceBoundSessionKeyDataView* output) {
  auto pointer = data_->session_key.Get();
  *output = DeviceBoundSessionKeyDataView(pointer, message_);
}


inline void DeviceBoundSessionScopeSpecificationDataView::GetDomainDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->domain.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionScopeSpecificationDataView::GetPathDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->path.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void DeviceBoundSessionScopeDataView::GetSpecificationsDataView(
    mojo::ArrayDataView<DeviceBoundSessionScopeSpecificationDataView>* output) {
  auto pointer = data_->specifications.Get();
  *output = mojo::ArrayDataView<DeviceBoundSessionScopeSpecificationDataView>(pointer, message_);
}
inline void DeviceBoundSessionScopeDataView::GetOriginDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->origin.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void DeviceBoundSessionCredentialDataView::GetNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionCredentialDataView::GetAttributesDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->attributes.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void DeviceBoundSessionParamsDataView::GetSessionIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->session_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionParamsDataView::GetFetcherUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->fetcher_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void DeviceBoundSessionParamsDataView::GetRefreshUrlDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->refresh_url.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionParamsDataView::GetScopeDataView(
    DeviceBoundSessionScopeDataView* output) {
  auto pointer = data_->scope.Get();
  *output = DeviceBoundSessionScopeDataView(pointer, message_);
}
inline void DeviceBoundSessionParamsDataView::GetCredentialsDataView(
    mojo::ArrayDataView<DeviceBoundSessionCredentialDataView>* output) {
  auto pointer = data_->credentials.Get();
  *output = mojo::ArrayDataView<DeviceBoundSessionCredentialDataView>(pointer, message_);
}
inline void DeviceBoundSessionParamsDataView::GetAllowedRefreshInitiatorsDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->allowed_refresh_initiators.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, message_);
}


inline void DeviceBoundSessionCookieCravingDisplayDataView::GetNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionCookieCravingDisplayDataView::GetDomainDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->domain.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionCookieCravingDisplayDataView::GetPathDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->path.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void DeviceBoundSessionUrlRuleDisplayDataView::GetHostPatternDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->host_pattern.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionUrlRuleDisplayDataView::GetPathPrefixDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->path_prefix.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void DeviceBoundSessionInclusionRulesDisplayDataView::GetOriginDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->origin.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionInclusionRulesDisplayDataView::GetUrlRulesDataView(
    mojo::ArrayDataView<DeviceBoundSessionUrlRuleDisplayDataView>* output) {
  auto pointer = data_->url_rules.Get();
  *output = mojo::ArrayDataView<DeviceBoundSessionUrlRuleDisplayDataView>(pointer, message_);
}


inline void DeviceBoundSessionDisplayDataView::GetKeyDataView(
    DeviceBoundSessionKeyDataView* output) {
  auto pointer = data_->key.Get();
  *output = DeviceBoundSessionKeyDataView(pointer, message_);
}
inline void DeviceBoundSessionDisplayDataView::GetRefreshUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->refresh_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void DeviceBoundSessionDisplayDataView::GetInclusionRulesDataView(
    DeviceBoundSessionInclusionRulesDisplayDataView* output) {
  auto pointer = data_->inclusion_rules.Get();
  *output = DeviceBoundSessionInclusionRulesDisplayDataView(pointer, message_);
}
inline void DeviceBoundSessionDisplayDataView::GetCookieCravingsDataView(
    mojo::ArrayDataView<DeviceBoundSessionCookieCravingDisplayDataView>* output) {
  auto pointer = data_->cookie_cravings.Get();
  *output = mojo::ArrayDataView<DeviceBoundSessionCookieCravingDisplayDataView>(pointer, message_);
}
inline void DeviceBoundSessionDisplayDataView::GetExpiryDateDataView(
    ::mojo_base::mojom::TimeDataView* output) {
  auto pointer = data_->expiry_date.Get();
  *output = ::mojo_base::mojom::TimeDataView(pointer, message_);
}
inline void DeviceBoundSessionDisplayDataView::GetCachedChallengeDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->cached_challenge.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionDisplayDataView::GetAllowedRefreshInitiatorsDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->allowed_refresh_initiators.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, message_);
}


inline void DeviceBoundSessionFailedRequestDataView::GetRequestUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->request_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void DeviceBoundSessionFailedRequestDataView::GetResponseErrorBodyDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->response_error_body.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void DeviceBoundSessionCreationDetailsDataView::GetNewSessionDisplayDataView(
    DeviceBoundSessionDisplayDataView* output) {
  auto pointer = data_->new_session_display.Get();
  *output = DeviceBoundSessionDisplayDataView(pointer, message_);
}
inline void DeviceBoundSessionCreationDetailsDataView::GetFailedRequestDataView(
    DeviceBoundSessionFailedRequestDataView* output) {
  auto pointer = data_->failed_request.Get();
  *output = DeviceBoundSessionFailedRequestDataView(pointer, message_);
}


inline void DeviceBoundSessionRefreshDetailsDataView::GetNewSessionDisplayDataView(
    DeviceBoundSessionDisplayDataView* output) {
  auto pointer = data_->new_session_display.Get();
  *output = DeviceBoundSessionDisplayDataView(pointer, message_);
}
inline void DeviceBoundSessionRefreshDetailsDataView::GetFailedRequestDataView(
    DeviceBoundSessionFailedRequestDataView* output) {
  auto pointer = data_->failed_request.Get();
  *output = DeviceBoundSessionFailedRequestDataView(pointer, message_);
}




inline void DeviceBoundSessionChallengeDetailsDataView::GetChallengeDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->challenge.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void DeviceBoundSessionEventDataView::GetEventIdDataView(
    ::mojo_base::mojom::UnguessableTokenDataView* output) {
  auto pointer = data_->event_id.Get();
  *output = ::mojo_base::mojom::UnguessableTokenDataView(pointer, message_);
}
inline void DeviceBoundSessionEventDataView::GetSiteDataView(
    ::network::mojom::SchemefulSiteDataView* output) {
  auto pointer = data_->site.Get();
  *output = ::network::mojom::SchemefulSiteDataView(pointer, message_);
}
inline void DeviceBoundSessionEventDataView::GetSessionIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->session_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void DeviceBoundSessionEventDataView::GetEventTypeDetailsDataView(
    DeviceBoundSessionEventTypeDetailsDataView* output) {
  auto pointer = &data_->event_type_details;
  *output = DeviceBoundSessionEventTypeDetailsDataView(pointer, message_);
}


inline void DeviceBoundSessionEventTypeDetailsDataView::GetCreationDataView(
    DeviceBoundSessionCreationDetailsDataView* output) const {
  CHECK(is_creation());
  *output = DeviceBoundSessionCreationDetailsDataView(data_->data.f_creation.Get(), message_);
}
inline void DeviceBoundSessionEventTypeDetailsDataView::GetRefreshDataView(
    DeviceBoundSessionRefreshDetailsDataView* output) const {
  CHECK(is_refresh());
  *output = DeviceBoundSessionRefreshDetailsDataView(data_->data.f_refresh.Get(), message_);
}
inline void DeviceBoundSessionEventTypeDetailsDataView::GetTerminationDataView(
    DeviceBoundSessionTerminationDetailsDataView* output) const {
  CHECK(is_termination());
  *output = DeviceBoundSessionTerminationDetailsDataView(data_->data.f_termination.Get(), message_);
}
inline void DeviceBoundSessionEventTypeDetailsDataView::GetChallengeDataView(
    DeviceBoundSessionChallengeDetailsDataView* output) const {
  CHECK(is_challenge());
  *output = DeviceBoundSessionChallengeDetailsDataView(data_->data.f_challenge.Get(), message_);
}


}  // network::mojom

// Declare TraceFormatTraits for enums, which should be defined in ::perfetto
// namespace.

namespace perfetto {

template <>
struct  TraceFormatTraits<::network::mojom::DeviceBoundSessionAccessType> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::network::mojom::DeviceBoundSessionAccessType value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::network::mojom::DeviceBoundSessionUsage> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::network::mojom::DeviceBoundSessionUsage value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::network::mojom::DeviceBoundSessionDeletionReason> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::network::mojom::DeviceBoundSessionDeletionReason value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::network::mojom::DeviceBoundSessionScopeSpecificationType> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::network::mojom::DeviceBoundSessionScopeSpecificationType value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::network::mojom::DeviceBoundSessionError> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::network::mojom::DeviceBoundSessionError value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::network::mojom::DeviceBoundSessionRefreshResult> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::network::mojom::DeviceBoundSessionRefreshResult value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::network::mojom::DeviceBoundSessionChallengeResult> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::network::mojom::DeviceBoundSessionChallengeResult value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::network::mojom::DeviceBoundSessionInclusionResult> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::network::mojom::DeviceBoundSessionInclusionResult value);
};

} // namespace perfetto

#endif  // SERVICES_NETWORK_PUBLIC_MOJOM_DEVICE_BOUND_SESSIONS_MOJOM_SHARED_H_