// This file is generated by TypeBuilder_h.template.

// 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 protocol_Ads_h
#define protocol_Ads_h

#include "chrome/browser/devtools/protocol/protocol.h"
// For each imported domain we generate a ValueConversions struct instead of a full domain definition
// and include Domain::API version from there.
#include "chrome/browser/devtools/protocol/page.h"

namespace protocol {
namespace Ads {
class AdFrameData;
class AdMetrics;

// ------------- Forward and enum declarations.

// ------------- Type and builder declarations.

class  AdFrameData : public ::crdtp::ProtocolObject<AdFrameData> {
public:
    ~AdFrameData() override;  // Defined below

    String GetFrameId() { return m_frameId; }
    void SetFrameId(const String& value);  // Defined below

    bool HasInitialOrigin() { return !!m_initialOrigin; }
    String GetInitialOrigin(const String& defaultValue) const {
       return m_initialOrigin.value_or(defaultValue);
    }
    const std::optional<String>& GetInitialOrigin() const {
       return m_initialOrigin;
    }
    void SetInitialOrigin(const String& value);  // Defined below

    double GetNetworkBytes() { return m_networkBytes; }
    void SetNetworkBytes(double value);  // Defined below

    double GetCpuTime() { return m_cpuTime; }
    void SetCpuTime(double value);  // Defined below

    template<int STATE>
    class AdFrameDataBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            FrameIdSet = 1 << 1,
            NetworkBytesSet = 1 << 2,
            CpuTimeSet = 1 << 3,
            AllFieldsSet = (FrameIdSet | NetworkBytesSet | CpuTimeSet | 0)};


        AdFrameDataBuilder<STATE | FrameIdSet>& SetFrameId(const String& value);  // Defined below

        AdFrameDataBuilder<STATE>& SetInitialOrigin(const String& value);  // Defined below

        AdFrameDataBuilder<STATE | NetworkBytesSet>& SetNetworkBytes(double value);  // Defined below

        AdFrameDataBuilder<STATE | CpuTimeSet>& SetCpuTime(double value);  // Defined below

        std::unique_ptr<AdFrameData> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class AdFrameData;
        AdFrameDataBuilder() : m_result(new AdFrameData()) { }

        template<int STEP> AdFrameDataBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<AdFrameDataBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Ads::AdFrameData> m_result;
    };

    static AdFrameDataBuilder<0> Create()
    {
        return AdFrameDataBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    AdFrameData();  // Defined below

    String m_frameId;
    std::optional<String> m_initialOrigin;
    double m_networkBytes;
    double m_cpuTime;
};


class  AdMetrics : public ::crdtp::ProtocolObject<AdMetrics> {
public:
    ~AdMetrics() override;  // Defined below

    int GetViewportAdDensityByArea() { return m_viewportAdDensityByArea; }
    void SetViewportAdDensityByArea(int value);  // Defined below

    double GetAverageViewportAdDensityByArea() { return m_averageViewportAdDensityByArea; }
    void SetAverageViewportAdDensityByArea(double value);  // Defined below

    int GetViewportAdCount() { return m_viewportAdCount; }
    void SetViewportAdCount(int value);  // Defined below

    double GetAverageViewportAdCount() { return m_averageViewportAdCount; }
    void SetAverageViewportAdCount(double value);  // Defined below

    double GetTotalAdCpuTime() { return m_totalAdCpuTime; }
    void SetTotalAdCpuTime(double value);  // Defined below

    double GetTotalAdNetworkBytes() { return m_totalAdNetworkBytes; }
    void SetTotalAdNetworkBytes(double value);  // Defined below

    protocol::Array<protocol::Ads::AdFrameData>* GetUpdateAdFrames() { return m_updateAdFrames.get(); }
    void SetUpdateAdFrames(std::unique_ptr<protocol::Array<protocol::Ads::AdFrameData>> value);  // Defined below

    protocol::Array<String>* GetRemoveAdFrames() { return m_removeAdFrames.get(); }
    void SetRemoveAdFrames(std::unique_ptr<protocol::Array<String>> value);  // Defined below

