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

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

const char* ToString(ShelfAlignmentType enum_param) { … }

ShelfAlignmentType ParseShelfAlignmentType(std::string_view enum_string) { … }

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


const char* ToString(ShelfItemType enum_param) { … }

ShelfItemType ParseShelfItemType(std::string_view enum_string) { … }

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


const char* ToString(ShelfItemStatus enum_param) { … }

ShelfItemStatus ParseShelfItemStatus(std::string_view enum_string) { … }

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


const char* ToString(AppType enum_param) { … }

AppType ParseAppType(std::string_view enum_string) { … }

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


const char* ToString(AppInstallSource enum_param) { … }

AppInstallSource ParseAppInstallSource(std::string_view enum_string) { … }

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


const char* ToString(AppReadiness enum_param) { … }

AppReadiness ParseAppReadiness(std::string_view enum_string) { … }

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


const char* ToString(WakefulnessMode enum_param) { … }

WakefulnessMode ParseWakefulnessMode(std::string_view enum_string) { … }

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


const char* ToString(WindowStateType enum_param) { … }

WindowStateType ParseWindowStateType(std::string_view enum_string) { … }

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


const char* ToString(WMEventType enum_param) { … }

WMEventType ParseWMEventType(std::string_view enum_string) { … }

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


const char* ToString(RotationType enum_param) { … }

RotationType ParseRotationType(std::string_view enum_string) { … }

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


const char* ToString(LauncherStateType enum_param) { … }

LauncherStateType ParseLauncherStateType(std::string_view enum_string) { … }

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


const char* ToString(OverviewStateType enum_param) { … }

OverviewStateType ParseOverviewStateType(std::string_view enum_string) { … }

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


const char* ToString(MouseButton enum_param) { … }

MouseButton ParseMouseButton(std::string_view enum_string) { … }

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


WindowStateChangeDict::WindowStateChangeDict()
: … { … }

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

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

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

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

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

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


LoginStatusDict::LoginStatusDict()
: … { … }

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

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

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

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

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

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


ExtensionInfoDict::ExtensionInfoDict()
: … { … }

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

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

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

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

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

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


ExtensionsInfoArray::ExtensionsInfoArray()
 { … }

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

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

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

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

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

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


Notification::Notification()
: … { … }

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

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

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

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

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

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


Printer::Printer()
 { … }

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

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

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

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

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

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


ArcState::ArcState()
: … { … }

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

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

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

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

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

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


PlayStoreState::PlayStoreState()
: … { … }

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

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

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

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

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

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


AssistantQueryResponse::AssistantQueryResponse()
 { … }

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

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

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

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

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

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


AssistantQueryStatus::AssistantQueryStatus()
: … { … }

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

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

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

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

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

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


const char* ToString(LacrosState enum_param) { … }

LacrosState ParseLacrosState(std::string_view enum_string) { … }

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


const char* ToString(LacrosMode enum_param) { … }

LacrosMode ParseLacrosMode(std::string_view enum_string) { … }

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


LacrosInfo::LacrosInfo()
: … { … }

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

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

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

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

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

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


ArcAppDict::ArcAppDict()
: … { … }

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

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

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

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

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

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


ArcAppKillsDict::ArcAppKillsDict()
: … { … }

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

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

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

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

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

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


ArcPackageDict::ArcPackageDict()
: … { … }

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

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

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

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

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

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


Location::Location()
: … { … }

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

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

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

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

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

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


Bounds::Bounds()
: … { … }

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

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

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

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

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

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


ArcAppTracingInfo::ArcAppTracingInfo()
: … { … }

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

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

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

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

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

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


const char* ToString(ThemeStyle enum_param) { … }

ThemeStyle ParseThemeStyle(std::string_view enum_string) { … }

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


App::App()
: … { … }

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

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

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

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

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

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


SystemWebApp::SystemWebApp()
 { … }

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

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

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

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

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

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


ShelfItem::ShelfItem()
: … { … }

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

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

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

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

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

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


const char* ToString(AppWindowType enum_param) { … }

AppWindowType ParseAppWindowType(std::string_view enum_string) { … }

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


