chromium/out/Default/gen/extensions/common/api/networking_private.cc

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// GENERATED FROM THE API DEFINITION IN
//   extensions/common/api/networking_private.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "extensions/common/api/networking_private.h"

#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/check_op.h"
#include "base/notreached.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "tools/json_schema_compiler/util.h"
#include <string_view>


UTF8ToUTF16;

namespace extensions {
namespace api {
namespace networking_private {
//
// Types
//

const char* ToString(ActivationStateType enum_param) { … }

ActivationStateType ParseActivationStateType(std::string_view enum_string) { … }

std::u16string GetActivationStateTypeParseError(std::string_view enum_string) { … }


const char* ToString(CaptivePortalStatus enum_param) { … }

CaptivePortalStatus ParseCaptivePortalStatus(std::string_view enum_string) { … }

std::u16string GetCaptivePortalStatusParseError(std::string_view enum_string) { … }


const char* ToString(ConnectionStateType enum_param) { … }

ConnectionStateType ParseConnectionStateType(std::string_view enum_string) { … }

std::u16string GetConnectionStateTypeParseError(std::string_view enum_string) { … }


const char* ToString(DeviceStateType enum_param) { … }

DeviceStateType ParseDeviceStateType(std::string_view enum_string) { … }

std::u16string GetDeviceStateTypeParseError(std::string_view enum_string) { … }


const char* ToString(IPConfigType enum_param) { … }

IPConfigType ParseIPConfigType(std::string_view enum_string) { … }

std::u16string GetIPConfigTypeParseError(std::string_view enum_string) { … }


const char* ToString(NetworkType enum_param) { … }

NetworkType ParseNetworkType(std::string_view enum_string) { … }

std::u16string GetNetworkTypeParseError(std::string_view enum_string) { … }


const char* ToString(ProxySettingsType enum_param) { … }

ProxySettingsType ParseProxySettingsType(std::string_view enum_string) { … }

std::u16string GetProxySettingsTypeParseError(std::string_view enum_string) { … }


const char* ToString(ApnType enum_param) { … }

ApnType ParseApnType(std::string_view enum_string) { … }

std::u16string GetApnTypeParseError(std::string_view enum_string) { … }


const char* ToString(ApnSource enum_param) { … }

ApnSource ParseApnSource(std::string_view enum_string) { … }

std::u16string GetApnSourceParseError(std::string_view enum_string) { … }


ManagedBoolean::ManagedBoolean()
 { … }

ManagedBoolean::~ManagedBoolean() = default;
ManagedBoolean::ManagedBoolean(ManagedBoolean&& rhs) noexcept = default;
ManagedBoolean& ManagedBoolean::operator=(ManagedBoolean&& rhs) noexcept = default;
ManagedBoolean ManagedBoolean::Clone() const { … }

// static
bool ManagedBoolean::Populate(
    const base::Value::Dict& dict, ManagedBoolean& out) { … }

// static
bool ManagedBoolean::Populate(
    const base::Value& value, ManagedBoolean& out) { … }

// static
std::optional<ManagedBoolean> ManagedBoolean::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedBoolean> ManagedBoolean::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedBoolean::ToValue() const { … }


ManagedLong::ManagedLong()
 { … }

ManagedLong::~ManagedLong() = default;
ManagedLong::ManagedLong(ManagedLong&& rhs) noexcept = default;
ManagedLong& ManagedLong::operator=(ManagedLong&& rhs) noexcept = default;
ManagedLong ManagedLong::Clone() const { … }

// static
bool ManagedLong::Populate(
    const base::Value::Dict& dict, ManagedLong& out) { … }

// static
bool ManagedLong::Populate(
    const base::Value& value, ManagedLong& out) { … }

// static
std::optional<ManagedLong> ManagedLong::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedLong> ManagedLong::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedLong::ToValue() const { … }


ManagedDOMString::ManagedDOMString()
 { … }

ManagedDOMString::~ManagedDOMString() = default;
ManagedDOMString::ManagedDOMString(ManagedDOMString&& rhs) noexcept = default;
ManagedDOMString& ManagedDOMString::operator=(ManagedDOMString&& rhs) noexcept = default;
ManagedDOMString ManagedDOMString::Clone() const { … }

// static
bool ManagedDOMString::Populate(
    const base::Value::Dict& dict, ManagedDOMString& out) { … }

// static
bool ManagedDOMString::Populate(
    const base::Value& value, ManagedDOMString& out) { … }

// static
std::optional<ManagedDOMString> ManagedDOMString::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedDOMString> ManagedDOMString::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedDOMString::ToValue() const { … }


ManagedDOMStringList::ManagedDOMStringList()
 { … }

ManagedDOMStringList::~ManagedDOMStringList() = default;
ManagedDOMStringList::ManagedDOMStringList(ManagedDOMStringList&& rhs) noexcept = default;
ManagedDOMStringList& ManagedDOMStringList::operator=(ManagedDOMStringList&& rhs) noexcept = default;
ManagedDOMStringList ManagedDOMStringList::Clone() const { … }

// static
bool ManagedDOMStringList::Populate(
    const base::Value::Dict& dict, ManagedDOMStringList& out) { … }

// static
bool ManagedDOMStringList::Populate(
    const base::Value& value, ManagedDOMStringList& out) { … }

// static
std::optional<ManagedDOMStringList> ManagedDOMStringList::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedDOMStringList> ManagedDOMStringList::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedDOMStringList::ToValue() const { … }


ManagedIPConfigType::ManagedIPConfigType()
: … { … }

ManagedIPConfigType::~ManagedIPConfigType() = default;
ManagedIPConfigType::ManagedIPConfigType(ManagedIPConfigType&& rhs) noexcept = default;
ManagedIPConfigType& ManagedIPConfigType::operator=(ManagedIPConfigType&& rhs) noexcept = default;
ManagedIPConfigType ManagedIPConfigType::Clone() const { … }

// static
bool ManagedIPConfigType::Populate(
    const base::Value::Dict& dict, ManagedIPConfigType& out) { … }

// static
bool ManagedIPConfigType::Populate(
    const base::Value& value, ManagedIPConfigType& out) { … }

// static
std::optional<ManagedIPConfigType> ManagedIPConfigType::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedIPConfigType> ManagedIPConfigType::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedIPConfigType::ToValue() const { … }


ManagedProxySettingsType::ManagedProxySettingsType()
: … { … }

ManagedProxySettingsType::~ManagedProxySettingsType() = default;
ManagedProxySettingsType::ManagedProxySettingsType(ManagedProxySettingsType&& rhs) noexcept = default;
ManagedProxySettingsType& ManagedProxySettingsType::operator=(ManagedProxySettingsType&& rhs) noexcept = default;
ManagedProxySettingsType ManagedProxySettingsType::Clone() const { … }

// static
bool ManagedProxySettingsType::Populate(
    const base::Value::Dict& dict, ManagedProxySettingsType& out) { … }

// static
bool ManagedProxySettingsType::Populate(
    const base::Value& value, ManagedProxySettingsType& out) { … }

// static
std::optional<ManagedProxySettingsType> ManagedProxySettingsType::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedProxySettingsType> ManagedProxySettingsType::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedProxySettingsType::ToValue() const { … }


APNProperties::APNProperties()
: … { … }

APNProperties::~APNProperties() = default;
APNProperties::APNProperties(APNProperties&& rhs) noexcept = default;
APNProperties& APNProperties::operator=(APNProperties&& rhs) noexcept = default;
APNProperties APNProperties::Clone() const { … }

// static
bool APNProperties::Populate(
    const base::Value::Dict& dict, APNProperties& out) { … }

// static
bool APNProperties::Populate(
    const base::Value& value, APNProperties& out) { … }

// static
std::optional<APNProperties> APNProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<APNProperties> APNProperties::FromValue(const base::Value& value) { … }

base::Value::Dict APNProperties::ToValue() const { … }


ManagedAPNProperties::ManagedAPNProperties()
 { … }

ManagedAPNProperties::~ManagedAPNProperties() = default;
ManagedAPNProperties::ManagedAPNProperties(ManagedAPNProperties&& rhs) noexcept = default;
ManagedAPNProperties& ManagedAPNProperties::operator=(ManagedAPNProperties&& rhs) noexcept = default;
ManagedAPNProperties ManagedAPNProperties::Clone() const { … }

// static
bool ManagedAPNProperties::Populate(
    const base::Value::Dict& dict, ManagedAPNProperties& out) { … }

// static
bool ManagedAPNProperties::Populate(
    const base::Value& value, ManagedAPNProperties& out) { … }

// static
std::optional<ManagedAPNProperties> ManagedAPNProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedAPNProperties> ManagedAPNProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedAPNProperties::ToValue() const { … }


ManagedAPNList::ManagedAPNList()
 { … }

ManagedAPNList::~ManagedAPNList() = default;
ManagedAPNList::ManagedAPNList(ManagedAPNList&& rhs) noexcept = default;
ManagedAPNList& ManagedAPNList::operator=(ManagedAPNList&& rhs) noexcept = default;
ManagedAPNList ManagedAPNList::Clone() const { … }

// static
bool ManagedAPNList::Populate(
    const base::Value::Dict& dict, ManagedAPNList& out) { … }

// static
bool ManagedAPNList::Populate(
    const base::Value& value, ManagedAPNList& out) { … }

// static
std::optional<ManagedAPNList> ManagedAPNList::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedAPNList> ManagedAPNList::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedAPNList::ToValue() const { … }


CellularProviderProperties::CellularProviderProperties()
 { … }

CellularProviderProperties::~CellularProviderProperties() = default;
CellularProviderProperties::CellularProviderProperties(CellularProviderProperties&& rhs) noexcept = default;
CellularProviderProperties& CellularProviderProperties::operator=(CellularProviderProperties&& rhs) noexcept = default;
CellularProviderProperties CellularProviderProperties::Clone() const { … }

// static
bool CellularProviderProperties::Populate(
    const base::Value::Dict& dict, CellularProviderProperties& out) { … }

// static
bool CellularProviderProperties::Populate(
    const base::Value& value, CellularProviderProperties& out) { … }

// static
std::optional<CellularProviderProperties> CellularProviderProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<CellularProviderProperties> CellularProviderProperties::FromValue(const base::Value& value) { … }

base::Value::Dict CellularProviderProperties::ToValue() const { … }


CellularSimState::CellularSimState()
: … { … }

CellularSimState::~CellularSimState() = default;
CellularSimState::CellularSimState(CellularSimState&& rhs) noexcept = default;
CellularSimState& CellularSimState::operator=(CellularSimState&& rhs) noexcept = default;
CellularSimState CellularSimState::Clone() const { … }

// static
bool CellularSimState::Populate(
    const base::Value::Dict& dict, CellularSimState& out) { … }

// static
bool CellularSimState::Populate(
    const base::Value& value, CellularSimState& out) { … }

// static
std::optional<CellularSimState> CellularSimState::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<CellularSimState> CellularSimState::FromValue(const base::Value& value) { … }

base::Value::Dict CellularSimState::ToValue() const { … }


IssuerSubjectPattern::IssuerSubjectPattern()
 { … }

IssuerSubjectPattern::~IssuerSubjectPattern() = default;
IssuerSubjectPattern::IssuerSubjectPattern(IssuerSubjectPattern&& rhs) noexcept = default;
IssuerSubjectPattern& IssuerSubjectPattern::operator=(IssuerSubjectPattern&& rhs) noexcept = default;
IssuerSubjectPattern IssuerSubjectPattern::Clone() const { … }

// static
bool IssuerSubjectPattern::Populate(
    const base::Value::Dict& dict, IssuerSubjectPattern& out) { … }

// static
bool IssuerSubjectPattern::Populate(
    const base::Value& value, IssuerSubjectPattern& out) { … }

// static
std::optional<IssuerSubjectPattern> IssuerSubjectPattern::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<IssuerSubjectPattern> IssuerSubjectPattern::FromValue(const base::Value& value) { … }

base::Value::Dict IssuerSubjectPattern::ToValue() const { … }


ManagedIssuerSubjectPattern::ManagedIssuerSubjectPattern()
 { … }

ManagedIssuerSubjectPattern::~ManagedIssuerSubjectPattern() = default;
ManagedIssuerSubjectPattern::ManagedIssuerSubjectPattern(ManagedIssuerSubjectPattern&& rhs) noexcept = default;
ManagedIssuerSubjectPattern& ManagedIssuerSubjectPattern::operator=(ManagedIssuerSubjectPattern&& rhs) noexcept = default;
ManagedIssuerSubjectPattern ManagedIssuerSubjectPattern::Clone() const { … }

// static
bool ManagedIssuerSubjectPattern::Populate(
    const base::Value::Dict& dict, ManagedIssuerSubjectPattern& out) { … }

// static
bool ManagedIssuerSubjectPattern::Populate(
    const base::Value& value, ManagedIssuerSubjectPattern& out) { … }

// static
std::optional<ManagedIssuerSubjectPattern> ManagedIssuerSubjectPattern::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedIssuerSubjectPattern> ManagedIssuerSubjectPattern::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedIssuerSubjectPattern::ToValue() const { … }


CertificatePattern::CertificatePattern()
 { … }

CertificatePattern::~CertificatePattern() = default;
CertificatePattern::CertificatePattern(CertificatePattern&& rhs) noexcept = default;
CertificatePattern& CertificatePattern::operator=(CertificatePattern&& rhs) noexcept = default;
CertificatePattern CertificatePattern::Clone() const { … }

// static
bool CertificatePattern::Populate(
    const base::Value::Dict& dict, CertificatePattern& out) { … }

// static
bool CertificatePattern::Populate(
    const base::Value& value, CertificatePattern& out) { … }

// static
std::optional<CertificatePattern> CertificatePattern::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<CertificatePattern> CertificatePattern::FromValue(const base::Value& value) { … }

base::Value::Dict CertificatePattern::ToValue() const { … }


ManagedCertificatePattern::ManagedCertificatePattern()
 { … }

ManagedCertificatePattern::~ManagedCertificatePattern() = default;
ManagedCertificatePattern::ManagedCertificatePattern(ManagedCertificatePattern&& rhs) noexcept = default;
ManagedCertificatePattern& ManagedCertificatePattern::operator=(ManagedCertificatePattern&& rhs) noexcept = default;
ManagedCertificatePattern ManagedCertificatePattern::Clone() const { … }

// static
bool ManagedCertificatePattern::Populate(
    const base::Value::Dict& dict, ManagedCertificatePattern& out) { … }

// static
bool ManagedCertificatePattern::Populate(
    const base::Value& value, ManagedCertificatePattern& out) { … }

// static
std::optional<ManagedCertificatePattern> ManagedCertificatePattern::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedCertificatePattern> ManagedCertificatePattern::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedCertificatePattern::ToValue() const { … }


EAPProperties::EAPProperties()
 { … }

EAPProperties::~EAPProperties() = default;
EAPProperties::EAPProperties(EAPProperties&& rhs) noexcept = default;
EAPProperties& EAPProperties::operator=(EAPProperties&& rhs) noexcept = default;
EAPProperties EAPProperties::Clone() const { … }

// static
bool EAPProperties::Populate(
    const base::Value::Dict& dict, EAPProperties& out) { … }

// static
bool EAPProperties::Populate(
    const base::Value& value, EAPProperties& out) { … }

// static
std::optional<EAPProperties> EAPProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<EAPProperties> EAPProperties::FromValue(const base::Value& value) { … }

base::Value::Dict EAPProperties::ToValue() const { … }


ManagedEAPProperties::ManagedEAPProperties()
 { … }

ManagedEAPProperties::~ManagedEAPProperties() = default;
ManagedEAPProperties::ManagedEAPProperties(ManagedEAPProperties&& rhs) noexcept = default;
ManagedEAPProperties& ManagedEAPProperties::operator=(ManagedEAPProperties&& rhs) noexcept = default;
ManagedEAPProperties ManagedEAPProperties::Clone() const { … }

// static
bool ManagedEAPProperties::Populate(
    const base::Value::Dict& dict, ManagedEAPProperties& out) { … }

// static
bool ManagedEAPProperties::Populate(
    const base::Value& value, ManagedEAPProperties& out) { … }

// static
std::optional<ManagedEAPProperties> ManagedEAPProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedEAPProperties> ManagedEAPProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedEAPProperties::ToValue() const { … }


FoundNetworkProperties::FoundNetworkProperties()
 { … }

FoundNetworkProperties::~FoundNetworkProperties() = default;
FoundNetworkProperties::FoundNetworkProperties(FoundNetworkProperties&& rhs) noexcept = default;
FoundNetworkProperties& FoundNetworkProperties::operator=(FoundNetworkProperties&& rhs) noexcept = default;
FoundNetworkProperties FoundNetworkProperties::Clone() const { … }

// static
bool FoundNetworkProperties::Populate(
    const base::Value::Dict& dict, FoundNetworkProperties& out) { … }

// static
bool FoundNetworkProperties::Populate(
    const base::Value& value, FoundNetworkProperties& out) { … }

// static
std::optional<FoundNetworkProperties> FoundNetworkProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<FoundNetworkProperties> FoundNetworkProperties::FromValue(const base::Value& value) { … }

base::Value::Dict FoundNetworkProperties::ToValue() const { … }


IPConfigProperties::IPConfigProperties()
 { … }

IPConfigProperties::~IPConfigProperties() = default;
IPConfigProperties::IPConfigProperties(IPConfigProperties&& rhs) noexcept = default;
IPConfigProperties& IPConfigProperties::operator=(IPConfigProperties&& rhs) noexcept = default;
IPConfigProperties IPConfigProperties::Clone() const { … }

// static
bool IPConfigProperties::Populate(
    const base::Value::Dict& dict, IPConfigProperties& out) { … }

// static
bool IPConfigProperties::Populate(
    const base::Value& value, IPConfigProperties& out) { … }

// static
std::optional<IPConfigProperties> IPConfigProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<IPConfigProperties> IPConfigProperties::FromValue(const base::Value& value) { … }

base::Value::Dict IPConfigProperties::ToValue() const { … }


ManagedIPConfigProperties::ManagedIPConfigProperties()
 { … }

ManagedIPConfigProperties::~ManagedIPConfigProperties() = default;
ManagedIPConfigProperties::ManagedIPConfigProperties(ManagedIPConfigProperties&& rhs) noexcept = default;
ManagedIPConfigProperties& ManagedIPConfigProperties::operator=(ManagedIPConfigProperties&& rhs) noexcept = default;
ManagedIPConfigProperties ManagedIPConfigProperties::Clone() const { … }

// static
bool ManagedIPConfigProperties::Populate(
    const base::Value::Dict& dict, ManagedIPConfigProperties& out) { … }

// static
bool ManagedIPConfigProperties::Populate(
    const base::Value& value, ManagedIPConfigProperties& out) { … }

// static
std::optional<ManagedIPConfigProperties> ManagedIPConfigProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedIPConfigProperties> ManagedIPConfigProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedIPConfigProperties::ToValue() const { … }


XAUTHProperties::XAUTHProperties()
 { … }

XAUTHProperties::~XAUTHProperties() = default;
XAUTHProperties::XAUTHProperties(XAUTHProperties&& rhs) noexcept = default;
XAUTHProperties& XAUTHProperties::operator=(XAUTHProperties&& rhs) noexcept = default;
XAUTHProperties XAUTHProperties::Clone() const { … }

// static
bool XAUTHProperties::Populate(
    const base::Value::Dict& dict, XAUTHProperties& out) { … }

// static
bool XAUTHProperties::Populate(
    const base::Value& value, XAUTHProperties& out) { … }

// static
std::optional<XAUTHProperties> XAUTHProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<XAUTHProperties> XAUTHProperties::FromValue(const base::Value& value) { … }

base::Value::Dict XAUTHProperties::ToValue() const { … }


ManagedXAUTHProperties::ManagedXAUTHProperties()
 { … }

ManagedXAUTHProperties::~ManagedXAUTHProperties() = default;
ManagedXAUTHProperties::ManagedXAUTHProperties(ManagedXAUTHProperties&& rhs) noexcept = default;
ManagedXAUTHProperties& ManagedXAUTHProperties::operator=(ManagedXAUTHProperties&& rhs) noexcept = default;
ManagedXAUTHProperties ManagedXAUTHProperties::Clone() const { … }

// static
bool ManagedXAUTHProperties::Populate(
    const base::Value::Dict& dict, ManagedXAUTHProperties& out) { … }

// static
bool ManagedXAUTHProperties::Populate(
    const base::Value& value, ManagedXAUTHProperties& out) { … }

// static
std::optional<ManagedXAUTHProperties> ManagedXAUTHProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedXAUTHProperties> ManagedXAUTHProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedXAUTHProperties::ToValue() const { … }


IPSecProperties::IPSecProperties()
 { … }

IPSecProperties::~IPSecProperties() = default;
IPSecProperties::IPSecProperties(IPSecProperties&& rhs) noexcept = default;
IPSecProperties& IPSecProperties::operator=(IPSecProperties&& rhs) noexcept = default;
IPSecProperties IPSecProperties::Clone() const { … }

// static
bool IPSecProperties::Populate(
    const base::Value::Dict& dict, IPSecProperties& out) { … }

// static
bool IPSecProperties::Populate(
    const base::Value& value, IPSecProperties& out) { … }

// static
std::optional<IPSecProperties> IPSecProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<IPSecProperties> IPSecProperties::FromValue(const base::Value& value) { … }

base::Value::Dict IPSecProperties::ToValue() const { … }


ManagedIPSecProperties::ManagedIPSecProperties()
 { … }

ManagedIPSecProperties::~ManagedIPSecProperties() = default;
ManagedIPSecProperties::ManagedIPSecProperties(ManagedIPSecProperties&& rhs) noexcept = default;
ManagedIPSecProperties& ManagedIPSecProperties::operator=(ManagedIPSecProperties&& rhs) noexcept = default;
ManagedIPSecProperties ManagedIPSecProperties::Clone() const { … }

// static
bool ManagedIPSecProperties::Populate(
    const base::Value::Dict& dict, ManagedIPSecProperties& out) { … }

// static
bool ManagedIPSecProperties::Populate(
    const base::Value& value, ManagedIPSecProperties& out) { … }

// static
std::optional<ManagedIPSecProperties> ManagedIPSecProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedIPSecProperties> ManagedIPSecProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedIPSecProperties::ToValue() const { … }


L2TPProperties::L2TPProperties()
 { … }

L2TPProperties::~L2TPProperties() = default;
L2TPProperties::L2TPProperties(L2TPProperties&& rhs) noexcept = default;
L2TPProperties& L2TPProperties::operator=(L2TPProperties&& rhs) noexcept = default;
L2TPProperties L2TPProperties::Clone() const { … }

// static
bool L2TPProperties::Populate(
    const base::Value::Dict& dict, L2TPProperties& out) { … }

// static
bool L2TPProperties::Populate(
    const base::Value& value, L2TPProperties& out) { … }

// static
std::optional<L2TPProperties> L2TPProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<L2TPProperties> L2TPProperties::FromValue(const base::Value& value) { … }

base::Value::Dict L2TPProperties::ToValue() const { … }


ManagedL2TPProperties::ManagedL2TPProperties()
 { … }

ManagedL2TPProperties::~ManagedL2TPProperties() = default;
ManagedL2TPProperties::ManagedL2TPProperties(ManagedL2TPProperties&& rhs) noexcept = default;
ManagedL2TPProperties& ManagedL2TPProperties::operator=(ManagedL2TPProperties&& rhs) noexcept = default;
ManagedL2TPProperties ManagedL2TPProperties::Clone() const { … }

// static
bool ManagedL2TPProperties::Populate(
    const base::Value::Dict& dict, ManagedL2TPProperties& out) { … }

// static
bool ManagedL2TPProperties::Populate(
    const base::Value& value, ManagedL2TPProperties& out) { … }

// static
std::optional<ManagedL2TPProperties> ManagedL2TPProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedL2TPProperties> ManagedL2TPProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedL2TPProperties::ToValue() const { … }


PaymentPortal::PaymentPortal()
 { … }

PaymentPortal::~PaymentPortal() = default;
PaymentPortal::PaymentPortal(PaymentPortal&& rhs) noexcept = default;
PaymentPortal& PaymentPortal::operator=(PaymentPortal&& rhs) noexcept = default;
PaymentPortal PaymentPortal::Clone() const { … }

// static
bool PaymentPortal::Populate(
    const base::Value::Dict& dict, PaymentPortal& out) { … }

// static
bool PaymentPortal::Populate(
    const base::Value& value, PaymentPortal& out) { … }

// static
std::optional<PaymentPortal> PaymentPortal::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<PaymentPortal> PaymentPortal::FromValue(const base::Value& value) { … }

base::Value::Dict PaymentPortal::ToValue() const { … }


ProxyLocation::ProxyLocation()
: … { … }

ProxyLocation::~ProxyLocation() = default;
ProxyLocation::ProxyLocation(ProxyLocation&& rhs) noexcept = default;
ProxyLocation& ProxyLocation::operator=(ProxyLocation&& rhs) noexcept = default;
ProxyLocation ProxyLocation::Clone() const { … }

// static
bool ProxyLocation::Populate(
    const base::Value::Dict& dict, ProxyLocation& out) { … }

// static
bool ProxyLocation::Populate(
    const base::Value& value, ProxyLocation& out) { … }

// static
std::optional<ProxyLocation> ProxyLocation::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ProxyLocation> ProxyLocation::FromValue(const base::Value& value) { … }

base::Value::Dict ProxyLocation::ToValue() const { … }


ManagedProxyLocation::ManagedProxyLocation()
 { … }

ManagedProxyLocation::~ManagedProxyLocation() = default;
ManagedProxyLocation::ManagedProxyLocation(ManagedProxyLocation&& rhs) noexcept = default;
ManagedProxyLocation& ManagedProxyLocation::operator=(ManagedProxyLocation&& rhs) noexcept = default;
ManagedProxyLocation ManagedProxyLocation::Clone() const { … }

// static
bool ManagedProxyLocation::Populate(
    const base::Value::Dict& dict, ManagedProxyLocation& out) { … }

// static
bool ManagedProxyLocation::Populate(
    const base::Value& value, ManagedProxyLocation& out) { … }

// static
std::optional<ManagedProxyLocation> ManagedProxyLocation::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedProxyLocation> ManagedProxyLocation::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedProxyLocation::ToValue() const { … }


ManualProxySettings::ManualProxySettings()
 { … }

ManualProxySettings::~ManualProxySettings() = default;
ManualProxySettings::ManualProxySettings(ManualProxySettings&& rhs) noexcept = default;
ManualProxySettings& ManualProxySettings::operator=(ManualProxySettings&& rhs) noexcept = default;
ManualProxySettings ManualProxySettings::Clone() const { … }

// static
bool ManualProxySettings::Populate(
    const base::Value::Dict& dict, ManualProxySettings& out) { … }

// static
bool ManualProxySettings::Populate(
    const base::Value& value, ManualProxySettings& out) { … }

// static
std::optional<ManualProxySettings> ManualProxySettings::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManualProxySettings> ManualProxySettings::FromValue(const base::Value& value) { … }

base::Value::Dict ManualProxySettings::ToValue() const { … }


ManagedManualProxySettings::ManagedManualProxySettings()
 { … }

ManagedManualProxySettings::~ManagedManualProxySettings() = default;
ManagedManualProxySettings::ManagedManualProxySettings(ManagedManualProxySettings&& rhs) noexcept = default;
ManagedManualProxySettings& ManagedManualProxySettings::operator=(ManagedManualProxySettings&& rhs) noexcept = default;
ManagedManualProxySettings ManagedManualProxySettings::Clone() const { … }

// static
bool ManagedManualProxySettings::Populate(
    const base::Value::Dict& dict, ManagedManualProxySettings& out) { … }

// static
bool ManagedManualProxySettings::Populate(
    const base::Value& value, ManagedManualProxySettings& out) { … }

// static
std::optional<ManagedManualProxySettings> ManagedManualProxySettings::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedManualProxySettings> ManagedManualProxySettings::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedManualProxySettings::ToValue() const { … }


ProxySettings::ProxySettings()
: … { … }

ProxySettings::~ProxySettings() = default;
ProxySettings::ProxySettings(ProxySettings&& rhs) noexcept = default;
ProxySettings& ProxySettings::operator=(ProxySettings&& rhs) noexcept = default;
ProxySettings ProxySettings::Clone() const { … }

// static
bool ProxySettings::Populate(
    const base::Value::Dict& dict, ProxySettings& out) { … }

// static
bool ProxySettings::Populate(
    const base::Value& value, ProxySettings& out) { … }

// static
std::optional<ProxySettings> ProxySettings::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ProxySettings> ProxySettings::FromValue(const base::Value& value) { … }

base::Value::Dict ProxySettings::ToValue() const { … }


ManagedProxySettings::ManagedProxySettings()
 { … }

ManagedProxySettings::~ManagedProxySettings() = default;
ManagedProxySettings::ManagedProxySettings(ManagedProxySettings&& rhs) noexcept = default;
ManagedProxySettings& ManagedProxySettings::operator=(ManagedProxySettings&& rhs) noexcept = default;
ManagedProxySettings ManagedProxySettings::Clone() const { … }

// static
bool ManagedProxySettings::Populate(
    const base::Value::Dict& dict, ManagedProxySettings& out) { … }

// static
bool ManagedProxySettings::Populate(
    const base::Value& value, ManagedProxySettings& out) { … }

// static
std::optional<ManagedProxySettings> ManagedProxySettings::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedProxySettings> ManagedProxySettings::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedProxySettings::ToValue() const { … }


VerifyX509::VerifyX509()
 { … }

VerifyX509::~VerifyX509() = default;
VerifyX509::VerifyX509(VerifyX509&& rhs) noexcept = default;
VerifyX509& VerifyX509::operator=(VerifyX509&& rhs) noexcept = default;
VerifyX509 VerifyX509::Clone() const { … }

// static
bool VerifyX509::Populate(
    const base::Value::Dict& dict, VerifyX509& out) { … }

// static
bool VerifyX509::Populate(
    const base::Value& value, VerifyX509& out) { … }

// static
std::optional<VerifyX509> VerifyX509::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<VerifyX509> VerifyX509::FromValue(const base::Value& value) { … }

base::Value::Dict VerifyX509::ToValue() const { … }


ManagedVerifyX509::ManagedVerifyX509()
 { … }

ManagedVerifyX509::~ManagedVerifyX509() = default;
ManagedVerifyX509::ManagedVerifyX509(ManagedVerifyX509&& rhs) noexcept = default;
ManagedVerifyX509& ManagedVerifyX509::operator=(ManagedVerifyX509&& rhs) noexcept = default;
ManagedVerifyX509 ManagedVerifyX509::Clone() const { … }

// static
bool ManagedVerifyX509::Populate(
    const base::Value::Dict& dict, ManagedVerifyX509& out) { … }

// static
bool ManagedVerifyX509::Populate(
    const base::Value& value, ManagedVerifyX509& out) { … }

// static
std::optional<ManagedVerifyX509> ManagedVerifyX509::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedVerifyX509> ManagedVerifyX509::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedVerifyX509::ToValue() const { … }


OpenVPNProperties::OpenVPNProperties()
 { … }

OpenVPNProperties::~OpenVPNProperties() = default;
OpenVPNProperties::OpenVPNProperties(OpenVPNProperties&& rhs) noexcept = default;
OpenVPNProperties& OpenVPNProperties::operator=(OpenVPNProperties&& rhs) noexcept = default;
OpenVPNProperties OpenVPNProperties::Clone() const { … }

// static
bool OpenVPNProperties::Populate(
    const base::Value::Dict& dict, OpenVPNProperties& out) { … }

// static
bool OpenVPNProperties::Populate(
    const base::Value& value, OpenVPNProperties& out) { … }

// static
std::optional<OpenVPNProperties> OpenVPNProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<OpenVPNProperties> OpenVPNProperties::FromValue(const base::Value& value) { … }

base::Value::Dict OpenVPNProperties::ToValue() const { … }


ManagedOpenVPNProperties::ManagedOpenVPNProperties()
 { … }

ManagedOpenVPNProperties::~ManagedOpenVPNProperties() = default;
ManagedOpenVPNProperties::ManagedOpenVPNProperties(ManagedOpenVPNProperties&& rhs) noexcept = default;
ManagedOpenVPNProperties& ManagedOpenVPNProperties::operator=(ManagedOpenVPNProperties&& rhs) noexcept = default;
ManagedOpenVPNProperties ManagedOpenVPNProperties::Clone() const { … }

// static
bool ManagedOpenVPNProperties::Populate(
    const base::Value::Dict& dict, ManagedOpenVPNProperties& out) { … }

// static
bool ManagedOpenVPNProperties::Populate(
    const base::Value& value, ManagedOpenVPNProperties& out) { … }

// static
std::optional<ManagedOpenVPNProperties> ManagedOpenVPNProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedOpenVPNProperties> ManagedOpenVPNProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedOpenVPNProperties::ToValue() const { … }


SIMLockStatus::SIMLockStatus()
: … { … }

SIMLockStatus::~SIMLockStatus() = default;
SIMLockStatus::SIMLockStatus(SIMLockStatus&& rhs) noexcept = default;
SIMLockStatus& SIMLockStatus::operator=(SIMLockStatus&& rhs) noexcept = default;
SIMLockStatus SIMLockStatus::Clone() const { … }

// static
bool SIMLockStatus::Populate(
    const base::Value::Dict& dict, SIMLockStatus& out) { … }

// static
bool SIMLockStatus::Populate(
    const base::Value& value, SIMLockStatus& out) { … }

// static
std::optional<SIMLockStatus> SIMLockStatus::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<SIMLockStatus> SIMLockStatus::FromValue(const base::Value& value) { … }

base::Value::Dict SIMLockStatus::ToValue() const { … }


ThirdPartyVPNProperties::ThirdPartyVPNProperties()
 { … }

ThirdPartyVPNProperties::~ThirdPartyVPNProperties() = default;
ThirdPartyVPNProperties::ThirdPartyVPNProperties(ThirdPartyVPNProperties&& rhs) noexcept = default;
ThirdPartyVPNProperties& ThirdPartyVPNProperties::operator=(ThirdPartyVPNProperties&& rhs) noexcept = default;
ThirdPartyVPNProperties ThirdPartyVPNProperties::Clone() const { … }

// static
bool ThirdPartyVPNProperties::Populate(
    const base::Value::Dict& dict, ThirdPartyVPNProperties& out) { … }

// static
bool ThirdPartyVPNProperties::Populate(
    const base::Value& value, ThirdPartyVPNProperties& out) { … }

// static
std::optional<ThirdPartyVPNProperties> ThirdPartyVPNProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ThirdPartyVPNProperties> ThirdPartyVPNProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ThirdPartyVPNProperties::ToValue() const { … }


ManagedThirdPartyVPNProperties::ManagedThirdPartyVPNProperties()
 { … }

ManagedThirdPartyVPNProperties::~ManagedThirdPartyVPNProperties() = default;
ManagedThirdPartyVPNProperties::ManagedThirdPartyVPNProperties(ManagedThirdPartyVPNProperties&& rhs) noexcept = default;
ManagedThirdPartyVPNProperties& ManagedThirdPartyVPNProperties::operator=(ManagedThirdPartyVPNProperties&& rhs) noexcept = default;
ManagedThirdPartyVPNProperties ManagedThirdPartyVPNProperties::Clone() const { … }

// static
bool ManagedThirdPartyVPNProperties::Populate(
    const base::Value::Dict& dict, ManagedThirdPartyVPNProperties& out) { … }

// static
bool ManagedThirdPartyVPNProperties::Populate(
    const base::Value& value, ManagedThirdPartyVPNProperties& out) { … }

// static
std::optional<ManagedThirdPartyVPNProperties> ManagedThirdPartyVPNProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedThirdPartyVPNProperties> ManagedThirdPartyVPNProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedThirdPartyVPNProperties::ToValue() const { … }


CellularProperties::CellularProperties()
: … { … }

CellularProperties::~CellularProperties() = default;
CellularProperties::CellularProperties(CellularProperties&& rhs) noexcept = default;
CellularProperties& CellularProperties::operator=(CellularProperties&& rhs) noexcept = default;
CellularProperties CellularProperties::Clone() const { … }

// static
bool CellularProperties::Populate(
    const base::Value::Dict& dict, CellularProperties& out) { … }

// static
bool CellularProperties::Populate(
    const base::Value& value, CellularProperties& out) { … }

// static
std::optional<CellularProperties> CellularProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<CellularProperties> CellularProperties::FromValue(const base::Value& value) { … }

base::Value::Dict CellularProperties::ToValue() const { … }


ManagedCellularProperties::ManagedCellularProperties()
: … { … }

ManagedCellularProperties::~ManagedCellularProperties() = default;
ManagedCellularProperties::ManagedCellularProperties(ManagedCellularProperties&& rhs) noexcept = default;
ManagedCellularProperties& ManagedCellularProperties::operator=(ManagedCellularProperties&& rhs) noexcept = default;
ManagedCellularProperties ManagedCellularProperties::Clone() const { … }

// static
bool ManagedCellularProperties::Populate(
    const base::Value::Dict& dict, ManagedCellularProperties& out) { … }

// static
bool ManagedCellularProperties::Populate(
    const base::Value& value, ManagedCellularProperties& out) { … }

// static
std::optional<ManagedCellularProperties> ManagedCellularProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedCellularProperties> ManagedCellularProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedCellularProperties::ToValue() const { … }


CellularStateProperties::CellularStateProperties()
: … { … }

CellularStateProperties::~CellularStateProperties() = default;
CellularStateProperties::CellularStateProperties(CellularStateProperties&& rhs) noexcept = default;
CellularStateProperties& CellularStateProperties::operator=(CellularStateProperties&& rhs) noexcept = default;
CellularStateProperties CellularStateProperties::Clone() const { … }

// static
bool CellularStateProperties::Populate(
    const base::Value::Dict& dict, CellularStateProperties& out) { … }

// static
bool CellularStateProperties::Populate(
    const base::Value& value, CellularStateProperties& out) { … }

// static
std::optional<CellularStateProperties> CellularStateProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<CellularStateProperties> CellularStateProperties::FromValue(const base::Value& value) { … }

base::Value::Dict CellularStateProperties::ToValue() const { … }


EAPStateProperties::EAPStateProperties()
 { … }

EAPStateProperties::~EAPStateProperties() = default;
EAPStateProperties::EAPStateProperties(EAPStateProperties&& rhs) noexcept = default;
EAPStateProperties& EAPStateProperties::operator=(EAPStateProperties&& rhs) noexcept = default;
EAPStateProperties EAPStateProperties::Clone() const { … }

// static
bool EAPStateProperties::Populate(
    const base::Value::Dict& dict, EAPStateProperties& out) { … }

// static
bool EAPStateProperties::Populate(
    const base::Value& value, EAPStateProperties& out) { … }

// static
std::optional<EAPStateProperties> EAPStateProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<EAPStateProperties> EAPStateProperties::FromValue(const base::Value& value) { … }

base::Value::Dict EAPStateProperties::ToValue() const { … }


EthernetProperties::EthernetProperties()
 { … }

EthernetProperties::~EthernetProperties() = default;
EthernetProperties::EthernetProperties(EthernetProperties&& rhs) noexcept = default;
EthernetProperties& EthernetProperties::operator=(EthernetProperties&& rhs) noexcept = default;
EthernetProperties EthernetProperties::Clone() const { … }

// static
bool EthernetProperties::Populate(
    const base::Value::Dict& dict, EthernetProperties& out) { … }

// static
bool EthernetProperties::Populate(
    const base::Value& value, EthernetProperties& out) { … }

// static
std::optional<EthernetProperties> EthernetProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<EthernetProperties> EthernetProperties::FromValue(const base::Value& value) { … }

base::Value::Dict EthernetProperties::ToValue() const { … }


ManagedEthernetProperties::ManagedEthernetProperties()
 { … }

ManagedEthernetProperties::~ManagedEthernetProperties() = default;
ManagedEthernetProperties::ManagedEthernetProperties(ManagedEthernetProperties&& rhs) noexcept = default;
ManagedEthernetProperties& ManagedEthernetProperties::operator=(ManagedEthernetProperties&& rhs) noexcept = default;
ManagedEthernetProperties ManagedEthernetProperties::Clone() const { … }

// static
bool ManagedEthernetProperties::Populate(
    const base::Value::Dict& dict, ManagedEthernetProperties& out) { … }

// static
bool ManagedEthernetProperties::Populate(
    const base::Value& value, ManagedEthernetProperties& out) { … }

// static
std::optional<ManagedEthernetProperties> ManagedEthernetProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedEthernetProperties> ManagedEthernetProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedEthernetProperties::ToValue() const { … }


EthernetStateProperties::EthernetStateProperties()
 { … }

EthernetStateProperties::~EthernetStateProperties() = default;
EthernetStateProperties::EthernetStateProperties(EthernetStateProperties&& rhs) noexcept = default;
EthernetStateProperties& EthernetStateProperties::operator=(EthernetStateProperties&& rhs) noexcept = default;
EthernetStateProperties EthernetStateProperties::Clone() const { … }

// static
bool EthernetStateProperties::Populate(
    const base::Value::Dict& dict, EthernetStateProperties& out) { … }

// static
bool EthernetStateProperties::Populate(
    const base::Value& value, EthernetStateProperties& out) { … }

// static
std::optional<EthernetStateProperties> EthernetStateProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<EthernetStateProperties> EthernetStateProperties::FromValue(const base::Value& value) { … }

base::Value::Dict EthernetStateProperties::ToValue() const { … }


TetherProperties::TetherProperties()
: … { … }

TetherProperties::~TetherProperties() = default;
TetherProperties::TetherProperties(TetherProperties&& rhs) noexcept = default;
TetherProperties& TetherProperties::operator=(TetherProperties&& rhs) noexcept = default;
TetherProperties TetherProperties::Clone() const { … }

// static
bool TetherProperties::Populate(
    const base::Value::Dict& dict, TetherProperties& out) { … }

// static
bool TetherProperties::Populate(
    const base::Value& value, TetherProperties& out) { … }

// static
std::optional<TetherProperties> TetherProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<TetherProperties> TetherProperties::FromValue(const base::Value& value) { … }

base::Value::Dict TetherProperties::ToValue() const { … }


VPNProperties::VPNProperties()
 { … }

VPNProperties::~VPNProperties() = default;
VPNProperties::VPNProperties(VPNProperties&& rhs) noexcept = default;
VPNProperties& VPNProperties::operator=(VPNProperties&& rhs) noexcept = default;
VPNProperties VPNProperties::Clone() const { … }

// static
bool VPNProperties::Populate(
    const base::Value::Dict& dict, VPNProperties& out) { … }

// static
bool VPNProperties::Populate(
    const base::Value& value, VPNProperties& out) { … }

// static
std::optional<VPNProperties> VPNProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<VPNProperties> VPNProperties::FromValue(const base::Value& value) { … }

base::Value::Dict VPNProperties::ToValue() const { … }


ManagedVPNProperties::ManagedVPNProperties()
 { … }

ManagedVPNProperties::~ManagedVPNProperties() = default;
ManagedVPNProperties::ManagedVPNProperties(ManagedVPNProperties&& rhs) noexcept = default;
ManagedVPNProperties& ManagedVPNProperties::operator=(ManagedVPNProperties&& rhs) noexcept = default;
ManagedVPNProperties ManagedVPNProperties::Clone() const { … }

// static
bool ManagedVPNProperties::Populate(
    const base::Value::Dict& dict, ManagedVPNProperties& out) { … }

// static
bool ManagedVPNProperties::Populate(
    const base::Value& value, ManagedVPNProperties& out) { … }

// static
std::optional<ManagedVPNProperties> ManagedVPNProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedVPNProperties> ManagedVPNProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedVPNProperties::ToValue() const { … }


VPNStateProperties::VPNStateProperties()
 { … }

VPNStateProperties::~VPNStateProperties() = default;
VPNStateProperties::VPNStateProperties(VPNStateProperties&& rhs) noexcept = default;
VPNStateProperties& VPNStateProperties::operator=(VPNStateProperties&& rhs) noexcept = default;
VPNStateProperties VPNStateProperties::Clone() const { … }

// static
bool VPNStateProperties::Populate(
    const base::Value::Dict& dict, VPNStateProperties& out) { … }

// static
bool VPNStateProperties::Populate(
    const base::Value& value, VPNStateProperties& out) { … }

// static
std::optional<VPNStateProperties> VPNStateProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<VPNStateProperties> VPNStateProperties::FromValue(const base::Value& value) { … }

base::Value::Dict VPNStateProperties::ToValue() const { … }


WiFiProperties::WiFiProperties()
 { … }

WiFiProperties::~WiFiProperties() = default;
WiFiProperties::WiFiProperties(WiFiProperties&& rhs) noexcept = default;
WiFiProperties& WiFiProperties::operator=(WiFiProperties&& rhs) noexcept = default;
WiFiProperties WiFiProperties::Clone() const { … }

// static
bool WiFiProperties::Populate(
    const base::Value::Dict& dict, WiFiProperties& out) { … }

// static
bool WiFiProperties::Populate(
    const base::Value& value, WiFiProperties& out) { … }

// static
std::optional<WiFiProperties> WiFiProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<WiFiProperties> WiFiProperties::FromValue(const base::Value& value) { … }

base::Value::Dict WiFiProperties::ToValue() const { … }


ManagedWiFiProperties::ManagedWiFiProperties()
 { … }

ManagedWiFiProperties::~ManagedWiFiProperties() = default;
ManagedWiFiProperties::ManagedWiFiProperties(ManagedWiFiProperties&& rhs) noexcept = default;
ManagedWiFiProperties& ManagedWiFiProperties::operator=(ManagedWiFiProperties&& rhs) noexcept = default;
ManagedWiFiProperties ManagedWiFiProperties::Clone() const { … }

// static
bool ManagedWiFiProperties::Populate(
    const base::Value::Dict& dict, ManagedWiFiProperties& out) { … }

// static
bool ManagedWiFiProperties::Populate(
    const base::Value& value, ManagedWiFiProperties& out) { … }

// static
std::optional<ManagedWiFiProperties> ManagedWiFiProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedWiFiProperties> ManagedWiFiProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedWiFiProperties::ToValue() const { … }


WiFiStateProperties::WiFiStateProperties()
 { … }

WiFiStateProperties::~WiFiStateProperties() = default;
WiFiStateProperties::WiFiStateProperties(WiFiStateProperties&& rhs) noexcept = default;
WiFiStateProperties& WiFiStateProperties::operator=(WiFiStateProperties&& rhs) noexcept = default;
WiFiStateProperties WiFiStateProperties::Clone() const { … }

// static
bool WiFiStateProperties::Populate(
    const base::Value::Dict& dict, WiFiStateProperties& out) { … }

// static
bool WiFiStateProperties::Populate(
    const base::Value& value, WiFiStateProperties& out) { … }

// static
std::optional<WiFiStateProperties> WiFiStateProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<WiFiStateProperties> WiFiStateProperties::FromValue(const base::Value& value) { … }

base::Value::Dict WiFiStateProperties::ToValue() const { … }


NetworkConfigProperties::NetworkConfigProperties()
: … { … }

NetworkConfigProperties::~NetworkConfigProperties() = default;
NetworkConfigProperties::NetworkConfigProperties(NetworkConfigProperties&& rhs) noexcept = default;
NetworkConfigProperties& NetworkConfigProperties::operator=(NetworkConfigProperties&& rhs) noexcept = default;
NetworkConfigProperties NetworkConfigProperties::Clone() const { … }

// static
bool NetworkConfigProperties::Populate(
    const base::Value::Dict& dict, NetworkConfigProperties& out) { … }

// static
bool NetworkConfigProperties::Populate(
    const base::Value& value, NetworkConfigProperties& out) { … }

// static
std::optional<NetworkConfigProperties> NetworkConfigProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<NetworkConfigProperties> NetworkConfigProperties::FromValue(const base::Value& value) { … }

base::Value::Dict NetworkConfigProperties::ToValue() const { … }


NetworkProperties::NetworkProperties()
: … { … }

NetworkProperties::~NetworkProperties() = default;
NetworkProperties::NetworkProperties(NetworkProperties&& rhs) noexcept = default;
NetworkProperties& NetworkProperties::operator=(NetworkProperties&& rhs) noexcept = default;
NetworkProperties NetworkProperties::Clone() const { … }

// static
bool NetworkProperties::Populate(
    const base::Value::Dict& dict, NetworkProperties& out) { … }

// static
bool NetworkProperties::Populate(
    const base::Value& value, NetworkProperties& out) { … }

// static
std::optional<NetworkProperties> NetworkProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<NetworkProperties> NetworkProperties::FromValue(const base::Value& value) { … }

base::Value::Dict NetworkProperties::ToValue() const { … }


ManagedProperties::ManagedProperties()
: … { … }

ManagedProperties::~ManagedProperties() = default;
ManagedProperties::ManagedProperties(ManagedProperties&& rhs) noexcept = default;
ManagedProperties& ManagedProperties::operator=(ManagedProperties&& rhs) noexcept = default;
ManagedProperties ManagedProperties::Clone() const { … }

// static
bool ManagedProperties::Populate(
    const base::Value::Dict& dict, ManagedProperties& out) { … }

// static
bool ManagedProperties::Populate(
    const base::Value& value, ManagedProperties& out) { … }

// static
std::optional<ManagedProperties> ManagedProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ManagedProperties> ManagedProperties::FromValue(const base::Value& value) { … }

base::Value::Dict ManagedProperties::ToValue() const { … }


NetworkStateProperties::NetworkStateProperties()
: … { … }

NetworkStateProperties::~NetworkStateProperties() = default;
NetworkStateProperties::NetworkStateProperties(NetworkStateProperties&& rhs) noexcept = default;
NetworkStateProperties& NetworkStateProperties::operator=(NetworkStateProperties&& rhs) noexcept = default;
NetworkStateProperties NetworkStateProperties::Clone() const { … }

// static
bool NetworkStateProperties::Populate(
    const base::Value::Dict& dict, NetworkStateProperties& out) { … }

// static
bool NetworkStateProperties::Populate(
    const base::Value& value, NetworkStateProperties& out) { … }

// static
std::optional<NetworkStateProperties> NetworkStateProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<NetworkStateProperties> NetworkStateProperties::FromValue(const base::Value& value) { … }

base::Value::Dict NetworkStateProperties::ToValue() const { … }


DeviceStateProperties::DeviceStateProperties()
: … { … }

DeviceStateProperties::~DeviceStateProperties() = default;
DeviceStateProperties::DeviceStateProperties(DeviceStateProperties&& rhs) noexcept = default;
DeviceStateProperties& DeviceStateProperties::operator=(DeviceStateProperties&& rhs) noexcept = default;
DeviceStateProperties DeviceStateProperties::Clone() const { … }

// static
bool DeviceStateProperties::Populate(
    const base::Value::Dict& dict, DeviceStateProperties& out) { … }

// static
bool DeviceStateProperties::Populate(
    const base::Value& value, DeviceStateProperties& out) { … }

// static
std::optional<DeviceStateProperties> DeviceStateProperties::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<DeviceStateProperties> DeviceStateProperties::FromValue(const base::Value& value) { … }

base::Value::Dict DeviceStateProperties::ToValue() const { … }


NetworkFilter::NetworkFilter()
: … { … }

NetworkFilter::~NetworkFilter() = default;
NetworkFilter::NetworkFilter(NetworkFilter&& rhs) noexcept = default;
NetworkFilter& NetworkFilter::operator=(NetworkFilter&& rhs) noexcept = default;
NetworkFilter NetworkFilter::Clone() const { … }

// static
bool NetworkFilter::Populate(
    const base::Value::Dict& dict, NetworkFilter& out) { … }

// static
bool NetworkFilter::Populate(
    const base::Value& value, NetworkFilter& out) { … }

// static
std::optional<NetworkFilter> NetworkFilter::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<NetworkFilter> NetworkFilter::FromValue(const base::Value& value) { … }

base::Value::Dict NetworkFilter::ToValue() const { … }


GlobalPolicy::GlobalPolicy()
 { … }

GlobalPolicy::~GlobalPolicy() = default;
GlobalPolicy::GlobalPolicy(GlobalPolicy&& rhs) noexcept = default;
GlobalPolicy& GlobalPolicy::operator=(GlobalPolicy&& rhs) noexcept = default;
GlobalPolicy GlobalPolicy::Clone() const { … }

// static
bool GlobalPolicy::Populate(
    const base::Value::Dict& dict, GlobalPolicy& out) { … }

// static
bool GlobalPolicy::Populate(
    const base::Value& value, GlobalPolicy& out) { … }

// static
std::optional<GlobalPolicy> GlobalPolicy::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<GlobalPolicy> GlobalPolicy::FromValue(const base::Value& value) { … }

base::Value::Dict GlobalPolicy::ToValue() const { … }


Certificate::Certificate()
: … { … }

Certificate::~Certificate() = default;
Certificate::Certificate(Certificate&& rhs) noexcept = default;
Certificate& Certificate::operator=(Certificate&& rhs) noexcept = default;
Certificate Certificate::Clone() const { … }

// static
bool Certificate::Populate(
    const base::Value::Dict& dict, Certificate& out) { … }

// static
bool Certificate::Populate(
    const base::Value& value, Certificate& out) { … }

// static
std::optional<Certificate> Certificate::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<Certificate> Certificate::FromValue(const base::Value& value) { … }

base::Value::Dict Certificate::ToValue() const { … }


CertificateLists::CertificateLists()
 { … }

CertificateLists::~CertificateLists() = default;
CertificateLists::CertificateLists(CertificateLists&& rhs) noexcept = default;
CertificateLists& CertificateLists::operator=(CertificateLists&& rhs) noexcept = default;
CertificateLists CertificateLists::Clone() const { … }

// static
bool CertificateLists::Populate(
    const base::Value::Dict& dict, CertificateLists& out) { … }

// static
bool CertificateLists::Populate(
    const base::Value& value, CertificateLists& out) { … }

// static
std::optional<CertificateLists> CertificateLists::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<CertificateLists> CertificateLists::FromValue(const base::Value& value) { … }

base::Value::Dict CertificateLists::ToValue() const { … }



//
// Functions
//

namespace GetProperties {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const NetworkProperties& result) { … }
}  // namespace GetProperties

namespace GetManagedProperties {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const ManagedProperties& result) { … }
}  // namespace GetManagedProperties

namespace GetState {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const NetworkStateProperties& result) { … }
}  // namespace GetState