    template<int STATE>
    class AdMetricsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ViewportAdDensityByAreaSet = 1 << 1,
            AverageViewportAdDensityByAreaSet = 1 << 2,
            ViewportAdCountSet = 1 << 3,
            AverageViewportAdCountSet = 1 << 4,
            TotalAdCpuTimeSet = 1 << 5,
            TotalAdNetworkBytesSet = 1 << 6,
            UpdateAdFramesSet = 1 << 7,
            RemoveAdFramesSet = 1 << 8,
            AllFieldsSet = (ViewportAdDensityByAreaSet | AverageViewportAdDensityByAreaSet | ViewportAdCountSet | AverageViewportAdCountSet | TotalAdCpuTimeSet | TotalAdNetworkBytesSet | UpdateAdFramesSet | RemoveAdFramesSet | 0)};


        AdMetricsBuilder<STATE | ViewportAdDensityByAreaSet>& SetViewportAdDensityByArea(int value);  // Defined below

        AdMetricsBuilder<STATE | AverageViewportAdDensityByAreaSet>& SetAverageViewportAdDensityByArea(double value);  // Defined below

        AdMetricsBuilder<STATE | ViewportAdCountSet>& SetViewportAdCount(int value);  // Defined below

        AdMetricsBuilder<STATE | AverageViewportAdCountSet>& SetAverageViewportAdCount(double value);  // Defined below

        AdMetricsBuilder<STATE | TotalAdCpuTimeSet>& SetTotalAdCpuTime(double value);  // Defined below

        AdMetricsBuilder<STATE | TotalAdNetworkBytesSet>& SetTotalAdNetworkBytes(double value);  // Defined below

        AdMetricsBuilder<STATE | UpdateAdFramesSet>& SetUpdateAdFrames(std::unique_ptr<protocol::Array<protocol::Ads::AdFrameData>> value);  // Defined below

        AdMetricsBuilder<STATE | RemoveAdFramesSet>& SetRemoveAdFrames(std::unique_ptr<protocol::Array<String>> value);  // Defined below

        std::unique_ptr<AdMetrics> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class AdMetrics;
        AdMetricsBuilder() : m_result(new AdMetrics()) { }

        template<int STEP> AdMetricsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<AdMetricsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Ads::AdMetrics> m_result;
    };

    static AdMetricsBuilder<0> Create()
    {
        return AdMetricsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    AdMetrics();  // Defined below

    int m_viewportAdDensityByArea;
    double m_averageViewportAdDensityByArea;
    int m_viewportAdCount;
    double m_averageViewportAdCount;
    double m_totalAdCpuTime;
    double m_totalAdNetworkBytes;
    std::unique_ptr<protocol::Array<protocol::Ads::AdFrameData>> m_updateAdFrames;
    std::unique_ptr<protocol::Array<String>> m_removeAdFrames;
};


// ------------- Type and builder method definitions.
//
// These methods separate from the type declaration because of
// https://github.com/llvm/llvm-project/issues/59966. The DevTools protocol has
// mutually recursive types, so we cannot simply reorder the types.
inline AdFrameData::~AdFrameData() = default;
inline void AdFrameData::SetFrameId(const String& value) { m_frameId = value; }
inline void AdFrameData::SetInitialOrigin(const String& value) { m_initialOrigin = value; }
inline void AdFrameData::SetNetworkBytes(double value) { m_networkBytes = value; }
inline void AdFrameData::SetCpuTime(double value) { m_cpuTime = value; }

