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

#include "content/common/content_export.h"
#include "content/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 "content/browser/devtools/protocol/target.h"

namespace content {
namespace protocol {
namespace ServiceWorker {
using RegistrationID = String;
class ServiceWorkerRegistration;
using ServiceWorkerVersionRunningStatus = String;
using ServiceWorkerVersionStatus = String;
class ServiceWorkerRouterCondition;
using ServiceWorkerRouterSourceType = String;
class ServiceWorkerRouterSourceDict;
class ServiceWorkerRouterSource;
class ServiceWorkerRouterRule;
class ServiceWorkerVersion;
class ServiceWorkerErrorMessage;

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

namespace ServiceWorkerVersionRunningStatusEnum {
inline constexpr char Stopped[] = "stopped";
inline constexpr char Starting[] = "starting";
inline constexpr char Running[] = "running";
inline constexpr char Stopping[] = "stopping";
} // namespace ServiceWorkerVersionRunningStatusEnum

namespace ServiceWorkerVersionStatusEnum {
inline constexpr char New[] = "new";
inline constexpr char Installing[] = "installing";
inline constexpr char Installed[] = "installed";
inline constexpr char Activating[] = "activating";
inline constexpr char Activated[] = "activated";
inline constexpr char Redundant[] = "redundant";
} // namespace ServiceWorkerVersionStatusEnum

namespace ServiceWorkerRouterSourceTypeEnum {
inline constexpr char Cache[] = "cache";
inline constexpr char FetchEvent[] = "fetchEvent";
inline constexpr char Network[] = "network";
inline constexpr char RaceNetworkAndFetchHandler[] = "raceNetworkAndFetchHandler";
inline constexpr char RaceNetworkAndCache[] = "raceNetworkAndCache";
inline constexpr char SourceDict[] = "sourceDict";
} // namespace ServiceWorkerRouterSourceTypeEnum

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

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

    String GetRegistrationId() { return m_registrationId; }
    void SetRegistrationId(const String& value);  // Defined below

    String GetScopeURL() { return m_scopeURL; }
    void SetScopeURL(const String& value);  // Defined below

    bool GetIsDeleted() { return m_isDeleted; }
    void SetIsDeleted(bool value);  // Defined below

    template<int STATE>
    class ServiceWorkerRegistrationBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            RegistrationIdSet = 1 << 1,
            ScopeURLSet = 1 << 2,
            IsDeletedSet = 1 << 3,
            AllFieldsSet = (RegistrationIdSet | ScopeURLSet | IsDeletedSet | 0)};


        ServiceWorkerRegistrationBuilder<STATE | RegistrationIdSet>& SetRegistrationId(const String& value);  // Defined below

        ServiceWorkerRegistrationBuilder<STATE | ScopeURLSet>& SetScopeURL(const String& value);  // Defined below

        ServiceWorkerRegistrationBuilder<STATE | IsDeletedSet>& SetIsDeleted(bool value);  // Defined below

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

    private:
        friend class ServiceWorkerRegistration;
        ServiceWorkerRegistrationBuilder() : m_result(new ServiceWorkerRegistration()) { }

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

        std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRegistration> m_result;
    };

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

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ServiceWorkerRegistration();  // Defined below

