// services/viz/privileged/mojom/compositing/display_private.mojom-params-data.h is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2019 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_VIZ_PRIVILEGED_MOJOM_COMPOSITING_DISPLAY_PRIVATE_MOJOM_PARAMS_DATA_H_
#define SERVICES_VIZ_PRIVILEGED_MOJOM_COMPOSITING_DISPLAY_PRIVATE_MOJOM_PARAMS_DATA_H_
#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"

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

namespace mojo::internal {
class ValidationContext;
}


namespace viz::mojom {
namespace internal {
class  DisplayPrivate_SetDisplayVisible_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  DisplayPrivate_SetDisplayVisible_Params_Data();
  ~DisplayPrivate_SetDisplayVisible_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetDisplayVisible_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetDisplayVisible_Params_Data)");
class  DisplayPrivate_Resize_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> size;

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

  DisplayPrivate_Resize_Params_Data();
  ~DisplayPrivate_Resize_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_Resize_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_Resize_Params_Data)");
class  DisplayPrivate_SetDisplayColorMatrix_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> color_matrix;

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

  DisplayPrivate_SetDisplayColorMatrix_Params_Data();
  ~DisplayPrivate_SetDisplayColorMatrix_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetDisplayColorMatrix_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetDisplayColorMatrix_Params_Data)");
class  DisplayPrivate_SetDisplayColorSpaces_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::DisplayColorSpaces_Data> display_color_spaces;

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

  DisplayPrivate_SetDisplayColorSpaces_Params_Data();
  ~DisplayPrivate_SetDisplayColorSpaces_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetDisplayColorSpaces_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetDisplayColorSpaces_Params_Data)");
class  DisplayPrivate_SetOutputIsSecure_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  DisplayPrivate_SetOutputIsSecure_Params_Data();
  ~DisplayPrivate_SetOutputIsSecure_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetOutputIsSecure_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetOutputIsSecure_Params_Data)");
class  DisplayPrivate_SetDisplayVSyncParameters_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeTicks_Data> timebase;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> interval;

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

  DisplayPrivate_SetDisplayVSyncParameters_Params_Data();
  ~DisplayPrivate_SetDisplayVSyncParameters_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetDisplayVSyncParameters_Params_Data) == 24,
              "Bad sizeof(DisplayPrivate_SetDisplayVSyncParameters_Params_Data)");
class  DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

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

  DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_Params_Data();
  ~DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_Params_Data) == 8,
              "Bad sizeof(DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_Params_Data)");
class  DisplayPrivate_UpdateRefreshRate_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float refresh_rate;
  uint8_t padfinal_[4];

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

  DisplayPrivate_UpdateRefreshRate_Params_Data();
  ~DisplayPrivate_UpdateRefreshRate_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_UpdateRefreshRate_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_UpdateRefreshRate_Params_Data)");
class  DisplayPrivate_SetAdaptiveRefreshRateInfo_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::AdaptiveRefreshRateInfo_Data> info;

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

  DisplayPrivate_SetAdaptiveRefreshRateInfo_Params_Data();
  ~DisplayPrivate_SetAdaptiveRefreshRateInfo_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetAdaptiveRefreshRateInfo_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetAdaptiveRefreshRateInfo_Params_Data)");
class  DisplayPrivate_SetSupportedRefreshRates_Params_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>> refresh_rates;

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

  DisplayPrivate_SetSupportedRefreshRates_Params_Data();
  ~DisplayPrivate_SetSupportedRefreshRates_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetSupportedRefreshRates_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetSupportedRefreshRates_Params_Data)");
class  DisplayPrivate_PreserveChildSurfaceControls_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

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

  DisplayPrivate_PreserveChildSurfaceControls_Params_Data();
  ~DisplayPrivate_PreserveChildSurfaceControls_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_PreserveChildSurfaceControls_Params_Data) == 8,
              "Bad sizeof(DisplayPrivate_PreserveChildSurfaceControls_Params_Data)");
class  DisplayPrivate_SetSwapCompletionCallbackEnabled_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  DisplayPrivate_SetSwapCompletionCallbackEnabled_Params_Data();
  ~DisplayPrivate_SetSwapCompletionCallbackEnabled_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetSwapCompletionCallbackEnabled_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetSwapCompletionCallbackEnabled_Params_Data)");
class  DisplayPrivate_AddVSyncParameterObserver_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Interface_Data observer;

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

  DisplayPrivate_AddVSyncParameterObserver_Params_Data();
  ~DisplayPrivate_AddVSyncParameterObserver_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_AddVSyncParameterObserver_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_AddVSyncParameterObserver_Params_Data)");