template<int STATE>
inline AdFrameData::AdFrameDataBuilder<STATE | AdFrameData::AdFrameDataBuilder<STATE>::FrameIdSet>&
AdFrameData::AdFrameDataBuilder<STATE>::SetFrameId(const String& value) {
  static_assert(!(STATE & FrameIdSet), "property frameId should not be set yet");
  m_result->SetFrameId(value);
  return castState<FrameIdSet>();
}
template<int STATE>
inline AdFrameData::AdFrameDataBuilder<STATE>& AdFrameData::AdFrameDataBuilder<STATE>::SetInitialOrigin(const String& value) {
  m_result->SetInitialOrigin(value);
  return *this;
}
template<int STATE>
inline AdFrameData::AdFrameDataBuilder<STATE | AdFrameData::AdFrameDataBuilder<STATE>::NetworkBytesSet>&
AdFrameData::AdFrameDataBuilder<STATE>::SetNetworkBytes(double value) {
  static_assert(!(STATE & NetworkBytesSet), "property networkBytes should not be set yet");
  m_result->SetNetworkBytes(value);
  return castState<NetworkBytesSet>();
}
template<int STATE>
inline AdFrameData::AdFrameDataBuilder<STATE | AdFrameData::AdFrameDataBuilder<STATE>::CpuTimeSet>&
AdFrameData::AdFrameDataBuilder<STATE>::SetCpuTime(double value) {
  static_assert(!(STATE & CpuTimeSet), "property cpuTime should not be set yet");
  m_result->SetCpuTime(value);
  return castState<CpuTimeSet>();
}

inline AdFrameData::AdFrameData() {
  m_networkBytes = 0;
  m_cpuTime = 0;
}
inline AdMetrics::~AdMetrics() = default;
inline void AdMetrics::SetViewportAdDensityByArea(int value) { m_viewportAdDensityByArea = value; }
inline void AdMetrics::SetAverageViewportAdDensityByArea(double value) { m_averageViewportAdDensityByArea = value; }
inline void AdMetrics::SetViewportAdCount(int value) { m_viewportAdCount = value; }
inline void AdMetrics::SetAverageViewportAdCount(double value) { m_averageViewportAdCount = value; }
inline void AdMetrics::SetTotalAdCpuTime(double value) { m_totalAdCpuTime = value; }
inline void AdMetrics::SetTotalAdNetworkBytes(double value) { m_totalAdNetworkBytes = value; }
inline void AdMetrics::SetUpdateAdFrames(std::unique_ptr<protocol::Array<protocol::Ads::AdFrameData>> value) { m_updateAdFrames = std::move(value); }
inline void AdMetrics::SetRemoveAdFrames(std::unique_ptr<protocol::Array<String>> value) { m_removeAdFrames = std::move(value); }