    String m_registrationId;
    String m_scopeURL;
    bool m_isDeleted;
};


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

    bool HasUrlPattern() { return !!m_urlPattern; }
    String GetUrlPattern(const String& defaultValue) const {
       return m_urlPattern.value_or(defaultValue);
    }
    const std::optional<String>& GetUrlPattern() const {
       return m_urlPattern;
    }
    void SetUrlPattern(const String& value);  // Defined below

    bool HasRequestMethod() { return !!m_requestMethod; }
    String GetRequestMethod(const String& defaultValue) const {
       return m_requestMethod.value_or(defaultValue);
    }
    const std::optional<String>& GetRequestMethod() const {
       return m_requestMethod;
    }
    void SetRequestMethod(const String& value);  // Defined below

    bool HasRequestMode() { return !!m_requestMode; }
    String GetRequestMode(const String& defaultValue) const {
       return m_requestMode.value_or(defaultValue);
    }
    const std::optional<String>& GetRequestMode() const {
       return m_requestMode;
    }
    void SetRequestMode(const String& value);  // Defined below

    bool HasRequestDestination() { return !!m_requestDestination; }
    String GetRequestDestination(const String& defaultValue) const {
       return m_requestDestination.value_or(defaultValue);
    }
    const std::optional<String>& GetRequestDestination() const {
       return m_requestDestination;
    }
    void SetRequestDestination(const String& value);  // Defined below

    bool HasRunningStatus() { return !!m_runningStatus; }
    String GetRunningStatus(const String& defaultValue) const {
       return m_runningStatus.value_or(defaultValue);
    }
    const std::optional<String>& GetRunningStatus() const {
       return m_runningStatus;
    }
    void SetRunningStatus(const String& value);  // Defined below

    template<int STATE>
    class ServiceWorkerRouterConditionBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            AllFieldsSet = (0)};


        ServiceWorkerRouterConditionBuilder<STATE>& SetUrlPattern(const String& value);  // Defined below

        ServiceWorkerRouterConditionBuilder<STATE>& SetRequestMethod(const String& value);  // Defined below

        ServiceWorkerRouterConditionBuilder<STATE>& SetRequestMode(const String& value);  // Defined below

        ServiceWorkerRouterConditionBuilder<STATE>& SetRequestDestination(const String& value);  // Defined below

        ServiceWorkerRouterConditionBuilder<STATE>& SetRunningStatus(const String& value);  // Defined below

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

    private:
        friend class ServiceWorkerRouterCondition;
        ServiceWorkerRouterConditionBuilder() : m_result(new ServiceWorkerRouterCondition()) { }

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

        std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterCondition> m_result;
    };

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

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ServiceWorkerRouterCondition();  // Defined below

    std::optional<String> m_urlPattern;
    std::optional<String> m_requestMethod;
    std::optional<String> m_requestMode;
    std::optional<String> m_requestDestination;
    std::optional<String> m_runningStatus;
};


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

    String GetCacheName() { return m_cacheName; }
    void SetCacheName(const String& value);  // Defined below

    template<int STATE>
    class ServiceWorkerRouterSourceDictBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            CacheNameSet = 1 << 1,
            AllFieldsSet = (CacheNameSet | 0)};


        ServiceWorkerRouterSourceDictBuilder<STATE | CacheNameSet>& SetCacheName(const String& value);  // Defined below

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

    private:
        friend class ServiceWorkerRouterSourceDict;
        ServiceWorkerRouterSourceDictBuilder() : m_result(new ServiceWorkerRouterSourceDict()) { }

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

        std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSourceDict> m_result;
    };

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

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ServiceWorkerRouterSourceDict();  // Defined below

    String m_cacheName;
};


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

    String GetType() { return m_type; }
    void SetType(const String& value);  // Defined below

    bool HasSourceDict() { return !!m_sourceDict; }
    protocol::ServiceWorker::ServiceWorkerRouterSourceDict* GetSourceDict(protocol::ServiceWorker::ServiceWorkerRouterSourceDict* defaultValue) {
       return m_sourceDict ? m_sourceDict.get() : defaultValue;
    }
    const std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSourceDict>& GetSourceDict() const {
       return m_sourceDict;
    }
    void SetSourceDict(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSourceDict> value);  // Defined below

    template<int STATE>
    class ServiceWorkerRouterSourceBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            TypeSet = 1 << 1,
            AllFieldsSet = (TypeSet | 0)};


        ServiceWorkerRouterSourceBuilder<STATE | TypeSet>& SetType(const String& value);  // Defined below

        ServiceWorkerRouterSourceBuilder<STATE>& SetSourceDict(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSourceDict> value);  // Defined below

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

    private:
        friend class ServiceWorkerRouterSource;
        ServiceWorkerRouterSourceBuilder() : m_result(new ServiceWorkerRouterSource()) { }

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

        std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSource> m_result;
    };

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

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ServiceWorkerRouterSource();  // Defined below

    String m_type;
    std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSourceDict> m_sourceDict;
};


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

    protocol::ServiceWorker::ServiceWorkerRouterCondition* GetCondition() { return m_condition.get(); }
    void SetCondition(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterCondition> value);  // Defined below

    protocol::ServiceWorker::ServiceWorkerRouterSource* GetSource() { return m_source.get(); }
    void SetSource(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSource> value);  // Defined below

    int GetId() { return m_id; }
    void SetId(int value);  // Defined below

    template<int STATE>
    class ServiceWorkerRouterRuleBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ConditionSet = 1 << 1,
            SourceSet = 1 << 2,
            IdSet = 1 << 3,
            AllFieldsSet = (ConditionSet | SourceSet | IdSet | 0)};


        ServiceWorkerRouterRuleBuilder<STATE | ConditionSet>& SetCondition(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterCondition> value);  // Defined below

        ServiceWorkerRouterRuleBuilder<STATE | SourceSet>& SetSource(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSource> value);  // Defined below

        ServiceWorkerRouterRuleBuilder<STATE | IdSet>& SetId(int value);  // Defined below

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

    private:
        friend class ServiceWorkerRouterRule;
        ServiceWorkerRouterRuleBuilder() : m_result(new ServiceWorkerRouterRule()) { }

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

        std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterRule> m_result;
    };

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

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ServiceWorkerRouterRule();  // Defined below

    std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterCondition> m_condition;
    std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSource> m_source;
    int m_id;
};


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

    String GetVersionId() { return m_versionId; }
    void SetVersionId(const String& value);  // Defined below

    String GetRegistrationId() { return m_registrationId; }
    void SetRegistrationId(const String& value);  // Defined below

    String GetScriptURL() { return m_scriptURL; }
    void SetScriptURL(const String& value);  // Defined below

    String GetRunningStatus() { return m_runningStatus; }
    void SetRunningStatus(const String& value);  // Defined below

    String GetStatus() { return m_status; }
    void SetStatus(const String& value);  // Defined below

    bool HasScriptLastModified() { return !!m_scriptLastModified; }
    double GetScriptLastModified(double defaultValue) const {
       return m_scriptLastModified.value_or(defaultValue);
    }
    const std::optional<double>& GetScriptLastModified() const {
       return m_scriptLastModified;
    }
    void SetScriptLastModified(double value);  // Defined below

    bool HasScriptResponseTime() { return !!m_scriptResponseTime; }
    double GetScriptResponseTime(double defaultValue) const {
       return m_scriptResponseTime.value_or(defaultValue);
    }
    const std::optional<double>& GetScriptResponseTime() const {
       return m_scriptResponseTime;
    }
    void SetScriptResponseTime(double value);  // Defined below

    bool HasControlledClients() { return !!m_controlledClients; }
    protocol::Array<String>* GetControlledClients(protocol::Array<String>* defaultValue) {
       return m_controlledClients ? m_controlledClients.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Array<String>>& GetControlledClients() const {
       return m_controlledClients;
    }
    void SetControlledClients(std::unique_ptr<protocol::Array<String>> value);  // Defined below

    bool HasTargetId() { return !!m_targetId; }
    String GetTargetId(const String& defaultValue) const {
       return m_targetId.value_or(defaultValue);
    }
    const std::optional<String>& GetTargetId() const {
       return m_targetId;
    }
    void SetTargetId(const String& value);  // Defined below

    bool HasRouterRules() { return !!m_routerRules; }
    String GetRouterRules(const String& defaultValue) const {
       return m_routerRules.value_or(defaultValue);
    }
    const std::optional<String>& GetRouterRules() const {
       return m_routerRules;
    }
    void SetRouterRules(const String& value);  // Defined below

    bool HasTypedRouterRules() { return !!m_typedRouterRules; }
    protocol::Array<protocol::ServiceWorker::ServiceWorkerRouterRule>* GetTypedRouterRules(protocol::Array<protocol::ServiceWorker::ServiceWorkerRouterRule>* defaultValue) {
       return m_typedRouterRules ? m_typedRouterRules.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Array<protocol::ServiceWorker::ServiceWorkerRouterRule>>& GetTypedRouterRules() const {
       return m_typedRouterRules;
    }
    void SetTypedRouterRules(std::unique_ptr<protocol::Array<protocol::ServiceWorker::ServiceWorkerRouterRule>> value);  // Defined below

    template<int STATE>
    class ServiceWorkerVersionBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            VersionIdSet = 1 << 1,
            RegistrationIdSet = 1 << 2,
            ScriptURLSet = 1 << 3,
            RunningStatusSet = 1 << 4,
            StatusSet = 1 << 5,
            AllFieldsSet = (VersionIdSet | RegistrationIdSet | ScriptURLSet | RunningStatusSet | StatusSet | 0)};


        ServiceWorkerVersionBuilder<STATE | VersionIdSet>& SetVersionId(const String& value);  // Defined below

        ServiceWorkerVersionBuilder<STATE | RegistrationIdSet>& SetRegistrationId(const String& value);  // Defined below

        ServiceWorkerVersionBuilder<STATE | ScriptURLSet>& SetScriptURL(const String& value);  // Defined below

        ServiceWorkerVersionBuilder<STATE | RunningStatusSet>& SetRunningStatus(const String& value);  // Defined below

        ServiceWorkerVersionBuilder<STATE | StatusSet>& SetStatus(const String& value);  // Defined below

        ServiceWorkerVersionBuilder<STATE>& SetScriptLastModified(double value);  // Defined below

        ServiceWorkerVersionBuilder<STATE>& SetScriptResponseTime(double value);  // Defined below

        ServiceWorkerVersionBuilder<STATE>& SetControlledClients(std::unique_ptr<protocol::Array<String>> value);  // Defined below

        ServiceWorkerVersionBuilder<STATE>& SetTargetId(const String& value);  // Defined below

        ServiceWorkerVersionBuilder<STATE>& SetRouterRules(const String& value);  // Defined below

        ServiceWorkerVersionBuilder<STATE>& SetTypedRouterRules(std::unique_ptr<protocol::Array<protocol::ServiceWorker::ServiceWorkerRouterRule>> value);  // Defined below

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

    private:
        friend class ServiceWorkerVersion;
        ServiceWorkerVersionBuilder() : m_result(new ServiceWorkerVersion()) { }

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

        std::unique_ptr<protocol::ServiceWorker::ServiceWorkerVersion> m_result;
    };

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

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ServiceWorkerVersion();  // Defined below

    String m_versionId;
    String m_registrationId;
    String m_scriptURL;
    String m_runningStatus;
    String m_status;
    std::optional<double> m_scriptLastModified;
    std::optional<double> m_scriptResponseTime;
    std::unique_ptr<protocol::Array<String>> m_controlledClients;
    std::optional<String> m_targetId;
    std::optional<String> m_routerRules;
    std::unique_ptr<protocol::Array<protocol::ServiceWorker::ServiceWorkerRouterRule>> m_typedRouterRules;
};


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

    String GetErrorMessage() { return m_errorMessage; }
    void SetErrorMessage(const String& value);  // Defined below

    String GetRegistrationId() { return m_registrationId; }
    void SetRegistrationId(const String& value);  // Defined below

    String GetVersionId() { return m_versionId; }
    void SetVersionId(const String& value);  // Defined below

    String GetSourceURL() { return m_sourceURL; }
    void SetSourceURL(const String& value);  // Defined below

    int GetLineNumber() { return m_lineNumber; }
    void SetLineNumber(int value);  // Defined below

    int GetColumnNumber() { return m_columnNumber; }
    void SetColumnNumber(int value);  // Defined below

    template<int STATE>
    class ServiceWorkerErrorMessageBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ErrorMessageSet = 1 << 1,
            RegistrationIdSet = 1 << 2,
            VersionIdSet = 1 << 3,
            SourceURLSet = 1 << 4,
            LineNumberSet = 1 << 5,
            ColumnNumberSet = 1 << 6,
            AllFieldsSet = (ErrorMessageSet | RegistrationIdSet | VersionIdSet | SourceURLSet | LineNumberSet | ColumnNumberSet | 0)};


        ServiceWorkerErrorMessageBuilder<STATE | ErrorMessageSet>& SetErrorMessage(const String& value);  // Defined below

        ServiceWorkerErrorMessageBuilder<STATE | RegistrationIdSet>& SetRegistrationId(const String& value);  // Defined below

        ServiceWorkerErrorMessageBuilder<STATE | VersionIdSet>& SetVersionId(const String& value);  // Defined below

        ServiceWorkerErrorMessageBuilder<STATE | SourceURLSet>& SetSourceURL(const String& value);  // Defined below

        ServiceWorkerErrorMessageBuilder<STATE | LineNumberSet>& SetLineNumber(int value);  // Defined below

        ServiceWorkerErrorMessageBuilder<STATE | ColumnNumberSet>& SetColumnNumber(int value);  // Defined below

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

    private:
        friend class ServiceWorkerErrorMessage;
        ServiceWorkerErrorMessageBuilder() : m_result(new ServiceWorkerErrorMessage()) { }

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

        std::unique_ptr<protocol::ServiceWorker::ServiceWorkerErrorMessage> m_result;
    };

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

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ServiceWorkerErrorMessage();  // Defined below

    String m_errorMessage;
    String m_registrationId;
    String m_versionId;
    String m_sourceURL;
    int m_lineNumber;
    int m_columnNumber;
};