class  DisplayPrivate_SetDelegatedInkPointRenderer_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Handle_Data receiver;
  uint8_t padfinal_[4];

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

  DisplayPrivate_SetDelegatedInkPointRenderer_Params_Data();
  ~DisplayPrivate_SetDelegatedInkPointRenderer_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetDelegatedInkPointRenderer_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetDelegatedInkPointRenderer_Params_Data)");
class  DisplayPrivate_SetStandaloneBeginFrameObserver_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Interface_Data observer;

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

  DisplayPrivate_SetStandaloneBeginFrameObserver_Params_Data();
  ~DisplayPrivate_SetStandaloneBeginFrameObserver_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetStandaloneBeginFrameObserver_Params_Data) == 16,
              "Bad sizeof(DisplayPrivate_SetStandaloneBeginFrameObserver_Params_Data)");
class  DisplayPrivate_SetMaxVSyncAndVrr_Params_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> max_vsync_interval;
  int32_t vrr_state;
  uint8_t padfinal_[4];

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

  DisplayPrivate_SetMaxVSyncAndVrr_Params_Data();
  ~DisplayPrivate_SetMaxVSyncAndVrr_Params_Data() = delete;
};
static_assert(sizeof(DisplayPrivate_SetMaxVSyncAndVrr_Params_Data) == 24,
              "Bad sizeof(DisplayPrivate_SetMaxVSyncAndVrr_Params_Data)");
class  DisplayClient_DidCompleteSwapWithSize_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> size;

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

  DisplayClient_DidCompleteSwapWithSize_Params_Data();
  ~DisplayClient_DidCompleteSwapWithSize_Params_Data() = delete;
};
static_assert(sizeof(DisplayClient_DidCompleteSwapWithSize_Params_Data) == 16,
              "Bad sizeof(DisplayClient_DidCompleteSwapWithSize_Params_Data)");
class  DisplayClient_OnContextCreationResult_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t result;
  uint8_t padfinal_[4];

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

  DisplayClient_OnContextCreationResult_Params_Data();
  ~DisplayClient_OnContextCreationResult_Params_Data() = delete;
};
static_assert(sizeof(DisplayClient_OnContextCreationResult_Params_Data) == 16,
              "Bad sizeof(DisplayClient_OnContextCreationResult_Params_Data)");
class  DisplayClient_SetWideColorEnabled_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  DisplayClient_SetWideColorEnabled_Params_Data();
  ~DisplayClient_SetWideColorEnabled_Params_Data() = delete;
};
static_assert(sizeof(DisplayClient_SetWideColorEnabled_Params_Data) == 16,
              "Bad sizeof(DisplayClient_SetWideColorEnabled_Params_Data)");
class  DisplayClient_SetPreferredRefreshRate_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float refresh_rate;
  uint8_t padfinal_[4];

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

  DisplayClient_SetPreferredRefreshRate_Params_Data();
  ~DisplayClient_SetPreferredRefreshRate_Params_Data() = delete;
};
static_assert(sizeof(DisplayClient_SetPreferredRefreshRate_Params_Data) == 16,
              "Bad sizeof(DisplayClient_SetPreferredRefreshRate_Params_Data)");

}  // namespace internal


class DisplayPrivate_SetDisplayVisible_ParamsDataView {
 public:
  DisplayPrivate_SetDisplayVisible_ParamsDataView() = default;

  DisplayPrivate_SetDisplayVisible_ParamsDataView(
      internal::DisplayPrivate_SetDisplayVisible_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool visible() const {
    return data_->visible;
  }
 private:
  internal::DisplayPrivate_SetDisplayVisible_Params_Data* data_ = nullptr;
};


class DisplayPrivate_Resize_ParamsDataView {
 public:
  DisplayPrivate_Resize_ParamsDataView() = default;