namespace SetProperties {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace SetProperties

namespace CreateNetwork {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::string& result) { … }
}  // namespace CreateNetwork

namespace ForgetNetwork {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace ForgetNetwork

namespace GetNetworks {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<NetworkStateProperties>& result) { … }
}  // namespace GetNetworks

namespace GetVisibleNetworks {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<NetworkStateProperties>& result) { … }
}  // namespace GetVisibleNetworks

namespace GetEnabledNetworkTypes {

base::Value::List Results::Create(const std::vector<NetworkType>& result) { … }
}  // namespace GetEnabledNetworkTypes

namespace GetDeviceStates {

base::Value::List Results::Create(const std::vector<DeviceStateProperties>& result) { … }
}  // namespace GetDeviceStates

namespace EnableNetworkType {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace EnableNetworkType

namespace DisableNetworkType {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace DisableNetworkType

namespace RequestNetworkScan {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


}  // namespace RequestNetworkScan

namespace StartConnect {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace StartConnect

namespace StartDisconnect {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace StartDisconnect

namespace StartActivate {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace StartActivate

namespace GetCaptivePortalStatus {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const CaptivePortalStatus& result) { … }
}  // namespace GetCaptivePortalStatus

namespace UnlockCellularSim {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace UnlockCellularSim

namespace SetCellularSimState {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace SetCellularSimState

namespace SelectCellularMobileNetwork {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace SelectCellularMobileNetwork

namespace GetGlobalPolicy {

base::Value::List Results::Create(const GlobalPolicy& result) { … }
}  // namespace GetGlobalPolicy

namespace GetCertificateLists {

base::Value::List Results::Create(const CertificateLists& result) { … }
}  // namespace GetCertificateLists

//
// Events
//

namespace OnNetworksChanged {

const char kEventName[] = …;

base::Value::List Create(const std::vector<std::string>& changes) { … }

}  // namespace OnNetworksChanged

namespace OnNetworkListChanged {

const char kEventName[] = …;

base::Value::List Create(const std::vector<std::string>& changes) { … }

}  // namespace OnNetworkListChanged

namespace OnDeviceStateListChanged {

const char kEventName[] = …;

base::Value::List Create() { … }

}  // namespace OnDeviceStateListChanged

namespace OnPortalDetectionCompleted {

const char kEventName[] = …;

base::Value::List Create(const std::string& network_guid, const CaptivePortalStatus& status) { … }

}  // namespace OnPortalDetectionCompleted

namespace OnCertificateListsChanged {

const char kEventName[] = …;

base::Value::List Create() { … }

}  // namespace OnCertificateListsChanged

}  // namespace networking_private
}  // namespace api
}  // namespace extensions