// third_party/blink/public/mojom/handwriting/handwriting.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 THIRD_PARTY_BLINK_PUBLIC_MOJOM_HANDWRITING_HANDWRITING_MOJOM_SHARED_INTERNAL_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_HANDWRITING_HANDWRITING_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/mojom/base/time.mojom-shared-internal.h"
#include "ui/gfx/geometry/mojom/geometry.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"
#include "base/component_export.h"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace handwriting::mojom {
namespace internal {
class HandwritingPoint_Data;
class HandwritingStroke_Data;
class HandwritingDrawingSegment_Data;
class HandwritingSegment_Data;
class HandwritingPrediction_Data;
class HandwritingHints_Data;
class HandwritingHintsQueryResult_Data;
class QueryHandwritingRecognizerResult_Data;
class HandwritingModelConstraint_Data;

struct HandwritingRecognitionType_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
        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 HandwritingInputType_Data {
 public:
  static bool constexpr kIsExtensible = false;

  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 CreateHandwritingRecognizerResult_Data {
 public:
  static bool constexpr kIsExtensible = false;

  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;
  }
};

#pragma pack(push, 1)
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) HandwritingPoint_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::PointF_Data> location;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> t;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::HandwritingPoint_Data>>> points;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t stroke_index;
  uint32_t begin_point_index;
  uint32_t end_point_index;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> grapheme;
  uint32_t begin_index;
  uint32_t end_index;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::HandwritingDrawingSegment_Data>>> drawing_segments;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    HandwritingSegment_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) HandwritingPrediction_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<mojo::internal::Array_Data<mojo::internal::Pointer<internal::HandwritingSegment_Data>>> segmentation_result;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> recognition_type;
  mojo::internal::Pointer<mojo::internal::String_Data> input_type;
  mojo::internal::Pointer<mojo::internal::String_Data> text_context;
  uint32_t alternatives;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> recognition_type;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> input_type;
  uint8_t text_context : 1;
  uint8_t alternatives : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t text_alternatives : 1;
  uint8_t text_segmentation : 1;
  uint8_t pad1_[7];
  mojo::internal::Pointer<internal::HandwritingHintsQueryResult_Data> hints;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> languages;

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

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

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

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

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

  UserType user_data_;
};

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

#pragma pack(pop)

}  // namespace internal

}  // handwriting::mojom

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_HANDWRITING_HANDWRITING_MOJOM_SHARED_INTERNAL_H_