chromium/out/Default/gen/chrome/common/extensions/api/developer_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
//   chrome/common/extensions/api/developer_private.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "chrome/common/extensions/api/developer_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 developer_private {
//
// Types
//

const char* ToString(ItemType enum_param) { … }

ItemType ParseItemType(std::string_view enum_string) { … }

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


ItemInspectView::ItemInspectView()
: … { … }

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

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

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

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

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

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


InspectOptions::RenderProcessId::RenderProcessId()
 { … }

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

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

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

base::Value InspectOptions::RenderProcessId::ToValue() const { … }


InspectOptions::RenderViewId::RenderViewId()
 { … }

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

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

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

base::Value InspectOptions::RenderViewId::ToValue() const { … }



InspectOptions::InspectOptions()
: … { … }

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

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

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

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

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

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


InstallWarning::InstallWarning()
 { … }

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

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

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

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

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

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


const char* ToString(ExtensionType enum_param) { … }

ExtensionType ParseExtensionType(std::string_view enum_string) { … }

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


const char* ToString(Location enum_param) { … }

Location ParseLocation(std::string_view enum_string) { … }

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


const char* ToString(ViewType enum_param) { … }

ViewType ParseViewType(std::string_view enum_string) { … }

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


const char* ToString(ErrorType enum_param) { … }

ErrorType ParseErrorType(std::string_view enum_string) { … }

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


const char* ToString(ErrorLevel enum_param) { … }

ErrorLevel ParseErrorLevel(std::string_view enum_string) { … }

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


const char* ToString(ExtensionState enum_param) { … }

ExtensionState ParseExtensionState(std::string_view enum_string) { … }

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


const char* ToString(CommandScope enum_param) { … }

CommandScope ParseCommandScope(std::string_view enum_string) { … }

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


const char* ToString(SafetyCheckWarningReason enum_param) { … }

SafetyCheckWarningReason ParseSafetyCheckWarningReason(std::string_view enum_string) { … }

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


AccessModifier::AccessModifier()
: … { … }

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

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

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

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

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

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


StackFrame::StackFrame()
: … { … }

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

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

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

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

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

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


ManifestError::ManifestError()
: … { … }

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

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

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

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

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

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


RuntimeError::RuntimeError()
: … { … }

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

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

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

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

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

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


DisableReasons::DisableReasons()
: … { … }

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

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

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

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

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

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


OptionsPage::OptionsPage()
: … { … }

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

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

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

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

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

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


HomePage::HomePage()
: … { … }

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

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

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

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

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

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


ExtensionView::ExtensionView()
: … { … }

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

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

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

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

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

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


const char* ToString(HostAccess enum_param) { … }

HostAccess ParseHostAccess(std::string_view enum_string) { … }

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


SafetyCheckStrings::SafetyCheckStrings()
 { … }

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

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

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

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

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

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


ControlledInfo::ControlledInfo()
 { … }

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

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

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

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

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

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


Command::Command()
: … { … }

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

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

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

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

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

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


DependentExtension::DependentExtension()
 { … }

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

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

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

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

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

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


Permission::Permission()
 { … }

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

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

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

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

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

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


SiteControl::SiteControl()
: … { … }

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

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

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

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

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

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


RuntimeHostPermissions::RuntimeHostPermissions()
: … { … }

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

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

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

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

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

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


Permissions::Permissions()
: … { … }

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

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

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

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

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

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


ExtensionInfo::ExtensionInfo()
: … { … }

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

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

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

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

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

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


ProfileInfo::ProfileInfo()
: … { … }

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

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

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

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

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

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


ItemInfo::ItemInfo()
: … { … }

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

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

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

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

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

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


GetExtensionsInfoOptions::GetExtensionsInfoOptions()
 { … }

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

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

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

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

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

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


ExtensionConfigurationUpdate::ExtensionConfigurationUpdate()
: … { … }

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

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

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

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

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

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


ProfileConfigurationUpdate::ProfileConfigurationUpdate()
 { … }

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

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

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

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

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

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


ExtensionCommandUpdate::ExtensionCommandUpdate()
: … { … }

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

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

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

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

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

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


ReloadOptions::ReloadOptions()
 { … }

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

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

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

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

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

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


LoadUnpackedOptions::LoadUnpackedOptions()
 { … }

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

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

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

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

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

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


const char* ToString(SiteSet enum_param) { … }

SiteSet ParseSiteSet(std::string_view enum_string) { … }

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


UserSiteSettingsOptions::UserSiteSettingsOptions()
: … { … }

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

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

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

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

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

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


UserSiteSettings::UserSiteSettings()
 { … }

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

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

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

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

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

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


SiteInfo::SiteInfo()
: … { … }

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

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

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

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

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

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


SiteGroup::SiteGroup()
: … { … }

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

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

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

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

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

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


MatchingExtensionInfo::MatchingExtensionInfo()
: … { … }

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

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

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

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

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

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


ExtensionSiteAccessUpdate::ExtensionSiteAccessUpdate()
: … { … }

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

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

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

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

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

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


const char* ToString(PackStatus enum_param) { … }

