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

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

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

#include "extensions/common/api/declarative_net_request.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 "tools/json_schema_compiler/manifest_parse_util.h"

#include <string_view>
#include "base/types/expected.h"
#include "extensions/common/api/extension_types.h"


UTF8ToUTF16;

namespace extensions {
namespace api {
namespace declarative_net_request {
//
// Properties
//

const int GUARANTEED_MINIMUM_STATIC_RULES = …;

const int MAX_NUMBER_OF_DYNAMIC_AND_SESSION_RULES = …;

const int MAX_NUMBER_OF_DYNAMIC_RULES = …;

const int MAX_NUMBER_OF_UNSAFE_DYNAMIC_RULES = …;

const int MAX_NUMBER_OF_SESSION_RULES = …;

const int MAX_NUMBER_OF_UNSAFE_SESSION_RULES = …;

const int GETMATCHEDRULES_QUOTA_INTERVAL = …;

const int MAX_GETMATCHEDRULES_CALLS_PER_INTERVAL = …;

const int MAX_NUMBER_OF_REGEX_RULES = …;

const int MAX_NUMBER_OF_STATIC_RULESETS = …;

const int MAX_NUMBER_OF_ENABLED_STATIC_RULESETS = …;

const char DYNAMIC_RULESET_ID[] = …;

const char SESSION_RULESET_ID[] = …;

//
// Types
//

const char* ToString(ResourceType enum_param) { … }

ResourceType ParseResourceType(std::string_view enum_string) { … }

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


const char* ToString(RequestMethod enum_param) { … }

RequestMethod ParseRequestMethod(std::string_view enum_string) { … }

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


const char* ToString(DomainType enum_param) { … }

DomainType ParseDomainType(std::string_view enum_string) { … }

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


const char* ToString(HeaderOperation enum_param) { … }

HeaderOperation ParseHeaderOperation(std::string_view enum_string) { … }

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


const char* ToString(RuleActionType enum_param) { … }

RuleActionType ParseRuleActionType(std::string_view enum_string) { … }

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


const char* ToString(UnsupportedRegexReason enum_param) { … }

UnsupportedRegexReason ParseUnsupportedRegexReason(std::string_view enum_string) { … }

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


Ruleset::Ruleset()
: … { … }

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

// static
bool Ruleset::Populate(
    const base::Value::Dict& dict, Ruleset& out, std::u16string& error) { … }

// static
bool Ruleset::Populate(
    const base::Value& value, Ruleset& out, std::u16string& error) { … }

// static
base::expected<Ruleset, std::u16string> Ruleset::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Ruleset, std::u16string> Ruleset::FromValue(const base::Value& value) { … }

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


QueryKeyValue::QueryKeyValue()
 { … }

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

// static
bool QueryKeyValue::Populate(
    const base::Value::Dict& dict, QueryKeyValue& out, std::u16string& error) { … }

// static
bool QueryKeyValue::Populate(
    const base::Value& value, QueryKeyValue& out, std::u16string& error) { … }

// static
base::expected<QueryKeyValue, std::u16string> QueryKeyValue::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<QueryKeyValue, std::u16string> QueryKeyValue::FromValue(const base::Value& value) { … }

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


QueryTransform::QueryTransform()
 { … }

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

// static
bool QueryTransform::Populate(
    const base::Value::Dict& dict, QueryTransform& out, std::u16string& error) { … }

// static
bool QueryTransform::Populate(
    const base::Value& value, QueryTransform& out, std::u16string& error) { … }

// static
base::expected<QueryTransform, std::u16string> QueryTransform::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<QueryTransform, std::u16string> QueryTransform::FromValue(const base::Value& value) { … }

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


URLTransform::URLTransform()
 { … }

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

// static
bool URLTransform::Populate(
    const base::Value::Dict& dict, URLTransform& out, std::u16string& error) { … }

// static
bool URLTransform::Populate(
    const base::Value& value, URLTransform& out, std::u16string& error) { … }

// static
base::expected<URLTransform, std::u16string> URLTransform::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<URLTransform, std::u16string> URLTransform::FromValue(const base::Value& value) { … }

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


Redirect::Redirect()
 { … }

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

// static
bool Redirect::Populate(
    const base::Value::Dict& dict, Redirect& out, std::u16string& error) { … }

// static
bool Redirect::Populate(
    const base::Value& value, Redirect& out, std::u16string& error) { … }

// static
base::expected<Redirect, std::u16string> Redirect::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Redirect, std::u16string> Redirect::FromValue(const base::Value& value) { … }

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


HeaderInfo::HeaderInfo()
 { … }

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

// static
bool HeaderInfo::Populate(
    const base::Value::Dict& dict, HeaderInfo& out, std::u16string& error) { … }

// static
bool HeaderInfo::Populate(
    const base::Value& value, HeaderInfo& out, std::u16string& error) { … }

// static
base::expected<HeaderInfo, std::u16string> HeaderInfo::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<HeaderInfo, std::u16string> HeaderInfo::FromValue(const base::Value& value) { … }

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


RuleCondition::RuleCondition()
: … { … }

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

// static
bool RuleCondition::Populate(
    const base::Value::Dict& dict, RuleCondition& out, std::u16string& error) { … }

// static
bool RuleCondition::Populate(
    const base::Value& value, RuleCondition& out, std::u16string& error) { … }

// static
base::expected<RuleCondition, std::u16string> RuleCondition::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<RuleCondition, std::u16string> RuleCondition::FromValue(const base::Value& value) { … }

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


HeaderRegexOptions::HeaderRegexOptions()
 { … }

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

// static
bool HeaderRegexOptions::Populate(
    const base::Value::Dict& dict, HeaderRegexOptions& out, std::u16string& error) { … }

// static
bool HeaderRegexOptions::Populate(
    const base::Value& value, HeaderRegexOptions& out, std::u16string& error) { … }

// static
base::expected<HeaderRegexOptions, std::u16string> HeaderRegexOptions::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<HeaderRegexOptions, std::u16string> HeaderRegexOptions::FromValue(const base::Value& value) { … }

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


ModifyHeaderInfo::ModifyHeaderInfo()
: … { … }

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

// static
bool ModifyHeaderInfo::Populate(
    const base::Value::Dict& dict, ModifyHeaderInfo& out, std::u16string& error) { … }

// static
bool ModifyHeaderInfo::Populate(
    const base::Value& value, ModifyHeaderInfo& out, std::u16string& error) { … }

// static
base::expected<ModifyHeaderInfo, std::u16string> ModifyHeaderInfo::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<ModifyHeaderInfo, std::u16string> ModifyHeaderInfo::FromValue(const base::Value& value) { … }

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


RuleAction::RuleAction()
: … { … }

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

// static
bool RuleAction::Populate(
    const base::Value::Dict& dict, RuleAction& out, std::u16string& error) { … }

// static
bool RuleAction::Populate(
    const base::Value& value, RuleAction& out, std::u16string& error) { … }

// static
base::expected<RuleAction, std::u16string> RuleAction::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<RuleAction, std::u16string> RuleAction::FromValue(const base::Value& value) { … }

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


Rule::Rule()
: … { … }

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

// static
bool Rule::Populate(
    const base::Value::Dict& dict, Rule& out, std::u16string& error) { … }

// static
bool Rule::Populate(
    const base::Value& value, Rule& out, std::u16string& error) { … }

// static
base::expected<Rule, std::u16string> Rule::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<Rule, std::u16string> Rule::FromValue(const base::Value& value) { … }

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


MatchedRule::MatchedRule()
: … { … }

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

// static
bool MatchedRule::Populate(
    const base::Value::Dict& dict, MatchedRule& out, std::u16string& error) { … }

// static
bool MatchedRule::Populate(
    const base::Value& value, MatchedRule& out, std::u16string& error) { … }

// static
base::expected<MatchedRule, std::u16string> MatchedRule::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<MatchedRule, std::u16string> MatchedRule::FromValue(const base::Value& value) { … }

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


GetRulesFilter::GetRulesFilter()
 { … }

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

// static
bool GetRulesFilter::Populate(
    const base::Value::Dict& dict, GetRulesFilter& out, std::u16string& error) { … }

// static
bool GetRulesFilter::Populate(
    const base::Value& value, GetRulesFilter& out, std::u16string& error) { … }

// static
base::expected<GetRulesFilter, std::u16string> GetRulesFilter::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<GetRulesFilter, std::u16string> GetRulesFilter::FromValue(const base::Value& value) { … }

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


MatchedRuleInfo::MatchedRuleInfo()
: … { … }

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

// static
bool MatchedRuleInfo::Populate(
    const base::Value::Dict& dict, MatchedRuleInfo& out, std::u16string& error) { … }

// static
bool MatchedRuleInfo::Populate(
    const base::Value& value, MatchedRuleInfo& out, std::u16string& error) { … }

// static
base::expected<MatchedRuleInfo, std::u16string> MatchedRuleInfo::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<MatchedRuleInfo, std::u16string> MatchedRuleInfo::FromValue(const base::Value& value) { … }

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


MatchedRulesFilter::MatchedRulesFilter()
 { … }

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

// static
bool MatchedRulesFilter::Populate(
    const base::Value::Dict& dict, MatchedRulesFilter& out, std::u16string& error) { … }

// static
bool MatchedRulesFilter::Populate(
    const base::Value& value, MatchedRulesFilter& out, std::u16string& error) { … }

// static
base::expected<MatchedRulesFilter, std::u16string> MatchedRulesFilter::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<MatchedRulesFilter, std::u16string> MatchedRulesFilter::FromValue(const base::Value& value) { … }

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


RulesMatchedDetails::RulesMatchedDetails()
 { … }

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

// static
bool RulesMatchedDetails::Populate(
    const base::Value::Dict& dict, RulesMatchedDetails& out, std::u16string& error) { … }

// static
bool RulesMatchedDetails::Populate(
    const base::Value& value, RulesMatchedDetails& out, std::u16string& error) { … }

// static
base::expected<RulesMatchedDetails, std::u16string> RulesMatchedDetails::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<RulesMatchedDetails, std::u16string> RulesMatchedDetails::FromValue(const base::Value& value) { … }

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


RequestDetails::RequestDetails()
: … { … }

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

// static
bool RequestDetails::Populate(
    const base::Value::Dict& dict, RequestDetails& out, std::u16string& error) { … }

// static
bool RequestDetails::Populate(
    const base::Value& value, RequestDetails& out, std::u16string& error) { … }

// static
base::expected<RequestDetails, std::u16string> RequestDetails::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<RequestDetails, std::u16string> RequestDetails::FromValue(const base::Value& value) { … }

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


TestMatchRequestDetails::ResponseHeaders::ResponseHeaders()
 { … }

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

// static
bool TestMatchRequestDetails::ResponseHeaders::Populate(
    const base::Value::Dict& dict, ResponseHeaders& out, std::u16string& error) { … }

// static
bool TestMatchRequestDetails::ResponseHeaders::Populate(
    const base::Value& value, ResponseHeaders& out, std::u16string& error) { … }

// static
base::expected<TestMatchRequestDetails::ResponseHeaders, std::u16string> TestMatchRequestDetails::ResponseHeaders::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<TestMatchRequestDetails::ResponseHeaders, std::u16string> TestMatchRequestDetails::ResponseHeaders::FromValue(const base::Value& value) { … }

base::Value::Dict TestMatchRequestDetails::ResponseHeaders::ToValue() const { … }



TestMatchRequestDetails::TestMatchRequestDetails()
: … { … }

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

// static
bool TestMatchRequestDetails::Populate(
    const base::Value::Dict& dict, TestMatchRequestDetails& out, std::u16string& error) { … }

// static
bool TestMatchRequestDetails::Populate(
    const base::Value& value, TestMatchRequestDetails& out, std::u16string& error) { … }

// static
base::expected<TestMatchRequestDetails, std::u16string> TestMatchRequestDetails::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<TestMatchRequestDetails, std::u16string> TestMatchRequestDetails::FromValue(const base::Value& value) { … }

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


MatchedRuleInfoDebug::MatchedRuleInfoDebug()
 { … }

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

// static
bool MatchedRuleInfoDebug::Populate(
    const base::Value::Dict& dict, MatchedRuleInfoDebug& out, std::u16string& error) { … }

// static
bool MatchedRuleInfoDebug::Populate(
    const base::Value& value, MatchedRuleInfoDebug& out, std::u16string& error) { … }

// static
base::expected<MatchedRuleInfoDebug, std::u16string> MatchedRuleInfoDebug::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<MatchedRuleInfoDebug, std::u16string> MatchedRuleInfoDebug::FromValue(const base::Value& value) { … }

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


DNRInfo::DNRInfo()
 { … }

DNRInfo::~DNRInfo() = default;
DNRInfo::DNRInfo(DNRInfo&& rhs) noexcept = default;
DNRInfo& DNRInfo::operator=(DNRInfo&& rhs) noexcept = default;
// static
constexpr char DNRInfo::kRuleResources[];

DNRInfo DNRInfo::Clone() const { … }

// static
bool DNRInfo::Populate(
    const base::Value::Dict& dict, DNRInfo& out, std::u16string& error) { … }

// static
bool DNRInfo::Populate(
    const base::Value& value, DNRInfo& out, std::u16string& error) { … }

// static
base::expected<DNRInfo, std::u16string> DNRInfo::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<DNRInfo, std::u16string> DNRInfo::FromValue(const base::Value& value) { … }

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

//static
bool DNRInfo::ParseFromDictionary(
const base::Value::Dict& root_dict, std::string_view key, DNRInfo& out, std::u16string& error, std::vector<std::string_view>& error_path_reversed) { … }


RegexOptions::RegexOptions()
 { … }

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

// static
bool RegexOptions::Populate(
    const base::Value::Dict& dict, RegexOptions& out, std::u16string& error) { … }

// static
bool RegexOptions::Populate(
    const base::Value& value, RegexOptions& out, std::u16string& error) { … }

// static
base::expected<RegexOptions, std::u16string> RegexOptions::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<RegexOptions, std::u16string> RegexOptions::FromValue(const base::Value& value) { … }

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


IsRegexSupportedResult::IsRegexSupportedResult()
: … { … }

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

// static
bool IsRegexSupportedResult::Populate(
    const base::Value::Dict& dict, IsRegexSupportedResult& out, std::u16string& error) { … }

// static
bool IsRegexSupportedResult::Populate(
    const base::Value& value, IsRegexSupportedResult& out, std::u16string& error) { … }

// static
base::expected<IsRegexSupportedResult, std::u16string> IsRegexSupportedResult::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<IsRegexSupportedResult, std::u16string> IsRegexSupportedResult::FromValue(const base::Value& value) { … }

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


TestMatchOutcomeResult::TestMatchOutcomeResult()
 { … }

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

// static
bool TestMatchOutcomeResult::Populate(
    const base::Value::Dict& dict, TestMatchOutcomeResult& out, std::u16string& error) { … }

// static
bool TestMatchOutcomeResult::Populate(
    const base::Value& value, TestMatchOutcomeResult& out, std::u16string& error) { … }

// static
base::expected<TestMatchOutcomeResult, std::u16string> TestMatchOutcomeResult::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<TestMatchOutcomeResult, std::u16string> TestMatchOutcomeResult::FromValue(const base::Value& value) { … }

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


UpdateRuleOptions::UpdateRuleOptions()
 { … }

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

// static
bool UpdateRuleOptions::Populate(
    const base::Value::Dict& dict, UpdateRuleOptions& out, std::u16string& error) { … }

// static
bool UpdateRuleOptions::Populate(
    const base::Value& value, UpdateRuleOptions& out, std::u16string& error) { … }

// static
base::expected<UpdateRuleOptions, std::u16string> UpdateRuleOptions::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<UpdateRuleOptions, std::u16string> UpdateRuleOptions::FromValue(const base::Value& value) { … }

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


UpdateRulesetOptions::UpdateRulesetOptions()
 { … }

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

// static
bool UpdateRulesetOptions::Populate(
    const base::Value::Dict& dict, UpdateRulesetOptions& out, std::u16string& error) { … }

// static
bool UpdateRulesetOptions::Populate(
    const base::Value& value, UpdateRulesetOptions& out, std::u16string& error) { … }

// static
base::expected<UpdateRulesetOptions, std::u16string> UpdateRulesetOptions::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<UpdateRulesetOptions, std::u16string> UpdateRulesetOptions::FromValue(const base::Value& value) { … }

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


UpdateStaticRulesOptions::UpdateStaticRulesOptions()
 { … }

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

// static
bool UpdateStaticRulesOptions::Populate(
    const base::Value::Dict& dict, UpdateStaticRulesOptions& out, std::u16string& error) { … }

// static
bool UpdateStaticRulesOptions::Populate(
    const base::Value& value, UpdateStaticRulesOptions& out, std::u16string& error) { … }

// static
base::expected<UpdateStaticRulesOptions, std::u16string> UpdateStaticRulesOptions::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<UpdateStaticRulesOptions, std::u16string> UpdateStaticRulesOptions::FromValue(const base::Value& value) { … }

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


GetDisabledRuleIdsOptions::GetDisabledRuleIdsOptions()
 { … }

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

// static
bool GetDisabledRuleIdsOptions::Populate(
    const base::Value::Dict& dict, GetDisabledRuleIdsOptions& out, std::u16string& error) { … }

// static
bool GetDisabledRuleIdsOptions::Populate(
    const base::Value& value, GetDisabledRuleIdsOptions& out, std::u16string& error) { … }

// static
base::expected<GetDisabledRuleIdsOptions, std::u16string> GetDisabledRuleIdsOptions::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<GetDisabledRuleIdsOptions, std::u16string> GetDisabledRuleIdsOptions::FromValue(const base::Value& value) { … }

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


TabActionCountUpdate::TabActionCountUpdate()
: … { … }

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

// static
bool TabActionCountUpdate::Populate(
    const base::Value::Dict& dict, TabActionCountUpdate& out, std::u16string& error) { … }

// static
bool TabActionCountUpdate::Populate(
    const base::Value& value, TabActionCountUpdate& out, std::u16string& error) { … }

// static
base::expected<TabActionCountUpdate, std::u16string> TabActionCountUpdate::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<TabActionCountUpdate, std::u16string> TabActionCountUpdate::FromValue(const base::Value& value) { … }

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


ExtensionActionOptions::ExtensionActionOptions()
 { … }

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

// static
bool ExtensionActionOptions::Populate(
    const base::Value::Dict& dict, ExtensionActionOptions& out, std::u16string& error) { … }

// static
bool ExtensionActionOptions::Populate(
    const base::Value& value, ExtensionActionOptions& out, std::u16string& error) { … }

// static
base::expected<ExtensionActionOptions, std::u16string> ExtensionActionOptions::FromValue(const base::Value::Dict& value) { … }

// static
base::expected<ExtensionActionOptions, std::u16string> ExtensionActionOptions::FromValue(const base::Value& value) { … }

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



//
// Manifest Keys
//

ManifestKeys::ManifestKeys()
 { … }

ManifestKeys::~ManifestKeys() = default;
ManifestKeys::ManifestKeys(ManifestKeys&& rhs) noexcept = default;
ManifestKeys& ManifestKeys::operator=(ManifestKeys&& rhs) noexcept = default;
// static
constexpr char ManifestKeys::kDeclarativeNetRequest[];

//static
bool ManifestKeys::ParseFromDictionary(
const base::Value::Dict& root_dict, ManifestKeys& out, std::u16string& error) { … }


//
// Functions
//

namespace UpdateDynamicRules {

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, std::u16string& error) { … }


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


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

namespace GetDynamicRules {

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, std::u16string& error) { … }


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


base::Value::List Results::Create(const std::vector<Rule>& rules) { … }
}  // namespace GetDynamicRules

namespace UpdateSessionRules {

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, std::u16string& error) { … }


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


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

namespace GetSessionRules {

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, std::u16string& error) { … }


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


base::Value::List Results::Create(const std::vector<Rule>& rules) { … }
}  // namespace GetSessionRules

namespace UpdateEnabledRulesets {

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, std::u16string& error) { … }


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


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

namespace GetEnabledRulesets {

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

namespace UpdateStaticRules {

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, std::u16string& error) { … }


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


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

namespace GetDisabledRuleIds {

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, std::u16string& error) { … }


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


base::Value::List Results::Create(const std::vector<int>& disabled_rule_ids) { … }
}  // namespace GetDisabledRuleIds

namespace GetMatchedRules {

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, std::u16string& error) { … }


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


base::Value::List Results::Create(const RulesMatchedDetails& details) { … }
}  // namespace GetMatchedRules

namespace SetExtensionActionOptions {

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, std::u16string& error) { … }


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


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

namespace IsRegexSupported {

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, std::u16string& error) { … }


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


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

namespace GetAvailableStaticRuleCount {

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

namespace TestMatchOutcome {

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, std::u16string& error) { … }


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


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

//
// Events
//

namespace OnRuleMatchedDebug {

const char kEventName[] = …;

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

}  // namespace OnRuleMatchedDebug

}  // namespace declarative_net_request
}  // namespace api
}  // namespace extensions