// media/mojo/mojom/speech_recognition.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 MEDIA_MOJO_MOJOM_SPEECH_RECOGNITION_MOJOM_SHARED_INTERNAL_H_
#define MEDIA_MOJO_MOJOM_SPEECH_RECOGNITION_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 "media/mojo/mojom/audio_data.mojom-shared-internal.h"
#include "media/mojo/mojom/speech_recognition_audio_forwarder.mojom-shared-internal.h"
#include "media/mojo/mojom/speech_recognition_recognition_context.mojom-shared-internal.h"
#include "media/mojo/mojom/speech_recognizer.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.mojom-shared-internal.h"
#include "mojo/public/mojom/base/unguessable_token.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"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace media::mojom {
namespace internal {
class HypothesisParts_Data;
class MediaTimestampRange_Data;
class TimingInformation_Data;
class SpeechRecognitionResult_Data;
class LanguageIdentificationEvent_Data;
class SpeechRecognitionOptions_Data;

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

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

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

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

#pragma pack(push, 1)
class  HypothesisParts_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>>> text;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> hypothesis_part_offset;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> start;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> end;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> audio_start_time;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> audio_end_time;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::HypothesisParts_Data>>> hypothesis_parts;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::MediaTimestampRange_Data>>> originating_media_timestamps;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    TimingInformation_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> transcription;
  uint8_t is_final : 1;
  uint8_t pad1_[7];
  mojo::internal::Pointer<internal::TimingInformation_Data> timing_information;

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

  SpeechRecognitionResult_Data();
  ~SpeechRecognitionResult_Data() = delete;
};
static_assert(sizeof(SpeechRecognitionResult_Data) == 32,
              "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  LanguageIdentificationEvent_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> language;
  int32_t confidence_level;
  uint8_t asr_switch_result_$flag : 1;
  uint8_t pad2_[3];
  int32_t asr_switch_result_$value;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t recognition_mode;
  uint8_t enable_formatting : 1;
  uint8_t is_server_based : 1;
  uint8_t skip_continuously_empty_audio : 1;
  uint8_t allow_multi_language : 1;
  uint8_t pad4_[3];
  mojo::internal::Pointer<mojo::internal::String_Data> language;
  int32_t recognizer_client_type;
  int32_t channel_count;
  mojo::internal::Pointer<mojo::internal::String_Data> experiment_recognizer_routing_key;
  int32_t sample_rate;
  uint8_t pad9_[4];
  mojo::internal::Pointer<::media::mojom::internal::SpeechRecognitionRecognitionContext_Data> recognition_context;

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

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

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

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

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

  UserType user_data_;
};

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

#pragma pack(pop)

}  // namespace internal

}  // media::mojom

#endif  // MEDIA_MOJO_MOJOM_SPEECH_RECOGNITION_MOJOM_SHARED_INTERNAL_H_