template<int STATE>
inline AdMetrics::AdMetricsBuilder<STATE | AdMetrics::AdMetricsBuilder<STATE>::ViewportAdDensityByAreaSet>&
AdMetrics::AdMetricsBuilder<STATE>::SetViewportAdDensityByArea(int value) {
  static_assert(!(STATE & ViewportAdDensityByAreaSet), "property viewportAdDensityByArea should not be set yet");
  m_result->SetViewportAdDensityByArea(value);
  return castState<ViewportAdDensityByAreaSet>();
}
template<int STATE>
inline AdMetrics::AdMetricsBuilder<STATE | AdMetrics::AdMetricsBuilder<STATE>::AverageViewportAdDensityByAreaSet>&
AdMetrics::AdMetricsBuilder<STATE>::SetAverageViewportAdDensityByArea(double value) {
  static_assert(!(STATE & AverageViewportAdDensityByAreaSet), "property averageViewportAdDensityByArea should not be set yet");
  m_result->SetAverageViewportAdDensityByArea(value);
  return castState<AverageViewportAdDensityByAreaSet>();
}
template<int STATE>
inline AdMetrics::AdMetricsBuilder<STATE | AdMetrics::AdMetricsBuilder<STATE>::ViewportAdCountSet>&
AdMetrics::AdMetricsBuilder<STATE>::SetViewportAdCount(int value) {
  static_assert(!(STATE & ViewportAdCountSet), "property viewportAdCount should not be set yet");
  m_result->SetViewportAdCount(value);
  return castState<ViewportAdCountSet>();
}
template<int STATE>
inline AdMetrics::AdMetricsBuilder<STATE | AdMetrics::AdMetricsBuilder<STATE>::AverageViewportAdCountSet>&
AdMetrics::AdMetricsBuilder<STATE>::SetAverageViewportAdCount(double value) {
  static_assert(!(STATE & AverageViewportAdCountSet), "property averageViewportAdCount should not be set yet");
  m_result->SetAverageViewportAdCount(value);
  return castState<AverageViewportAdCountSet>();
}
template<int STATE>
inline AdMetrics::AdMetricsBuilder<STATE | AdMetrics::AdMetricsBuilder<STATE>::TotalAdCpuTimeSet>&
AdMetrics::AdMetricsBuilder<STATE>::SetTotalAdCpuTime(double value) {
  static_assert(!(STATE & TotalAdCpuTimeSet), "property totalAdCpuTime should not be set yet");
  m_result->SetTotalAdCpuTime(value);
  return castState<TotalAdCpuTimeSet>();
}
template<int STATE>
inline AdMetrics::AdMetricsBuilder<STATE | AdMetrics::AdMetricsBuilder<STATE>::TotalAdNetworkBytesSet>&
AdMetrics::AdMetricsBuilder<STATE>::SetTotalAdNetworkBytes(double value) {
  static_assert(!(STATE & TotalAdNetworkBytesSet), "property totalAdNetworkBytes should not be set yet");
  m_result->SetTotalAdNetworkBytes(value);
  return castState<TotalAdNetworkBytesSet>();
}
template<int STATE>
inline AdMetrics::AdMetricsBuilder<STATE | AdMetrics::AdMetricsBuilder<STATE>::UpdateAdFramesSet>&
AdMetrics::AdMetricsBuilder<STATE>::SetUpdateAdFrames(std::unique_ptr<protocol::Array<protocol::Ads::AdFrameData>> value) {
  static_assert(!(STATE & UpdateAdFramesSet), "property updateAdFrames should not be set yet");
  m_result->SetUpdateAdFrames(std::move(value));
  return castState<UpdateAdFramesSet>();
}
template<int STATE>
inline AdMetrics::AdMetricsBuilder<STATE | AdMetrics::AdMetricsBuilder<STATE>::RemoveAdFramesSet>&
AdMetrics::AdMetricsBuilder<STATE>::SetRemoveAdFrames(std::unique_ptr<protocol::Array<String>> value) {
  static_assert(!(STATE & RemoveAdFramesSet), "property removeAdFrames should not be set yet");
  m_result->SetRemoveAdFrames(std::move(value));
  return castState<RemoveAdFramesSet>();
}

inline AdMetrics::AdMetrics() {
  m_viewportAdDensityByArea = 0;
  m_averageViewportAdDensityByArea = 0;
  m_viewportAdCount = 0;
  m_averageViewportAdCount = 0;
  m_totalAdCpuTime = 0;
  m_totalAdNetworkBytes = 0;
}

// ------------- Backend interface.

class  Backend {
public:
    virtual ~Backend() { }

    virtual DispatchResponse GetAdMetrics(std::unique_ptr<protocol::Ads::AdMetrics>* out_metrics) = 0;

    virtual DispatchResponse Disable()
    {
        return DispatchResponse::Success();
    }
};

// ------------- Frontend interface.

class  Frontend {
public:
  explicit Frontend(FrontendChannel* frontend_channel) : frontend_channel_(frontend_channel) {}

  void flush();
  void sendRawNotification(std::unique_ptr<Serializable>);
 private:
  FrontendChannel* frontend_channel_;
};

// ------------- Dispatcher.

class  Dispatcher {
public:
    static void wire(UberDispatcher*, Backend*);

private:
    Dispatcher() { }
};

// ------------- Metainfo.

class  Metainfo {
public:
    using BackendClass = Backend;
    using FrontendClass = Frontend;
    using DispatcherClass = Dispatcher;
    static const char domainName[];
    static const char commandPrefix[];
    static const char version[];
};

} // namespace Ads
} // namespace protocol

#endif // !defined(protocol_Ads_h)