// services/on_device_model/public/mojom/on_device_model.mojom-shared-internal.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_ON_DEVICE_MODEL_PUBLIC_MOJOM_ON_DEVICE_MODEL_MOJOM_SHARED_INTERNAL_H_
#define SERVICES_ON_DEVICE_MODEL_PUBLIC_MOJOM_ON_DEVICE_MODEL_MOJOM_SHARED_INTERNAL_H_
#include "mojo/public/cpp/bindings/lib/array_internal.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/message_fragment.h"
#include "mojo/public/c/system/macros.h"
#include "mojo/public/mojom/base/file.mojom-shared-internal.h"
#include "mojo/public/mojom/base/file_path.mojom-shared-internal.h"
#include "mojo/public/mojom/base/values.mojom-shared-internal.h"
#include "skia/public/mojom/bitmap.mojom-shared-internal.h"
#include "mojo/public/cpp/bindings/lib/native_enum_data.h"
#include "mojo/public/interfaces/bindings/native_struct.mojom-shared-internal.h"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace on_device_model::mojom {
namespace internal {
class AdaptationAssets_Data;
class LanguageDetectionResult_Data;
class SafetyInfo_Data;
class ResponseChunk_Data;
class ResponseSummary_Data;
class LoadAdaptationParams_Data;
class Capabilities_Data;
class SessionParams_Data;
class Input_Data;
class AppendOptions_Data;
class HintOptions_Data;
class GenerateOptions_Data;
class ToolDeclaration_Data;
class ToolCall_Data;
class ToolResponse_Data;
class AudioData_Data;
class SpeechRecognitionResult_Data;
class AsrStreamOptions_Data;
class DevicePerformanceInfo_Data;
class DeviceInfo_Data;
class InputPiece_Data;
class ResponseConstraint_Data;

struct GenerateError_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct Token_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct InputSource_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct Priority_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct PerformanceClass_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct LoadModelResult_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct AsrError_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

#pragma pack(push, 1)


class  InputPiece_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  InputPiece_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~InputPiece_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<InputPiece_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class InputPiece_Tag : uint32_t {

    
    kToken,
    
    kText,
    
    kBitmap,
    
    kUnknownType,
    
    kAudio,
    
    kToolDeclaration,
    
    kToolResponse,
    
    kToolCall,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    int32_t f_token;
    mojo::internal::Pointer<mojo::internal::String_Data> f_text;
    mojo::internal::Pointer<::skia::mojom::internal::BitmapWithArbitraryBpp_Data> f_bitmap;
    uint8_t f_unknown_type : 1;
    mojo::internal::Pointer<internal::AudioData_Data> f_audio;
    mojo::internal::Pointer<internal::ToolDeclaration_Data> f_tool_declaration;
    mojo::internal::Pointer<internal::ToolResponse_Data> f_tool_response;
    mojo::internal::Pointer<internal::ToolCall_Data> f_tool_call;
    uint64_t unknown;
  };

  uint32_t size;
  InputPiece_Tag tag;
  Union_ data;
};
static_assert(sizeof(InputPiece_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(InputPiece_Data)");


class  ResponseConstraint_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  ResponseConstraint_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~ResponseConstraint_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<ResponseConstraint_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class ResponseConstraint_Tag : uint32_t {

    
    kJsonSchema,
    
    kRegex,
    
    kUnknownType,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<mojo::internal::String_Data> f_json_schema;
    mojo::internal::Pointer<mojo::internal::String_Data> f_regex;
    uint8_t f_unknown_type : 1;
    uint64_t unknown;
  };

  uint32_t size;
  ResponseConstraint_Tag tag;
  Union_ data;
};
static_assert(sizeof(ResponseConstraint_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(ResponseConstraint_Data)");
class  AdaptationAssets_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::File_Data> weights;
  mojo::internal::Pointer<::mojo_base::mojom::internal::FilePath_Data> weights_path;

 private:
  friend class mojo::internal::MessageFragment<AdaptationAssets_Data>;

  AdaptationAssets_Data();
  ~AdaptationAssets_Data() = delete;
};
static_assert(sizeof(AdaptationAssets_Data) == 24,
              "Bad sizeof(AdaptationAssets_Data)");
// Used by AdaptationAssets::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AdaptationAssets_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AdaptationAssets_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AdaptationAssets_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AdaptationAssets_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AdaptationAssets_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  LanguageDetectionResult_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> code;
  float reliability;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<LanguageDetectionResult_Data>;

  LanguageDetectionResult_Data();
  ~LanguageDetectionResult_Data() = delete;
};
static_assert(sizeof(LanguageDetectionResult_Data) == 24,
              "Bad sizeof(LanguageDetectionResult_Data)");
// Used by LanguageDetectionResult::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct LanguageDetectionResult_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  LanguageDetectionResult_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~LanguageDetectionResult_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<LanguageDetectionResult_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    LanguageDetectionResult_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SafetyInfo_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<float>> class_scores;
  mojo::internal::Pointer<internal::LanguageDetectionResult_Data> language;

 private:
  friend class mojo::internal::MessageFragment<SafetyInfo_Data>;

  SafetyInfo_Data();
  ~SafetyInfo_Data() = delete;
};
static_assert(sizeof(SafetyInfo_Data) == 24,
              "Bad sizeof(SafetyInfo_Data)");