// ------------- 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 ServiceWorkerRegistration::~ServiceWorkerRegistration() = default;
inline void ServiceWorkerRegistration::SetRegistrationId(const String& value) { m_registrationId = value; }
inline void ServiceWorkerRegistration::SetScopeURL(const String& value) { m_scopeURL = value; }
inline void ServiceWorkerRegistration::SetIsDeleted(bool value) { m_isDeleted = value; }

template<int STATE>
inline ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE | ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE>::RegistrationIdSet>&
ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE>::SetRegistrationId(const String& value) {
  static_assert(!(STATE & RegistrationIdSet), "property registrationId should not be set yet");
  m_result->SetRegistrationId(value);
  return castState<RegistrationIdSet>();
}
template<int STATE>
inline ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE | ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE>::ScopeURLSet>&
ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE>::SetScopeURL(const String& value) {
  static_assert(!(STATE & ScopeURLSet), "property scopeURL should not be set yet");
  m_result->SetScopeURL(value);
  return castState<ScopeURLSet>();
}
template<int STATE>
inline ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE | ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE>::IsDeletedSet>&
ServiceWorkerRegistration::ServiceWorkerRegistrationBuilder<STATE>::SetIsDeleted(bool value) {
  static_assert(!(STATE & IsDeletedSet), "property isDeleted should not be set yet");
  m_result->SetIsDeleted(value);
  return castState<IsDeletedSet>();
}