  DisplayPrivate_Resize_ParamsDataView(
      internal::DisplayPrivate_Resize_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetSizeDataView(
      ::gfx::mojom::SizeDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSize(UserType* output) {
    
    auto* pointer = data_->size.Get();
    return mojo::internal::Deserialize<::gfx::mojom::SizeDataView>(
        pointer, output, message_);
  }
 private:
  internal::DisplayPrivate_Resize_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_SetDisplayColorMatrix_ParamsDataView {
 public:
  DisplayPrivate_SetDisplayColorMatrix_ParamsDataView() = default;

  DisplayPrivate_SetDisplayColorMatrix_ParamsDataView(
      internal::DisplayPrivate_SetDisplayColorMatrix_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetColorMatrixDataView(
      ::gfx::mojom::TransformDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadColorMatrix(UserType* output) {
    
    auto* pointer = data_->color_matrix.Get();
    return mojo::internal::Deserialize<::gfx::mojom::TransformDataView>(
        pointer, output, message_);
  }
 private:
  internal::DisplayPrivate_SetDisplayColorMatrix_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_SetDisplayColorSpaces_ParamsDataView {
 public:
  DisplayPrivate_SetDisplayColorSpaces_ParamsDataView() = default;

  DisplayPrivate_SetDisplayColorSpaces_ParamsDataView(
      internal::DisplayPrivate_SetDisplayColorSpaces_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDisplayColorSpacesDataView(
      ::gfx::mojom::DisplayColorSpacesDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDisplayColorSpaces(UserType* output) {
    
    auto* pointer = data_->display_color_spaces.Get();
    return mojo::internal::Deserialize<::gfx::mojom::DisplayColorSpacesDataView>(
        pointer, output, message_);
  }
 private:
  internal::DisplayPrivate_SetDisplayColorSpaces_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_SetOutputIsSecure_ParamsDataView {
 public:
  DisplayPrivate_SetOutputIsSecure_ParamsDataView() = default;

  DisplayPrivate_SetOutputIsSecure_ParamsDataView(
      internal::DisplayPrivate_SetOutputIsSecure_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool secure() const {
    return data_->secure;
  }
 private:
  internal::DisplayPrivate_SetOutputIsSecure_Params_Data* data_ = nullptr;
};


class DisplayPrivate_SetDisplayVSyncParameters_ParamsDataView {
 public:
  DisplayPrivate_SetDisplayVSyncParameters_ParamsDataView() = default;

  DisplayPrivate_SetDisplayVSyncParameters_ParamsDataView(
      internal::DisplayPrivate_SetDisplayVSyncParameters_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetTimebaseDataView(
      ::mojo_base::mojom::TimeTicksDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadTimebase(UserType* output) {
    
    auto* pointer = data_->timebase.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::TimeTicksDataView>(
        pointer, output, message_);
  }
  inline void GetIntervalDataView(
      ::mojo_base::mojom::TimeDeltaDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadInterval(UserType* output) {
    
    auto* pointer = data_->interval.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::TimeDeltaDataView>(
        pointer, output, message_);
  }
 private:
  internal::DisplayPrivate_SetDisplayVSyncParameters_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_ParamsDataView {
 public:
  DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_ParamsDataView() = default;

  DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_ParamsDataView(
      internal::DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::DisplayPrivate_ForceImmediateDrawAndSwapIfPossible_Params_Data* data_ = nullptr;
};


class DisplayPrivate_UpdateRefreshRate_ParamsDataView {
 public:
  DisplayPrivate_UpdateRefreshRate_ParamsDataView() = default;

  DisplayPrivate_UpdateRefreshRate_ParamsDataView(
      internal::DisplayPrivate_UpdateRefreshRate_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  float refresh_rate() const {
    return data_->refresh_rate;
  }
 private:
  internal::DisplayPrivate_UpdateRefreshRate_Params_Data* data_ = nullptr;
};


class DisplayPrivate_SetAdaptiveRefreshRateInfo_ParamsDataView {
 public:
  DisplayPrivate_SetAdaptiveRefreshRateInfo_ParamsDataView() = default;

  DisplayPrivate_SetAdaptiveRefreshRateInfo_ParamsDataView(
      internal::DisplayPrivate_SetAdaptiveRefreshRateInfo_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetInfoDataView(
      AdaptiveRefreshRateInfoDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadInfo(UserType* output) {
    
    auto* pointer = data_->info.Get();
    return mojo::internal::Deserialize<::viz::mojom::AdaptiveRefreshRateInfoDataView>(
        pointer, output, message_);
  }
 private:
  internal::DisplayPrivate_SetAdaptiveRefreshRateInfo_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_SetSupportedRefreshRates_ParamsDataView {
 public:
  DisplayPrivate_SetSupportedRefreshRates_ParamsDataView() = default;

  DisplayPrivate_SetSupportedRefreshRates_ParamsDataView(
      internal::DisplayPrivate_SetSupportedRefreshRates_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetRefreshRatesDataView(
      mojo::ArrayDataView<float>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadRefreshRates(UserType* output) {
    
    auto* pointer = data_->refresh_rates.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<float>>(
        pointer, output, message_);
  }
 private:
  internal::DisplayPrivate_SetSupportedRefreshRates_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_PreserveChildSurfaceControls_ParamsDataView {
 public:
  DisplayPrivate_PreserveChildSurfaceControls_ParamsDataView() = default;

  DisplayPrivate_PreserveChildSurfaceControls_ParamsDataView(
      internal::DisplayPrivate_PreserveChildSurfaceControls_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::DisplayPrivate_PreserveChildSurfaceControls_Params_Data* data_ = nullptr;
};


class DisplayPrivate_SetSwapCompletionCallbackEnabled_ParamsDataView {
 public:
  DisplayPrivate_SetSwapCompletionCallbackEnabled_ParamsDataView() = default;

  DisplayPrivate_SetSwapCompletionCallbackEnabled_ParamsDataView(
      internal::DisplayPrivate_SetSwapCompletionCallbackEnabled_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool enable() const {
    return data_->enable;
  }
 private:
  internal::DisplayPrivate_SetSwapCompletionCallbackEnabled_Params_Data* data_ = nullptr;
};


class DisplayPrivate_AddVSyncParameterObserver_ParamsDataView {
 public:
  DisplayPrivate_AddVSyncParameterObserver_ParamsDataView() = default;

  DisplayPrivate_AddVSyncParameterObserver_ParamsDataView(
      internal::DisplayPrivate_AddVSyncParameterObserver_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeObserver() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<mojo::InterfacePtrDataView<::viz::mojom::VSyncParameterObserverInterfaceBase>>(
            &data_->observer, &result, message_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::DisplayPrivate_AddVSyncParameterObserver_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_SetDelegatedInkPointRenderer_ParamsDataView {
 public:
  DisplayPrivate_SetDelegatedInkPointRenderer_ParamsDataView() = default;

  DisplayPrivate_SetDelegatedInkPointRenderer_ParamsDataView(
      internal::DisplayPrivate_SetDelegatedInkPointRenderer_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeReceiver() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<mojo::InterfaceRequestDataView<::gfx::mojom::DelegatedInkPointRendererInterfaceBase>>(
            &data_->receiver, &result, message_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::DisplayPrivate_SetDelegatedInkPointRenderer_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_SetStandaloneBeginFrameObserver_ParamsDataView {
 public:
  DisplayPrivate_SetStandaloneBeginFrameObserver_ParamsDataView() = default;

  DisplayPrivate_SetStandaloneBeginFrameObserver_ParamsDataView(
      internal::DisplayPrivate_SetStandaloneBeginFrameObserver_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeObserver() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<mojo::InterfacePtrDataView<::viz::mojom::BeginFrameObserverInterfaceBase>>(
            &data_->observer, &result, message_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::DisplayPrivate_SetStandaloneBeginFrameObserver_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayPrivate_SetMaxVSyncAndVrr_ParamsDataView {
 public:
  DisplayPrivate_SetMaxVSyncAndVrr_ParamsDataView() = default;

  DisplayPrivate_SetMaxVSyncAndVrr_ParamsDataView(
      internal::DisplayPrivate_SetMaxVSyncAndVrr_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetMaxVsyncIntervalDataView(
      ::mojo_base::mojom::TimeDeltaDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadMaxVsyncInterval(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::mojo_base::mojom::TimeDeltaDataView, UserType>(),
    "Attempting to read the optional `max_vsync_interval` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadMaxVsyncInterval` instead "
    "of `ReadMaxVsyncInterval if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->max_vsync_interval.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::TimeDeltaDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadVrrState(UserType* output) const {
    auto data_value = data_->vrr_state;
    return mojo::internal::Deserialize<::display::mojom::VariableRefreshRateState>(
        data_value, output);
  }
  ::display::mojom::VariableRefreshRateState vrr_state() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::display::mojom::VariableRefreshRateState>(data_->vrr_state));
  }
 private:
  internal::DisplayPrivate_SetMaxVSyncAndVrr_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayClient_DidCompleteSwapWithSize_ParamsDataView {
 public:
  DisplayClient_DidCompleteSwapWithSize_ParamsDataView() = default;

  DisplayClient_DidCompleteSwapWithSize_ParamsDataView(
      internal::DisplayClient_DidCompleteSwapWithSize_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetSizeDataView(
      ::gfx::mojom::SizeDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSize(UserType* output) {
    
    auto* pointer = data_->size.Get();
    return mojo::internal::Deserialize<::gfx::mojom::SizeDataView>(
        pointer, output, message_);
  }
 private:
  internal::DisplayClient_DidCompleteSwapWithSize_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DisplayClient_OnContextCreationResult_ParamsDataView {
 public:
  DisplayClient_OnContextCreationResult_ParamsDataView() = default;

  DisplayClient_OnContextCreationResult_ParamsDataView(
      internal::DisplayClient_OnContextCreationResult_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::gpu::mojom::ContextResult>(
        data_value, output);
  }
  ::gpu::mojom::ContextResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::gpu::mojom::ContextResult>(data_->result));
  }
 private:
  internal::DisplayClient_OnContextCreationResult_Params_Data* data_ = nullptr;
};


class DisplayClient_SetWideColorEnabled_ParamsDataView {
 public:
  DisplayClient_SetWideColorEnabled_ParamsDataView() = default;

  DisplayClient_SetWideColorEnabled_ParamsDataView(
      internal::DisplayClient_SetWideColorEnabled_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool enabled() const {
    return data_->enabled;
  }
 private:
  internal::DisplayClient_SetWideColorEnabled_Params_Data* data_ = nullptr;
};


class DisplayClient_SetPreferredRefreshRate_ParamsDataView {
 public:
  DisplayClient_SetPreferredRefreshRate_ParamsDataView() = default;

  DisplayClient_SetPreferredRefreshRate_ParamsDataView(
      internal::DisplayClient_SetPreferredRefreshRate_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  float refresh_rate() const {
    return data_->refresh_rate;
  }
 private:
  internal::DisplayClient_SetPreferredRefreshRate_Params_Data* data_ = nullptr;
};



inline void DisplayPrivate_Resize_ParamsDataView::GetSizeDataView(
    ::gfx::mojom::SizeDataView* output) {
  auto pointer = data_->size.Get();
  *output = ::gfx::mojom::SizeDataView(pointer, message_);
}


inline void DisplayPrivate_SetDisplayColorMatrix_ParamsDataView::GetColorMatrixDataView(
    ::gfx::mojom::TransformDataView* output) {
  auto pointer = data_->color_matrix.Get();
  *output = ::gfx::mojom::TransformDataView(pointer, message_);
}


inline void DisplayPrivate_SetDisplayColorSpaces_ParamsDataView::GetDisplayColorSpacesDataView(
    ::gfx::mojom::DisplayColorSpacesDataView* output) {
  auto pointer = data_->display_color_spaces.Get();
  *output = ::gfx::mojom::DisplayColorSpacesDataView(pointer, message_);
}




inline void DisplayPrivate_SetDisplayVSyncParameters_ParamsDataView::GetTimebaseDataView(
    ::mojo_base::mojom::TimeTicksDataView* output) {
  auto pointer = data_->timebase.Get();
  *output = ::mojo_base::mojom::TimeTicksDataView(pointer, message_);
}
inline void DisplayPrivate_SetDisplayVSyncParameters_ParamsDataView::GetIntervalDataView(
    ::mojo_base::mojom::TimeDeltaDataView* output) {
  auto pointer = data_->interval.Get();
  *output = ::mojo_base::mojom::TimeDeltaDataView(pointer, message_);
}






inline void DisplayPrivate_SetAdaptiveRefreshRateInfo_ParamsDataView::GetInfoDataView(
    AdaptiveRefreshRateInfoDataView* output) {
  auto pointer = data_->info.Get();
  *output = AdaptiveRefreshRateInfoDataView(pointer, message_);
}


inline void DisplayPrivate_SetSupportedRefreshRates_ParamsDataView::GetRefreshRatesDataView(
    mojo::ArrayDataView<float>* output) {
  auto pointer = data_->refresh_rates.Get();
  *output = mojo::ArrayDataView<float>(pointer, message_);
}












inline void DisplayPrivate_SetMaxVSyncAndVrr_ParamsDataView::GetMaxVsyncIntervalDataView(
    ::mojo_base::mojom::TimeDeltaDataView* output) {
  auto pointer = data_->max_vsync_interval.Get();
  *output = ::mojo_base::mojom::TimeDeltaDataView(pointer, message_);
}


inline void DisplayClient_DidCompleteSwapWithSize_ParamsDataView::GetSizeDataView(
    ::gfx::mojom::SizeDataView* output) {
  auto pointer = data_->size.Get();
  *output = ::gfx::mojom::SizeDataView(pointer, message_);
}









}  // viz::mojom

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

#endif  // SERVICES_VIZ_PRIVILEGED_MOJOM_COMPOSITING_DISPLAY_PRIVATE_MOJOM_PARAMS_DATA_H_