PackStatus ParsePackStatus(std::string_view enum_string) { … }

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


const char* ToString(FileType enum_param) { … }

FileType ParseFileType(std::string_view enum_string) { … }

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


const char* ToString(SelectType enum_param) { … }

SelectType ParseSelectType(std::string_view enum_string) { … }

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


const char* ToString(EventType enum_param) { … }

EventType ParseEventType(std::string_view enum_string) { … }

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


PackDirectoryResponse::PackDirectoryResponse()
: … { … }

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

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

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

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

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

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


ProjectInfo::ProjectInfo()
 { … }

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

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

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

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

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

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


EventData::EventData()
: … { … }

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

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

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

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

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

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


ErrorFileSource::ErrorFileSource()
 { … }

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

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

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

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

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

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


LoadError::LoadError()
 { … }

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

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

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

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

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

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


RequestFileSourceProperties::RequestFileSourceProperties()
 { … }

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

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

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

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

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

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


RequestFileSourceResponse::RequestFileSourceResponse()
 { … }

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

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

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

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

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

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


OpenDevToolsProperties::OpenDevToolsProperties()
: … { … }

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

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

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

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

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

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


DeleteExtensionErrorsProperties::DeleteExtensionErrorsProperties()
: … { … }

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

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

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

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

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

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



//
// Functions
//

namespace AutoUpdate {

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

namespace GetExtensionsInfo {

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<ExtensionInfo>& result) { … }
}  // namespace GetExtensionsInfo

namespace GetExtensionInfo {

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 ExtensionInfo& result) { … }
}  // namespace GetExtensionInfo

namespace GetExtensionSize {

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& string) { … }
}  // namespace GetExtensionSize

namespace GetProfileConfiguration {

base::Value::List Results::Create(const ProfileInfo& info) { … }
}  // namespace GetProfileConfiguration

namespace UpdateProfileConfiguration {

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 UpdateProfileConfiguration

namespace Reload {

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 LoadError& error) { … }
}  // namespace Reload

namespace UpdateExtensionConfiguration {

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 UpdateExtensionConfiguration

namespace LoadUnpacked {

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 LoadError& error) { … }
}  // namespace LoadUnpacked

namespace InstallDroppedFile {

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

namespace NotifyDragInstallInProgress {

}  // namespace NotifyDragInstallInProgress

namespace LoadDirectory {

Params::Directory::Directory()
 { … }

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

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

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

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

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


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& string) { … }
}  // namespace LoadDirectory

namespace ChoosePath {

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& string) { … }
}  // namespace ChoosePath

namespace PackDirectory {

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 PackDirectoryResponse& response) { … }
}  // namespace PackDirectory

namespace IsProfileManaged {

base::Value::List Results::Create(bool result) { … }
}  // namespace IsProfileManaged

namespace RequestFileSource {

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 RequestFileSourceResponse& response) { … }
}  // namespace RequestFileSource

namespace OpenDevTools {

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 OpenDevTools

namespace DeleteExtensionErrors {

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 DeleteExtensionErrors

namespace RepairExtension {

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 RepairExtension

namespace ShowOptions {

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 ShowOptions

namespace ShowPath {

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 ShowPath

namespace SetShortcutHandlingSuspended {

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 SetShortcutHandlingSuspended

namespace UpdateExtensionCommand {

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 UpdateExtensionCommand

namespace AddHostPermission {

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 AddHostPermission

namespace RemoveHostPermission {

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 RemoveHostPermission

namespace GetUserSiteSettings {

base::Value::List Results::Create(const UserSiteSettings& settings) { … }
}  // namespace GetUserSiteSettings

namespace AddUserSpecifiedSites {

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 AddUserSpecifiedSites

namespace RemoveUserSpecifiedSites {

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 RemoveUserSpecifiedSites

namespace GetUserAndExtensionSitesByEtld {

base::Value::List Results::Create(const std::vector<SiteGroup>& site_groups) { … }
}  // namespace GetUserAndExtensionSitesByEtld

namespace GetMatchingExtensionsForSite {

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<MatchingExtensionInfo>& matching_extensions) { … }
}  // namespace GetMatchingExtensionsForSite

namespace UpdateSiteAccess {

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 UpdateSiteAccess

namespace RemoveMultipleExtensions {

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 RemoveMultipleExtensions

namespace DismissSafetyHubExtensionsMenuNotification {

}  // namespace DismissSafetyHubExtensionsMenuNotification

namespace DismissMv2DeprecationNoticeForExtension {

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 DismissMv2DeprecationNoticeForExtension

//
// Events
//

namespace OnItemStateChanged {

const char kEventName[] = …;

base::Value::List Create(const EventData& response) { … }

}  // namespace OnItemStateChanged

namespace OnProfileStateChanged {

const char kEventName[] = …;

base::Value::List Create(const ProfileInfo& info) { … }

}  // namespace OnProfileStateChanged

namespace OnUserSiteSettingsChanged {

const char kEventName[] = …;

base::Value::List Create(const UserSiteSettings& settings) { … }

}  // namespace OnUserSiteSettingsChanged

}  // namespace developer_private
}  // namespace api
}  // namespace extensions