inline ServiceWorkerRegistration::ServiceWorkerRegistration() {
  m_isDeleted = false;
}
inline ServiceWorkerRouterCondition::~ServiceWorkerRouterCondition() = default;
inline void ServiceWorkerRouterCondition::SetUrlPattern(const String& value) { m_urlPattern = value; }
inline void ServiceWorkerRouterCondition::SetRequestMethod(const String& value) { m_requestMethod = value; }
inline void ServiceWorkerRouterCondition::SetRequestMode(const String& value) { m_requestMode = value; }
inline void ServiceWorkerRouterCondition::SetRequestDestination(const String& value) { m_requestDestination = value; }
inline void ServiceWorkerRouterCondition::SetRunningStatus(const String& value) { m_runningStatus = value; }

template<int STATE>
inline ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>& ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>::SetUrlPattern(const String& value) {
  m_result->SetUrlPattern(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>& ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>::SetRequestMethod(const String& value) {
  m_result->SetRequestMethod(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>& ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>::SetRequestMode(const String& value) {
  m_result->SetRequestMode(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>& ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>::SetRequestDestination(const String& value) {
  m_result->SetRequestDestination(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>& ServiceWorkerRouterCondition::ServiceWorkerRouterConditionBuilder<STATE>::SetRunningStatus(const String& value) {
  m_result->SetRunningStatus(value);
  return *this;
}

inline ServiceWorkerRouterCondition::ServiceWorkerRouterCondition() {
}
inline ServiceWorkerRouterSourceDict::~ServiceWorkerRouterSourceDict() = default;
inline void ServiceWorkerRouterSourceDict::SetCacheName(const String& value) { m_cacheName = value; }

template<int STATE>
inline ServiceWorkerRouterSourceDict::ServiceWorkerRouterSourceDictBuilder<STATE | ServiceWorkerRouterSourceDict::ServiceWorkerRouterSourceDictBuilder<STATE>::CacheNameSet>&
ServiceWorkerRouterSourceDict::ServiceWorkerRouterSourceDictBuilder<STATE>::SetCacheName(const String& value) {
  static_assert(!(STATE & CacheNameSet), "property cacheName should not be set yet");
  m_result->SetCacheName(value);
  return castState<CacheNameSet>();
}

inline ServiceWorkerRouterSourceDict::ServiceWorkerRouterSourceDict() {
}
inline ServiceWorkerRouterSource::~ServiceWorkerRouterSource() = default;
inline void ServiceWorkerRouterSource::SetType(const String& value) { m_type = value; }
inline void ServiceWorkerRouterSource::SetSourceDict(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSourceDict> value) { m_sourceDict = std::move(value); }

template<int STATE>
inline ServiceWorkerRouterSource::ServiceWorkerRouterSourceBuilder<STATE | ServiceWorkerRouterSource::ServiceWorkerRouterSourceBuilder<STATE>::TypeSet>&
ServiceWorkerRouterSource::ServiceWorkerRouterSourceBuilder<STATE>::SetType(const String& value) {
  static_assert(!(STATE & TypeSet), "property type should not be set yet");
  m_result->SetType(value);
  return castState<TypeSet>();
}
template<int STATE>
inline ServiceWorkerRouterSource::ServiceWorkerRouterSourceBuilder<STATE>& ServiceWorkerRouterSource::ServiceWorkerRouterSourceBuilder<STATE>::SetSourceDict(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSourceDict> value) {
  m_result->SetSourceDict(std::move(value));
  return *this;
}

inline ServiceWorkerRouterSource::ServiceWorkerRouterSource() {
}
inline ServiceWorkerRouterRule::~ServiceWorkerRouterRule() = default;
inline void ServiceWorkerRouterRule::SetCondition(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterCondition> value) { m_condition = std::move(value); }
inline void ServiceWorkerRouterRule::SetSource(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSource> value) { m_source = std::move(value); }
inline void ServiceWorkerRouterRule::SetId(int value) { m_id = value; }

template<int STATE>
inline ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE | ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE>::ConditionSet>&
ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE>::SetCondition(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterCondition> value) {
  static_assert(!(STATE & ConditionSet), "property condition should not be set yet");
  m_result->SetCondition(std::move(value));
  return castState<ConditionSet>();
}
template<int STATE>
inline ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE | ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE>::SourceSet>&
ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE>::SetSource(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerRouterSource> value) {
  static_assert(!(STATE & SourceSet), "property source should not be set yet");
  m_result->SetSource(std::move(value));
  return castState<SourceSet>();
}
template<int STATE>
inline ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE | ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE>::IdSet>&
ServiceWorkerRouterRule::ServiceWorkerRouterRuleBuilder<STATE>::SetId(int value) {
  static_assert(!(STATE & IdSet), "property id should not be set yet");
  m_result->SetId(value);
  return castState<IdSet>();
}

inline ServiceWorkerRouterRule::ServiceWorkerRouterRule() {
  m_id = 0;
}
inline ServiceWorkerVersion::~ServiceWorkerVersion() = default;
inline void ServiceWorkerVersion::SetVersionId(const String& value) { m_versionId = value; }
inline void ServiceWorkerVersion::SetRegistrationId(const String& value) { m_registrationId = value; }
inline void ServiceWorkerVersion::SetScriptURL(const String& value) { m_scriptURL = value; }
inline void ServiceWorkerVersion::SetRunningStatus(const String& value) { m_runningStatus = value; }
inline void ServiceWorkerVersion::SetStatus(const String& value) { m_status = value; }
inline void ServiceWorkerVersion::SetScriptLastModified(double value) { m_scriptLastModified = value; }
inline void ServiceWorkerVersion::SetScriptResponseTime(double value) { m_scriptResponseTime = value; }
inline void ServiceWorkerVersion::SetControlledClients(std::unique_ptr<protocol::Array<String>> value) { m_controlledClients = std::move(value); }
inline void ServiceWorkerVersion::SetTargetId(const String& value) { m_targetId = value; }
inline void ServiceWorkerVersion::SetRouterRules(const String& value) { m_routerRules = value; }
inline void ServiceWorkerVersion::SetTypedRouterRules(std::unique_ptr<protocol::Array<protocol::ServiceWorker::ServiceWorkerRouterRule>> value) { m_typedRouterRules = std::move(value); }

template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE | ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::VersionIdSet>&
ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetVersionId(const String& value) {
  static_assert(!(STATE & VersionIdSet), "property versionId should not be set yet");
  m_result->SetVersionId(value);
  return castState<VersionIdSet>();
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE | ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::RegistrationIdSet>&
ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetRegistrationId(const String& value) {
  static_assert(!(STATE & RegistrationIdSet), "property registrationId should not be set yet");
  m_result->SetRegistrationId(value);
  return castState<RegistrationIdSet>();
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE | ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::ScriptURLSet>&
ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetScriptURL(const String& value) {
  static_assert(!(STATE & ScriptURLSet), "property scriptURL should not be set yet");
  m_result->SetScriptURL(value);
  return castState<ScriptURLSet>();
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE | ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::RunningStatusSet>&
ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetRunningStatus(const String& value) {
  static_assert(!(STATE & RunningStatusSet), "property runningStatus should not be set yet");
  m_result->SetRunningStatus(value);
  return castState<RunningStatusSet>();
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE | ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::StatusSet>&
ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetStatus(const String& value) {
  static_assert(!(STATE & StatusSet), "property status should not be set yet");
  m_result->SetStatus(value);
  return castState<StatusSet>();
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>& ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetScriptLastModified(double value) {
  m_result->SetScriptLastModified(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>& ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetScriptResponseTime(double value) {
  m_result->SetScriptResponseTime(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>& ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetControlledClients(std::unique_ptr<protocol::Array<String>> value) {
  m_result->SetControlledClients(std::move(value));
  return *this;
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>& ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetTargetId(const String& value) {
  m_result->SetTargetId(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>& ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetRouterRules(const String& value) {
  m_result->SetRouterRules(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>& ServiceWorkerVersion::ServiceWorkerVersionBuilder<STATE>::SetTypedRouterRules(std::unique_ptr<protocol::Array<protocol::ServiceWorker::ServiceWorkerRouterRule>> value) {
  m_result->SetTypedRouterRules(std::move(value));
  return *this;
}

inline ServiceWorkerVersion::ServiceWorkerVersion() {
}
inline ServiceWorkerErrorMessage::~ServiceWorkerErrorMessage() = default;
inline void ServiceWorkerErrorMessage::SetErrorMessage(const String& value) { m_errorMessage = value; }
inline void ServiceWorkerErrorMessage::SetRegistrationId(const String& value) { m_registrationId = value; }
inline void ServiceWorkerErrorMessage::SetVersionId(const String& value) { m_versionId = value; }
inline void ServiceWorkerErrorMessage::SetSourceURL(const String& value) { m_sourceURL = value; }
inline void ServiceWorkerErrorMessage::SetLineNumber(int value) { m_lineNumber = value; }
inline void ServiceWorkerErrorMessage::SetColumnNumber(int value) { m_columnNumber = value; }

template<int STATE>
inline ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE | ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::ErrorMessageSet>&
ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::SetErrorMessage(const String& value) {
  static_assert(!(STATE & ErrorMessageSet), "property errorMessage should not be set yet");
  m_result->SetErrorMessage(value);
  return castState<ErrorMessageSet>();
}
template<int STATE>
inline ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE | ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::RegistrationIdSet>&
ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::SetRegistrationId(const String& value) {
  static_assert(!(STATE & RegistrationIdSet), "property registrationId should not be set yet");
  m_result->SetRegistrationId(value);
  return castState<RegistrationIdSet>();
}
template<int STATE>
inline ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE | ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::VersionIdSet>&
ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::SetVersionId(const String& value) {
  static_assert(!(STATE & VersionIdSet), "property versionId should not be set yet");
  m_result->SetVersionId(value);
  return castState<VersionIdSet>();
}
template<int STATE>
inline ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE | ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::SourceURLSet>&
ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::SetSourceURL(const String& value) {
  static_assert(!(STATE & SourceURLSet), "property sourceURL should not be set yet");
  m_result->SetSourceURL(value);
  return castState<SourceURLSet>();
}
template<int STATE>
inline ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE | ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::LineNumberSet>&
ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::SetLineNumber(int value) {
  static_assert(!(STATE & LineNumberSet), "property lineNumber should not be set yet");
  m_result->SetLineNumber(value);
  return castState<LineNumberSet>();
}
template<int STATE>
inline ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE | ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::ColumnNumberSet>&
ServiceWorkerErrorMessage::ServiceWorkerErrorMessageBuilder<STATE>::SetColumnNumber(int value) {
  static_assert(!(STATE & ColumnNumberSet), "property columnNumber should not be set yet");
  m_result->SetColumnNumber(value);
  return castState<ColumnNumberSet>();
}

inline ServiceWorkerErrorMessage::ServiceWorkerErrorMessage() {
  m_lineNumber = 0;
  m_columnNumber = 0;
}

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

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

    virtual DispatchResponse DeliverPushMessage(const String& in_origin, const String& in_registrationId, const String& in_data) = 0;
    virtual DispatchResponse Disable() = 0;
    virtual DispatchResponse DispatchSyncEvent(const String& in_origin, const String& in_registrationId, const String& in_tag, bool in_lastChance) = 0;
    virtual DispatchResponse DispatchPeriodicSyncEvent(const String& in_origin, const String& in_registrationId, const String& in_tag) = 0;
    virtual DispatchResponse Enable() = 0;
    virtual DispatchResponse SetForceUpdateOnPageLoad(bool in_forceUpdateOnPageLoad) = 0;
    virtual DispatchResponse SkipWaiting(const String& in_scopeURL) = 0;
    virtual DispatchResponse StartWorker(const String& in_scopeURL) = 0;
    class CONTENT_EXPORT StopAllWorkersCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~StopAllWorkersCallback() { }
    };
    virtual void StopAllWorkers(std::unique_ptr<StopAllWorkersCallback> callback) = 0;
    virtual DispatchResponse StopWorker(const String& in_versionId) = 0;
    virtual DispatchResponse Unregister(const String& in_scopeURL) = 0;
    virtual DispatchResponse UpdateRegistration(const String& in_scopeURL) = 0;

};

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

class CONTENT_EXPORT Frontend {
public:
  explicit Frontend(FrontendChannel* frontend_channel) : frontend_channel_(frontend_channel) {}
    void WorkerErrorReported(std::unique_ptr<protocol::ServiceWorker::ServiceWorkerErrorMessage> errorMessage);
    void WorkerRegistrationUpdated(std::unique_ptr<protocol::Array<protocol::ServiceWorker::ServiceWorkerRegistration>> registrations);
    void WorkerVersionUpdated(std::unique_ptr<protocol::Array<protocol::ServiceWorker::ServiceWorkerVersion>> versions);

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

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

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

private:
    Dispatcher() { }
};

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

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

} // namespace ServiceWorker
} // namespace content
} // namespace protocol

#endif // !defined(content_protocol_ServiceWorker_h)