// Used by SafetyInfo::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SafetyInfo_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SafetyInfo_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SafetyInfo_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SafetyInfo_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SafetyInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  ResponseChunk_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> text;
  mojo::internal::Pointer<internal::SafetyInfo_Data> safety_info;

 private:
  friend class mojo::internal::MessageFragment<ResponseChunk_Data>;

  ResponseChunk_Data();
  ~ResponseChunk_Data() = delete;
};
static_assert(sizeof(ResponseChunk_Data) == 24,
              "Bad sizeof(ResponseChunk_Data)");
// Used by ResponseChunk::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ResponseChunk_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ResponseChunk_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ResponseChunk_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ResponseChunk_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ResponseChunk_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  ResponseSummary_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::SafetyInfo_Data> safety_info;
  uint32_t output_token_count;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<ResponseSummary_Data>;

  ResponseSummary_Data();
  ~ResponseSummary_Data() = delete;
};
static_assert(sizeof(ResponseSummary_Data) == 24,
              "Bad sizeof(ResponseSummary_Data)");
// Used by ResponseSummary::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ResponseSummary_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ResponseSummary_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ResponseSummary_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ResponseSummary_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ResponseSummary_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  LoadAdaptationParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::AdaptationAssets_Data> assets;

 private:
  friend class mojo::internal::MessageFragment<LoadAdaptationParams_Data>;

  LoadAdaptationParams_Data();
  ~LoadAdaptationParams_Data() = delete;
};
static_assert(sizeof(LoadAdaptationParams_Data) == 16,
              "Bad sizeof(LoadAdaptationParams_Data)");
// Used by LoadAdaptationParams::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct LoadAdaptationParams_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  LoadAdaptationParams_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~LoadAdaptationParams_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<LoadAdaptationParams_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    LoadAdaptationParams_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  Capabilities_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t image_input : 1;
  uint8_t audio_input : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<Capabilities_Data>;

  Capabilities_Data();
  ~Capabilities_Data() = delete;
};
static_assert(sizeof(Capabilities_Data) == 16,
              "Bad sizeof(Capabilities_Data)");
// Used by Capabilities::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct Capabilities_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  Capabilities_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~Capabilities_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<Capabilities_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    Capabilities_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SessionParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t max_tokens;
  uint32_t top_k;
  mojo::internal::Pointer<internal::Capabilities_Data> capabilities;
  float temperature;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<SessionParams_Data>;

  SessionParams_Data();
  ~SessionParams_Data() = delete;
};
static_assert(sizeof(SessionParams_Data) == 32,
              "Bad sizeof(SessionParams_Data)");
// Used by SessionParams::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SessionParams_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SessionParams_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SessionParams_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SessionParams_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SessionParams_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  Input_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<internal::InputPiece_Data>> pieces;

 private:
  friend class mojo::internal::MessageFragment<Input_Data>;

  Input_Data();
  ~Input_Data() = delete;
};
static_assert(sizeof(Input_Data) == 16,
              "Bad sizeof(Input_Data)");
// Used by Input::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct Input_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  Input_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~Input_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<Input_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    Input_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  AppendOptions_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::Input_Data> input;
  uint32_t max_tokens;
  int32_t input_source;

 private:
  friend class mojo::internal::MessageFragment<AppendOptions_Data>;

  AppendOptions_Data();
  ~AppendOptions_Data() = delete;
};
static_assert(sizeof(AppendOptions_Data) == 24,
              "Bad sizeof(AppendOptions_Data)");
// Used by AppendOptions::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AppendOptions_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AppendOptions_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AppendOptions_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AppendOptions_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AppendOptions_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  HintOptions_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t constrained_decoding_hint : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<HintOptions_Data>;

  HintOptions_Data();
  ~HintOptions_Data() = delete;
};
static_assert(sizeof(HintOptions_Data) == 16,
              "Bad sizeof(HintOptions_Data)");
// Used by HintOptions::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct HintOptions_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  HintOptions_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~HintOptions_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<HintOptions_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    HintOptions_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  GenerateOptions_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t max_output_tokens;
  uint8_t add_output_tokens_to_context : 1;
  uint8_t pad1_[3];
  internal::ResponseConstraint_Data constraint;

 private:
  friend class mojo::internal::MessageFragment<GenerateOptions_Data>;

  GenerateOptions_Data();
  ~GenerateOptions_Data() = delete;
};
static_assert(sizeof(GenerateOptions_Data) == 32,
              "Bad sizeof(GenerateOptions_Data)");