const char* ToString(HotseatState enum_param) { … }

HotseatState ParseHotseatState(std::string_view enum_string) { … }

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


const char* ToString(FrameMode enum_param) { … }

FrameMode ParseFrameMode(std::string_view enum_string) { … }

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


OverviewInfo::OverviewInfo()
: … { … }

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

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

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

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

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

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


ShelfIconPinUpdateParam::ShelfIconPinUpdateParam()
: … { … }

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

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

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

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

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

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


AppWindowInfo::AppWindowInfo()
: … { … }

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

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

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

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

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

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


Accelerator::Accelerator()
: … { … }

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

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

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

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

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

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


ScrollableShelfState::ScrollableShelfState()
 { … }

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

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

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

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

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

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


ShelfState::ShelfState()
 { … }

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

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

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

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

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

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


ScrollableShelfInfo::ScrollableShelfInfo()
: … { … }

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

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

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

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

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

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


HotseatSwipeDescriptor::HotseatSwipeDescriptor()
 { … }

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

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

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

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

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

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


HotseatInfo::HotseatInfo()
: … { … }

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

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

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

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

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

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


ShelfUIInfo::ShelfUIInfo()
 { … }

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

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

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

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

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

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


DesksInfo::DesksInfo()
: … { … }

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

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

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

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

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

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


LauncherSearchBoxState::LauncherSearchBoxState()
 { … }

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

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

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

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

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

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


FrameCountingPerSinkData::FrameCountingPerSinkData()
: … { … }

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

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

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

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

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

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


OverdrawData::OverdrawData()
 { … }

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

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

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

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

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

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


SetWindowBoundsResult::SetWindowBoundsResult()
 { … }

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

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

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

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

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

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


DisplaySmoothnessData::DisplaySmoothnessData()
: … { … }

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

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

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

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

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

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


ThroughputTrackerAnimationData::ThroughputTrackerAnimationData()
: … { … }

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

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

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

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

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

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


ResetHoldingSpaceOptions::ResetHoldingSpaceOptions()
: … { … }

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

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

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

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

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

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


LoginEventRecorderData::LoginEventRecorderData()
: … { … }

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

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

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

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

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

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


GetAccessTokenParams::GetAccessTokenParams()
 { … }

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

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

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

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

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

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


GetAccessTokenData::GetAccessTokenData()
 { … }

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

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

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

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

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

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


MakeFuseboxTempDirData::MakeFuseboxTempDirData()
 { … }

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

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

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

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

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

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


GetCurrentInputMethodDescriptorData::GetCurrentInputMethodDescriptorData()
 { … }

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

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

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

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

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

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


OrcaResponseArray::OrcaResponseArray()
 { … }

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

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

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

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

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

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



//
// Functions
//

namespace InitializeEvents {

}  // namespace InitializeEvents

namespace Logout {

}  // namespace Logout

namespace Restart {

}  // namespace Restart

