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

// 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.

#ifndef EXTENSIONS_COMMON_API_NETWORKING_PRIVATE_H__
#define EXTENSIONS_COMMON_API_NETWORKING_PRIVATE_H__

#include <stdint.h>

#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>

#include "base/values.h"
#include <string_view>


namespace extensions {
namespace api {
namespace networking_private {

//
// Types
//

enum class ActivationStateType { … };


const char* ToString(ActivationStateType as_enum);
ActivationStateType ParseActivationStateType(std::string_view as_string);
std::u16string GetActivationStateTypeParseError(std::string_view as_string);

enum class CaptivePortalStatus { … };


const char* ToString(CaptivePortalStatus as_enum);
CaptivePortalStatus ParseCaptivePortalStatus(std::string_view as_string);
std::u16string GetCaptivePortalStatusParseError(std::string_view as_string);

enum class ConnectionStateType { … };


const char* ToString(ConnectionStateType as_enum);
ConnectionStateType ParseConnectionStateType(std::string_view as_string);
std::u16string GetConnectionStateTypeParseError(std::string_view as_string);

enum class DeviceStateType { … };


const char* ToString(DeviceStateType as_enum);
DeviceStateType ParseDeviceStateType(std::string_view as_string);
std::u16string GetDeviceStateTypeParseError(std::string_view as_string);

enum class IPConfigType { … };


const char* ToString(IPConfigType as_enum);
IPConfigType ParseIPConfigType(std::string_view as_string);
std::u16string GetIPConfigTypeParseError(std::string_view as_string);

enum class NetworkType { … };


const char* ToString(NetworkType as_enum);
NetworkType ParseNetworkType(std::string_view as_string);
std::u16string GetNetworkTypeParseError(std::string_view as_string);

enum class ProxySettingsType { … };


const char* ToString(ProxySettingsType as_enum);
ProxySettingsType ParseProxySettingsType(std::string_view as_string);
std::u16string GetProxySettingsTypeParseError(std::string_view as_string);

enum class ApnType { … };


const char* ToString(ApnType as_enum);
ApnType ParseApnType(std::string_view as_string);
std::u16string GetApnTypeParseError(std::string_view as_string);

enum class ApnSource { … };


const char* ToString(ApnSource as_enum);
ApnSource ParseApnSource(std::string_view as_string);
std::u16string GetApnSourceParseError(std::string_view as_string);

struct ManagedBoolean { … };

struct ManagedLong { … };

struct ManagedDOMString { … };

struct ManagedDOMStringList { … };

struct ManagedIPConfigType { … };

struct ManagedProxySettingsType { … };

struct APNProperties { … };

struct ManagedAPNProperties { … };

struct ManagedAPNList { … };

struct CellularProviderProperties { … };

struct CellularSimState { … };

struct IssuerSubjectPattern { … };

struct ManagedIssuerSubjectPattern { … };

struct CertificatePattern { … };

struct ManagedCertificatePattern { … };

struct EAPProperties { … };

struct ManagedEAPProperties { … };

struct FoundNetworkProperties { … };

struct IPConfigProperties { … };

struct ManagedIPConfigProperties { … };

struct XAUTHProperties { … };

struct ManagedXAUTHProperties { … };

struct IPSecProperties { … };

struct ManagedIPSecProperties { … };

struct L2TPProperties { … };

struct ManagedL2TPProperties { … };

struct PaymentPortal { … };

struct ProxyLocation { … };

struct ManagedProxyLocation { … };

struct ManualProxySettings { … };

struct ManagedManualProxySettings { … };

struct ProxySettings { … };

struct ManagedProxySettings { … };

struct VerifyX509 { … };

struct ManagedVerifyX509 { … };

struct OpenVPNProperties { … };

struct ManagedOpenVPNProperties { … };

struct SIMLockStatus { … };

struct ThirdPartyVPNProperties { … };

struct ManagedThirdPartyVPNProperties { … };

struct CellularProperties { … };

struct ManagedCellularProperties { … };

struct CellularStateProperties { … };

struct EAPStateProperties { … };

struct EthernetProperties { … };

struct ManagedEthernetProperties { … };

struct EthernetStateProperties { … };

struct TetherProperties { … };

struct VPNProperties { … };

struct ManagedVPNProperties { … };

struct VPNStateProperties { … };

struct WiFiProperties { … };

struct ManagedWiFiProperties { … };

struct WiFiStateProperties { … };

struct NetworkConfigProperties { … };

struct NetworkProperties { … };

struct ManagedProperties { … };

struct NetworkStateProperties { … };

struct DeviceStateProperties { … };

struct NetworkFilter { … };

struct GlobalPolicy { … };

struct Certificate { … };

struct CertificateLists { … };


//
// Functions
//

namespace GetProperties {

struct Params { … };

namespace Results {

base::Value::List Create(const NetworkProperties& result);
}  // namespace Results

}  // namespace GetProperties

namespace GetManagedProperties {

struct Params { … };

namespace Results {

base::Value::List Create(const ManagedProperties& result);
}  // namespace Results

}  // namespace GetManagedProperties

namespace GetState {

struct Params { … };

namespace Results {

base::Value::List Create(const NetworkStateProperties& result);
}  // namespace Results

}  // namespace GetState

namespace SetProperties {

struct Params { … };

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace SetProperties

namespace CreateNetwork {

struct Params { … };

namespace Results {

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

}  // namespace CreateNetwork

namespace ForgetNetwork {

struct Params { … };

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace ForgetNetwork

namespace GetNetworks {

struct Params { … };

namespace Results {

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

}  // namespace GetNetworks

namespace GetVisibleNetworks {

struct Params { … };

namespace Results {

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

}  // namespace GetVisibleNetworks

namespace GetEnabledNetworkTypes {

namespace Results {

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

}  // namespace GetEnabledNetworkTypes

namespace GetDeviceStates {

namespace Results {

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

}  // namespace GetDeviceStates

namespace EnableNetworkType {

struct Params { … };

}  // namespace EnableNetworkType

namespace DisableNetworkType {

struct Params { … };

}  // namespace DisableNetworkType

namespace RequestNetworkScan {

struct Params { … };

}  // namespace RequestNetworkScan

namespace StartConnect {

struct Params { … };

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace StartConnect

namespace StartDisconnect {

struct Params { … };

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace StartDisconnect

namespace StartActivate {

struct Params { … };

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace StartActivate

namespace GetCaptivePortalStatus {

struct Params { … };

namespace Results {

base::Value::List Create(const CaptivePortalStatus& result);
}  // namespace Results

}  // namespace GetCaptivePortalStatus

namespace UnlockCellularSim {

struct Params { … };

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace UnlockCellularSim

namespace SetCellularSimState {

struct Params { … };

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace SetCellularSimState

namespace SelectCellularMobileNetwork {

struct Params { … };

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace SelectCellularMobileNetwork

namespace GetGlobalPolicy {

namespace Results {

base::Value::List Create(const GlobalPolicy& result);
}  // namespace Results

}  // namespace GetGlobalPolicy

namespace GetCertificateLists {

namespace Results {

base::Value::List Create(const CertificateLists& result);
}  // namespace Results

}  // namespace GetCertificateLists

//
// Events
//

namespace OnNetworksChanged {

extern const char kEventName[];  // "networkingPrivate.onNetworksChanged"

base::Value::List Create(const std::vector<std::string>& changes);
}  // namespace OnNetworksChanged

namespace OnNetworkListChanged {

extern const char kEventName[];  // "networkingPrivate.onNetworkListChanged"

base::Value::List Create(const std::vector<std::string>& changes);
}  // namespace OnNetworkListChanged

namespace OnDeviceStateListChanged {

extern const char kEventName[];  // "networkingPrivate.onDeviceStateListChanged"

base::Value::List Create();
}  // namespace OnDeviceStateListChanged

namespace OnPortalDetectionCompleted {

extern const char kEventName[];  // "networkingPrivate.onPortalDetectionCompleted"

base::Value::List Create(const std::string& network_guid, const CaptivePortalStatus& status);
}  // namespace OnPortalDetectionCompleted

namespace OnCertificateListsChanged {

extern const char kEventName[];  // "networkingPrivate.onCertificateListsChanged"

base::Value::List Create();
}  // namespace OnCertificateListsChanged

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

#endif  // EXTENSIONS_COMMON_API_NETWORKING_PRIVATE_H__