// Used by GenerateOptions::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct GenerateOptions_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  GenerateOptions_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~GenerateOptions_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<GenerateOptions_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    GenerateOptions_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  ToolDeclaration_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  mojo::internal::Pointer<mojo::internal::String_Data> description;
  mojo::internal::Pointer<::mojo_base::mojom::internal::DictionaryValue_Data> input_schema;

 private:
  friend class mojo::internal::MessageFragment<ToolDeclaration_Data>;

  ToolDeclaration_Data();
  ~ToolDeclaration_Data() = delete;
};
static_assert(sizeof(ToolDeclaration_Data) == 32,
              "Bad sizeof(ToolDeclaration_Data)");
// Used by ToolDeclaration::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ToolDeclaration_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ToolDeclaration_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ToolDeclaration_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ToolDeclaration_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ToolDeclaration_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  ToolCall_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> call_id;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  mojo::internal::Pointer<::mojo_base::mojom::internal::DictionaryValue_Data> arguments;

 private:
  friend class mojo::internal::MessageFragment<ToolCall_Data>;

  ToolCall_Data();
  ~ToolCall_Data() = delete;
};
static_assert(sizeof(ToolCall_Data) == 32,
              "Bad sizeof(ToolCall_Data)");
// Used by ToolCall::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ToolCall_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ToolCall_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ToolCall_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ToolCall_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ToolCall_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  ToolResponse_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> call_id;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  ::mojo_base::mojom::internal::Value_Data result;
  mojo::internal::Pointer<mojo::internal::String_Data> error_message;

 private:
  friend class mojo::internal::MessageFragment<ToolResponse_Data>;

  ToolResponse_Data();
  ~ToolResponse_Data() = delete;
};
static_assert(sizeof(ToolResponse_Data) == 48,
              "Bad sizeof(ToolResponse_Data)");
// Used by ToolResponse::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct ToolResponse_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  ToolResponse_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~ToolResponse_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<ToolResponse_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ToolResponse_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  AudioData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t channel_count;
  int32_t sample_rate;
  int32_t frame_count;
  uint8_t pad2_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<float>> data;

 private:
  friend class mojo::internal::MessageFragment<AudioData_Data>;

  AudioData_Data();
  ~AudioData_Data() = delete;
};
static_assert(sizeof(AudioData_Data) == 32,
              "Bad sizeof(AudioData_Data)");
// Used by AudioData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AudioData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AudioData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AudioData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AudioData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AudioData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SpeechRecognitionResult_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> transcript;
  uint8_t is_final : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<SpeechRecognitionResult_Data>;

  SpeechRecognitionResult_Data();
  ~SpeechRecognitionResult_Data() = delete;
};
static_assert(sizeof(SpeechRecognitionResult_Data) == 24,
              "Bad sizeof(SpeechRecognitionResult_Data)");
// Used by SpeechRecognitionResult::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SpeechRecognitionResult_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SpeechRecognitionResult_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SpeechRecognitionResult_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SpeechRecognitionResult_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SpeechRecognitionResult_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  AsrStreamOptions_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t sample_rate_hz;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> language;

 private:
  friend class mojo::internal::MessageFragment<AsrStreamOptions_Data>;

  AsrStreamOptions_Data();
  ~AsrStreamOptions_Data() = delete;
};
static_assert(sizeof(AsrStreamOptions_Data) == 24,
              "Bad sizeof(AsrStreamOptions_Data)");
// Used by AsrStreamOptions::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AsrStreamOptions_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AsrStreamOptions_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AsrStreamOptions_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AsrStreamOptions_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AsrStreamOptions_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  DevicePerformanceInfo_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t performance_class;
  uint8_t pad0_[4];
  uint64_t vram_mb;

 private:
  friend class mojo::internal::MessageFragment<DevicePerformanceInfo_Data>;

  DevicePerformanceInfo_Data();
  ~DevicePerformanceInfo_Data() = delete;
};
static_assert(sizeof(DevicePerformanceInfo_Data) == 24,
              "Bad sizeof(DevicePerformanceInfo_Data)");
// Used by DevicePerformanceInfo::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct DevicePerformanceInfo_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  DevicePerformanceInfo_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~DevicePerformanceInfo_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<DevicePerformanceInfo_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    DevicePerformanceInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  DeviceInfo_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t vendor_id;
  int32_t device_id;
  mojo::internal::Pointer<mojo::internal::String_Data> driver_version;
  uint8_t supports_fp16 : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<DeviceInfo_Data>;

  DeviceInfo_Data();
  ~DeviceInfo_Data() = delete;
};
static_assert(sizeof(DeviceInfo_Data) == 32,
              "Bad sizeof(DeviceInfo_Data)");
// Used by DeviceInfo::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct DeviceInfo_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  DeviceInfo_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~DeviceInfo_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<DeviceInfo_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    DeviceInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};

#pragma pack(pop)

}  // namespace internal

}  // on_device_model::mojom

#endif  // SERVICES_ON_DEVICE_MODEL_PUBLIC_MOJOM_ON_DEVICE_MODEL_MOJOM_SHARED_INTERNAL_H_