namespace Shutdown {

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 Shutdown

namespace LoginStatus {

base::Value::List Results::Create(const LoginStatusDict& status) { … }
}  // namespace LoginStatus

namespace WaitForLoginAnimationEnd {

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

namespace LockScreen {

}  // namespace LockScreen

namespace GetExtensionsInfo {

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

namespace GetAllEnterprisePolicies {

base::Value::List Results::Create(const base::Value& all_policies) { … }
}  // namespace GetAllEnterprisePolicies

namespace RefreshEnterprisePolicies {

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

namespace RefreshRemoteCommands {

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

namespace SimulateAsanMemoryBug {

}  // namespace SimulateAsanMemoryBug

namespace SetTouchpadSensitivity {

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 SetTouchpadSensitivity

namespace SetTapToClick {

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 SetTapToClick

namespace SetThreeFingerClick {

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 SetThreeFingerClick

namespace SetTapDragging {

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 SetTapDragging

namespace SetNaturalScroll {

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 SetNaturalScroll

namespace SetMouseSensitivity {

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 SetMouseSensitivity

namespace SetPrimaryButtonRight {

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 SetPrimaryButtonRight

namespace SetMouseReverseScroll {

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 SetMouseReverseScroll

namespace GetVisibleNotifications {

base::Value::List Results::Create(const std::vector<Notification>& notifications) { … }
}  // namespace GetVisibleNotifications

namespace RemoveAllNotifications {

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

namespace GetArcStartTime {

base::Value::List Results::Create(double start_ticks) { … }
}  // namespace GetArcStartTime

namespace GetArcState {

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

namespace GetPlayStoreState {

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

namespace GetPrinterList {

base::Value::List Results::Create(const std::vector<Printer>& printers) { … }
}  // namespace GetPrinterList

namespace IsAppShown {

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(bool app_shown) { … }
}  // namespace IsAppShown

namespace IsArcProvisioned {

base::Value::List Results::Create(bool arc_provisioned) { … }
}  // namespace IsArcProvisioned

namespace GetLacrosInfo {

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

namespace GetArcApp {

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 ArcAppDict& package) { … }
}  // namespace GetArcApp

namespace GetArcAppKills {

base::Value::List Results::Create(const ArcAppKillsDict& counts) { … }
}  // namespace GetArcAppKills

namespace GetArcPackage {

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 ArcPackageDict& package) { … }
}  // namespace GetArcPackage

namespace WaitForSystemWebAppsInstall {

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

namespace GetDefaultPinnedAppIds {

base::Value::List Results::Create(const std::vector<std::string>& items) { … }
}  // namespace GetDefaultPinnedAppIds

namespace GetRegisteredSystemWebApps {

base::Value::List Results::Create(const std::vector<SystemWebApp>& system_web_apps) { … }
}  // namespace GetRegisteredSystemWebApps

namespace IsSystemWebAppOpen {

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(bool is_open) { … }
}  // namespace IsSystemWebAppOpen

namespace LaunchApp {

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 LaunchApp

namespace LaunchSystemWebApp {

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 LaunchSystemWebApp

namespace LaunchFilesAppToPath {

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 LaunchFilesAppToPath

namespace CloseApp {

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 CloseApp

namespace UpdatePrinter {

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 UpdatePrinter

namespace RemovePrinter {

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 RemovePrinter

namespace StartArc {

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

namespace StopArc {

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

namespace SetPlayStoreEnabled {

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 SetPlayStoreEnabled

namespace GetClipboardTextData {

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

namespace SetClipboardTextData {

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 SetClipboardTextData

namespace RunCrostiniInstaller {

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

namespace RunCrostiniUninstaller {

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

namespace SetCrostiniEnabled {

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 SetCrostiniEnabled

namespace ExportCrostini {

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 ExportCrostini

namespace ImportCrostini {

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 ImportCrostini

namespace CouldAllowCrostini {

base::Value::List Results::Create(bool can_be_allowed) { … }
}  // namespace CouldAllowCrostini

namespace SetPluginVMPolicy {

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 SetPluginVMPolicy

namespace ShowPluginVMInstaller {

}  // namespace ShowPluginVMInstaller

namespace InstallBorealis {

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

namespace RegisterComponent {

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 RegisterComponent

namespace TakeScreenshot {

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

namespace TakeScreenshotForDisplay {

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& base64_png) { … }
}  // namespace TakeScreenshotForDisplay

namespace LoadSmartDimComponent {

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

namespace SetAssistantEnabled {

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 SetAssistantEnabled

namespace EnableAssistantAndWaitForReady {

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

namespace SendAssistantTextQuery {

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 AssistantQueryStatus& status) { … }
}  // namespace SendAssistantTextQuery

namespace WaitForAssistantQueryStatus {

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 AssistantQueryStatus& status) { … }
}  // namespace WaitForAssistantQueryStatus

namespace IsArcPackageListInitialRefreshed {

base::Value::List Results::Create(bool refreshed) { … }
}  // namespace IsArcPackageListInitialRefreshed

namespace SetAllowedPref {

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 SetAllowedPref

namespace ClearAllowedPref {

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 ClearAllowedPref

namespace SetWhitelistedPref {

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 SetWhitelistedPref

namespace SetCrostiniAppScaled {

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 SetCrostiniAppScaled

namespace GetPrimaryDisplayScaleFactor {

base::Value::List Results::Create(double scale_factor) { … }
}  // namespace GetPrimaryDisplayScaleFactor

namespace IsTabletModeEnabled {

base::Value::List Results::Create(bool enabled) { … }
}  // namespace IsTabletModeEnabled

namespace SetTabletModeEnabled {

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(bool enabled) { … }
}  // namespace SetTabletModeEnabled

namespace GetAllInstalledApps {

base::Value::List Results::Create(const std::vector<App>& apps) { … }
}  // namespace GetAllInstalledApps

namespace GetShelfItems {

base::Value::List Results::Create(const std::vector<ShelfItem>& items) { … }
}  // namespace GetShelfItems

namespace GetLauncherSearchBoxState {

base::Value::List Results::Create(const LauncherSearchBoxState& state) { … }
}  // namespace GetLauncherSearchBoxState

namespace GetShelfAutoHideBehavior {

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& behavior) { … }
}  // namespace GetShelfAutoHideBehavior

namespace SetShelfAutoHideBehavior {

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 SetShelfAutoHideBehavior

namespace GetShelfAlignment {

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 ShelfAlignmentType& alignment) { … }
}  // namespace GetShelfAlignment

namespace SetShelfAlignment {

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 SetShelfAlignment

namespace PinShelfIcon {

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 PinShelfIcon

namespace SetShelfIconPin {

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<std::string>& results) { … }
}  // namespace SetShelfIconPin

namespace SetOverviewModeState {

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(bool finished) { … }
}  // namespace SetOverviewModeState

namespace ShowVirtualKeyboardIfEnabled {

}  // namespace ShowVirtualKeyboardIfEnabled

namespace SendArcOverlayColor {

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(bool result) { … }
}  // namespace SendArcOverlayColor

namespace ArcAppTracingStart {

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

namespace ArcAppTracingStopAndAnalyze {

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

namespace SwapWindowsInSplitView {

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

namespace SetArcAppWindowFocus {

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 SetArcAppWindowFocus

namespace WaitForDisplayRotation {

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(bool success) { … }
}  // namespace WaitForDisplayRotation

namespace GetAppWindowList {

base::Value::List Results::Create(const std::vector<AppWindowInfo>& window_list) { … }
}  // namespace GetAppWindowList

namespace SetAppWindowState {

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 WindowStateType& current_type) { … }
}  // namespace SetAppWindowState

namespace ActivateAppWindow {

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 ActivateAppWindow

namespace CloseAppWindow {

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 CloseAppWindow

namespace InstallPWAForCurrentURL {

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& app_id) { … }
}  // namespace InstallPWAForCurrentURL

namespace ActivateAccelerator {

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(bool success) { … }
}  // namespace ActivateAccelerator

namespace WaitForLauncherState {

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 WaitForLauncherState

namespace WaitForOverviewState {

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 WaitForOverviewState

namespace CreateNewDesk {

base::Value::List Results::Create(bool success) { … }
}  // namespace CreateNewDesk

namespace ActivateDeskAtIndex {

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(bool success) { … }
}  // namespace ActivateDeskAtIndex

namespace RemoveActiveDesk {

base::Value::List Results::Create(bool success) { … }
}  // namespace RemoveActiveDesk

namespace ActivateAdjacentDesksToTargetIndex {

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(bool success) { … }
}  // namespace ActivateAdjacentDesksToTargetIndex

namespace GetDeskCount {

base::Value::List Results::Create(int count) { … }
}  // namespace GetDeskCount

namespace GetDesksInfo {

base::Value::List Results::Create(const DesksInfo& desks) { … }
}  // namespace GetDesksInfo

namespace MouseClick {

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 MouseClick

namespace MousePress {

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 MousePress

namespace MouseRelease {

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 MouseRelease

namespace MouseMove {

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 MouseMove

namespace SetMetricsEnabled {

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 SetMetricsEnabled

namespace SetArcTouchMode {

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 SetArcTouchMode

namespace GetScrollableShelfInfoForState {

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 ScrollableShelfInfo& info) { … }
}  // namespace GetScrollableShelfInfoForState

namespace GetShelfUIInfoForState {

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 ShelfUIInfo& info) { … }
}  // namespace GetShelfUIInfoForState

namespace SetWindowBounds {

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

namespace StartSmoothnessTracking {

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 StartSmoothnessTracking

namespace StopSmoothnessTracking {

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 DisplaySmoothnessData& data) { … }
}  // namespace StopSmoothnessTracking

namespace DisableSwitchAccessDialog {

}  // namespace DisableSwitchAccessDialog

namespace WaitForAmbientPhotoAnimation {

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 WaitForAmbientPhotoAnimation

namespace WaitForAmbientVideo {

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 WaitForAmbientVideo

namespace DisableAutomation {

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

namespace StartThroughputTrackerDataCollection {

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

namespace StopThroughputTrackerDataCollection {

base::Value::List Results::Create(const std::vector<ThroughputTrackerAnimationData>& data) { … }
}  // namespace StopThroughputTrackerDataCollection

namespace GetThroughputTrackerData {

base::Value::List Results::Create(const std::vector<ThroughputTrackerAnimationData>& data) { … }
}  // namespace GetThroughputTrackerData

namespace GetDisplaySmoothness {

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(int smoothness) { … }
}  // namespace GetDisplaySmoothness

namespace ResetHoldingSpace {

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 ResetHoldingSpace

namespace StartLoginEventRecorderDataCollection {

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

namespace GetLoginEventRecorderLoginEvents {

base::Value::List Results::Create(const std::vector<LoginEventRecorderData>& data) { … }
}  // namespace GetLoginEventRecorderLoginEvents

namespace AddLoginEventForTesting {

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

namespace ForceAutoThemeMode {

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 ForceAutoThemeMode

namespace GetAccessToken {

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 GetAccessTokenData& data) { … }
}  // namespace GetAccessToken

namespace IsInputMethodReadyForTesting {

base::Value::List Results::Create(bool is_ready) { … }
}  // namespace IsInputMethodReadyForTesting

namespace MakeFuseboxTempDir {

base::Value::List Results::Create(const MakeFuseboxTempDirData& data) { … }
}  // namespace MakeFuseboxTempDir

namespace RemoveFuseboxTempDir {

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 RemoveFuseboxTempDir

namespace RemoveComponentExtension {

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 RemoveComponentExtension

namespace StartFrameCounting {

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 StartFrameCounting

namespace StopFrameCounting {

base::Value::List Results::Create(const std::vector<FrameCountingPerSinkData>& data) { … }
}  // namespace StopFrameCounting

namespace StartOverdrawTracking {

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 StartOverdrawTracking

namespace StopOverdrawTracking {

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 OverdrawData& data) { … }
}  // namespace StopOverdrawTracking

namespace InstallBruschetta {

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 InstallBruschetta

namespace RemoveBruschetta {

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 RemoveBruschetta

namespace IsFeatureEnabled {

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(bool enabled) { … }
}  // namespace IsFeatureEnabled

namespace GetCurrentInputMethodDescriptor {

base::Value::List Results::Create(const GetCurrentInputMethodDescriptorData& data) { … }
}  // namespace GetCurrentInputMethodDescriptor

namespace OverrideOrcaResponseForTesting {

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(bool success) { … }
}  // namespace OverrideOrcaResponseForTesting

namespace SetArcInteractiveState {

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 SetArcInteractiveState

namespace IsFieldTrialActive {

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(bool active) { … }
}  // namespace IsFieldTrialActive

namespace GetArcWakefulnessMode {

base::Value::List Results::Create(const WakefulnessMode& mode) { … }
}  // namespace GetArcWakefulnessMode

namespace SetDeviceLanguage {

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 SetDeviceLanguage

//
// Events
//

namespace OnClipboardDataChanged {

const char kEventName[] = …;

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

}  // namespace OnClipboardDataChanged

}  // namespace autotest_private
}  // namespace api
}  // namespace extensions