// This file is generated by TypeBuilder_h.template.

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

#ifndef content_protocol_Network_h
#define content_protocol_Network_h

#include "content/common/content_export.h"
#include "content/browser/devtools/protocol/protocol.h"
// For each imported domain we generate a ValueConversions struct instead of a full domain definition
// and include Domain::API version from there.
#include "content/browser/devtools/protocol/debugger.h"
#include "content/browser/devtools/protocol/runtime.h"
#include "content/browser/devtools/protocol/security.h"

namespace content {
namespace protocol {
namespace Network {
using ResourceType = String;
using LoaderId = String;
using RequestId = String;
using ErrorReason = String;
using TimeSinceEpoch = double;
using MonotonicTime = double;
using Headers = Object;
using ConnectionType = String;
using CookieSameSite = String;
using CookiePriority = String;
using CookieSourceScheme = String;
class ResourceTiming;
using ResourcePriority = String;
using RenderBlockingBehavior = String;
class PostDataEntry;
class Request;
class SignedCertificateTimestamp;
class SecurityDetails;
using CertificateTransparencyCompliance = String;
using BlockedReason = String;
using CorsError = String;
class CorsErrorStatus;
using ServiceWorkerResponseSource = String;
class TrustTokenParams;
using TrustTokenOperationType = String;
using AlternateProtocolUsage = String;
using ServiceWorkerRouterSource = String;
class ServiceWorkerRouterInfo;
class Response;
class Initiator;
class CookiePartitionKey;
class Cookie;
using SetCookieBlockedReason = String;
using CookieBlockedReason = String;
using CookieExemptionReason = String;
class BlockedSetCookieWithReason;
class ExemptedSetCookieWithReason;
class AssociatedCookie;
class CookieParam;
class SignedExchangeSignature;
class SignedExchangeHeader;
using SignedExchangeErrorField = String;
class SignedExchangeError;
class SignedExchangeInfo;
class NetworkConditions;
using LocalNetworkAccessRequestPolicy = String;
using IPAddressSpace = String;
class ConnectTiming;
class ClientSecurityState;
class AdScriptIdentifier;
class AdAncestry;
using CrossOriginOpenerPolicyValue = String;
class CrossOriginOpenerPolicyStatus;
using CrossOriginEmbedderPolicyValue = String;
class CrossOriginEmbedderPolicyStatus;
using ContentSecurityPolicySource = String;
class ContentSecurityPolicyStatus;
class SecurityIsolationStatus;
using ReportStatus = String;
using ReportId = String;
class ReportingApiReport;
class ReportingApiEndpoint;
class DeviceBoundSessionKey;
class DeviceBoundSessionWithUsage;
class DeviceBoundSessionCookieCraving;
class DeviceBoundSessionUrlRule;
class DeviceBoundSessionInclusionRules;
class DeviceBoundSession;
using DeviceBoundSessionEventId = String;
using DeviceBoundSessionFetchResult = String;
class DeviceBoundSessionFailedRequest;
class CreationEventDetails;
class RefreshEventDetails;
class TerminationEventDetails;
class ChallengeEventDetails;
class LoadNetworkResourcePageResult;
class LoadNetworkResourceOptions;

// ------------- Forward and enum declarations.

namespace ResourceTypeEnum {
inline constexpr char Document[] = "Document";
inline constexpr char Stylesheet[] = "Stylesheet";
inline constexpr char Image[] = "Image";
inline constexpr char Media[] = "Media";
inline constexpr char Font[] = "Font";
inline constexpr char Script[] = "Script";
inline constexpr char TextTrack[] = "TextTrack";
inline constexpr char XHR[] = "XHR";
inline constexpr char Fetch[] = "Fetch";
inline constexpr char Prefetch[] = "Prefetch";
inline constexpr char EventSource[] = "EventSource";
inline constexpr char WebSocket[] = "WebSocket";
inline constexpr char Manifest[] = "Manifest";
inline constexpr char SignedExchange[] = "SignedExchange";
inline constexpr char Ping[] = "Ping";
inline constexpr char CSPViolationReport[] = "CSPViolationReport";
inline constexpr char Preflight[] = "Preflight";
inline constexpr char FedCM[] = "FedCM";
inline constexpr char Other[] = "Other";
} // namespace ResourceTypeEnum

namespace ErrorReasonEnum {
inline constexpr char Failed[] = "Failed";
inline constexpr char Aborted[] = "Aborted";
inline constexpr char TimedOut[] = "TimedOut";
inline constexpr char AccessDenied[] = "AccessDenied";
inline constexpr char ConnectionClosed[] = "ConnectionClosed";
inline constexpr char ConnectionReset[] = "ConnectionReset";
inline constexpr char ConnectionRefused[] = "ConnectionRefused";
inline constexpr char ConnectionAborted[] = "ConnectionAborted";
inline constexpr char ConnectionFailed[] = "ConnectionFailed";
inline constexpr char NameNotResolved[] = "NameNotResolved";
inline constexpr char InternetDisconnected[] = "InternetDisconnected";
inline constexpr char AddressUnreachable[] = "AddressUnreachable";
inline constexpr char BlockedByClient[] = "BlockedByClient";
inline constexpr char BlockedByResponse[] = "BlockedByResponse";
} // namespace ErrorReasonEnum

namespace ConnectionTypeEnum {
inline constexpr char None[] = "none";
inline constexpr char Cellular2g[] = "cellular2g";
inline constexpr char Cellular3g[] = "cellular3g";
inline constexpr char Cellular4g[] = "cellular4g";
inline constexpr char Bluetooth[] = "bluetooth";
inline constexpr char Ethernet[] = "ethernet";
inline constexpr char Wifi[] = "wifi";
inline constexpr char Wimax[] = "wimax";
inline constexpr char Other[] = "other";
} // namespace ConnectionTypeEnum

namespace CookieSameSiteEnum {
inline constexpr char Strict[] = "Strict";
inline constexpr char Lax[] = "Lax";
inline constexpr char None[] = "None";
} // namespace CookieSameSiteEnum

namespace CookiePriorityEnum {
inline constexpr char Low[] = "Low";
inline constexpr char Medium[] = "Medium";
inline constexpr char High[] = "High";
} // namespace CookiePriorityEnum

namespace CookieSourceSchemeEnum {
inline constexpr char Unset[] = "Unset";
inline constexpr char NonSecure[] = "NonSecure";
inline constexpr char Secure[] = "Secure";
} // namespace CookieSourceSchemeEnum

namespace ResourcePriorityEnum {
inline constexpr char VeryLow[] = "VeryLow";
inline constexpr char Low[] = "Low";
inline constexpr char Medium[] = "Medium";
inline constexpr char High[] = "High";
inline constexpr char VeryHigh[] = "VeryHigh";
} // namespace ResourcePriorityEnum

namespace RenderBlockingBehaviorEnum {
inline constexpr char Blocking[] = "Blocking";
inline constexpr char InBodyParserBlocking[] = "InBodyParserBlocking";
inline constexpr char NonBlocking[] = "NonBlocking";
inline constexpr char NonBlockingDynamic[] = "NonBlockingDynamic";
inline constexpr char PotentiallyBlocking[] = "PotentiallyBlocking";
} // namespace RenderBlockingBehaviorEnum

namespace CertificateTransparencyComplianceEnum {
inline constexpr char Unknown[] = "unknown";
inline constexpr char NotCompliant[] = "not-compliant";
inline constexpr char Compliant[] = "compliant";
} // namespace CertificateTransparencyComplianceEnum

namespace BlockedReasonEnum {
inline constexpr char Other[] = "other";
inline constexpr char Csp[] = "csp";
inline constexpr char MixedContent[] = "mixed-content";
inline constexpr char Origin[] = "origin";
inline constexpr char Inspector[] = "inspector";
inline constexpr char Integrity[] = "integrity";
inline constexpr char SubresourceFilter[] = "subresource-filter";
inline constexpr char ContentType[] = "content-type";
inline constexpr char CoepFrameResourceNeedsCoepHeader[] = "coep-frame-resource-needs-coep-header";
inline constexpr char CoopSandboxedIframeCannotNavigateToCoopPage[] = "coop-sandboxed-iframe-cannot-navigate-to-coop-page";
inline constexpr char CorpNotSameOrigin[] = "corp-not-same-origin";
inline constexpr char CorpNotSameOriginAfterDefaultedToSameOriginByCoep[] = "corp-not-same-origin-after-defaulted-to-same-origin-by-coep";
inline constexpr char CorpNotSameOriginAfterDefaultedToSameOriginByDip[] = "corp-not-same-origin-after-defaulted-to-same-origin-by-dip";
inline constexpr char CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip[] = "corp-not-same-origin-after-defaulted-to-same-origin-by-coep-and-dip";
inline constexpr char CorpNotSameSite[] = "corp-not-same-site";
inline constexpr char SriMessageSignatureMismatch[] = "sri-message-signature-mismatch";
} // namespace BlockedReasonEnum

namespace CorsErrorEnum {
inline constexpr char DisallowedByMode[] = "DisallowedByMode";
inline constexpr char InvalidResponse[] = "InvalidResponse";
inline constexpr char WildcardOriginNotAllowed[] = "WildcardOriginNotAllowed";
inline constexpr char MissingAllowOriginHeader[] = "MissingAllowOriginHeader";
inline constexpr char MultipleAllowOriginValues[] = "MultipleAllowOriginValues";
inline constexpr char InvalidAllowOriginValue[] = "InvalidAllowOriginValue";
inline constexpr char AllowOriginMismatch[] = "AllowOriginMismatch";
inline constexpr char InvalidAllowCredentials[] = "InvalidAllowCredentials";
inline constexpr char CorsDisabledScheme[] = "CorsDisabledScheme";
inline constexpr char PreflightInvalidStatus[] = "PreflightInvalidStatus";
inline constexpr char PreflightDisallowedRedirect[] = "PreflightDisallowedRedirect";
inline constexpr char PreflightWildcardOriginNotAllowed[] = "PreflightWildcardOriginNotAllowed";
inline constexpr char PreflightMissingAllowOriginHeader[] = "PreflightMissingAllowOriginHeader";
inline constexpr char PreflightMultipleAllowOriginValues[] = "PreflightMultipleAllowOriginValues";
inline constexpr char PreflightInvalidAllowOriginValue[] = "PreflightInvalidAllowOriginValue";
inline constexpr char PreflightAllowOriginMismatch[] = "PreflightAllowOriginMismatch";
inline constexpr char PreflightInvalidAllowCredentials[] = "PreflightInvalidAllowCredentials";
inline constexpr char PreflightMissingAllowExternal[] = "PreflightMissingAllowExternal";
inline constexpr char PreflightInvalidAllowExternal[] = "PreflightInvalidAllowExternal";
inline constexpr char InvalidAllowMethodsPreflightResponse[] = "InvalidAllowMethodsPreflightResponse";
inline constexpr char InvalidAllowHeadersPreflightResponse[] = "InvalidAllowHeadersPreflightResponse";
inline constexpr char MethodDisallowedByPreflightResponse[] = "MethodDisallowedByPreflightResponse";
inline constexpr char HeaderDisallowedByPreflightResponse[] = "HeaderDisallowedByPreflightResponse";
inline constexpr char RedirectContainsCredentials[] = "RedirectContainsCredentials";
inline constexpr char InsecureLocalNetwork[] = "InsecureLocalNetwork";
inline constexpr char InvalidLocalNetworkAccess[] = "InvalidLocalNetworkAccess";
inline constexpr char NoCorsRedirectModeNotFollow[] = "NoCorsRedirectModeNotFollow";
inline constexpr char LocalNetworkAccessPermissionDenied[] = "LocalNetworkAccessPermissionDenied";
} // namespace CorsErrorEnum

namespace ServiceWorkerResponseSourceEnum {
inline constexpr char CacheStorage[] = "cache-storage";
inline constexpr char HttpCache[] = "http-cache";
inline constexpr char FallbackCode[] = "fallback-code";
inline constexpr char Network[] = "network";
} // namespace ServiceWorkerResponseSourceEnum

namespace TrustTokenOperationTypeEnum {
inline constexpr char Issuance[] = "Issuance";
inline constexpr char Redemption[] = "Redemption";
inline constexpr char Signing[] = "Signing";
} // namespace TrustTokenOperationTypeEnum

namespace AlternateProtocolUsageEnum {
inline constexpr char AlternativeJobWonWithoutRace[] = "alternativeJobWonWithoutRace";
inline constexpr char AlternativeJobWonRace[] = "alternativeJobWonRace";
inline constexpr char MainJobWonRace[] = "mainJobWonRace";
inline constexpr char MappingMissing[] = "mappingMissing";
inline constexpr char Broken[] = "broken";
inline constexpr char DnsAlpnH3JobWonWithoutRace[] = "dnsAlpnH3JobWonWithoutRace";
inline constexpr char DnsAlpnH3JobWonRace[] = "dnsAlpnH3JobWonRace";
inline constexpr char UnspecifiedReason[] = "unspecifiedReason";
} // namespace AlternateProtocolUsageEnum

namespace ServiceWorkerRouterSourceEnum {
inline constexpr char Network[] = "network";
inline constexpr char Cache[] = "cache";
inline constexpr char FetchEvent[] = "fetch-event";
inline constexpr char RaceNetworkAndFetchHandler[] = "race-network-and-fetch-handler";
inline constexpr char RaceNetworkAndCache[] = "race-network-and-cache";
} // namespace ServiceWorkerRouterSourceEnum

namespace SetCookieBlockedReasonEnum {
inline constexpr char SecureOnly[] = "SecureOnly";
inline constexpr char SameSiteStrict[] = "SameSiteStrict";
inline constexpr char SameSiteLax[] = "SameSiteLax";
inline constexpr char SameSiteUnspecifiedTreatedAsLax[] = "SameSiteUnspecifiedTreatedAsLax";
inline constexpr char SameSiteNoneInsecure[] = "SameSiteNoneInsecure";
inline constexpr char UserPreferences[] = "UserPreferences";
inline constexpr char ThirdPartyPhaseout[] = "ThirdPartyPhaseout";
inline constexpr char ThirdPartyBlockedInFirstPartySet[] = "ThirdPartyBlockedInFirstPartySet";
inline constexpr char SyntaxError[] = "SyntaxError";
inline constexpr char SchemeNotSupported[] = "SchemeNotSupported";
inline constexpr char OverwriteSecure[] = "OverwriteSecure";
inline constexpr char InvalidDomain[] = "InvalidDomain";
inline constexpr char InvalidPrefix[] = "InvalidPrefix";
inline constexpr char UnknownError[] = "UnknownError";
inline constexpr char SchemefulSameSiteStrict[] = "SchemefulSameSiteStrict";
inline constexpr char SchemefulSameSiteLax[] = "SchemefulSameSiteLax";
inline constexpr char SchemefulSameSiteUnspecifiedTreatedAsLax[] = "SchemefulSameSiteUnspecifiedTreatedAsLax";
inline constexpr char NameValuePairExceedsMaxSize[] = "NameValuePairExceedsMaxSize";
inline constexpr char DisallowedCharacter[] = "DisallowedCharacter";
inline constexpr char NoCookieContent[] = "NoCookieContent";
} // namespace SetCookieBlockedReasonEnum

namespace CookieBlockedReasonEnum {
inline constexpr char SecureOnly[] = "SecureOnly";
inline constexpr char NotOnPath[] = "NotOnPath";
inline constexpr char DomainMismatch[] = "DomainMismatch";
inline constexpr char SameSiteStrict[] = "SameSiteStrict";
inline constexpr char SameSiteLax[] = "SameSiteLax";
inline constexpr char SameSiteUnspecifiedTreatedAsLax[] = "SameSiteUnspecifiedTreatedAsLax";
inline constexpr char SameSiteNoneInsecure[] = "SameSiteNoneInsecure";
inline constexpr char UserPreferences[] = "UserPreferences";
inline constexpr char ThirdPartyPhaseout[] = "ThirdPartyPhaseout";
inline constexpr char ThirdPartyBlockedInFirstPartySet[] = "ThirdPartyBlockedInFirstPartySet";
inline constexpr char UnknownError[] = "UnknownError";
inline constexpr char SchemefulSameSiteStrict[] = "SchemefulSameSiteStrict";
inline constexpr char SchemefulSameSiteLax[] = "SchemefulSameSiteLax";
inline constexpr char SchemefulSameSiteUnspecifiedTreatedAsLax[] = "SchemefulSameSiteUnspecifiedTreatedAsLax";
inline constexpr char NameValuePairExceedsMaxSize[] = "NameValuePairExceedsMaxSize";
inline constexpr char PortMismatch[] = "PortMismatch";
inline constexpr char SchemeMismatch[] = "SchemeMismatch";
inline constexpr char AnonymousContext[] = "AnonymousContext";
} // namespace CookieBlockedReasonEnum

namespace CookieExemptionReasonEnum {
inline constexpr char None[] = "None";
inline constexpr char UserSetting[] = "UserSetting";
inline constexpr char EnterprisePolicy[] = "EnterprisePolicy";
inline constexpr char StorageAccess[] = "StorageAccess";
inline constexpr char TopLevelStorageAccess[] = "TopLevelStorageAccess";
inline constexpr char Scheme[] = "Scheme";
inline constexpr char SameSiteNoneCookiesInSandbox[] = "SameSiteNoneCookiesInSandbox";
} // namespace CookieExemptionReasonEnum

namespace SignedExchangeErrorFieldEnum {
inline constexpr char SignatureSig[] = "signatureSig";
inline constexpr char SignatureIntegrity[] = "signatureIntegrity";
inline constexpr char SignatureCertUrl[] = "signatureCertUrl";
inline constexpr char SignatureCertSha256[] = "signatureCertSha256";
inline constexpr char SignatureValidityUrl[] = "signatureValidityUrl";
inline constexpr char SignatureTimestamps[] = "signatureTimestamps";
} // namespace SignedExchangeErrorFieldEnum

namespace LocalNetworkAccessRequestPolicyEnum {
inline constexpr char Allow[] = "Allow";
inline constexpr char BlockFromInsecureToMorePrivate[] = "BlockFromInsecureToMorePrivate";
inline constexpr char WarnFromInsecureToMorePrivate[] = "WarnFromInsecureToMorePrivate";
inline constexpr char PermissionBlock[] = "PermissionBlock";
inline constexpr char PermissionWarn[] = "PermissionWarn";
} // namespace LocalNetworkAccessRequestPolicyEnum

namespace IPAddressSpaceEnum {
inline constexpr char Loopback[] = "Loopback";
inline constexpr char Local[] = "Local";
inline constexpr char Public[] = "Public";
inline constexpr char Unknown[] = "Unknown";
} // namespace IPAddressSpaceEnum

namespace CrossOriginOpenerPolicyValueEnum {
inline constexpr char SameOrigin[] = "SameOrigin";
inline constexpr char SameOriginAllowPopups[] = "SameOriginAllowPopups";
inline constexpr char RestrictProperties[] = "RestrictProperties";
inline constexpr char UnsafeNone[] = "UnsafeNone";
inline constexpr char SameOriginPlusCoep[] = "SameOriginPlusCoep";
inline constexpr char RestrictPropertiesPlusCoep[] = "RestrictPropertiesPlusCoep";
inline constexpr char NoopenerAllowPopups[] = "NoopenerAllowPopups";
} // namespace CrossOriginOpenerPolicyValueEnum

namespace CrossOriginEmbedderPolicyValueEnum {
inline constexpr char None[] = "None";
inline constexpr char Credentialless[] = "Credentialless";
inline constexpr char RequireCorp[] = "RequireCorp";
} // namespace CrossOriginEmbedderPolicyValueEnum

namespace ContentSecurityPolicySourceEnum {
inline constexpr char HTTP[] = "HTTP";
inline constexpr char Meta[] = "Meta";
} // namespace ContentSecurityPolicySourceEnum

namespace ReportStatusEnum {
inline constexpr char Queued[] = "Queued";
inline constexpr char Pending[] = "Pending";
inline constexpr char MarkedForRemoval[] = "MarkedForRemoval";
inline constexpr char Success[] = "Success";
} // namespace ReportStatusEnum

namespace DeviceBoundSessionFetchResultEnum {
inline constexpr char Success[] = "Success";
inline constexpr char SigningKeyGenerationError[] = "SigningKeyGenerationError";
inline constexpr char AttestationKeyGenerationError[] = "AttestationKeyGenerationError";
inline constexpr char SigningError[] = "SigningError";
inline constexpr char TransientSigningError[] = "TransientSigningError";
inline constexpr char ServerRequestedTermination[] = "ServerRequestedTermination";
inline constexpr char InvalidSessionId[] = "InvalidSessionId";
inline constexpr char InvalidChallenge[] = "InvalidChallenge";
inline constexpr char TooManyChallenges[] = "TooManyChallenges";
inline constexpr char InvalidFetcherUrl[] = "InvalidFetcherUrl";
inline constexpr char InvalidRefreshUrl[] = "InvalidRefreshUrl";
inline constexpr char TransientHttpError[] = "TransientHttpError";
inline constexpr char ScopeOriginSameSiteMismatch[] = "ScopeOriginSameSiteMismatch";
inline constexpr char RefreshUrlSameSiteMismatch[] = "RefreshUrlSameSiteMismatch";
inline constexpr char MismatchedSessionId[] = "MismatchedSessionId";
inline constexpr char MissingScope[] = "MissingScope";
inline constexpr char NoCredentials[] = "NoCredentials";
inline constexpr char SubdomainRegistrationWellKnownUnavailable[] = "SubdomainRegistrationWellKnownUnavailable";
inline constexpr char SubdomainRegistrationUnauthorized[] = "SubdomainRegistrationUnauthorized";
inline constexpr char SubdomainRegistrationWellKnownMalformed[] = "SubdomainRegistrationWellKnownMalformed";
inline constexpr char SessionProviderWellKnownUnavailable[] = "SessionProviderWellKnownUnavailable";
inline constexpr char RelyingPartyWellKnownUnavailable[] = "RelyingPartyWellKnownUnavailable";
inline constexpr char FederatedKeyThumbprintMismatch[] = "FederatedKeyThumbprintMismatch";
inline constexpr char InvalidFederatedSessionUrl[] = "InvalidFederatedSessionUrl";
inline constexpr char InvalidFederatedKey[] = "InvalidFederatedKey";
inline constexpr char TooManyRelyingOriginLabels[] = "TooManyRelyingOriginLabels";
inline constexpr char BoundCookieSetForbidden[] = "BoundCookieSetForbidden";
inline constexpr char NetError[] = "NetError";
inline constexpr char ProxyError[] = "ProxyError";
inline constexpr char EmptySessionConfig[] = "EmptySessionConfig";
inline constexpr char InvalidCredentialsConfig[] = "InvalidCredentialsConfig";
inline constexpr char InvalidCredentialsType[] = "InvalidCredentialsType";
inline constexpr char InvalidCredentialsEmptyName[] = "InvalidCredentialsEmptyName";
inline constexpr char InvalidCredentialsCookie[] = "InvalidCredentialsCookie";
inline constexpr char PersistentHttpError[] = "PersistentHttpError";
inline constexpr char RegistrationAttemptedChallenge[] = "RegistrationAttemptedChallenge";
inline constexpr char InvalidScopeOrigin[] = "InvalidScopeOrigin";
inline constexpr char ScopeOriginContainsPath[] = "ScopeOriginContainsPath";
inline constexpr char RefreshInitiatorNotString[] = "RefreshInitiatorNotString";
inline constexpr char RefreshInitiatorInvalidHostPattern[] = "RefreshInitiatorInvalidHostPattern";
inline constexpr char InvalidScopeSpecification[] = "InvalidScopeSpecification";
inline constexpr char MissingScopeSpecificationType[] = "MissingScopeSpecificationType";
inline constexpr char EmptyScopeSpecificationDomain[] = "EmptyScopeSpecificationDomain";
inline constexpr char EmptyScopeSpecificationPath[] = "EmptyScopeSpecificationPath";
inline constexpr char InvalidScopeSpecificationType[] = "InvalidScopeSpecificationType";
inline constexpr char InvalidScopeIncludeSite[] = "InvalidScopeIncludeSite";
inline constexpr char MissingScopeIncludeSite[] = "MissingScopeIncludeSite";
inline constexpr char FederatedNotAuthorizedByProvider[] = "FederatedNotAuthorizedByProvider";
inline constexpr char FederatedNotAuthorizedByRelyingParty[] = "FederatedNotAuthorizedByRelyingParty";
inline constexpr char SessionProviderWellKnownMalformed[] = "SessionProviderWellKnownMalformed";
inline constexpr char SessionProviderWellKnownHasProviderOrigin[] = "SessionProviderWellKnownHasProviderOrigin";
inline constexpr char RelyingPartyWellKnownMalformed[] = "RelyingPartyWellKnownMalformed";
inline constexpr char RelyingPartyWellKnownHasRelyingOrigins[] = "RelyingPartyWellKnownHasRelyingOrigins";
inline constexpr char InvalidFederatedSessionProviderSessionMissing[] = "InvalidFederatedSessionProviderSessionMissing";
inline constexpr char InvalidFederatedSessionWrongProviderOrigin[] = "InvalidFederatedSessionWrongProviderOrigin";
inline constexpr char InvalidCredentialsCookieCreationTime[] = "InvalidCredentialsCookieCreationTime";
inline constexpr char InvalidCredentialsCookieName[] = "InvalidCredentialsCookieName";
inline constexpr char InvalidCredentialsCookieParsing[] = "InvalidCredentialsCookieParsing";
inline constexpr char InvalidCredentialsCookieUnpermittedAttribute[] = "InvalidCredentialsCookieUnpermittedAttribute";
inline constexpr char InvalidCredentialsCookieInvalidDomain[] = "InvalidCredentialsCookieInvalidDomain";
inline constexpr char InvalidCredentialsCookiePrefix[] = "InvalidCredentialsCookiePrefix";
inline constexpr char InvalidScopeRulePath[] = "InvalidScopeRulePath";
inline constexpr char InvalidScopeRuleHostPattern[] = "InvalidScopeRuleHostPattern";
inline constexpr char ScopeRuleOriginScopedHostPatternMismatch[] = "ScopeRuleOriginScopedHostPatternMismatch";
inline constexpr char ScopeRuleSiteScopedHostPatternMismatch[] = "ScopeRuleSiteScopedHostPatternMismatch";
inline constexpr char SigningQuotaExceeded[] = "SigningQuotaExceeded";
inline constexpr char InvalidConfigJson[] = "InvalidConfigJson";
inline constexpr char InvalidFederatedSessionProviderFailedToRestoreKey[] = "InvalidFederatedSessionProviderFailedToRestoreKey";
inline constexpr char FailedToUnwrapKey[] = "FailedToUnwrapKey";
inline constexpr char SessionDeletedDuringRefresh[] = "SessionDeletedDuringRefresh";
inline constexpr char CrossOriginRegistrationSiteNotIncluded[] = "CrossOriginRegistrationSiteNotIncluded";
inline constexpr char InvalidPreProvisionedKeyInitiatorMissing[] = "InvalidPreProvisionedKeyInitiatorMissing";
inline constexpr char PreProvisionedKeyAccessNotGranted[] = "PreProvisionedKeyAccessNotGranted";
inline constexpr char PreProvisionedKeyNotFound[] = "PreProvisionedKeyNotFound";
inline constexpr char AttestationCertificationError[] = "AttestationCertificationError";
inline constexpr char AttestationSigningError[] = "AttestationSigningError";
} // namespace DeviceBoundSessionFetchResultEnum

namespace TrustTokenOperationDone {
namespace StatusEnum {
inline constexpr char Ok[] = "Ok";
inline constexpr char InvalidArgument[] = "InvalidArgument";
inline constexpr char MissingIssuerKeys[] = "MissingIssuerKeys";
inline constexpr char FailedPrecondition[] = "FailedPrecondition";
inline constexpr char ResourceExhausted[] = "ResourceExhausted";
inline constexpr char AlreadyExists[] = "AlreadyExists";
inline constexpr char ResourceLimited[] = "ResourceLimited";
inline constexpr char Unauthorized[] = "Unauthorized";
inline constexpr char BadResponse[] = "BadResponse";
inline constexpr char InternalError[] = "InternalError";
inline constexpr char UnknownError[] = "UnknownError";
inline constexpr char FulfilledLocally[] = "FulfilledLocally";
inline constexpr char SiteIssuerLimit[] = "SiteIssuerLimit";
} // StatusEnum
} // TrustTokenOperationDone

// ------------- Type and builder declarations.

class CONTENT_EXPORT ResourceTiming : public ::crdtp::ProtocolObject<ResourceTiming> {
public:
    ~ResourceTiming() override;  // Defined below

    double GetRequestTime() { return m_requestTime; }
    void SetRequestTime(double value);  // Defined below

    double GetProxyStart() { return m_proxyStart; }
    void SetProxyStart(double value);  // Defined below

    double GetProxyEnd() { return m_proxyEnd; }
    void SetProxyEnd(double value);  // Defined below

    double GetDnsStart() { return m_dnsStart; }
    void SetDnsStart(double value);  // Defined below

    double GetDnsEnd() { return m_dnsEnd; }
    void SetDnsEnd(double value);  // Defined below

    double GetConnectStart() { return m_connectStart; }
    void SetConnectStart(double value);  // Defined below

    double GetConnectEnd() { return m_connectEnd; }
    void SetConnectEnd(double value);  // Defined below

    double GetSslStart() { return m_sslStart; }
    void SetSslStart(double value);  // Defined below

    double GetSslEnd() { return m_sslEnd; }
    void SetSslEnd(double value);  // Defined below

    double GetWorkerStart() { return m_workerStart; }
    void SetWorkerStart(double value);  // Defined below

    double GetWorkerReady() { return m_workerReady; }
    void SetWorkerReady(double value);  // Defined below

    double GetWorkerFetchStart() { return m_workerFetchStart; }
    void SetWorkerFetchStart(double value);  // Defined below

    double GetWorkerRespondWithSettled() { return m_workerRespondWithSettled; }
    void SetWorkerRespondWithSettled(double value);  // Defined below

    bool HasWorkerRouterEvaluationStart() { return !!m_workerRouterEvaluationStart; }
    double GetWorkerRouterEvaluationStart(double defaultValue) const {
       return m_workerRouterEvaluationStart.value_or(defaultValue);
    }
    const std::optional<double>& GetWorkerRouterEvaluationStart() const {
       return m_workerRouterEvaluationStart;
    }
    void SetWorkerRouterEvaluationStart(double value);  // Defined below

    bool HasWorkerCacheLookupStart() { return !!m_workerCacheLookupStart; }
    double GetWorkerCacheLookupStart(double defaultValue) const {
       return m_workerCacheLookupStart.value_or(defaultValue);
    }
    const std::optional<double>& GetWorkerCacheLookupStart() const {
       return m_workerCacheLookupStart;
    }
    void SetWorkerCacheLookupStart(double value);  // Defined below

    double GetSendStart() { return m_sendStart; }
    void SetSendStart(double value);  // Defined below

    double GetSendEnd() { return m_sendEnd; }
    void SetSendEnd(double value);  // Defined below

    double GetPushStart() { return m_pushStart; }
    void SetPushStart(double value);  // Defined below

    double GetPushEnd() { return m_pushEnd; }
    void SetPushEnd(double value);  // Defined below

    double GetReceiveHeadersStart() { return m_receiveHeadersStart; }
    void SetReceiveHeadersStart(double value);  // Defined below

    double GetReceiveHeadersEnd() { return m_receiveHeadersEnd; }
    void SetReceiveHeadersEnd(double value);  // Defined below

    template<int STATE>
    class ResourceTimingBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            RequestTimeSet = 1 << 1,
            ProxyStartSet = 1 << 2,
            ProxyEndSet = 1 << 3,
            DnsStartSet = 1 << 4,
            DnsEndSet = 1 << 5,
            ConnectStartSet = 1 << 6,
            ConnectEndSet = 1 << 7,
            SslStartSet = 1 << 8,
            SslEndSet = 1 << 9,
            WorkerStartSet = 1 << 10,
            WorkerReadySet = 1 << 11,
            WorkerFetchStartSet = 1 << 12,
            WorkerRespondWithSettledSet = 1 << 13,
            SendStartSet = 1 << 14,
            SendEndSet = 1 << 15,
            PushStartSet = 1 << 16,
            PushEndSet = 1 << 17,
            ReceiveHeadersStartSet = 1 << 18,
            ReceiveHeadersEndSet = 1 << 19,
            AllFieldsSet = (RequestTimeSet | ProxyStartSet | ProxyEndSet | DnsStartSet | DnsEndSet | ConnectStartSet | ConnectEndSet | SslStartSet | SslEndSet | WorkerStartSet | WorkerReadySet | WorkerFetchStartSet | WorkerRespondWithSettledSet | SendStartSet | SendEndSet | PushStartSet | PushEndSet | ReceiveHeadersStartSet | ReceiveHeadersEndSet | 0)};


        ResourceTimingBuilder<STATE | RequestTimeSet>& SetRequestTime(double value);  // Defined below

        ResourceTimingBuilder<STATE | ProxyStartSet>& SetProxyStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | ProxyEndSet>& SetProxyEnd(double value);  // Defined below

        ResourceTimingBuilder<STATE | DnsStartSet>& SetDnsStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | DnsEndSet>& SetDnsEnd(double value);  // Defined below

        ResourceTimingBuilder<STATE | ConnectStartSet>& SetConnectStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | ConnectEndSet>& SetConnectEnd(double value);  // Defined below

        ResourceTimingBuilder<STATE | SslStartSet>& SetSslStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | SslEndSet>& SetSslEnd(double value);  // Defined below

        ResourceTimingBuilder<STATE | WorkerStartSet>& SetWorkerStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | WorkerReadySet>& SetWorkerReady(double value);  // Defined below

        ResourceTimingBuilder<STATE | WorkerFetchStartSet>& SetWorkerFetchStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | WorkerRespondWithSettledSet>& SetWorkerRespondWithSettled(double value);  // Defined below

        ResourceTimingBuilder<STATE>& SetWorkerRouterEvaluationStart(double value);  // Defined below

        ResourceTimingBuilder<STATE>& SetWorkerCacheLookupStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | SendStartSet>& SetSendStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | SendEndSet>& SetSendEnd(double value);  // Defined below

        ResourceTimingBuilder<STATE | PushStartSet>& SetPushStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | PushEndSet>& SetPushEnd(double value);  // Defined below

        ResourceTimingBuilder<STATE | ReceiveHeadersStartSet>& SetReceiveHeadersStart(double value);  // Defined below

        ResourceTimingBuilder<STATE | ReceiveHeadersEndSet>& SetReceiveHeadersEnd(double value);  // Defined below

        std::unique_ptr<ResourceTiming> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ResourceTiming;
        ResourceTimingBuilder() : m_result(new ResourceTiming()) { }

        template<int STEP> ResourceTimingBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ResourceTimingBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ResourceTiming> m_result;
    };

    static ResourceTimingBuilder<0> Create()
    {
        return ResourceTimingBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ResourceTiming();  // Defined below

    double m_requestTime;
    double m_proxyStart;
    double m_proxyEnd;
    double m_dnsStart;
    double m_dnsEnd;
    double m_connectStart;
    double m_connectEnd;
    double m_sslStart;
    double m_sslEnd;
    double m_workerStart;
    double m_workerReady;
    double m_workerFetchStart;
    double m_workerRespondWithSettled;
    std::optional<double> m_workerRouterEvaluationStart;
    std::optional<double> m_workerCacheLookupStart;
    double m_sendStart;
    double m_sendEnd;
    double m_pushStart;
    double m_pushEnd;
    double m_receiveHeadersStart;
    double m_receiveHeadersEnd;
};


class CONTENT_EXPORT PostDataEntry : public ::crdtp::ProtocolObject<PostDataEntry> {
public:
    ~PostDataEntry() override;  // Defined below

    bool HasBytes() { return !!m_bytes; }
    Binary GetBytes(const Binary& defaultValue) const {
       return m_bytes.value_or(defaultValue);
    }
    const std::optional<Binary>& GetBytes() const {
       return m_bytes;
    }
    void SetBytes(const Binary& value);  // Defined below

    template<int STATE>
    class PostDataEntryBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            AllFieldsSet = (0)};


        PostDataEntryBuilder<STATE>& SetBytes(const Binary& value);  // Defined below

        std::unique_ptr<PostDataEntry> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class PostDataEntry;
        PostDataEntryBuilder() : m_result(new PostDataEntry()) { }

        template<int STEP> PostDataEntryBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<PostDataEntryBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::PostDataEntry> m_result;
    };

    static PostDataEntryBuilder<0> Create()
    {
        return PostDataEntryBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    PostDataEntry();  // Defined below

    std::optional<Binary> m_bytes;
};


class CONTENT_EXPORT Request : public ::crdtp::ProtocolObject<Request> {
public:
    ~Request() override;  // Defined below

    String GetUrl() { return m_url; }
    void SetUrl(const String& value);  // Defined below

    bool HasUrlFragment() { return !!m_urlFragment; }
    String GetUrlFragment(const String& defaultValue) const {
       return m_urlFragment.value_or(defaultValue);
    }
    const std::optional<String>& GetUrlFragment() const {
       return m_urlFragment;
    }
    void SetUrlFragment(const String& value);  // Defined below

    String GetMethod() { return m_method; }
    void SetMethod(const String& value);  // Defined below

    protocol::Network::Headers* GetHeaders() { return m_headers.get(); }
    void SetHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

    bool HasPostData() { return !!m_postData; }
    String GetPostData(const String& defaultValue) const {
       return m_postData.value_or(defaultValue);
    }
    const std::optional<String>& GetPostData() const {
       return m_postData;
    }
    void SetPostData(const String& value);  // Defined below

    bool HasHasPostData() { return !!m_hasPostData; }
    bool GetHasPostData(bool defaultValue) const {
       return m_hasPostData.value_or(defaultValue);
    }
    const std::optional<bool>& GetHasPostData() const {
       return m_hasPostData;
    }
    void SetHasPostData(bool value);  // Defined below

    bool HasPostDataEntries() { return !!m_postDataEntries; }
    protocol::Array<protocol::Network::PostDataEntry>* GetPostDataEntries(protocol::Array<protocol::Network::PostDataEntry>* defaultValue) {
       return m_postDataEntries ? m_postDataEntries.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Array<protocol::Network::PostDataEntry>>& GetPostDataEntries() const {
       return m_postDataEntries;
    }
    void SetPostDataEntries(std::unique_ptr<protocol::Array<protocol::Network::PostDataEntry>> value);  // Defined below

    bool HasMixedContentType() { return !!m_mixedContentType; }
    String GetMixedContentType(const String& defaultValue) const {
       return m_mixedContentType.value_or(defaultValue);
    }
    const std::optional<String>& GetMixedContentType() const {
       return m_mixedContentType;
    }
    void SetMixedContentType(const String& value);  // Defined below

    String GetInitialPriority() { return m_initialPriority; }
    void SetInitialPriority(const String& value);  // Defined below

    struct CONTENT_EXPORT ReferrerPolicyEnum {
        static const char* UnsafeUrl;
        static const char* NoReferrerWhenDowngrade;
        static const char* NoReferrer;
        static const char* Origin;
        static const char* OriginWhenCrossOrigin;
        static const char* SameOrigin;
        static const char* StrictOrigin;
        static const char* StrictOriginWhenCrossOrigin;
    }; // ReferrerPolicyEnum

    String GetReferrerPolicy() { return m_referrerPolicy; }
    void SetReferrerPolicy(const String& value);  // Defined below

    bool HasIsLinkPreload() { return !!m_isLinkPreload; }
    bool GetIsLinkPreload(bool defaultValue) const {
       return m_isLinkPreload.value_or(defaultValue);
    }
    const std::optional<bool>& GetIsLinkPreload() const {
       return m_isLinkPreload;
    }
    void SetIsLinkPreload(bool value);  // Defined below

    bool HasTrustTokenParams() { return !!m_trustTokenParams; }
    protocol::Network::TrustTokenParams* GetTrustTokenParams(protocol::Network::TrustTokenParams* defaultValue) {
       return m_trustTokenParams ? m_trustTokenParams.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::TrustTokenParams>& GetTrustTokenParams() const {
       return m_trustTokenParams;
    }
    void SetTrustTokenParams(std::unique_ptr<protocol::Network::TrustTokenParams> value);  // Defined below

    bool HasIsSameSite() { return !!m_isSameSite; }
    bool GetIsSameSite(bool defaultValue) const {
       return m_isSameSite.value_or(defaultValue);
    }
    const std::optional<bool>& GetIsSameSite() const {
       return m_isSameSite;
    }
    void SetIsSameSite(bool value);  // Defined below

    bool HasIsAdRelated() { return !!m_isAdRelated; }
    bool GetIsAdRelated(bool defaultValue) const {
       return m_isAdRelated.value_or(defaultValue);
    }
    const std::optional<bool>& GetIsAdRelated() const {
       return m_isAdRelated;
    }
    void SetIsAdRelated(bool value);  // Defined below

    template<int STATE>
    class RequestBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            UrlSet = 1 << 1,
            MethodSet = 1 << 2,
            HeadersSet = 1 << 3,
            InitialPrioritySet = 1 << 4,
            ReferrerPolicySet = 1 << 5,
            AllFieldsSet = (UrlSet | MethodSet | HeadersSet | InitialPrioritySet | ReferrerPolicySet | 0)};


        RequestBuilder<STATE | UrlSet>& SetUrl(const String& value);  // Defined below

        RequestBuilder<STATE>& SetUrlFragment(const String& value);  // Defined below

        RequestBuilder<STATE | MethodSet>& SetMethod(const String& value);  // Defined below

        RequestBuilder<STATE | HeadersSet>& SetHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

        RequestBuilder<STATE>& SetPostData(const String& value);  // Defined below

        RequestBuilder<STATE>& SetHasPostData(bool value);  // Defined below

        RequestBuilder<STATE>& SetPostDataEntries(std::unique_ptr<protocol::Array<protocol::Network::PostDataEntry>> value);  // Defined below

        RequestBuilder<STATE>& SetMixedContentType(const String& value);  // Defined below

        RequestBuilder<STATE | InitialPrioritySet>& SetInitialPriority(const String& value);  // Defined below

        RequestBuilder<STATE | ReferrerPolicySet>& SetReferrerPolicy(const String& value);  // Defined below

        RequestBuilder<STATE>& SetIsLinkPreload(bool value);  // Defined below

        RequestBuilder<STATE>& SetTrustTokenParams(std::unique_ptr<protocol::Network::TrustTokenParams> value);  // Defined below

        RequestBuilder<STATE>& SetIsSameSite(bool value);  // Defined below

        RequestBuilder<STATE>& SetIsAdRelated(bool value);  // Defined below

        std::unique_ptr<Request> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class Request;
        RequestBuilder() : m_result(new Request()) { }

        template<int STEP> RequestBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<RequestBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::Request> m_result;
    };

    static RequestBuilder<0> Create()
    {
        return RequestBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    Request();  // Defined below

    String m_url;
    std::optional<String> m_urlFragment;
    String m_method;
    std::unique_ptr<protocol::Network::Headers> m_headers;
    std::optional<String> m_postData;
    std::optional<bool> m_hasPostData;
    std::unique_ptr<protocol::Array<protocol::Network::PostDataEntry>> m_postDataEntries;
    std::optional<String> m_mixedContentType;
    String m_initialPriority;
    String m_referrerPolicy;
    std::optional<bool> m_isLinkPreload;
    std::unique_ptr<protocol::Network::TrustTokenParams> m_trustTokenParams;
    std::optional<bool> m_isSameSite;
    std::optional<bool> m_isAdRelated;
};


class CONTENT_EXPORT SignedCertificateTimestamp : public ::crdtp::ProtocolObject<SignedCertificateTimestamp> {
public:
    ~SignedCertificateTimestamp() override;  // Defined below

    String GetStatus() { return m_status; }
    void SetStatus(const String& value);  // Defined below

    String GetOrigin() { return m_origin; }
    void SetOrigin(const String& value);  // Defined below

    String GetLogDescription() { return m_logDescription; }
    void SetLogDescription(const String& value);  // Defined below

    String GetLogId() { return m_logId; }
    void SetLogId(const String& value);  // Defined below

    double GetTimestamp() { return m_timestamp; }
    void SetTimestamp(double value);  // Defined below

    String GetHashAlgorithm() { return m_hashAlgorithm; }
    void SetHashAlgorithm(const String& value);  // Defined below

    String GetSignatureAlgorithm() { return m_signatureAlgorithm; }
    void SetSignatureAlgorithm(const String& value);  // Defined below

    String GetSignatureData() { return m_signatureData; }
    void SetSignatureData(const String& value);  // Defined below

    template<int STATE>
    class SignedCertificateTimestampBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            StatusSet = 1 << 1,
            OriginSet = 1 << 2,
            LogDescriptionSet = 1 << 3,
            LogIdSet = 1 << 4,
            TimestampSet = 1 << 5,
            HashAlgorithmSet = 1 << 6,
            SignatureAlgorithmSet = 1 << 7,
            SignatureDataSet = 1 << 8,
            AllFieldsSet = (StatusSet | OriginSet | LogDescriptionSet | LogIdSet | TimestampSet | HashAlgorithmSet | SignatureAlgorithmSet | SignatureDataSet | 0)};


        SignedCertificateTimestampBuilder<STATE | StatusSet>& SetStatus(const String& value);  // Defined below

        SignedCertificateTimestampBuilder<STATE | OriginSet>& SetOrigin(const String& value);  // Defined below

        SignedCertificateTimestampBuilder<STATE | LogDescriptionSet>& SetLogDescription(const String& value);  // Defined below

        SignedCertificateTimestampBuilder<STATE | LogIdSet>& SetLogId(const String& value);  // Defined below

        SignedCertificateTimestampBuilder<STATE | TimestampSet>& SetTimestamp(double value);  // Defined below

        SignedCertificateTimestampBuilder<STATE | HashAlgorithmSet>& SetHashAlgorithm(const String& value);  // Defined below

        SignedCertificateTimestampBuilder<STATE | SignatureAlgorithmSet>& SetSignatureAlgorithm(const String& value);  // Defined below

        SignedCertificateTimestampBuilder<STATE | SignatureDataSet>& SetSignatureData(const String& value);  // Defined below

        std::unique_ptr<SignedCertificateTimestamp> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class SignedCertificateTimestamp;
        SignedCertificateTimestampBuilder() : m_result(new SignedCertificateTimestamp()) { }

        template<int STEP> SignedCertificateTimestampBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<SignedCertificateTimestampBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::SignedCertificateTimestamp> m_result;
    };

    static SignedCertificateTimestampBuilder<0> Create()
    {
        return SignedCertificateTimestampBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    SignedCertificateTimestamp();  // Defined below

    String m_status;
    String m_origin;
    String m_logDescription;
    String m_logId;
    double m_timestamp;
    String m_hashAlgorithm;
    String m_signatureAlgorithm;
    String m_signatureData;
};


class CONTENT_EXPORT SecurityDetails : public ::crdtp::ProtocolObject<SecurityDetails> {
public:
    ~SecurityDetails() override;  // Defined below

    String GetProtocol() { return m_protocol; }
    void SetProtocol(const String& value);  // Defined below

    String GetKeyExchange() { return m_keyExchange; }
    void SetKeyExchange(const String& value);  // Defined below

    bool HasKeyExchangeGroup() { return !!m_keyExchangeGroup; }
    String GetKeyExchangeGroup(const String& defaultValue) const {
       return m_keyExchangeGroup.value_or(defaultValue);
    }
    const std::optional<String>& GetKeyExchangeGroup() const {
       return m_keyExchangeGroup;
    }
    void SetKeyExchangeGroup(const String& value);  // Defined below

    String GetCipher() { return m_cipher; }
    void SetCipher(const String& value);  // Defined below

    bool HasMac() { return !!m_mac; }
    String GetMac(const String& defaultValue) const {
       return m_mac.value_or(defaultValue);
    }
    const std::optional<String>& GetMac() const {
       return m_mac;
    }
    void SetMac(const String& value);  // Defined below

    int GetCertificateId() { return m_certificateId; }
    void SetCertificateId(int value);  // Defined below

    String GetSubjectName() { return m_subjectName; }
    void SetSubjectName(const String& value);  // Defined below

    protocol::Array<String>* GetSanList() { return m_sanList.get(); }
    void SetSanList(std::unique_ptr<protocol::Array<String>> value);  // Defined below

    String GetIssuer() { return m_issuer; }
    void SetIssuer(const String& value);  // Defined below

    double GetValidFrom() { return m_validFrom; }
    void SetValidFrom(double value);  // Defined below

    double GetValidTo() { return m_validTo; }
    void SetValidTo(double value);  // Defined below

    protocol::Array<protocol::Network::SignedCertificateTimestamp>* GetSignedCertificateTimestampList() { return m_signedCertificateTimestampList.get(); }
    void SetSignedCertificateTimestampList(std::unique_ptr<protocol::Array<protocol::Network::SignedCertificateTimestamp>> value);  // Defined below

    String GetCertificateTransparencyCompliance() { return m_certificateTransparencyCompliance; }
    void SetCertificateTransparencyCompliance(const String& value);  // Defined below

    bool HasServerSignatureAlgorithm() { return !!m_serverSignatureAlgorithm; }
    int GetServerSignatureAlgorithm(int defaultValue) const {
       return m_serverSignatureAlgorithm.value_or(defaultValue);
    }
    const std::optional<int>& GetServerSignatureAlgorithm() const {
       return m_serverSignatureAlgorithm;
    }
    void SetServerSignatureAlgorithm(int value);  // Defined below

    bool GetEncryptedClientHello() { return m_encryptedClientHello; }
    void SetEncryptedClientHello(bool value);  // Defined below

    template<int STATE>
    class SecurityDetailsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ProtocolSet = 1 << 1,
            KeyExchangeSet = 1 << 2,
            CipherSet = 1 << 3,
            CertificateIdSet = 1 << 4,
            SubjectNameSet = 1 << 5,
            SanListSet = 1 << 6,
            IssuerSet = 1 << 7,
            ValidFromSet = 1 << 8,
            ValidToSet = 1 << 9,
            SignedCertificateTimestampListSet = 1 << 10,
            CertificateTransparencyComplianceSet = 1 << 11,
            EncryptedClientHelloSet = 1 << 12,
            AllFieldsSet = (ProtocolSet | KeyExchangeSet | CipherSet | CertificateIdSet | SubjectNameSet | SanListSet | IssuerSet | ValidFromSet | ValidToSet | SignedCertificateTimestampListSet | CertificateTransparencyComplianceSet | EncryptedClientHelloSet | 0)};


        SecurityDetailsBuilder<STATE | ProtocolSet>& SetProtocol(const String& value);  // Defined below

        SecurityDetailsBuilder<STATE | KeyExchangeSet>& SetKeyExchange(const String& value);  // Defined below

        SecurityDetailsBuilder<STATE>& SetKeyExchangeGroup(const String& value);  // Defined below

        SecurityDetailsBuilder<STATE | CipherSet>& SetCipher(const String& value);  // Defined below

        SecurityDetailsBuilder<STATE>& SetMac(const String& value);  // Defined below

        SecurityDetailsBuilder<STATE | CertificateIdSet>& SetCertificateId(int value);  // Defined below

        SecurityDetailsBuilder<STATE | SubjectNameSet>& SetSubjectName(const String& value);  // Defined below

        SecurityDetailsBuilder<STATE | SanListSet>& SetSanList(std::unique_ptr<protocol::Array<String>> value);  // Defined below

        SecurityDetailsBuilder<STATE | IssuerSet>& SetIssuer(const String& value);  // Defined below

        SecurityDetailsBuilder<STATE | ValidFromSet>& SetValidFrom(double value);  // Defined below

        SecurityDetailsBuilder<STATE | ValidToSet>& SetValidTo(double value);  // Defined below

        SecurityDetailsBuilder<STATE | SignedCertificateTimestampListSet>& SetSignedCertificateTimestampList(std::unique_ptr<protocol::Array<protocol::Network::SignedCertificateTimestamp>> value);  // Defined below

        SecurityDetailsBuilder<STATE | CertificateTransparencyComplianceSet>& SetCertificateTransparencyCompliance(const String& value);  // Defined below

        SecurityDetailsBuilder<STATE>& SetServerSignatureAlgorithm(int value);  // Defined below

        SecurityDetailsBuilder<STATE | EncryptedClientHelloSet>& SetEncryptedClientHello(bool value);  // Defined below

        std::unique_ptr<SecurityDetails> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class SecurityDetails;
        SecurityDetailsBuilder() : m_result(new SecurityDetails()) { }

        template<int STEP> SecurityDetailsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<SecurityDetailsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::SecurityDetails> m_result;
    };

    static SecurityDetailsBuilder<0> Create()
    {
        return SecurityDetailsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    SecurityDetails();  // Defined below

    String m_protocol;
    String m_keyExchange;
    std::optional<String> m_keyExchangeGroup;
    String m_cipher;
    std::optional<String> m_mac;
    int m_certificateId;
    String m_subjectName;
    std::unique_ptr<protocol::Array<String>> m_sanList;
    String m_issuer;
    double m_validFrom;
    double m_validTo;
    std::unique_ptr<protocol::Array<protocol::Network::SignedCertificateTimestamp>> m_signedCertificateTimestampList;
    String m_certificateTransparencyCompliance;
    std::optional<int> m_serverSignatureAlgorithm;
    bool m_encryptedClientHello;
};


class CONTENT_EXPORT CorsErrorStatus : public ::crdtp::ProtocolObject<CorsErrorStatus> {
public:
    ~CorsErrorStatus() override;  // Defined below

    String GetCorsError() { return m_corsError; }
    void SetCorsError(const String& value);  // Defined below

    String GetFailedParameter() { return m_failedParameter; }
    void SetFailedParameter(const String& value);  // Defined below

    template<int STATE>
    class CorsErrorStatusBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            CorsErrorSet = 1 << 1,
            FailedParameterSet = 1 << 2,
            AllFieldsSet = (CorsErrorSet | FailedParameterSet | 0)};


        CorsErrorStatusBuilder<STATE | CorsErrorSet>& SetCorsError(const String& value);  // Defined below

        CorsErrorStatusBuilder<STATE | FailedParameterSet>& SetFailedParameter(const String& value);  // Defined below

        std::unique_ptr<CorsErrorStatus> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class CorsErrorStatus;
        CorsErrorStatusBuilder() : m_result(new CorsErrorStatus()) { }

        template<int STEP> CorsErrorStatusBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<CorsErrorStatusBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::CorsErrorStatus> m_result;
    };

    static CorsErrorStatusBuilder<0> Create()
    {
        return CorsErrorStatusBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    CorsErrorStatus();  // Defined below

    String m_corsError;
    String m_failedParameter;
};


class CONTENT_EXPORT TrustTokenParams : public ::crdtp::ProtocolObject<TrustTokenParams> {
public:
    ~TrustTokenParams() override;  // Defined below

    String GetOperation() { return m_operation; }
    void SetOperation(const String& value);  // Defined below

    struct CONTENT_EXPORT RefreshPolicyEnum {
        static const char* UseCached;
        static const char* Refresh;
    }; // RefreshPolicyEnum

    String GetRefreshPolicy() { return m_refreshPolicy; }
    void SetRefreshPolicy(const String& value);  // Defined below

    bool HasIssuers() { return !!m_issuers; }
    protocol::Array<String>* GetIssuers(protocol::Array<String>* defaultValue) {
       return m_issuers ? m_issuers.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Array<String>>& GetIssuers() const {
       return m_issuers;
    }
    void SetIssuers(std::unique_ptr<protocol::Array<String>> value);  // Defined below

    template<int STATE>
    class TrustTokenParamsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            OperationSet = 1 << 1,
            RefreshPolicySet = 1 << 2,
            AllFieldsSet = (OperationSet | RefreshPolicySet | 0)};


        TrustTokenParamsBuilder<STATE | OperationSet>& SetOperation(const String& value);  // Defined below

        TrustTokenParamsBuilder<STATE | RefreshPolicySet>& SetRefreshPolicy(const String& value);  // Defined below

        TrustTokenParamsBuilder<STATE>& SetIssuers(std::unique_ptr<protocol::Array<String>> value);  // Defined below

        std::unique_ptr<TrustTokenParams> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class TrustTokenParams;
        TrustTokenParamsBuilder() : m_result(new TrustTokenParams()) { }

        template<int STEP> TrustTokenParamsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<TrustTokenParamsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::TrustTokenParams> m_result;
    };

    static TrustTokenParamsBuilder<0> Create()
    {
        return TrustTokenParamsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    TrustTokenParams();  // Defined below

    String m_operation;
    String m_refreshPolicy;
    std::unique_ptr<protocol::Array<String>> m_issuers;
};


class CONTENT_EXPORT ServiceWorkerRouterInfo : public ::crdtp::ProtocolObject<ServiceWorkerRouterInfo> {
public:
    ~ServiceWorkerRouterInfo() override;  // Defined below

    bool HasRuleIdMatched() { return !!m_ruleIdMatched; }
    int GetRuleIdMatched(int defaultValue) const {
       return m_ruleIdMatched.value_or(defaultValue);
    }
    const std::optional<int>& GetRuleIdMatched() const {
       return m_ruleIdMatched;
    }
    void SetRuleIdMatched(int value);  // Defined below

    bool HasMatchedSourceType() { return !!m_matchedSourceType; }
    String GetMatchedSourceType(const String& defaultValue) const {
       return m_matchedSourceType.value_or(defaultValue);
    }
    const std::optional<String>& GetMatchedSourceType() const {
       return m_matchedSourceType;
    }
    void SetMatchedSourceType(const String& value);  // Defined below

    bool HasActualSourceType() { return !!m_actualSourceType; }
    String GetActualSourceType(const String& defaultValue) const {
       return m_actualSourceType.value_or(defaultValue);
    }
    const std::optional<String>& GetActualSourceType() const {
       return m_actualSourceType;
    }
    void SetActualSourceType(const String& value);  // Defined below

    template<int STATE>
    class ServiceWorkerRouterInfoBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            AllFieldsSet = (0)};


        ServiceWorkerRouterInfoBuilder<STATE>& SetRuleIdMatched(int value);  // Defined below

        ServiceWorkerRouterInfoBuilder<STATE>& SetMatchedSourceType(const String& value);  // Defined below

        ServiceWorkerRouterInfoBuilder<STATE>& SetActualSourceType(const String& value);  // Defined below

        std::unique_ptr<ServiceWorkerRouterInfo> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ServiceWorkerRouterInfo;
        ServiceWorkerRouterInfoBuilder() : m_result(new ServiceWorkerRouterInfo()) { }

        template<int STEP> ServiceWorkerRouterInfoBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ServiceWorkerRouterInfoBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ServiceWorkerRouterInfo> m_result;
    };

    static ServiceWorkerRouterInfoBuilder<0> Create()
    {
        return ServiceWorkerRouterInfoBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ServiceWorkerRouterInfo();  // Defined below

    std::optional<int> m_ruleIdMatched;
    std::optional<String> m_matchedSourceType;
    std::optional<String> m_actualSourceType;
};


class CONTENT_EXPORT Response : public ::crdtp::ProtocolObject<Response> {
public:
    ~Response() override;  // Defined below

    String GetUrl() { return m_url; }
    void SetUrl(const String& value);  // Defined below

    int GetStatus() { return m_status; }
    void SetStatus(int value);  // Defined below

    String GetStatusText() { return m_statusText; }
    void SetStatusText(const String& value);  // Defined below

    protocol::Network::Headers* GetHeaders() { return m_headers.get(); }
    void SetHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

    bool HasHeadersText() { return !!m_headersText; }
    String GetHeadersText(const String& defaultValue) const {
       return m_headersText.value_or(defaultValue);
    }
    const std::optional<String>& GetHeadersText() const {
       return m_headersText;
    }
    void SetHeadersText(const String& value);  // Defined below

    String GetMimeType() { return m_mimeType; }
    void SetMimeType(const String& value);  // Defined below

    String GetCharset() { return m_charset; }
    void SetCharset(const String& value);  // Defined below

    bool HasRequestHeaders() { return !!m_requestHeaders; }
    protocol::Network::Headers* GetRequestHeaders(protocol::Network::Headers* defaultValue) {
       return m_requestHeaders ? m_requestHeaders.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::Headers>& GetRequestHeaders() const {
       return m_requestHeaders;
    }
    void SetRequestHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

    bool HasRequestHeadersText() { return !!m_requestHeadersText; }
    String GetRequestHeadersText(const String& defaultValue) const {
       return m_requestHeadersText.value_or(defaultValue);
    }
    const std::optional<String>& GetRequestHeadersText() const {
       return m_requestHeadersText;
    }
    void SetRequestHeadersText(const String& value);  // Defined below

    bool GetConnectionReused() { return m_connectionReused; }
    void SetConnectionReused(bool value);  // Defined below

    double GetConnectionId() { return m_connectionId; }
    void SetConnectionId(double value);  // Defined below

    bool HasRemoteIPAddress() { return !!m_remoteIPAddress; }
    String GetRemoteIPAddress(const String& defaultValue) const {
       return m_remoteIPAddress.value_or(defaultValue);
    }
    const std::optional<String>& GetRemoteIPAddress() const {
       return m_remoteIPAddress;
    }
    void SetRemoteIPAddress(const String& value);  // Defined below

    bool HasRemotePort() { return !!m_remotePort; }
    int GetRemotePort(int defaultValue) const {
       return m_remotePort.value_or(defaultValue);
    }
    const std::optional<int>& GetRemotePort() const {
       return m_remotePort;
    }
    void SetRemotePort(int value);  // Defined below

    bool HasFromDiskCache() { return !!m_fromDiskCache; }
    bool GetFromDiskCache(bool defaultValue) const {
       return m_fromDiskCache.value_or(defaultValue);
    }
    const std::optional<bool>& GetFromDiskCache() const {
       return m_fromDiskCache;
    }
    void SetFromDiskCache(bool value);  // Defined below

    bool HasFromServiceWorker() { return !!m_fromServiceWorker; }
    bool GetFromServiceWorker(bool defaultValue) const {
       return m_fromServiceWorker.value_or(defaultValue);
    }
    const std::optional<bool>& GetFromServiceWorker() const {
       return m_fromServiceWorker;
    }
    void SetFromServiceWorker(bool value);  // Defined below

    bool HasFromPrefetchCache() { return !!m_fromPrefetchCache; }
    bool GetFromPrefetchCache(bool defaultValue) const {
       return m_fromPrefetchCache.value_or(defaultValue);
    }
    const std::optional<bool>& GetFromPrefetchCache() const {
       return m_fromPrefetchCache;
    }
    void SetFromPrefetchCache(bool value);  // Defined below

    bool HasFromEarlyHints() { return !!m_fromEarlyHints; }
    bool GetFromEarlyHints(bool defaultValue) const {
       return m_fromEarlyHints.value_or(defaultValue);
    }
    const std::optional<bool>& GetFromEarlyHints() const {
       return m_fromEarlyHints;
    }
    void SetFromEarlyHints(bool value);  // Defined below

    bool HasServiceWorkerRouterInfo() { return !!m_serviceWorkerRouterInfo; }
    protocol::Network::ServiceWorkerRouterInfo* GetServiceWorkerRouterInfo(protocol::Network::ServiceWorkerRouterInfo* defaultValue) {
       return m_serviceWorkerRouterInfo ? m_serviceWorkerRouterInfo.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::ServiceWorkerRouterInfo>& GetServiceWorkerRouterInfo() const {
       return m_serviceWorkerRouterInfo;
    }
    void SetServiceWorkerRouterInfo(std::unique_ptr<protocol::Network::ServiceWorkerRouterInfo> value);  // Defined below

    double GetEncodedDataLength() { return m_encodedDataLength; }
    void SetEncodedDataLength(double value);  // Defined below

    bool HasTiming() { return !!m_timing; }
    protocol::Network::ResourceTiming* GetTiming(protocol::Network::ResourceTiming* defaultValue) {
       return m_timing ? m_timing.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::ResourceTiming>& GetTiming() const {
       return m_timing;
    }
    void SetTiming(std::unique_ptr<protocol::Network::ResourceTiming> value);  // Defined below

    bool HasServiceWorkerResponseSource() { return !!m_serviceWorkerResponseSource; }
    String GetServiceWorkerResponseSource(const String& defaultValue) const {
       return m_serviceWorkerResponseSource.value_or(defaultValue);
    }
    const std::optional<String>& GetServiceWorkerResponseSource() const {
       return m_serviceWorkerResponseSource;
    }
    void SetServiceWorkerResponseSource(const String& value);  // Defined below

    bool HasResponseTime() { return !!m_responseTime; }
    double GetResponseTime(double defaultValue) const {
       return m_responseTime.value_or(defaultValue);
    }
    const std::optional<double>& GetResponseTime() const {
       return m_responseTime;
    }
    void SetResponseTime(double value);  // Defined below

    bool HasCacheStorageCacheName() { return !!m_cacheStorageCacheName; }
    String GetCacheStorageCacheName(const String& defaultValue) const {
       return m_cacheStorageCacheName.value_or(defaultValue);
    }
    const std::optional<String>& GetCacheStorageCacheName() const {
       return m_cacheStorageCacheName;
    }
    void SetCacheStorageCacheName(const String& value);  // Defined below

    bool HasProtocol() { return !!m_protocol; }
    String GetProtocol(const String& defaultValue) const {
       return m_protocol.value_or(defaultValue);
    }
    const std::optional<String>& GetProtocol() const {
       return m_protocol;
    }
    void SetProtocol(const String& value);  // Defined below

    bool HasAlternateProtocolUsage() { return !!m_alternateProtocolUsage; }
    String GetAlternateProtocolUsage(const String& defaultValue) const {
       return m_alternateProtocolUsage.value_or(defaultValue);
    }
    const std::optional<String>& GetAlternateProtocolUsage() const {
       return m_alternateProtocolUsage;
    }
    void SetAlternateProtocolUsage(const String& value);  // Defined below

    String GetSecurityState() { return m_securityState; }
    void SetSecurityState(const String& value);  // Defined below

    bool HasSecurityDetails() { return !!m_securityDetails; }
    protocol::Network::SecurityDetails* GetSecurityDetails(protocol::Network::SecurityDetails* defaultValue) {
       return m_securityDetails ? m_securityDetails.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::SecurityDetails>& GetSecurityDetails() const {
       return m_securityDetails;
    }
    void SetSecurityDetails(std::unique_ptr<protocol::Network::SecurityDetails> value);  // Defined below

    template<int STATE>
    class ResponseBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            UrlSet = 1 << 1,
            StatusSet = 1 << 2,
            StatusTextSet = 1 << 3,
            HeadersSet = 1 << 4,
            MimeTypeSet = 1 << 5,
            CharsetSet = 1 << 6,
            ConnectionReusedSet = 1 << 7,
            ConnectionIdSet = 1 << 8,
            EncodedDataLengthSet = 1 << 9,
            SecurityStateSet = 1 << 10,
            AllFieldsSet = (UrlSet | StatusSet | StatusTextSet | HeadersSet | MimeTypeSet | CharsetSet | ConnectionReusedSet | ConnectionIdSet | EncodedDataLengthSet | SecurityStateSet | 0)};


        ResponseBuilder<STATE | UrlSet>& SetUrl(const String& value);  // Defined below

        ResponseBuilder<STATE | StatusSet>& SetStatus(int value);  // Defined below

        ResponseBuilder<STATE | StatusTextSet>& SetStatusText(const String& value);  // Defined below

        ResponseBuilder<STATE | HeadersSet>& SetHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

        ResponseBuilder<STATE>& SetHeadersText(const String& value);  // Defined below

        ResponseBuilder<STATE | MimeTypeSet>& SetMimeType(const String& value);  // Defined below

        ResponseBuilder<STATE | CharsetSet>& SetCharset(const String& value);  // Defined below

        ResponseBuilder<STATE>& SetRequestHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

        ResponseBuilder<STATE>& SetRequestHeadersText(const String& value);  // Defined below

        ResponseBuilder<STATE | ConnectionReusedSet>& SetConnectionReused(bool value);  // Defined below

        ResponseBuilder<STATE | ConnectionIdSet>& SetConnectionId(double value);  // Defined below

        ResponseBuilder<STATE>& SetRemoteIPAddress(const String& value);  // Defined below

        ResponseBuilder<STATE>& SetRemotePort(int value);  // Defined below

        ResponseBuilder<STATE>& SetFromDiskCache(bool value);  // Defined below

        ResponseBuilder<STATE>& SetFromServiceWorker(bool value);  // Defined below

        ResponseBuilder<STATE>& SetFromPrefetchCache(bool value);  // Defined below

        ResponseBuilder<STATE>& SetFromEarlyHints(bool value);  // Defined below

        ResponseBuilder<STATE>& SetServiceWorkerRouterInfo(std::unique_ptr<protocol::Network::ServiceWorkerRouterInfo> value);  // Defined below

        ResponseBuilder<STATE | EncodedDataLengthSet>& SetEncodedDataLength(double value);  // Defined below

        ResponseBuilder<STATE>& SetTiming(std::unique_ptr<protocol::Network::ResourceTiming> value);  // Defined below

        ResponseBuilder<STATE>& SetServiceWorkerResponseSource(const String& value);  // Defined below

        ResponseBuilder<STATE>& SetResponseTime(double value);  // Defined below

        ResponseBuilder<STATE>& SetCacheStorageCacheName(const String& value);  // Defined below

        ResponseBuilder<STATE>& SetProtocol(const String& value);  // Defined below

        ResponseBuilder<STATE>& SetAlternateProtocolUsage(const String& value);  // Defined below

        ResponseBuilder<STATE | SecurityStateSet>& SetSecurityState(const String& value);  // Defined below

        ResponseBuilder<STATE>& SetSecurityDetails(std::unique_ptr<protocol::Network::SecurityDetails> value);  // Defined below

        std::unique_ptr<Response> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class Response;
        ResponseBuilder() : m_result(new Response()) { }

        template<int STEP> ResponseBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ResponseBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::Response> m_result;
    };

    static ResponseBuilder<0> Create()
    {
        return ResponseBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    Response();  // Defined below

    String m_url;
    int m_status;
    String m_statusText;
    std::unique_ptr<protocol::Network::Headers> m_headers;
    std::optional<String> m_headersText;
    String m_mimeType;
    String m_charset;
    std::unique_ptr<protocol::Network::Headers> m_requestHeaders;
    std::optional<String> m_requestHeadersText;
    bool m_connectionReused;
    double m_connectionId;
    std::optional<String> m_remoteIPAddress;
    std::optional<int> m_remotePort;
    std::optional<bool> m_fromDiskCache;
    std::optional<bool> m_fromServiceWorker;
    std::optional<bool> m_fromPrefetchCache;
    std::optional<bool> m_fromEarlyHints;
    std::unique_ptr<protocol::Network::ServiceWorkerRouterInfo> m_serviceWorkerRouterInfo;
    double m_encodedDataLength;
    std::unique_ptr<protocol::Network::ResourceTiming> m_timing;
    std::optional<String> m_serviceWorkerResponseSource;
    std::optional<double> m_responseTime;
    std::optional<String> m_cacheStorageCacheName;
    std::optional<String> m_protocol;
    std::optional<String> m_alternateProtocolUsage;
    String m_securityState;
    std::unique_ptr<protocol::Network::SecurityDetails> m_securityDetails;
};


class CONTENT_EXPORT Initiator : public ::crdtp::ProtocolObject<Initiator> {
public:
    ~Initiator() override;  // Defined below

    struct CONTENT_EXPORT TypeEnum {
        static const char* Parser;
        static const char* Script;
        static const char* Preload;
        static const char* SignedExchange;
        static const char* Preflight;
        static const char* FedCM;
        static const char* Other;
    }; // TypeEnum

    String GetType() { return m_type; }
    void SetType(const String& value);  // Defined below

    bool HasStack() { return !!m_stack; }
    protocol::Runtime::StackTrace* GetStack(protocol::Runtime::StackTrace* defaultValue) {
       return m_stack ? m_stack.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Runtime::StackTrace>& GetStack() const {
       return m_stack;
    }
    void SetStack(std::unique_ptr<protocol::Runtime::StackTrace> value);  // Defined below

    bool HasUrl() { return !!m_url; }
    String GetUrl(const String& defaultValue) const {
       return m_url.value_or(defaultValue);
    }
    const std::optional<String>& GetUrl() const {
       return m_url;
    }
    void SetUrl(const String& value);  // Defined below

    bool HasLineNumber() { return !!m_lineNumber; }
    double GetLineNumber(double defaultValue) const {
       return m_lineNumber.value_or(defaultValue);
    }
    const std::optional<double>& GetLineNumber() const {
       return m_lineNumber;
    }
    void SetLineNumber(double value);  // Defined below

    bool HasColumnNumber() { return !!m_columnNumber; }
    double GetColumnNumber(double defaultValue) const {
       return m_columnNumber.value_or(defaultValue);
    }
    const std::optional<double>& GetColumnNumber() const {
       return m_columnNumber;
    }
    void SetColumnNumber(double value);  // Defined below

    bool HasRequestId() { return !!m_requestId; }
    String GetRequestId(const String& defaultValue) const {
       return m_requestId.value_or(defaultValue);
    }
    const std::optional<String>& GetRequestId() const {
       return m_requestId;
    }
    void SetRequestId(const String& value);  // Defined below

    template<int STATE>
    class InitiatorBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            TypeSet = 1 << 1,
            AllFieldsSet = (TypeSet | 0)};


        InitiatorBuilder<STATE | TypeSet>& SetType(const String& value);  // Defined below

        InitiatorBuilder<STATE>& SetStack(std::unique_ptr<protocol::Runtime::StackTrace> value);  // Defined below

        InitiatorBuilder<STATE>& SetUrl(const String& value);  // Defined below

        InitiatorBuilder<STATE>& SetLineNumber(double value);  // Defined below

        InitiatorBuilder<STATE>& SetColumnNumber(double value);  // Defined below

        InitiatorBuilder<STATE>& SetRequestId(const String& value);  // Defined below

        std::unique_ptr<Initiator> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class Initiator;
        InitiatorBuilder() : m_result(new Initiator()) { }

        template<int STEP> InitiatorBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<InitiatorBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::Initiator> m_result;
    };

    static InitiatorBuilder<0> Create()
    {
        return InitiatorBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    Initiator();  // Defined below

    String m_type;
    std::unique_ptr<protocol::Runtime::StackTrace> m_stack;
    std::optional<String> m_url;
    std::optional<double> m_lineNumber;
    std::optional<double> m_columnNumber;
    std::optional<String> m_requestId;
};


class CONTENT_EXPORT CookiePartitionKey : public ::crdtp::ProtocolObject<CookiePartitionKey> {
public:
    ~CookiePartitionKey() override;  // Defined below

    String GetTopLevelSite() { return m_topLevelSite; }
    void SetTopLevelSite(const String& value);  // Defined below

    bool GetHasCrossSiteAncestor() { return m_hasCrossSiteAncestor; }
    void SetHasCrossSiteAncestor(bool value);  // Defined below

    template<int STATE>
    class CookiePartitionKeyBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            TopLevelSiteSet = 1 << 1,
            HasCrossSiteAncestorSet = 1 << 2,
            AllFieldsSet = (TopLevelSiteSet | HasCrossSiteAncestorSet | 0)};


        CookiePartitionKeyBuilder<STATE | TopLevelSiteSet>& SetTopLevelSite(const String& value);  // Defined below

        CookiePartitionKeyBuilder<STATE | HasCrossSiteAncestorSet>& SetHasCrossSiteAncestor(bool value);  // Defined below

        std::unique_ptr<CookiePartitionKey> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class CookiePartitionKey;
        CookiePartitionKeyBuilder() : m_result(new CookiePartitionKey()) { }

        template<int STEP> CookiePartitionKeyBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<CookiePartitionKeyBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::CookiePartitionKey> m_result;
    };

    static CookiePartitionKeyBuilder<0> Create()
    {
        return CookiePartitionKeyBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    CookiePartitionKey();  // Defined below

    String m_topLevelSite;
    bool m_hasCrossSiteAncestor;
};


class CONTENT_EXPORT Cookie : public ::crdtp::ProtocolObject<Cookie> {
public:
    ~Cookie() override;  // Defined below

    String GetName() { return m_name; }
    void SetName(const String& value);  // Defined below

    String GetValue() { return m_value; }
    void SetValue(const String& value);  // Defined below

    String GetDomain() { return m_domain; }
    void SetDomain(const String& value);  // Defined below

    String GetPath() { return m_path; }
    void SetPath(const String& value);  // Defined below

    double GetExpires() { return m_expires; }
    void SetExpires(double value);  // Defined below

    int GetSize() { return m_size; }
    void SetSize(int value);  // Defined below

    bool GetHttpOnly() { return m_httpOnly; }
    void SetHttpOnly(bool value);  // Defined below

    bool GetSecure() { return m_secure; }
    void SetSecure(bool value);  // Defined below

    bool GetSession() { return m_session; }
    void SetSession(bool value);  // Defined below

    bool HasSameSite() { return !!m_sameSite; }
    String GetSameSite(const String& defaultValue) const {
       return m_sameSite.value_or(defaultValue);
    }
    const std::optional<String>& GetSameSite() const {
       return m_sameSite;
    }
    void SetSameSite(const String& value);  // Defined below

    String GetPriority() { return m_priority; }
    void SetPriority(const String& value);  // Defined below

    String GetSourceScheme() { return m_sourceScheme; }
    void SetSourceScheme(const String& value);  // Defined below

    int GetSourcePort() { return m_sourcePort; }
    void SetSourcePort(int value);  // Defined below

    bool HasPartitionKey() { return !!m_partitionKey; }
    protocol::Network::CookiePartitionKey* GetPartitionKey(protocol::Network::CookiePartitionKey* defaultValue) {
       return m_partitionKey ? m_partitionKey.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::CookiePartitionKey>& GetPartitionKey() const {
       return m_partitionKey;
    }
    void SetPartitionKey(std::unique_ptr<protocol::Network::CookiePartitionKey> value);  // Defined below

    bool HasPartitionKeyOpaque() { return !!m_partitionKeyOpaque; }
    bool GetPartitionKeyOpaque(bool defaultValue) const {
       return m_partitionKeyOpaque.value_or(defaultValue);
    }
    const std::optional<bool>& GetPartitionKeyOpaque() const {
       return m_partitionKeyOpaque;
    }
    void SetPartitionKeyOpaque(bool value);  // Defined below

    template<int STATE>
    class CookieBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            NameSet = 1 << 1,
            ValueSet = 1 << 2,
            DomainSet = 1 << 3,
            PathSet = 1 << 4,
            ExpiresSet = 1 << 5,
            SizeSet = 1 << 6,
            HttpOnlySet = 1 << 7,
            SecureSet = 1 << 8,
            SessionSet = 1 << 9,
            PrioritySet = 1 << 10,
            SourceSchemeSet = 1 << 11,
            SourcePortSet = 1 << 12,
            AllFieldsSet = (NameSet | ValueSet | DomainSet | PathSet | ExpiresSet | SizeSet | HttpOnlySet | SecureSet | SessionSet | PrioritySet | SourceSchemeSet | SourcePortSet | 0)};


        CookieBuilder<STATE | NameSet>& SetName(const String& value);  // Defined below

        CookieBuilder<STATE | ValueSet>& SetValue(const String& value);  // Defined below

        CookieBuilder<STATE | DomainSet>& SetDomain(const String& value);  // Defined below

        CookieBuilder<STATE | PathSet>& SetPath(const String& value);  // Defined below

        CookieBuilder<STATE | ExpiresSet>& SetExpires(double value);  // Defined below

        CookieBuilder<STATE | SizeSet>& SetSize(int value);  // Defined below

        CookieBuilder<STATE | HttpOnlySet>& SetHttpOnly(bool value);  // Defined below

        CookieBuilder<STATE | SecureSet>& SetSecure(bool value);  // Defined below

        CookieBuilder<STATE | SessionSet>& SetSession(bool value);  // Defined below

        CookieBuilder<STATE>& SetSameSite(const String& value);  // Defined below

        CookieBuilder<STATE | PrioritySet>& SetPriority(const String& value);  // Defined below

        CookieBuilder<STATE | SourceSchemeSet>& SetSourceScheme(const String& value);  // Defined below

        CookieBuilder<STATE | SourcePortSet>& SetSourcePort(int value);  // Defined below

        CookieBuilder<STATE>& SetPartitionKey(std::unique_ptr<protocol::Network::CookiePartitionKey> value);  // Defined below

        CookieBuilder<STATE>& SetPartitionKeyOpaque(bool value);  // Defined below

        std::unique_ptr<Cookie> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class Cookie;
        CookieBuilder() : m_result(new Cookie()) { }

        template<int STEP> CookieBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<CookieBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::Cookie> m_result;
    };

    static CookieBuilder<0> Create()
    {
        return CookieBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    Cookie();  // Defined below

    String m_name;
    String m_value;
    String m_domain;
    String m_path;
    double m_expires;
    int m_size;
    bool m_httpOnly;
    bool m_secure;
    bool m_session;
    std::optional<String> m_sameSite;
    String m_priority;
    String m_sourceScheme;
    int m_sourcePort;
    std::unique_ptr<protocol::Network::CookiePartitionKey> m_partitionKey;
    std::optional<bool> m_partitionKeyOpaque;
};


class CONTENT_EXPORT BlockedSetCookieWithReason : public ::crdtp::ProtocolObject<BlockedSetCookieWithReason> {
public:
    ~BlockedSetCookieWithReason() override;  // Defined below

    protocol::Array<String>* GetBlockedReasons() { return m_blockedReasons.get(); }
    void SetBlockedReasons(std::unique_ptr<protocol::Array<String>> value);  // Defined below

    String GetCookieLine() { return m_cookieLine; }
    void SetCookieLine(const String& value);  // Defined below

    bool HasCookie() { return !!m_cookie; }
    protocol::Network::Cookie* GetCookie(protocol::Network::Cookie* defaultValue) {
       return m_cookie ? m_cookie.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::Cookie>& GetCookie() const {
       return m_cookie;
    }
    void SetCookie(std::unique_ptr<protocol::Network::Cookie> value);  // Defined below

    template<int STATE>
    class BlockedSetCookieWithReasonBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            BlockedReasonsSet = 1 << 1,
            CookieLineSet = 1 << 2,
            AllFieldsSet = (BlockedReasonsSet | CookieLineSet | 0)};


        BlockedSetCookieWithReasonBuilder<STATE | BlockedReasonsSet>& SetBlockedReasons(std::unique_ptr<protocol::Array<String>> value);  // Defined below

        BlockedSetCookieWithReasonBuilder<STATE | CookieLineSet>& SetCookieLine(const String& value);  // Defined below

        BlockedSetCookieWithReasonBuilder<STATE>& SetCookie(std::unique_ptr<protocol::Network::Cookie> value);  // Defined below

        std::unique_ptr<BlockedSetCookieWithReason> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class BlockedSetCookieWithReason;
        BlockedSetCookieWithReasonBuilder() : m_result(new BlockedSetCookieWithReason()) { }

        template<int STEP> BlockedSetCookieWithReasonBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<BlockedSetCookieWithReasonBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::BlockedSetCookieWithReason> m_result;
    };

    static BlockedSetCookieWithReasonBuilder<0> Create()
    {
        return BlockedSetCookieWithReasonBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    BlockedSetCookieWithReason();  // Defined below

    std::unique_ptr<protocol::Array<String>> m_blockedReasons;
    String m_cookieLine;
    std::unique_ptr<protocol::Network::Cookie> m_cookie;
};


class CONTENT_EXPORT ExemptedSetCookieWithReason : public ::crdtp::ProtocolObject<ExemptedSetCookieWithReason> {
public:
    ~ExemptedSetCookieWithReason() override;  // Defined below

    String GetExemptionReason() { return m_exemptionReason; }
    void SetExemptionReason(const String& value);  // Defined below

    String GetCookieLine() { return m_cookieLine; }
    void SetCookieLine(const String& value);  // Defined below

    protocol::Network::Cookie* GetCookie() { return m_cookie.get(); }
    void SetCookie(std::unique_ptr<protocol::Network::Cookie> value);  // Defined below

    template<int STATE>
    class ExemptedSetCookieWithReasonBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ExemptionReasonSet = 1 << 1,
            CookieLineSet = 1 << 2,
            CookieSet = 1 << 3,
            AllFieldsSet = (ExemptionReasonSet | CookieLineSet | CookieSet | 0)};


        ExemptedSetCookieWithReasonBuilder<STATE | ExemptionReasonSet>& SetExemptionReason(const String& value);  // Defined below

        ExemptedSetCookieWithReasonBuilder<STATE | CookieLineSet>& SetCookieLine(const String& value);  // Defined below

        ExemptedSetCookieWithReasonBuilder<STATE | CookieSet>& SetCookie(std::unique_ptr<protocol::Network::Cookie> value);  // Defined below

        std::unique_ptr<ExemptedSetCookieWithReason> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ExemptedSetCookieWithReason;
        ExemptedSetCookieWithReasonBuilder() : m_result(new ExemptedSetCookieWithReason()) { }

        template<int STEP> ExemptedSetCookieWithReasonBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ExemptedSetCookieWithReasonBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ExemptedSetCookieWithReason> m_result;
    };

    static ExemptedSetCookieWithReasonBuilder<0> Create()
    {
        return ExemptedSetCookieWithReasonBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ExemptedSetCookieWithReason();  // Defined below

    String m_exemptionReason;
    String m_cookieLine;
    std::unique_ptr<protocol::Network::Cookie> m_cookie;
};


class CONTENT_EXPORT AssociatedCookie : public ::crdtp::ProtocolObject<AssociatedCookie> {
public:
    ~AssociatedCookie() override;  // Defined below

    protocol::Network::Cookie* GetCookie() { return m_cookie.get(); }
    void SetCookie(std::unique_ptr<protocol::Network::Cookie> value);  // Defined below

    protocol::Array<String>* GetBlockedReasons() { return m_blockedReasons.get(); }
    void SetBlockedReasons(std::unique_ptr<protocol::Array<String>> value);  // Defined below

    bool HasExemptionReason() { return !!m_exemptionReason; }
    String GetExemptionReason(const String& defaultValue) const {
       return m_exemptionReason.value_or(defaultValue);
    }
    const std::optional<String>& GetExemptionReason() const {
       return m_exemptionReason;
    }
    void SetExemptionReason(const String& value);  // Defined below

    template<int STATE>
    class AssociatedCookieBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            CookieSet = 1 << 1,
            BlockedReasonsSet = 1 << 2,
            AllFieldsSet = (CookieSet | BlockedReasonsSet | 0)};


        AssociatedCookieBuilder<STATE | CookieSet>& SetCookie(std::unique_ptr<protocol::Network::Cookie> value);  // Defined below

        AssociatedCookieBuilder<STATE | BlockedReasonsSet>& SetBlockedReasons(std::unique_ptr<protocol::Array<String>> value);  // Defined below

        AssociatedCookieBuilder<STATE>& SetExemptionReason(const String& value);  // Defined below

        std::unique_ptr<AssociatedCookie> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class AssociatedCookie;
        AssociatedCookieBuilder() : m_result(new AssociatedCookie()) { }

        template<int STEP> AssociatedCookieBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<AssociatedCookieBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::AssociatedCookie> m_result;
    };

    static AssociatedCookieBuilder<0> Create()
    {
        return AssociatedCookieBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    AssociatedCookie();  // Defined below

    std::unique_ptr<protocol::Network::Cookie> m_cookie;
    std::unique_ptr<protocol::Array<String>> m_blockedReasons;
    std::optional<String> m_exemptionReason;
};


class CONTENT_EXPORT CookieParam : public ::crdtp::ProtocolObject<CookieParam> {
public:
    ~CookieParam() override;  // Defined below

    String GetName() { return m_name; }
    void SetName(const String& value);  // Defined below

    String GetValue() { return m_value; }
    void SetValue(const String& value);  // Defined below

    bool HasUrl() { return !!m_url; }
    String GetUrl(const String& defaultValue) const {
       return m_url.value_or(defaultValue);
    }
    const std::optional<String>& GetUrl() const {
       return m_url;
    }
    void SetUrl(const String& value);  // Defined below

    bool HasDomain() { return !!m_domain; }
    String GetDomain(const String& defaultValue) const {
       return m_domain.value_or(defaultValue);
    }
    const std::optional<String>& GetDomain() const {
       return m_domain;
    }
    void SetDomain(const String& value);  // Defined below

    bool HasPath() { return !!m_path; }
    String GetPath(const String& defaultValue) const {
       return m_path.value_or(defaultValue);
    }
    const std::optional<String>& GetPath() const {
       return m_path;
    }
    void SetPath(const String& value);  // Defined below

    bool HasSecure() { return !!m_secure; }
    bool GetSecure(bool defaultValue) const {
       return m_secure.value_or(defaultValue);
    }
    const std::optional<bool>& GetSecure() const {
       return m_secure;
    }
    void SetSecure(bool value);  // Defined below

    bool HasHttpOnly() { return !!m_httpOnly; }
    bool GetHttpOnly(bool defaultValue) const {
       return m_httpOnly.value_or(defaultValue);
    }
    const std::optional<bool>& GetHttpOnly() const {
       return m_httpOnly;
    }
    void SetHttpOnly(bool value);  // Defined below

    bool HasSameSite() { return !!m_sameSite; }
    String GetSameSite(const String& defaultValue) const {
       return m_sameSite.value_or(defaultValue);
    }
    const std::optional<String>& GetSameSite() const {
       return m_sameSite;
    }
    void SetSameSite(const String& value);  // Defined below

    bool HasExpires() { return !!m_expires; }
    double GetExpires(double defaultValue) const {
       return m_expires.value_or(defaultValue);
    }
    const std::optional<double>& GetExpires() const {
       return m_expires;
    }
    void SetExpires(double value);  // Defined below

    bool HasPriority() { return !!m_priority; }
    String GetPriority(const String& defaultValue) const {
       return m_priority.value_or(defaultValue);
    }
    const std::optional<String>& GetPriority() const {
       return m_priority;
    }
    void SetPriority(const String& value);  // Defined below

    bool HasSourceScheme() { return !!m_sourceScheme; }
    String GetSourceScheme(const String& defaultValue) const {
       return m_sourceScheme.value_or(defaultValue);
    }
    const std::optional<String>& GetSourceScheme() const {
       return m_sourceScheme;
    }
    void SetSourceScheme(const String& value);  // Defined below

    bool HasSourcePort() { return !!m_sourcePort; }
    int GetSourcePort(int defaultValue) const {
       return m_sourcePort.value_or(defaultValue);
    }
    const std::optional<int>& GetSourcePort() const {
       return m_sourcePort;
    }
    void SetSourcePort(int value);  // Defined below

    bool HasPartitionKey() { return !!m_partitionKey; }
    protocol::Network::CookiePartitionKey* GetPartitionKey(protocol::Network::CookiePartitionKey* defaultValue) {
       return m_partitionKey ? m_partitionKey.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::CookiePartitionKey>& GetPartitionKey() const {
       return m_partitionKey;
    }
    void SetPartitionKey(std::unique_ptr<protocol::Network::CookiePartitionKey> value);  // Defined below

    template<int STATE>
    class CookieParamBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            NameSet = 1 << 1,
            ValueSet = 1 << 2,
            AllFieldsSet = (NameSet | ValueSet | 0)};


        CookieParamBuilder<STATE | NameSet>& SetName(const String& value);  // Defined below

        CookieParamBuilder<STATE | ValueSet>& SetValue(const String& value);  // Defined below

        CookieParamBuilder<STATE>& SetUrl(const String& value);  // Defined below

        CookieParamBuilder<STATE>& SetDomain(const String& value);  // Defined below

        CookieParamBuilder<STATE>& SetPath(const String& value);  // Defined below

        CookieParamBuilder<STATE>& SetSecure(bool value);  // Defined below

        CookieParamBuilder<STATE>& SetHttpOnly(bool value);  // Defined below

        CookieParamBuilder<STATE>& SetSameSite(const String& value);  // Defined below

        CookieParamBuilder<STATE>& SetExpires(double value);  // Defined below

        CookieParamBuilder<STATE>& SetPriority(const String& value);  // Defined below

        CookieParamBuilder<STATE>& SetSourceScheme(const String& value);  // Defined below

        CookieParamBuilder<STATE>& SetSourcePort(int value);  // Defined below

        CookieParamBuilder<STATE>& SetPartitionKey(std::unique_ptr<protocol::Network::CookiePartitionKey> value);  // Defined below

        std::unique_ptr<CookieParam> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class CookieParam;
        CookieParamBuilder() : m_result(new CookieParam()) { }

        template<int STEP> CookieParamBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<CookieParamBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::CookieParam> m_result;
    };

    static CookieParamBuilder<0> Create()
    {
        return CookieParamBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    CookieParam();  // Defined below

    String m_name;
    String m_value;
    std::optional<String> m_url;
    std::optional<String> m_domain;
    std::optional<String> m_path;
    std::optional<bool> m_secure;
    std::optional<bool> m_httpOnly;
    std::optional<String> m_sameSite;
    std::optional<double> m_expires;
    std::optional<String> m_priority;
    std::optional<String> m_sourceScheme;
    std::optional<int> m_sourcePort;
    std::unique_ptr<protocol::Network::CookiePartitionKey> m_partitionKey;
};


class CONTENT_EXPORT SignedExchangeSignature : public ::crdtp::ProtocolObject<SignedExchangeSignature> {
public:
    ~SignedExchangeSignature() override;  // Defined below

    String GetLabel() { return m_label; }
    void SetLabel(const String& value);  // Defined below

    String GetSignature() { return m_signature; }
    void SetSignature(const String& value);  // Defined below

    String GetIntegrity() { return m_integrity; }
    void SetIntegrity(const String& value);  // Defined below

    bool HasCertUrl() { return !!m_certUrl; }
    String GetCertUrl(const String& defaultValue) const {
       return m_certUrl.value_or(defaultValue);
    }
    const std::optional<String>& GetCertUrl() const {
       return m_certUrl;
    }
    void SetCertUrl(const String& value);  // Defined below

    bool HasCertSha256() { return !!m_certSha256; }
    String GetCertSha256(const String& defaultValue) const {
       return m_certSha256.value_or(defaultValue);
    }
    const std::optional<String>& GetCertSha256() const {
       return m_certSha256;
    }
    void SetCertSha256(const String& value);  // Defined below

    String GetValidityUrl() { return m_validityUrl; }
    void SetValidityUrl(const String& value);  // Defined below

    int GetDate() { return m_date; }
    void SetDate(int value);  // Defined below

    int GetExpires() { return m_expires; }
    void SetExpires(int value);  // Defined below

    bool HasCertificates() { return !!m_certificates; }
    protocol::Array<String>* GetCertificates(protocol::Array<String>* defaultValue) {
       return m_certificates ? m_certificates.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Array<String>>& GetCertificates() const {
       return m_certificates;
    }
    void SetCertificates(std::unique_ptr<protocol::Array<String>> value);  // Defined below

    template<int STATE>
    class SignedExchangeSignatureBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            LabelSet = 1 << 1,
            SignatureSet = 1 << 2,
            IntegritySet = 1 << 3,
            ValidityUrlSet = 1 << 4,
            DateSet = 1 << 5,
            ExpiresSet = 1 << 6,
            AllFieldsSet = (LabelSet | SignatureSet | IntegritySet | ValidityUrlSet | DateSet | ExpiresSet | 0)};


        SignedExchangeSignatureBuilder<STATE | LabelSet>& SetLabel(const String& value);  // Defined below

        SignedExchangeSignatureBuilder<STATE | SignatureSet>& SetSignature(const String& value);  // Defined below

        SignedExchangeSignatureBuilder<STATE | IntegritySet>& SetIntegrity(const String& value);  // Defined below

        SignedExchangeSignatureBuilder<STATE>& SetCertUrl(const String& value);  // Defined below

        SignedExchangeSignatureBuilder<STATE>& SetCertSha256(const String& value);  // Defined below

        SignedExchangeSignatureBuilder<STATE | ValidityUrlSet>& SetValidityUrl(const String& value);  // Defined below

        SignedExchangeSignatureBuilder<STATE | DateSet>& SetDate(int value);  // Defined below

        SignedExchangeSignatureBuilder<STATE | ExpiresSet>& SetExpires(int value);  // Defined below

        SignedExchangeSignatureBuilder<STATE>& SetCertificates(std::unique_ptr<protocol::Array<String>> value);  // Defined below

        std::unique_ptr<SignedExchangeSignature> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class SignedExchangeSignature;
        SignedExchangeSignatureBuilder() : m_result(new SignedExchangeSignature()) { }

        template<int STEP> SignedExchangeSignatureBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<SignedExchangeSignatureBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::SignedExchangeSignature> m_result;
    };

    static SignedExchangeSignatureBuilder<0> Create()
    {
        return SignedExchangeSignatureBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    SignedExchangeSignature();  // Defined below

    String m_label;
    String m_signature;
    String m_integrity;
    std::optional<String> m_certUrl;
    std::optional<String> m_certSha256;
    String m_validityUrl;
    int m_date;
    int m_expires;
    std::unique_ptr<protocol::Array<String>> m_certificates;
};


class CONTENT_EXPORT SignedExchangeHeader : public ::crdtp::ProtocolObject<SignedExchangeHeader> {
public:
    ~SignedExchangeHeader() override;  // Defined below

    String GetRequestUrl() { return m_requestUrl; }
    void SetRequestUrl(const String& value);  // Defined below

    int GetResponseCode() { return m_responseCode; }
    void SetResponseCode(int value);  // Defined below

    protocol::Network::Headers* GetResponseHeaders() { return m_responseHeaders.get(); }
    void SetResponseHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

    protocol::Array<protocol::Network::SignedExchangeSignature>* GetSignatures() { return m_signatures.get(); }
    void SetSignatures(std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeSignature>> value);  // Defined below

    String GetHeaderIntegrity() { return m_headerIntegrity; }
    void SetHeaderIntegrity(const String& value);  // Defined below

    template<int STATE>
    class SignedExchangeHeaderBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            RequestUrlSet = 1 << 1,
            ResponseCodeSet = 1 << 2,
            ResponseHeadersSet = 1 << 3,
            SignaturesSet = 1 << 4,
            HeaderIntegritySet = 1 << 5,
            AllFieldsSet = (RequestUrlSet | ResponseCodeSet | ResponseHeadersSet | SignaturesSet | HeaderIntegritySet | 0)};


        SignedExchangeHeaderBuilder<STATE | RequestUrlSet>& SetRequestUrl(const String& value);  // Defined below

        SignedExchangeHeaderBuilder<STATE | ResponseCodeSet>& SetResponseCode(int value);  // Defined below

        SignedExchangeHeaderBuilder<STATE | ResponseHeadersSet>& SetResponseHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

        SignedExchangeHeaderBuilder<STATE | SignaturesSet>& SetSignatures(std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeSignature>> value);  // Defined below

        SignedExchangeHeaderBuilder<STATE | HeaderIntegritySet>& SetHeaderIntegrity(const String& value);  // Defined below

        std::unique_ptr<SignedExchangeHeader> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class SignedExchangeHeader;
        SignedExchangeHeaderBuilder() : m_result(new SignedExchangeHeader()) { }

        template<int STEP> SignedExchangeHeaderBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<SignedExchangeHeaderBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::SignedExchangeHeader> m_result;
    };

    static SignedExchangeHeaderBuilder<0> Create()
    {
        return SignedExchangeHeaderBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    SignedExchangeHeader();  // Defined below

    String m_requestUrl;
    int m_responseCode;
    std::unique_ptr<protocol::Network::Headers> m_responseHeaders;
    std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeSignature>> m_signatures;
    String m_headerIntegrity;
};


class CONTENT_EXPORT SignedExchangeError : public ::crdtp::ProtocolObject<SignedExchangeError> {
public:
    ~SignedExchangeError() override;  // Defined below

    String GetMessage() { return m_message; }
    void SetMessage(const String& value);  // Defined below

    bool HasSignatureIndex() { return !!m_signatureIndex; }
    int GetSignatureIndex(int defaultValue) const {
       return m_signatureIndex.value_or(defaultValue);
    }
    const std::optional<int>& GetSignatureIndex() const {
       return m_signatureIndex;
    }
    void SetSignatureIndex(int value);  // Defined below

    bool HasErrorField() { return !!m_errorField; }
    String GetErrorField(const String& defaultValue) const {
       return m_errorField.value_or(defaultValue);
    }
    const std::optional<String>& GetErrorField() const {
       return m_errorField;
    }
    void SetErrorField(const String& value);  // Defined below

    template<int STATE>
    class SignedExchangeErrorBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            MessageSet = 1 << 1,
            AllFieldsSet = (MessageSet | 0)};


        SignedExchangeErrorBuilder<STATE | MessageSet>& SetMessage(const String& value);  // Defined below

        SignedExchangeErrorBuilder<STATE>& SetSignatureIndex(int value);  // Defined below

        SignedExchangeErrorBuilder<STATE>& SetErrorField(const String& value);  // Defined below

        std::unique_ptr<SignedExchangeError> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class SignedExchangeError;
        SignedExchangeErrorBuilder() : m_result(new SignedExchangeError()) { }

        template<int STEP> SignedExchangeErrorBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<SignedExchangeErrorBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::SignedExchangeError> m_result;
    };

    static SignedExchangeErrorBuilder<0> Create()
    {
        return SignedExchangeErrorBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    SignedExchangeError();  // Defined below

    String m_message;
    std::optional<int> m_signatureIndex;
    std::optional<String> m_errorField;
};


class CONTENT_EXPORT SignedExchangeInfo : public ::crdtp::ProtocolObject<SignedExchangeInfo> {
public:
    ~SignedExchangeInfo() override;  // Defined below

    protocol::Network::Response* GetOuterResponse() { return m_outerResponse.get(); }
    void SetOuterResponse(std::unique_ptr<protocol::Network::Response> value);  // Defined below

    bool GetHasExtraInfo() { return m_hasExtraInfo; }
    void SetHasExtraInfo(bool value);  // Defined below

    bool HasHeader() { return !!m_header; }
    protocol::Network::SignedExchangeHeader* GetHeader(protocol::Network::SignedExchangeHeader* defaultValue) {
       return m_header ? m_header.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::SignedExchangeHeader>& GetHeader() const {
       return m_header;
    }
    void SetHeader(std::unique_ptr<protocol::Network::SignedExchangeHeader> value);  // Defined below

    bool HasSecurityDetails() { return !!m_securityDetails; }
    protocol::Network::SecurityDetails* GetSecurityDetails(protocol::Network::SecurityDetails* defaultValue) {
       return m_securityDetails ? m_securityDetails.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::SecurityDetails>& GetSecurityDetails() const {
       return m_securityDetails;
    }
    void SetSecurityDetails(std::unique_ptr<protocol::Network::SecurityDetails> value);  // Defined below

    bool HasErrors() { return !!m_errors; }
    protocol::Array<protocol::Network::SignedExchangeError>* GetErrors(protocol::Array<protocol::Network::SignedExchangeError>* defaultValue) {
       return m_errors ? m_errors.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeError>>& GetErrors() const {
       return m_errors;
    }
    void SetErrors(std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeError>> value);  // Defined below

    template<int STATE>
    class SignedExchangeInfoBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            OuterResponseSet = 1 << 1,
            HasExtraInfoSet = 1 << 2,
            AllFieldsSet = (OuterResponseSet | HasExtraInfoSet | 0)};


        SignedExchangeInfoBuilder<STATE | OuterResponseSet>& SetOuterResponse(std::unique_ptr<protocol::Network::Response> value);  // Defined below

        SignedExchangeInfoBuilder<STATE | HasExtraInfoSet>& SetHasExtraInfo(bool value);  // Defined below

        SignedExchangeInfoBuilder<STATE>& SetHeader(std::unique_ptr<protocol::Network::SignedExchangeHeader> value);  // Defined below

        SignedExchangeInfoBuilder<STATE>& SetSecurityDetails(std::unique_ptr<protocol::Network::SecurityDetails> value);  // Defined below

        SignedExchangeInfoBuilder<STATE>& SetErrors(std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeError>> value);  // Defined below

        std::unique_ptr<SignedExchangeInfo> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class SignedExchangeInfo;
        SignedExchangeInfoBuilder() : m_result(new SignedExchangeInfo()) { }

        template<int STEP> SignedExchangeInfoBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<SignedExchangeInfoBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::SignedExchangeInfo> m_result;
    };

    static SignedExchangeInfoBuilder<0> Create()
    {
        return SignedExchangeInfoBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    SignedExchangeInfo();  // Defined below

    std::unique_ptr<protocol::Network::Response> m_outerResponse;
    bool m_hasExtraInfo;
    std::unique_ptr<protocol::Network::SignedExchangeHeader> m_header;
    std::unique_ptr<protocol::Network::SecurityDetails> m_securityDetails;
    std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeError>> m_errors;
};


class CONTENT_EXPORT NetworkConditions : public ::crdtp::ProtocolObject<NetworkConditions> {
public:
    ~NetworkConditions() override;  // Defined below

    String GetUrlPattern() { return m_urlPattern; }
    void SetUrlPattern(const String& value);  // Defined below

    double GetLatency() { return m_latency; }
    void SetLatency(double value);  // Defined below

    double GetDownloadThroughput() { return m_downloadThroughput; }
    void SetDownloadThroughput(double value);  // Defined below

    double GetUploadThroughput() { return m_uploadThroughput; }
    void SetUploadThroughput(double value);  // Defined below

    bool HasConnectionType() { return !!m_connectionType; }
    String GetConnectionType(const String& defaultValue) const {
       return m_connectionType.value_or(defaultValue);
    }
    const std::optional<String>& GetConnectionType() const {
       return m_connectionType;
    }
    void SetConnectionType(const String& value);  // Defined below

    bool HasPacketLoss() { return !!m_packetLoss; }
    double GetPacketLoss(double defaultValue) const {
       return m_packetLoss.value_or(defaultValue);
    }
    const std::optional<double>& GetPacketLoss() const {
       return m_packetLoss;
    }
    void SetPacketLoss(double value);  // Defined below

    bool HasPacketQueueLength() { return !!m_packetQueueLength; }
    int GetPacketQueueLength(int defaultValue) const {
       return m_packetQueueLength.value_or(defaultValue);
    }
    const std::optional<int>& GetPacketQueueLength() const {
       return m_packetQueueLength;
    }
    void SetPacketQueueLength(int value);  // Defined below

    bool HasPacketReordering() { return !!m_packetReordering; }
    bool GetPacketReordering(bool defaultValue) const {
       return m_packetReordering.value_or(defaultValue);
    }
    const std::optional<bool>& GetPacketReordering() const {
       return m_packetReordering;
    }
    void SetPacketReordering(bool value);  // Defined below

    bool HasOffline() { return !!m_offline; }
    bool GetOffline(bool defaultValue) const {
       return m_offline.value_or(defaultValue);
    }
    const std::optional<bool>& GetOffline() const {
       return m_offline;
    }
    void SetOffline(bool value);  // Defined below

    template<int STATE>
    class NetworkConditionsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            UrlPatternSet = 1 << 1,
            LatencySet = 1 << 2,
            DownloadThroughputSet = 1 << 3,
            UploadThroughputSet = 1 << 4,
            AllFieldsSet = (UrlPatternSet | LatencySet | DownloadThroughputSet | UploadThroughputSet | 0)};


        NetworkConditionsBuilder<STATE | UrlPatternSet>& SetUrlPattern(const String& value);  // Defined below

        NetworkConditionsBuilder<STATE | LatencySet>& SetLatency(double value);  // Defined below

        NetworkConditionsBuilder<STATE | DownloadThroughputSet>& SetDownloadThroughput(double value);  // Defined below

        NetworkConditionsBuilder<STATE | UploadThroughputSet>& SetUploadThroughput(double value);  // Defined below

        NetworkConditionsBuilder<STATE>& SetConnectionType(const String& value);  // Defined below

        NetworkConditionsBuilder<STATE>& SetPacketLoss(double value);  // Defined below

        NetworkConditionsBuilder<STATE>& SetPacketQueueLength(int value);  // Defined below

        NetworkConditionsBuilder<STATE>& SetPacketReordering(bool value);  // Defined below

        NetworkConditionsBuilder<STATE>& SetOffline(bool value);  // Defined below

        std::unique_ptr<NetworkConditions> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class NetworkConditions;
        NetworkConditionsBuilder() : m_result(new NetworkConditions()) { }

        template<int STEP> NetworkConditionsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<NetworkConditionsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::NetworkConditions> m_result;
    };

    static NetworkConditionsBuilder<0> Create()
    {
        return NetworkConditionsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    NetworkConditions();  // Defined below

    String m_urlPattern;
    double m_latency;
    double m_downloadThroughput;
    double m_uploadThroughput;
    std::optional<String> m_connectionType;
    std::optional<double> m_packetLoss;
    std::optional<int> m_packetQueueLength;
    std::optional<bool> m_packetReordering;
    std::optional<bool> m_offline;
};


class CONTENT_EXPORT ConnectTiming : public ::crdtp::ProtocolObject<ConnectTiming> {
public:
    ~ConnectTiming() override;  // Defined below

    double GetRequestTime() { return m_requestTime; }
    void SetRequestTime(double value);  // Defined below

    template<int STATE>
    class ConnectTimingBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            RequestTimeSet = 1 << 1,
            AllFieldsSet = (RequestTimeSet | 0)};


        ConnectTimingBuilder<STATE | RequestTimeSet>& SetRequestTime(double value);  // Defined below

        std::unique_ptr<ConnectTiming> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ConnectTiming;
        ConnectTimingBuilder() : m_result(new ConnectTiming()) { }

        template<int STEP> ConnectTimingBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ConnectTimingBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ConnectTiming> m_result;
    };

    static ConnectTimingBuilder<0> Create()
    {
        return ConnectTimingBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ConnectTiming();  // Defined below

    double m_requestTime;
};


class CONTENT_EXPORT ClientSecurityState : public ::crdtp::ProtocolObject<ClientSecurityState> {
public:
    ~ClientSecurityState() override;  // Defined below

    bool GetInitiatorIsSecureContext() { return m_initiatorIsSecureContext; }
    void SetInitiatorIsSecureContext(bool value);  // Defined below

    String GetInitiatorIPAddressSpace() { return m_initiatorIPAddressSpace; }
    void SetInitiatorIPAddressSpace(const String& value);  // Defined below

    String GetLocalNetworkAccessRequestPolicy() { return m_localNetworkAccessRequestPolicy; }
    void SetLocalNetworkAccessRequestPolicy(const String& value);  // Defined below

    template<int STATE>
    class ClientSecurityStateBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            InitiatorIsSecureContextSet = 1 << 1,
            InitiatorIPAddressSpaceSet = 1 << 2,
            LocalNetworkAccessRequestPolicySet = 1 << 3,
            AllFieldsSet = (InitiatorIsSecureContextSet | InitiatorIPAddressSpaceSet | LocalNetworkAccessRequestPolicySet | 0)};


        ClientSecurityStateBuilder<STATE | InitiatorIsSecureContextSet>& SetInitiatorIsSecureContext(bool value);  // Defined below

        ClientSecurityStateBuilder<STATE | InitiatorIPAddressSpaceSet>& SetInitiatorIPAddressSpace(const String& value);  // Defined below

        ClientSecurityStateBuilder<STATE | LocalNetworkAccessRequestPolicySet>& SetLocalNetworkAccessRequestPolicy(const String& value);  // Defined below

        std::unique_ptr<ClientSecurityState> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ClientSecurityState;
        ClientSecurityStateBuilder() : m_result(new ClientSecurityState()) { }

        template<int STEP> ClientSecurityStateBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ClientSecurityStateBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ClientSecurityState> m_result;
    };

    static ClientSecurityStateBuilder<0> Create()
    {
        return ClientSecurityStateBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ClientSecurityState();  // Defined below

    bool m_initiatorIsSecureContext;
    String m_initiatorIPAddressSpace;
    String m_localNetworkAccessRequestPolicy;
};


class CONTENT_EXPORT AdScriptIdentifier : public ::crdtp::ProtocolObject<AdScriptIdentifier> {
public:
    ~AdScriptIdentifier() override;  // Defined below

    String GetScriptId() { return m_scriptId; }
    void SetScriptId(const String& value);  // Defined below

    String GetDebuggerId() { return m_debuggerId; }
    void SetDebuggerId(const String& value);  // Defined below

    String GetName() { return m_name; }
    void SetName(const String& value);  // Defined below

    template<int STATE>
    class AdScriptIdentifierBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ScriptIdSet = 1 << 1,
            DebuggerIdSet = 1 << 2,
            NameSet = 1 << 3,
            AllFieldsSet = (ScriptIdSet | DebuggerIdSet | NameSet | 0)};


        AdScriptIdentifierBuilder<STATE | ScriptIdSet>& SetScriptId(const String& value);  // Defined below

        AdScriptIdentifierBuilder<STATE | DebuggerIdSet>& SetDebuggerId(const String& value);  // Defined below

        AdScriptIdentifierBuilder<STATE | NameSet>& SetName(const String& value);  // Defined below

        std::unique_ptr<AdScriptIdentifier> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class AdScriptIdentifier;
        AdScriptIdentifierBuilder() : m_result(new AdScriptIdentifier()) { }

        template<int STEP> AdScriptIdentifierBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<AdScriptIdentifierBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::AdScriptIdentifier> m_result;
    };

    static AdScriptIdentifierBuilder<0> Create()
    {
        return AdScriptIdentifierBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    AdScriptIdentifier();  // Defined below

    String m_scriptId;
    String m_debuggerId;
    String m_name;
};


class CONTENT_EXPORT AdAncestry : public ::crdtp::ProtocolObject<AdAncestry> {
public:
    ~AdAncestry() override;  // Defined below

    protocol::Array<protocol::Network::AdScriptIdentifier>* GetAncestryChain() { return m_ancestryChain.get(); }
    void SetAncestryChain(std::unique_ptr<protocol::Array<protocol::Network::AdScriptIdentifier>> value);  // Defined below

    bool HasRootScriptFilterlistRule() { return !!m_rootScriptFilterlistRule; }
    String GetRootScriptFilterlistRule(const String& defaultValue) const {
       return m_rootScriptFilterlistRule.value_or(defaultValue);
    }
    const std::optional<String>& GetRootScriptFilterlistRule() const {
       return m_rootScriptFilterlistRule;
    }
    void SetRootScriptFilterlistRule(const String& value);  // Defined below

    template<int STATE>
    class AdAncestryBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            AncestryChainSet = 1 << 1,
            AllFieldsSet = (AncestryChainSet | 0)};


        AdAncestryBuilder<STATE | AncestryChainSet>& SetAncestryChain(std::unique_ptr<protocol::Array<protocol::Network::AdScriptIdentifier>> value);  // Defined below

        AdAncestryBuilder<STATE>& SetRootScriptFilterlistRule(const String& value);  // Defined below

        std::unique_ptr<AdAncestry> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class AdAncestry;
        AdAncestryBuilder() : m_result(new AdAncestry()) { }

        template<int STEP> AdAncestryBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<AdAncestryBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::AdAncestry> m_result;
    };

    static AdAncestryBuilder<0> Create()
    {
        return AdAncestryBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    AdAncestry();  // Defined below

    std::unique_ptr<protocol::Array<protocol::Network::AdScriptIdentifier>> m_ancestryChain;
    std::optional<String> m_rootScriptFilterlistRule;
};


class CONTENT_EXPORT CrossOriginOpenerPolicyStatus : public ::crdtp::ProtocolObject<CrossOriginOpenerPolicyStatus> {
public:
    ~CrossOriginOpenerPolicyStatus() override;  // Defined below

    String GetValue() { return m_value; }
    void SetValue(const String& value);  // Defined below

    String GetReportOnlyValue() { return m_reportOnlyValue; }
    void SetReportOnlyValue(const String& value);  // Defined below

    bool HasReportingEndpoint() { return !!m_reportingEndpoint; }
    String GetReportingEndpoint(const String& defaultValue) const {
       return m_reportingEndpoint.value_or(defaultValue);
    }
    const std::optional<String>& GetReportingEndpoint() const {
       return m_reportingEndpoint;
    }
    void SetReportingEndpoint(const String& value);  // Defined below

    bool HasReportOnlyReportingEndpoint() { return !!m_reportOnlyReportingEndpoint; }
    String GetReportOnlyReportingEndpoint(const String& defaultValue) const {
       return m_reportOnlyReportingEndpoint.value_or(defaultValue);
    }
    const std::optional<String>& GetReportOnlyReportingEndpoint() const {
       return m_reportOnlyReportingEndpoint;
    }
    void SetReportOnlyReportingEndpoint(const String& value);  // Defined below

    template<int STATE>
    class CrossOriginOpenerPolicyStatusBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ValueSet = 1 << 1,
            ReportOnlyValueSet = 1 << 2,
            AllFieldsSet = (ValueSet | ReportOnlyValueSet | 0)};


        CrossOriginOpenerPolicyStatusBuilder<STATE | ValueSet>& SetValue(const String& value);  // Defined below

        CrossOriginOpenerPolicyStatusBuilder<STATE | ReportOnlyValueSet>& SetReportOnlyValue(const String& value);  // Defined below

        CrossOriginOpenerPolicyStatusBuilder<STATE>& SetReportingEndpoint(const String& value);  // Defined below

        CrossOriginOpenerPolicyStatusBuilder<STATE>& SetReportOnlyReportingEndpoint(const String& value);  // Defined below

        std::unique_ptr<CrossOriginOpenerPolicyStatus> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class CrossOriginOpenerPolicyStatus;
        CrossOriginOpenerPolicyStatusBuilder() : m_result(new CrossOriginOpenerPolicyStatus()) { }

        template<int STEP> CrossOriginOpenerPolicyStatusBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<CrossOriginOpenerPolicyStatusBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::CrossOriginOpenerPolicyStatus> m_result;
    };

    static CrossOriginOpenerPolicyStatusBuilder<0> Create()
    {
        return CrossOriginOpenerPolicyStatusBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    CrossOriginOpenerPolicyStatus();  // Defined below

    String m_value;
    String m_reportOnlyValue;
    std::optional<String> m_reportingEndpoint;
    std::optional<String> m_reportOnlyReportingEndpoint;
};


class CONTENT_EXPORT CrossOriginEmbedderPolicyStatus : public ::crdtp::ProtocolObject<CrossOriginEmbedderPolicyStatus> {
public:
    ~CrossOriginEmbedderPolicyStatus() override;  // Defined below

    String GetValue() { return m_value; }
    void SetValue(const String& value);  // Defined below

    String GetReportOnlyValue() { return m_reportOnlyValue; }
    void SetReportOnlyValue(const String& value);  // Defined below

    bool HasReportingEndpoint() { return !!m_reportingEndpoint; }
    String GetReportingEndpoint(const String& defaultValue) const {
       return m_reportingEndpoint.value_or(defaultValue);
    }
    const std::optional<String>& GetReportingEndpoint() const {
       return m_reportingEndpoint;
    }
    void SetReportingEndpoint(const String& value);  // Defined below

    bool HasReportOnlyReportingEndpoint() { return !!m_reportOnlyReportingEndpoint; }
    String GetReportOnlyReportingEndpoint(const String& defaultValue) const {
       return m_reportOnlyReportingEndpoint.value_or(defaultValue);
    }
    const std::optional<String>& GetReportOnlyReportingEndpoint() const {
       return m_reportOnlyReportingEndpoint;
    }
    void SetReportOnlyReportingEndpoint(const String& value);  // Defined below

    template<int STATE>
    class CrossOriginEmbedderPolicyStatusBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ValueSet = 1 << 1,
            ReportOnlyValueSet = 1 << 2,
            AllFieldsSet = (ValueSet | ReportOnlyValueSet | 0)};


        CrossOriginEmbedderPolicyStatusBuilder<STATE | ValueSet>& SetValue(const String& value);  // Defined below

        CrossOriginEmbedderPolicyStatusBuilder<STATE | ReportOnlyValueSet>& SetReportOnlyValue(const String& value);  // Defined below

        CrossOriginEmbedderPolicyStatusBuilder<STATE>& SetReportingEndpoint(const String& value);  // Defined below

        CrossOriginEmbedderPolicyStatusBuilder<STATE>& SetReportOnlyReportingEndpoint(const String& value);  // Defined below

        std::unique_ptr<CrossOriginEmbedderPolicyStatus> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class CrossOriginEmbedderPolicyStatus;
        CrossOriginEmbedderPolicyStatusBuilder() : m_result(new CrossOriginEmbedderPolicyStatus()) { }

        template<int STEP> CrossOriginEmbedderPolicyStatusBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<CrossOriginEmbedderPolicyStatusBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::CrossOriginEmbedderPolicyStatus> m_result;
    };

    static CrossOriginEmbedderPolicyStatusBuilder<0> Create()
    {
        return CrossOriginEmbedderPolicyStatusBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    CrossOriginEmbedderPolicyStatus();  // Defined below

    String m_value;
    String m_reportOnlyValue;
    std::optional<String> m_reportingEndpoint;
    std::optional<String> m_reportOnlyReportingEndpoint;
};


class CONTENT_EXPORT ContentSecurityPolicyStatus : public ::crdtp::ProtocolObject<ContentSecurityPolicyStatus> {
public:
    ~ContentSecurityPolicyStatus() override;  // Defined below

    String GetEffectiveDirectives() { return m_effectiveDirectives; }
    void SetEffectiveDirectives(const String& value);  // Defined below

    bool GetIsEnforced() { return m_isEnforced; }
    void SetIsEnforced(bool value);  // Defined below

    String GetSource() { return m_source; }
    void SetSource(const String& value);  // Defined below

    template<int STATE>
    class ContentSecurityPolicyStatusBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            EffectiveDirectivesSet = 1 << 1,
            IsEnforcedSet = 1 << 2,
            SourceSet = 1 << 3,
            AllFieldsSet = (EffectiveDirectivesSet | IsEnforcedSet | SourceSet | 0)};


        ContentSecurityPolicyStatusBuilder<STATE | EffectiveDirectivesSet>& SetEffectiveDirectives(const String& value);  // Defined below

        ContentSecurityPolicyStatusBuilder<STATE | IsEnforcedSet>& SetIsEnforced(bool value);  // Defined below

        ContentSecurityPolicyStatusBuilder<STATE | SourceSet>& SetSource(const String& value);  // Defined below

        std::unique_ptr<ContentSecurityPolicyStatus> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ContentSecurityPolicyStatus;
        ContentSecurityPolicyStatusBuilder() : m_result(new ContentSecurityPolicyStatus()) { }

        template<int STEP> ContentSecurityPolicyStatusBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ContentSecurityPolicyStatusBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ContentSecurityPolicyStatus> m_result;
    };

    static ContentSecurityPolicyStatusBuilder<0> Create()
    {
        return ContentSecurityPolicyStatusBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ContentSecurityPolicyStatus();  // Defined below

    String m_effectiveDirectives;
    bool m_isEnforced;
    String m_source;
};


class CONTENT_EXPORT SecurityIsolationStatus : public ::crdtp::ProtocolObject<SecurityIsolationStatus> {
public:
    ~SecurityIsolationStatus() override;  // Defined below

    bool HasCoop() { return !!m_coop; }
    protocol::Network::CrossOriginOpenerPolicyStatus* GetCoop(protocol::Network::CrossOriginOpenerPolicyStatus* defaultValue) {
       return m_coop ? m_coop.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::CrossOriginOpenerPolicyStatus>& GetCoop() const {
       return m_coop;
    }
    void SetCoop(std::unique_ptr<protocol::Network::CrossOriginOpenerPolicyStatus> value);  // Defined below

    bool HasCoep() { return !!m_coep; }
    protocol::Network::CrossOriginEmbedderPolicyStatus* GetCoep(protocol::Network::CrossOriginEmbedderPolicyStatus* defaultValue) {
       return m_coep ? m_coep.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::CrossOriginEmbedderPolicyStatus>& GetCoep() const {
       return m_coep;
    }
    void SetCoep(std::unique_ptr<protocol::Network::CrossOriginEmbedderPolicyStatus> value);  // Defined below

    bool HasCsp() { return !!m_csp; }
    protocol::Array<protocol::Network::ContentSecurityPolicyStatus>* GetCsp(protocol::Array<protocol::Network::ContentSecurityPolicyStatus>* defaultValue) {
       return m_csp ? m_csp.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Array<protocol::Network::ContentSecurityPolicyStatus>>& GetCsp() const {
       return m_csp;
    }
    void SetCsp(std::unique_ptr<protocol::Array<protocol::Network::ContentSecurityPolicyStatus>> value);  // Defined below

    template<int STATE>
    class SecurityIsolationStatusBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            AllFieldsSet = (0)};


        SecurityIsolationStatusBuilder<STATE>& SetCoop(std::unique_ptr<protocol::Network::CrossOriginOpenerPolicyStatus> value);  // Defined below

        SecurityIsolationStatusBuilder<STATE>& SetCoep(std::unique_ptr<protocol::Network::CrossOriginEmbedderPolicyStatus> value);  // Defined below

        SecurityIsolationStatusBuilder<STATE>& SetCsp(std::unique_ptr<protocol::Array<protocol::Network::ContentSecurityPolicyStatus>> value);  // Defined below

        std::unique_ptr<SecurityIsolationStatus> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class SecurityIsolationStatus;
        SecurityIsolationStatusBuilder() : m_result(new SecurityIsolationStatus()) { }

        template<int STEP> SecurityIsolationStatusBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<SecurityIsolationStatusBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::SecurityIsolationStatus> m_result;
    };

    static SecurityIsolationStatusBuilder<0> Create()
    {
        return SecurityIsolationStatusBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    SecurityIsolationStatus();  // Defined below

    std::unique_ptr<protocol::Network::CrossOriginOpenerPolicyStatus> m_coop;
    std::unique_ptr<protocol::Network::CrossOriginEmbedderPolicyStatus> m_coep;
    std::unique_ptr<protocol::Array<protocol::Network::ContentSecurityPolicyStatus>> m_csp;
};


class CONTENT_EXPORT ReportingApiReport : public ::crdtp::ProtocolObject<ReportingApiReport> {
public:
    ~ReportingApiReport() override;  // Defined below

    String GetId() { return m_id; }
    void SetId(const String& value);  // Defined below

    String GetInitiatorUrl() { return m_initiatorUrl; }
    void SetInitiatorUrl(const String& value);  // Defined below

    String GetDestination() { return m_destination; }
    void SetDestination(const String& value);  // Defined below

    String GetType() { return m_type; }
    void SetType(const String& value);  // Defined below

    double GetTimestamp() { return m_timestamp; }
    void SetTimestamp(double value);  // Defined below

    int GetDepth() { return m_depth; }
    void SetDepth(int value);  // Defined below

    int GetCompletedAttempts() { return m_completedAttempts; }
    void SetCompletedAttempts(int value);  // Defined below

    protocol::DictionaryValue* GetBody() { return m_body.get(); }
    void SetBody(std::unique_ptr<protocol::DictionaryValue> value);  // Defined below

    String GetStatus() { return m_status; }
    void SetStatus(const String& value);  // Defined below

    template<int STATE>
    class ReportingApiReportBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            IdSet = 1 << 1,
            InitiatorUrlSet = 1 << 2,
            DestinationSet = 1 << 3,
            TypeSet = 1 << 4,
            TimestampSet = 1 << 5,
            DepthSet = 1 << 6,
            CompletedAttemptsSet = 1 << 7,
            BodySet = 1 << 8,
            StatusSet = 1 << 9,
            AllFieldsSet = (IdSet | InitiatorUrlSet | DestinationSet | TypeSet | TimestampSet | DepthSet | CompletedAttemptsSet | BodySet | StatusSet | 0)};


        ReportingApiReportBuilder<STATE | IdSet>& SetId(const String& value);  // Defined below

        ReportingApiReportBuilder<STATE | InitiatorUrlSet>& SetInitiatorUrl(const String& value);  // Defined below

        ReportingApiReportBuilder<STATE | DestinationSet>& SetDestination(const String& value);  // Defined below

        ReportingApiReportBuilder<STATE | TypeSet>& SetType(const String& value);  // Defined below

        ReportingApiReportBuilder<STATE | TimestampSet>& SetTimestamp(double value);  // Defined below

        ReportingApiReportBuilder<STATE | DepthSet>& SetDepth(int value);  // Defined below

        ReportingApiReportBuilder<STATE | CompletedAttemptsSet>& SetCompletedAttempts(int value);  // Defined below

        ReportingApiReportBuilder<STATE | BodySet>& SetBody(std::unique_ptr<protocol::DictionaryValue> value);  // Defined below

        ReportingApiReportBuilder<STATE | StatusSet>& SetStatus(const String& value);  // Defined below

        std::unique_ptr<ReportingApiReport> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ReportingApiReport;
        ReportingApiReportBuilder() : m_result(new ReportingApiReport()) { }

        template<int STEP> ReportingApiReportBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ReportingApiReportBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ReportingApiReport> m_result;
    };

    static ReportingApiReportBuilder<0> Create()
    {
        return ReportingApiReportBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ReportingApiReport();  // Defined below

    String m_id;
    String m_initiatorUrl;
    String m_destination;
    String m_type;
    double m_timestamp;
    int m_depth;
    int m_completedAttempts;
    std::unique_ptr<protocol::DictionaryValue> m_body;
    String m_status;
};


class CONTENT_EXPORT ReportingApiEndpoint : public ::crdtp::ProtocolObject<ReportingApiEndpoint> {
public:
    ~ReportingApiEndpoint() override;  // Defined below

    String GetUrl() { return m_url; }
    void SetUrl(const String& value);  // Defined below

    String GetGroupName() { return m_groupName; }
    void SetGroupName(const String& value);  // Defined below

    template<int STATE>
    class ReportingApiEndpointBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            UrlSet = 1 << 1,
            GroupNameSet = 1 << 2,
            AllFieldsSet = (UrlSet | GroupNameSet | 0)};


        ReportingApiEndpointBuilder<STATE | UrlSet>& SetUrl(const String& value);  // Defined below

        ReportingApiEndpointBuilder<STATE | GroupNameSet>& SetGroupName(const String& value);  // Defined below

        std::unique_ptr<ReportingApiEndpoint> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ReportingApiEndpoint;
        ReportingApiEndpointBuilder() : m_result(new ReportingApiEndpoint()) { }

        template<int STEP> ReportingApiEndpointBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ReportingApiEndpointBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ReportingApiEndpoint> m_result;
    };

    static ReportingApiEndpointBuilder<0> Create()
    {
        return ReportingApiEndpointBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ReportingApiEndpoint();  // Defined below

    String m_url;
    String m_groupName;
};


class CONTENT_EXPORT DeviceBoundSessionKey : public ::crdtp::ProtocolObject<DeviceBoundSessionKey> {
public:
    ~DeviceBoundSessionKey() override;  // Defined below

    String GetSite() { return m_site; }
    void SetSite(const String& value);  // Defined below

    String GetId() { return m_id; }
    void SetId(const String& value);  // Defined below

    template<int STATE>
    class DeviceBoundSessionKeyBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            SiteSet = 1 << 1,
            IdSet = 1 << 2,
            AllFieldsSet = (SiteSet | IdSet | 0)};


        DeviceBoundSessionKeyBuilder<STATE | SiteSet>& SetSite(const String& value);  // Defined below

        DeviceBoundSessionKeyBuilder<STATE | IdSet>& SetId(const String& value);  // Defined below

        std::unique_ptr<DeviceBoundSessionKey> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class DeviceBoundSessionKey;
        DeviceBoundSessionKeyBuilder() : m_result(new DeviceBoundSessionKey()) { }

        template<int STEP> DeviceBoundSessionKeyBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<DeviceBoundSessionKeyBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::DeviceBoundSessionKey> m_result;
    };

    static DeviceBoundSessionKeyBuilder<0> Create()
    {
        return DeviceBoundSessionKeyBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    DeviceBoundSessionKey();  // Defined below

    String m_site;
    String m_id;
};


class CONTENT_EXPORT DeviceBoundSessionWithUsage : public ::crdtp::ProtocolObject<DeviceBoundSessionWithUsage> {
public:
    ~DeviceBoundSessionWithUsage() override;  // Defined below

    protocol::Network::DeviceBoundSessionKey* GetSessionKey() { return m_sessionKey.get(); }
    void SetSessionKey(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> value);  // Defined below

    struct CONTENT_EXPORT UsageEnum {
        static const char* NotInScope;
        static const char* InScopeRefreshNotYetNeeded;
        static const char* InScopeRefreshNotAllowed;
        static const char* ProactiveRefreshNotPossible;
        static const char* ProactiveRefreshAttempted;
        static const char* Deferred;
    }; // UsageEnum

    String GetUsage() { return m_usage; }
    void SetUsage(const String& value);  // Defined below

    template<int STATE>
    class DeviceBoundSessionWithUsageBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            SessionKeySet = 1 << 1,
            UsageSet = 1 << 2,
            AllFieldsSet = (SessionKeySet | UsageSet | 0)};


        DeviceBoundSessionWithUsageBuilder<STATE | SessionKeySet>& SetSessionKey(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> value);  // Defined below

        DeviceBoundSessionWithUsageBuilder<STATE | UsageSet>& SetUsage(const String& value);  // Defined below

        std::unique_ptr<DeviceBoundSessionWithUsage> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class DeviceBoundSessionWithUsage;
        DeviceBoundSessionWithUsageBuilder() : m_result(new DeviceBoundSessionWithUsage()) { }

        template<int STEP> DeviceBoundSessionWithUsageBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<DeviceBoundSessionWithUsageBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::DeviceBoundSessionWithUsage> m_result;
    };

    static DeviceBoundSessionWithUsageBuilder<0> Create()
    {
        return DeviceBoundSessionWithUsageBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    DeviceBoundSessionWithUsage();  // Defined below

    std::unique_ptr<protocol::Network::DeviceBoundSessionKey> m_sessionKey;
    String m_usage;
};


class CONTENT_EXPORT DeviceBoundSessionCookieCraving : public ::crdtp::ProtocolObject<DeviceBoundSessionCookieCraving> {
public:
    ~DeviceBoundSessionCookieCraving() override;  // Defined below

    String GetName() { return m_name; }
    void SetName(const String& value);  // Defined below

    String GetDomain() { return m_domain; }
    void SetDomain(const String& value);  // Defined below

    String GetPath() { return m_path; }
    void SetPath(const String& value);  // Defined below

    bool GetSecure() { return m_secure; }
    void SetSecure(bool value);  // Defined below

    bool GetHttpOnly() { return m_httpOnly; }
    void SetHttpOnly(bool value);  // Defined below

    bool HasSameSite() { return !!m_sameSite; }
    String GetSameSite(const String& defaultValue) const {
       return m_sameSite.value_or(defaultValue);
    }
    const std::optional<String>& GetSameSite() const {
       return m_sameSite;
    }
    void SetSameSite(const String& value);  // Defined below

    template<int STATE>
    class DeviceBoundSessionCookieCravingBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            NameSet = 1 << 1,
            DomainSet = 1 << 2,
            PathSet = 1 << 3,
            SecureSet = 1 << 4,
            HttpOnlySet = 1 << 5,
            AllFieldsSet = (NameSet | DomainSet | PathSet | SecureSet | HttpOnlySet | 0)};


        DeviceBoundSessionCookieCravingBuilder<STATE | NameSet>& SetName(const String& value);  // Defined below

        DeviceBoundSessionCookieCravingBuilder<STATE | DomainSet>& SetDomain(const String& value);  // Defined below

        DeviceBoundSessionCookieCravingBuilder<STATE | PathSet>& SetPath(const String& value);  // Defined below

        DeviceBoundSessionCookieCravingBuilder<STATE | SecureSet>& SetSecure(bool value);  // Defined below

        DeviceBoundSessionCookieCravingBuilder<STATE | HttpOnlySet>& SetHttpOnly(bool value);  // Defined below

        DeviceBoundSessionCookieCravingBuilder<STATE>& SetSameSite(const String& value);  // Defined below

        std::unique_ptr<DeviceBoundSessionCookieCraving> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class DeviceBoundSessionCookieCraving;
        DeviceBoundSessionCookieCravingBuilder() : m_result(new DeviceBoundSessionCookieCraving()) { }

        template<int STEP> DeviceBoundSessionCookieCravingBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<DeviceBoundSessionCookieCravingBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::DeviceBoundSessionCookieCraving> m_result;
    };

    static DeviceBoundSessionCookieCravingBuilder<0> Create()
    {
        return DeviceBoundSessionCookieCravingBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    DeviceBoundSessionCookieCraving();  // Defined below

    String m_name;
    String m_domain;
    String m_path;
    bool m_secure;
    bool m_httpOnly;
    std::optional<String> m_sameSite;
};


class CONTENT_EXPORT DeviceBoundSessionUrlRule : public ::crdtp::ProtocolObject<DeviceBoundSessionUrlRule> {
public:
    ~DeviceBoundSessionUrlRule() override;  // Defined below

    struct CONTENT_EXPORT RuleTypeEnum {
        static const char* Exclude;
        static const char* Include;
    }; // RuleTypeEnum

    String GetRuleType() { return m_ruleType; }
    void SetRuleType(const String& value);  // Defined below

    String GetHostPattern() { return m_hostPattern; }
    void SetHostPattern(const String& value);  // Defined below

    String GetPathPrefix() { return m_pathPrefix; }
    void SetPathPrefix(const String& value);  // Defined below

    template<int STATE>
    class DeviceBoundSessionUrlRuleBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            RuleTypeSet = 1 << 1,
            HostPatternSet = 1 << 2,
            PathPrefixSet = 1 << 3,
            AllFieldsSet = (RuleTypeSet | HostPatternSet | PathPrefixSet | 0)};


        DeviceBoundSessionUrlRuleBuilder<STATE | RuleTypeSet>& SetRuleType(const String& value);  // Defined below

        DeviceBoundSessionUrlRuleBuilder<STATE | HostPatternSet>& SetHostPattern(const String& value);  // Defined below

        DeviceBoundSessionUrlRuleBuilder<STATE | PathPrefixSet>& SetPathPrefix(const String& value);  // Defined below

        std::unique_ptr<DeviceBoundSessionUrlRule> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class DeviceBoundSessionUrlRule;
        DeviceBoundSessionUrlRuleBuilder() : m_result(new DeviceBoundSessionUrlRule()) { }

        template<int STEP> DeviceBoundSessionUrlRuleBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<DeviceBoundSessionUrlRuleBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::DeviceBoundSessionUrlRule> m_result;
    };

    static DeviceBoundSessionUrlRuleBuilder<0> Create()
    {
        return DeviceBoundSessionUrlRuleBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    DeviceBoundSessionUrlRule();  // Defined below

    String m_ruleType;
    String m_hostPattern;
    String m_pathPrefix;
};


class CONTENT_EXPORT DeviceBoundSessionInclusionRules : public ::crdtp::ProtocolObject<DeviceBoundSessionInclusionRules> {
public:
    ~DeviceBoundSessionInclusionRules() override;  // Defined below

    String GetOrigin() { return m_origin; }
    void SetOrigin(const String& value);  // Defined below

    bool GetIncludeSite() { return m_includeSite; }
    void SetIncludeSite(bool value);  // Defined below

    protocol::Array<protocol::Network::DeviceBoundSessionUrlRule>* GetUrlRules() { return m_urlRules.get(); }
    void SetUrlRules(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionUrlRule>> value);  // Defined below

    template<int STATE>
    class DeviceBoundSessionInclusionRulesBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            OriginSet = 1 << 1,
            IncludeSiteSet = 1 << 2,
            UrlRulesSet = 1 << 3,
            AllFieldsSet = (OriginSet | IncludeSiteSet | UrlRulesSet | 0)};


        DeviceBoundSessionInclusionRulesBuilder<STATE | OriginSet>& SetOrigin(const String& value);  // Defined below

        DeviceBoundSessionInclusionRulesBuilder<STATE | IncludeSiteSet>& SetIncludeSite(bool value);  // Defined below

        DeviceBoundSessionInclusionRulesBuilder<STATE | UrlRulesSet>& SetUrlRules(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionUrlRule>> value);  // Defined below

        std::unique_ptr<DeviceBoundSessionInclusionRules> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class DeviceBoundSessionInclusionRules;
        DeviceBoundSessionInclusionRulesBuilder() : m_result(new DeviceBoundSessionInclusionRules()) { }

        template<int STEP> DeviceBoundSessionInclusionRulesBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<DeviceBoundSessionInclusionRulesBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::DeviceBoundSessionInclusionRules> m_result;
    };

    static DeviceBoundSessionInclusionRulesBuilder<0> Create()
    {
        return DeviceBoundSessionInclusionRulesBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    DeviceBoundSessionInclusionRules();  // Defined below

    String m_origin;
    bool m_includeSite;
    std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionUrlRule>> m_urlRules;
};


class CONTENT_EXPORT DeviceBoundSession : public ::crdtp::ProtocolObject<DeviceBoundSession> {
public:
    ~DeviceBoundSession() override;  // Defined below

    protocol::Network::DeviceBoundSessionKey* GetKey() { return m_key.get(); }
    void SetKey(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> value);  // Defined below

    String GetRefreshUrl() { return m_refreshUrl; }
    void SetRefreshUrl(const String& value);  // Defined below

    protocol::Network::DeviceBoundSessionInclusionRules* GetInclusionRules() { return m_inclusionRules.get(); }
    void SetInclusionRules(std::unique_ptr<protocol::Network::DeviceBoundSessionInclusionRules> value);  // Defined below

    protocol::Array<protocol::Network::DeviceBoundSessionCookieCraving>* GetCookieCravings() { return m_cookieCravings.get(); }
    void SetCookieCravings(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionCookieCraving>> value);  // Defined below

    double GetExpiryDate() { return m_expiryDate; }
    void SetExpiryDate(double value);  // Defined below

    bool HasCachedChallenge() { return !!m_cachedChallenge; }
    String GetCachedChallenge(const String& defaultValue) const {
       return m_cachedChallenge.value_or(defaultValue);
    }
    const std::optional<String>& GetCachedChallenge() const {
       return m_cachedChallenge;
    }
    void SetCachedChallenge(const String& value);  // Defined below

    protocol::Array<String>* GetAllowedRefreshInitiators() { return m_allowedRefreshInitiators.get(); }
    void SetAllowedRefreshInitiators(std::unique_ptr<protocol::Array<String>> value);  // Defined below

    template<int STATE>
    class DeviceBoundSessionBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            KeySet = 1 << 1,
            RefreshUrlSet = 1 << 2,
            InclusionRulesSet = 1 << 3,
            CookieCravingsSet = 1 << 4,
            ExpiryDateSet = 1 << 5,
            AllowedRefreshInitiatorsSet = 1 << 6,
            AllFieldsSet = (KeySet | RefreshUrlSet | InclusionRulesSet | CookieCravingsSet | ExpiryDateSet | AllowedRefreshInitiatorsSet | 0)};


        DeviceBoundSessionBuilder<STATE | KeySet>& SetKey(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> value);  // Defined below

        DeviceBoundSessionBuilder<STATE | RefreshUrlSet>& SetRefreshUrl(const String& value);  // Defined below

        DeviceBoundSessionBuilder<STATE | InclusionRulesSet>& SetInclusionRules(std::unique_ptr<protocol::Network::DeviceBoundSessionInclusionRules> value);  // Defined below

        DeviceBoundSessionBuilder<STATE | CookieCravingsSet>& SetCookieCravings(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionCookieCraving>> value);  // Defined below

        DeviceBoundSessionBuilder<STATE | ExpiryDateSet>& SetExpiryDate(double value);  // Defined below

        DeviceBoundSessionBuilder<STATE>& SetCachedChallenge(const String& value);  // Defined below

        DeviceBoundSessionBuilder<STATE | AllowedRefreshInitiatorsSet>& SetAllowedRefreshInitiators(std::unique_ptr<protocol::Array<String>> value);  // Defined below

        std::unique_ptr<DeviceBoundSession> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class DeviceBoundSession;
        DeviceBoundSessionBuilder() : m_result(new DeviceBoundSession()) { }

        template<int STEP> DeviceBoundSessionBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<DeviceBoundSessionBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::DeviceBoundSession> m_result;
    };

    static DeviceBoundSessionBuilder<0> Create()
    {
        return DeviceBoundSessionBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    DeviceBoundSession();  // Defined below

    std::unique_ptr<protocol::Network::DeviceBoundSessionKey> m_key;
    String m_refreshUrl;
    std::unique_ptr<protocol::Network::DeviceBoundSessionInclusionRules> m_inclusionRules;
    std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionCookieCraving>> m_cookieCravings;
    double m_expiryDate;
    std::optional<String> m_cachedChallenge;
    std::unique_ptr<protocol::Array<String>> m_allowedRefreshInitiators;
};


class CONTENT_EXPORT DeviceBoundSessionFailedRequest : public ::crdtp::ProtocolObject<DeviceBoundSessionFailedRequest> {
public:
    ~DeviceBoundSessionFailedRequest() override;  // Defined below

    String GetRequestUrl() { return m_requestUrl; }
    void SetRequestUrl(const String& value);  // Defined below

    bool HasNetError() { return !!m_netError; }
    String GetNetError(const String& defaultValue) const {
       return m_netError.value_or(defaultValue);
    }
    const std::optional<String>& GetNetError() const {
       return m_netError;
    }
    void SetNetError(const String& value);  // Defined below

    bool HasResponseError() { return !!m_responseError; }
    int GetResponseError(int defaultValue) const {
       return m_responseError.value_or(defaultValue);
    }
    const std::optional<int>& GetResponseError() const {
       return m_responseError;
    }
    void SetResponseError(int value);  // Defined below

    bool HasResponseErrorBody() { return !!m_responseErrorBody; }
    String GetResponseErrorBody(const String& defaultValue) const {
       return m_responseErrorBody.value_or(defaultValue);
    }
    const std::optional<String>& GetResponseErrorBody() const {
       return m_responseErrorBody;
    }
    void SetResponseErrorBody(const String& value);  // Defined below

    template<int STATE>
    class DeviceBoundSessionFailedRequestBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            RequestUrlSet = 1 << 1,
            AllFieldsSet = (RequestUrlSet | 0)};


        DeviceBoundSessionFailedRequestBuilder<STATE | RequestUrlSet>& SetRequestUrl(const String& value);  // Defined below

        DeviceBoundSessionFailedRequestBuilder<STATE>& SetNetError(const String& value);  // Defined below

        DeviceBoundSessionFailedRequestBuilder<STATE>& SetResponseError(int value);  // Defined below

        DeviceBoundSessionFailedRequestBuilder<STATE>& SetResponseErrorBody(const String& value);  // Defined below

        std::unique_ptr<DeviceBoundSessionFailedRequest> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class DeviceBoundSessionFailedRequest;
        DeviceBoundSessionFailedRequestBuilder() : m_result(new DeviceBoundSessionFailedRequest()) { }

        template<int STEP> DeviceBoundSessionFailedRequestBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<DeviceBoundSessionFailedRequestBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> m_result;
    };

    static DeviceBoundSessionFailedRequestBuilder<0> Create()
    {
        return DeviceBoundSessionFailedRequestBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    DeviceBoundSessionFailedRequest();  // Defined below

    String m_requestUrl;
    std::optional<String> m_netError;
    std::optional<int> m_responseError;
    std::optional<String> m_responseErrorBody;
};


class CONTENT_EXPORT CreationEventDetails : public ::crdtp::ProtocolObject<CreationEventDetails> {
public:
    ~CreationEventDetails() override;  // Defined below

    String GetFetchResult() { return m_fetchResult; }
    void SetFetchResult(const String& value);  // Defined below

    bool HasNewSession() { return !!m_newSession; }
    protocol::Network::DeviceBoundSession* GetNewSession(protocol::Network::DeviceBoundSession* defaultValue) {
       return m_newSession ? m_newSession.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::DeviceBoundSession>& GetNewSession() const {
       return m_newSession;
    }
    void SetNewSession(std::unique_ptr<protocol::Network::DeviceBoundSession> value);  // Defined below

    bool HasFailedRequest() { return !!m_failedRequest; }
    protocol::Network::DeviceBoundSessionFailedRequest* GetFailedRequest(protocol::Network::DeviceBoundSessionFailedRequest* defaultValue) {
       return m_failedRequest ? m_failedRequest.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest>& GetFailedRequest() const {
       return m_failedRequest;
    }
    void SetFailedRequest(std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> value);  // Defined below

    template<int STATE>
    class CreationEventDetailsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            FetchResultSet = 1 << 1,
            AllFieldsSet = (FetchResultSet | 0)};


        CreationEventDetailsBuilder<STATE | FetchResultSet>& SetFetchResult(const String& value);  // Defined below

        CreationEventDetailsBuilder<STATE>& SetNewSession(std::unique_ptr<protocol::Network::DeviceBoundSession> value);  // Defined below

        CreationEventDetailsBuilder<STATE>& SetFailedRequest(std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> value);  // Defined below

        std::unique_ptr<CreationEventDetails> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class CreationEventDetails;
        CreationEventDetailsBuilder() : m_result(new CreationEventDetails()) { }

        template<int STEP> CreationEventDetailsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<CreationEventDetailsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::CreationEventDetails> m_result;
    };

    static CreationEventDetailsBuilder<0> Create()
    {
        return CreationEventDetailsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    CreationEventDetails();  // Defined below

    String m_fetchResult;
    std::unique_ptr<protocol::Network::DeviceBoundSession> m_newSession;
    std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> m_failedRequest;
};


class CONTENT_EXPORT RefreshEventDetails : public ::crdtp::ProtocolObject<RefreshEventDetails> {
public:
    ~RefreshEventDetails() override;  // Defined below

    struct CONTENT_EXPORT RefreshResultEnum {
        static const char* Refreshed;
        static const char* InitializedService;
        static const char* Unreachable;
        static const char* ServerError;
        static const char* FatalError;
        static const char* SigningQuotaExceeded;
        static const char* RefreshedAsWaiter;
        static const char* TransientSigningError;
        static const char* InScopeRefreshNotYetNeeded;
    }; // RefreshResultEnum

    String GetRefreshResult() { return m_refreshResult; }
    void SetRefreshResult(const String& value);  // Defined below

    bool HasFetchResult() { return !!m_fetchResult; }
    String GetFetchResult(const String& defaultValue) const {
       return m_fetchResult.value_or(defaultValue);
    }
    const std::optional<String>& GetFetchResult() const {
       return m_fetchResult;
    }
    void SetFetchResult(const String& value);  // Defined below

    bool HasNewSession() { return !!m_newSession; }
    protocol::Network::DeviceBoundSession* GetNewSession(protocol::Network::DeviceBoundSession* defaultValue) {
       return m_newSession ? m_newSession.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::DeviceBoundSession>& GetNewSession() const {
       return m_newSession;
    }
    void SetNewSession(std::unique_ptr<protocol::Network::DeviceBoundSession> value);  // Defined below

    bool GetWasFullyProactiveRefresh() { return m_wasFullyProactiveRefresh; }
    void SetWasFullyProactiveRefresh(bool value);  // Defined below

    bool HasFailedRequest() { return !!m_failedRequest; }
    protocol::Network::DeviceBoundSessionFailedRequest* GetFailedRequest(protocol::Network::DeviceBoundSessionFailedRequest* defaultValue) {
       return m_failedRequest ? m_failedRequest.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest>& GetFailedRequest() const {
       return m_failedRequest;
    }
    void SetFailedRequest(std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> value);  // Defined below

    template<int STATE>
    class RefreshEventDetailsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            RefreshResultSet = 1 << 1,
            WasFullyProactiveRefreshSet = 1 << 2,
            AllFieldsSet = (RefreshResultSet | WasFullyProactiveRefreshSet | 0)};


        RefreshEventDetailsBuilder<STATE | RefreshResultSet>& SetRefreshResult(const String& value);  // Defined below

        RefreshEventDetailsBuilder<STATE>& SetFetchResult(const String& value);  // Defined below

        RefreshEventDetailsBuilder<STATE>& SetNewSession(std::unique_ptr<protocol::Network::DeviceBoundSession> value);  // Defined below

        RefreshEventDetailsBuilder<STATE | WasFullyProactiveRefreshSet>& SetWasFullyProactiveRefresh(bool value);  // Defined below

        RefreshEventDetailsBuilder<STATE>& SetFailedRequest(std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> value);  // Defined below

        std::unique_ptr<RefreshEventDetails> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class RefreshEventDetails;
        RefreshEventDetailsBuilder() : m_result(new RefreshEventDetails()) { }

        template<int STEP> RefreshEventDetailsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<RefreshEventDetailsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::RefreshEventDetails> m_result;
    };

    static RefreshEventDetailsBuilder<0> Create()
    {
        return RefreshEventDetailsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    RefreshEventDetails();  // Defined below

    String m_refreshResult;
    std::optional<String> m_fetchResult;
    std::unique_ptr<protocol::Network::DeviceBoundSession> m_newSession;
    bool m_wasFullyProactiveRefresh;
    std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> m_failedRequest;
};


class CONTENT_EXPORT TerminationEventDetails : public ::crdtp::ProtocolObject<TerminationEventDetails> {
public:
    ~TerminationEventDetails() override;  // Defined below

    struct CONTENT_EXPORT DeletionReasonEnum {
        static const char* Expired;
        static const char* FailedToRestoreKey;
        static const char* FailedToUnwrapKey;
        static const char* StoragePartitionCleared;
        static const char* ClearBrowsingData;
        static const char* ServerRequested;
        static const char* InvalidSessionParams;
        static const char* RefreshFatalError;
        static const char* DevTools;
    }; // DeletionReasonEnum

    String GetDeletionReason() { return m_deletionReason; }
    void SetDeletionReason(const String& value);  // Defined below

    template<int STATE>
    class TerminationEventDetailsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            DeletionReasonSet = 1 << 1,
            AllFieldsSet = (DeletionReasonSet | 0)};


        TerminationEventDetailsBuilder<STATE | DeletionReasonSet>& SetDeletionReason(const String& value);  // Defined below

        std::unique_ptr<TerminationEventDetails> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class TerminationEventDetails;
        TerminationEventDetailsBuilder() : m_result(new TerminationEventDetails()) { }

        template<int STEP> TerminationEventDetailsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<TerminationEventDetailsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::TerminationEventDetails> m_result;
    };

    static TerminationEventDetailsBuilder<0> Create()
    {
        return TerminationEventDetailsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    TerminationEventDetails();  // Defined below

    String m_deletionReason;
};


class CONTENT_EXPORT ChallengeEventDetails : public ::crdtp::ProtocolObject<ChallengeEventDetails> {
public:
    ~ChallengeEventDetails() override;  // Defined below

    struct CONTENT_EXPORT ChallengeResultEnum {
        static const char* Success;
        static const char* NoSessionId;
        static const char* NoSessionMatch;
        static const char* CantSetBoundCookie;
    }; // ChallengeResultEnum

    String GetChallengeResult() { return m_challengeResult; }
    void SetChallengeResult(const String& value);  // Defined below

    String GetChallenge() { return m_challenge; }
    void SetChallenge(const String& value);  // Defined below

    template<int STATE>
    class ChallengeEventDetailsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            ChallengeResultSet = 1 << 1,
            ChallengeSet = 1 << 2,
            AllFieldsSet = (ChallengeResultSet | ChallengeSet | 0)};


        ChallengeEventDetailsBuilder<STATE | ChallengeResultSet>& SetChallengeResult(const String& value);  // Defined below

        ChallengeEventDetailsBuilder<STATE | ChallengeSet>& SetChallenge(const String& value);  // Defined below

        std::unique_ptr<ChallengeEventDetails> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class ChallengeEventDetails;
        ChallengeEventDetailsBuilder() : m_result(new ChallengeEventDetails()) { }

        template<int STEP> ChallengeEventDetailsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<ChallengeEventDetailsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::ChallengeEventDetails> m_result;
    };

    static ChallengeEventDetailsBuilder<0> Create()
    {
        return ChallengeEventDetailsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    ChallengeEventDetails();  // Defined below

    String m_challengeResult;
    String m_challenge;
};


class CONTENT_EXPORT LoadNetworkResourcePageResult : public ::crdtp::ProtocolObject<LoadNetworkResourcePageResult> {
public:
    ~LoadNetworkResourcePageResult() override;  // Defined below

    bool GetSuccess() { return m_success; }
    void SetSuccess(bool value);  // Defined below

    bool HasNetError() { return !!m_netError; }
    double GetNetError(double defaultValue) const {
       return m_netError.value_or(defaultValue);
    }
    const std::optional<double>& GetNetError() const {
       return m_netError;
    }
    void SetNetError(double value);  // Defined below

    bool HasNetErrorName() { return !!m_netErrorName; }
    String GetNetErrorName(const String& defaultValue) const {
       return m_netErrorName.value_or(defaultValue);
    }
    const std::optional<String>& GetNetErrorName() const {
       return m_netErrorName;
    }
    void SetNetErrorName(const String& value);  // Defined below

    bool HasHttpStatusCode() { return !!m_httpStatusCode; }
    double GetHttpStatusCode(double defaultValue) const {
       return m_httpStatusCode.value_or(defaultValue);
    }
    const std::optional<double>& GetHttpStatusCode() const {
       return m_httpStatusCode;
    }
    void SetHttpStatusCode(double value);  // Defined below

    bool HasStream() { return !!m_stream; }
    String GetStream(const String& defaultValue) const {
       return m_stream.value_or(defaultValue);
    }
    const std::optional<String>& GetStream() const {
       return m_stream;
    }
    void SetStream(const String& value);  // Defined below

    bool HasHeaders() { return !!m_headers; }
    protocol::Network::Headers* GetHeaders(protocol::Network::Headers* defaultValue) {
       return m_headers ? m_headers.get() : defaultValue;
    }
    const std::unique_ptr<protocol::Network::Headers>& GetHeaders() const {
       return m_headers;
    }
    void SetHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

    template<int STATE>
    class LoadNetworkResourcePageResultBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            SuccessSet = 1 << 1,
            AllFieldsSet = (SuccessSet | 0)};


        LoadNetworkResourcePageResultBuilder<STATE | SuccessSet>& SetSuccess(bool value);  // Defined below

        LoadNetworkResourcePageResultBuilder<STATE>& SetNetError(double value);  // Defined below

        LoadNetworkResourcePageResultBuilder<STATE>& SetNetErrorName(const String& value);  // Defined below

        LoadNetworkResourcePageResultBuilder<STATE>& SetHttpStatusCode(double value);  // Defined below

        LoadNetworkResourcePageResultBuilder<STATE>& SetStream(const String& value);  // Defined below

        LoadNetworkResourcePageResultBuilder<STATE>& SetHeaders(std::unique_ptr<protocol::Network::Headers> value);  // Defined below

        std::unique_ptr<LoadNetworkResourcePageResult> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class LoadNetworkResourcePageResult;
        LoadNetworkResourcePageResultBuilder() : m_result(new LoadNetworkResourcePageResult()) { }

        template<int STEP> LoadNetworkResourcePageResultBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<LoadNetworkResourcePageResultBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::LoadNetworkResourcePageResult> m_result;
    };

    static LoadNetworkResourcePageResultBuilder<0> Create()
    {
        return LoadNetworkResourcePageResultBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    LoadNetworkResourcePageResult();  // Defined below

    bool m_success;
    std::optional<double> m_netError;
    std::optional<String> m_netErrorName;
    std::optional<double> m_httpStatusCode;
    std::optional<String> m_stream;
    std::unique_ptr<protocol::Network::Headers> m_headers;
};


class CONTENT_EXPORT LoadNetworkResourceOptions : public ::crdtp::ProtocolObject<LoadNetworkResourceOptions> {
public:
    ~LoadNetworkResourceOptions() override;  // Defined below

    bool GetDisableCache() { return m_disableCache; }
    void SetDisableCache(bool value);  // Defined below

    bool GetIncludeCredentials() { return m_includeCredentials; }
    void SetIncludeCredentials(bool value);  // Defined below

    template<int STATE>
    class LoadNetworkResourceOptionsBuilder {
    public:
        enum {
            NoFieldsSet = 0,
            DisableCacheSet = 1 << 1,
            IncludeCredentialsSet = 1 << 2,
            AllFieldsSet = (DisableCacheSet | IncludeCredentialsSet | 0)};


        LoadNetworkResourceOptionsBuilder<STATE | DisableCacheSet>& SetDisableCache(bool value);  // Defined below

        LoadNetworkResourceOptionsBuilder<STATE | IncludeCredentialsSet>& SetIncludeCredentials(bool value);  // Defined below

        std::unique_ptr<LoadNetworkResourceOptions> Build()
        {
            static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
            return std::move(m_result);
        }

    private:
        friend class LoadNetworkResourceOptions;
        LoadNetworkResourceOptionsBuilder() : m_result(new LoadNetworkResourceOptions()) { }

        template<int STEP> LoadNetworkResourceOptionsBuilder<STATE | STEP>& castState()
        {
            return *reinterpret_cast<LoadNetworkResourceOptionsBuilder<STATE | STEP>*>(this);
        }

        std::unique_ptr<protocol::Network::LoadNetworkResourceOptions> m_result;
    };

    static LoadNetworkResourceOptionsBuilder<0> Create()
    {
        return LoadNetworkResourceOptionsBuilder<0>();
    }

private:
    DECLARE_SERIALIZATION_SUPPORT();

    LoadNetworkResourceOptions();  // Defined below

    bool m_disableCache;
    bool m_includeCredentials;
};


// ------------- Type and builder method definitions.
//
// These methods separate from the type declaration because of
// https://github.com/llvm/llvm-project/issues/59966. The DevTools protocol has
// mutually recursive types, so we cannot simply reorder the types.
inline ResourceTiming::~ResourceTiming() = default;
inline void ResourceTiming::SetRequestTime(double value) { m_requestTime = value; }
inline void ResourceTiming::SetProxyStart(double value) { m_proxyStart = value; }
inline void ResourceTiming::SetProxyEnd(double value) { m_proxyEnd = value; }
inline void ResourceTiming::SetDnsStart(double value) { m_dnsStart = value; }
inline void ResourceTiming::SetDnsEnd(double value) { m_dnsEnd = value; }
inline void ResourceTiming::SetConnectStart(double value) { m_connectStart = value; }
inline void ResourceTiming::SetConnectEnd(double value) { m_connectEnd = value; }
inline void ResourceTiming::SetSslStart(double value) { m_sslStart = value; }
inline void ResourceTiming::SetSslEnd(double value) { m_sslEnd = value; }
inline void ResourceTiming::SetWorkerStart(double value) { m_workerStart = value; }
inline void ResourceTiming::SetWorkerReady(double value) { m_workerReady = value; }
inline void ResourceTiming::SetWorkerFetchStart(double value) { m_workerFetchStart = value; }
inline void ResourceTiming::SetWorkerRespondWithSettled(double value) { m_workerRespondWithSettled = value; }
inline void ResourceTiming::SetWorkerRouterEvaluationStart(double value) { m_workerRouterEvaluationStart = value; }
inline void ResourceTiming::SetWorkerCacheLookupStart(double value) { m_workerCacheLookupStart = value; }
inline void ResourceTiming::SetSendStart(double value) { m_sendStart = value; }
inline void ResourceTiming::SetSendEnd(double value) { m_sendEnd = value; }
inline void ResourceTiming::SetPushStart(double value) { m_pushStart = value; }
inline void ResourceTiming::SetPushEnd(double value) { m_pushEnd = value; }
inline void ResourceTiming::SetReceiveHeadersStart(double value) { m_receiveHeadersStart = value; }
inline void ResourceTiming::SetReceiveHeadersEnd(double value) { m_receiveHeadersEnd = value; }

template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::RequestTimeSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetRequestTime(double value) {
  static_assert(!(STATE & RequestTimeSet), "property requestTime should not be set yet");
  m_result->SetRequestTime(value);
  return castState<RequestTimeSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::ProxyStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetProxyStart(double value) {
  static_assert(!(STATE & ProxyStartSet), "property proxyStart should not be set yet");
  m_result->SetProxyStart(value);
  return castState<ProxyStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::ProxyEndSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetProxyEnd(double value) {
  static_assert(!(STATE & ProxyEndSet), "property proxyEnd should not be set yet");
  m_result->SetProxyEnd(value);
  return castState<ProxyEndSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::DnsStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetDnsStart(double value) {
  static_assert(!(STATE & DnsStartSet), "property dnsStart should not be set yet");
  m_result->SetDnsStart(value);
  return castState<DnsStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::DnsEndSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetDnsEnd(double value) {
  static_assert(!(STATE & DnsEndSet), "property dnsEnd should not be set yet");
  m_result->SetDnsEnd(value);
  return castState<DnsEndSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::ConnectStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetConnectStart(double value) {
  static_assert(!(STATE & ConnectStartSet), "property connectStart should not be set yet");
  m_result->SetConnectStart(value);
  return castState<ConnectStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::ConnectEndSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetConnectEnd(double value) {
  static_assert(!(STATE & ConnectEndSet), "property connectEnd should not be set yet");
  m_result->SetConnectEnd(value);
  return castState<ConnectEndSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::SslStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetSslStart(double value) {
  static_assert(!(STATE & SslStartSet), "property sslStart should not be set yet");
  m_result->SetSslStart(value);
  return castState<SslStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::SslEndSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetSslEnd(double value) {
  static_assert(!(STATE & SslEndSet), "property sslEnd should not be set yet");
  m_result->SetSslEnd(value);
  return castState<SslEndSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::WorkerStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetWorkerStart(double value) {
  static_assert(!(STATE & WorkerStartSet), "property workerStart should not be set yet");
  m_result->SetWorkerStart(value);
  return castState<WorkerStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::WorkerReadySet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetWorkerReady(double value) {
  static_assert(!(STATE & WorkerReadySet), "property workerReady should not be set yet");
  m_result->SetWorkerReady(value);
  return castState<WorkerReadySet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::WorkerFetchStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetWorkerFetchStart(double value) {
  static_assert(!(STATE & WorkerFetchStartSet), "property workerFetchStart should not be set yet");
  m_result->SetWorkerFetchStart(value);
  return castState<WorkerFetchStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::WorkerRespondWithSettledSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetWorkerRespondWithSettled(double value) {
  static_assert(!(STATE & WorkerRespondWithSettledSet), "property workerRespondWithSettled should not be set yet");
  m_result->SetWorkerRespondWithSettled(value);
  return castState<WorkerRespondWithSettledSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE>& ResourceTiming::ResourceTimingBuilder<STATE>::SetWorkerRouterEvaluationStart(double value) {
  m_result->SetWorkerRouterEvaluationStart(value);
  return *this;
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE>& ResourceTiming::ResourceTimingBuilder<STATE>::SetWorkerCacheLookupStart(double value) {
  m_result->SetWorkerCacheLookupStart(value);
  return *this;
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::SendStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetSendStart(double value) {
  static_assert(!(STATE & SendStartSet), "property sendStart should not be set yet");
  m_result->SetSendStart(value);
  return castState<SendStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::SendEndSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetSendEnd(double value) {
  static_assert(!(STATE & SendEndSet), "property sendEnd should not be set yet");
  m_result->SetSendEnd(value);
  return castState<SendEndSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::PushStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetPushStart(double value) {
  static_assert(!(STATE & PushStartSet), "property pushStart should not be set yet");
  m_result->SetPushStart(value);
  return castState<PushStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::PushEndSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetPushEnd(double value) {
  static_assert(!(STATE & PushEndSet), "property pushEnd should not be set yet");
  m_result->SetPushEnd(value);
  return castState<PushEndSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::ReceiveHeadersStartSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetReceiveHeadersStart(double value) {
  static_assert(!(STATE & ReceiveHeadersStartSet), "property receiveHeadersStart should not be set yet");
  m_result->SetReceiveHeadersStart(value);
  return castState<ReceiveHeadersStartSet>();
}
template<int STATE>
inline ResourceTiming::ResourceTimingBuilder<STATE | ResourceTiming::ResourceTimingBuilder<STATE>::ReceiveHeadersEndSet>&
ResourceTiming::ResourceTimingBuilder<STATE>::SetReceiveHeadersEnd(double value) {
  static_assert(!(STATE & ReceiveHeadersEndSet), "property receiveHeadersEnd should not be set yet");
  m_result->SetReceiveHeadersEnd(value);
  return castState<ReceiveHeadersEndSet>();
}

inline ResourceTiming::ResourceTiming() {
  m_requestTime = 0;
  m_proxyStart = 0;
  m_proxyEnd = 0;
  m_dnsStart = 0;
  m_dnsEnd = 0;
  m_connectStart = 0;
  m_connectEnd = 0;
  m_sslStart = 0;
  m_sslEnd = 0;
  m_workerStart = 0;
  m_workerReady = 0;
  m_workerFetchStart = 0;
  m_workerRespondWithSettled = 0;
  m_sendStart = 0;
  m_sendEnd = 0;
  m_pushStart = 0;
  m_pushEnd = 0;
  m_receiveHeadersStart = 0;
  m_receiveHeadersEnd = 0;
}
inline PostDataEntry::~PostDataEntry() = default;
inline void PostDataEntry::SetBytes(const Binary& value) { m_bytes = value; }

template<int STATE>
inline PostDataEntry::PostDataEntryBuilder<STATE>& PostDataEntry::PostDataEntryBuilder<STATE>::SetBytes(const Binary& value) {
  m_result->SetBytes(value);
  return *this;
}

inline PostDataEntry::PostDataEntry() {
}
inline Request::~Request() = default;
inline void Request::SetUrl(const String& value) { m_url = value; }
inline void Request::SetUrlFragment(const String& value) { m_urlFragment = value; }
inline void Request::SetMethod(const String& value) { m_method = value; }
inline void Request::SetHeaders(std::unique_ptr<protocol::Network::Headers> value) { m_headers = std::move(value); }
inline void Request::SetPostData(const String& value) { m_postData = value; }
inline void Request::SetHasPostData(bool value) { m_hasPostData = value; }
inline void Request::SetPostDataEntries(std::unique_ptr<protocol::Array<protocol::Network::PostDataEntry>> value) { m_postDataEntries = std::move(value); }
inline void Request::SetMixedContentType(const String& value) { m_mixedContentType = value; }
inline void Request::SetInitialPriority(const String& value) { m_initialPriority = value; }
inline void Request::SetReferrerPolicy(const String& value) { m_referrerPolicy = value; }
inline void Request::SetIsLinkPreload(bool value) { m_isLinkPreload = value; }
inline void Request::SetTrustTokenParams(std::unique_ptr<protocol::Network::TrustTokenParams> value) { m_trustTokenParams = std::move(value); }
inline void Request::SetIsSameSite(bool value) { m_isSameSite = value; }
inline void Request::SetIsAdRelated(bool value) { m_isAdRelated = value; }

template<int STATE>
inline Request::RequestBuilder<STATE | Request::RequestBuilder<STATE>::UrlSet>&
Request::RequestBuilder<STATE>::SetUrl(const String& value) {
  static_assert(!(STATE & UrlSet), "property url should not be set yet");
  m_result->SetUrl(value);
  return castState<UrlSet>();
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetUrlFragment(const String& value) {
  m_result->SetUrlFragment(value);
  return *this;
}
template<int STATE>
inline Request::RequestBuilder<STATE | Request::RequestBuilder<STATE>::MethodSet>&
Request::RequestBuilder<STATE>::SetMethod(const String& value) {
  static_assert(!(STATE & MethodSet), "property method should not be set yet");
  m_result->SetMethod(value);
  return castState<MethodSet>();
}
template<int STATE>
inline Request::RequestBuilder<STATE | Request::RequestBuilder<STATE>::HeadersSet>&
Request::RequestBuilder<STATE>::SetHeaders(std::unique_ptr<protocol::Network::Headers> value) {
  static_assert(!(STATE & HeadersSet), "property headers should not be set yet");
  m_result->SetHeaders(std::move(value));
  return castState<HeadersSet>();
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetPostData(const String& value) {
  m_result->SetPostData(value);
  return *this;
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetHasPostData(bool value) {
  m_result->SetHasPostData(value);
  return *this;
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetPostDataEntries(std::unique_ptr<protocol::Array<protocol::Network::PostDataEntry>> value) {
  m_result->SetPostDataEntries(std::move(value));
  return *this;
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetMixedContentType(const String& value) {
  m_result->SetMixedContentType(value);
  return *this;
}
template<int STATE>
inline Request::RequestBuilder<STATE | Request::RequestBuilder<STATE>::InitialPrioritySet>&
Request::RequestBuilder<STATE>::SetInitialPriority(const String& value) {
  static_assert(!(STATE & InitialPrioritySet), "property initialPriority should not be set yet");
  m_result->SetInitialPriority(value);
  return castState<InitialPrioritySet>();
}
template<int STATE>
inline Request::RequestBuilder<STATE | Request::RequestBuilder<STATE>::ReferrerPolicySet>&
Request::RequestBuilder<STATE>::SetReferrerPolicy(const String& value) {
  static_assert(!(STATE & ReferrerPolicySet), "property referrerPolicy should not be set yet");
  m_result->SetReferrerPolicy(value);
  return castState<ReferrerPolicySet>();
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetIsLinkPreload(bool value) {
  m_result->SetIsLinkPreload(value);
  return *this;
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetTrustTokenParams(std::unique_ptr<protocol::Network::TrustTokenParams> value) {
  m_result->SetTrustTokenParams(std::move(value));
  return *this;
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetIsSameSite(bool value) {
  m_result->SetIsSameSite(value);
  return *this;
}
template<int STATE>
inline Request::RequestBuilder<STATE>& Request::RequestBuilder<STATE>::SetIsAdRelated(bool value) {
  m_result->SetIsAdRelated(value);
  return *this;
}

inline Request::Request() {
}
inline SignedCertificateTimestamp::~SignedCertificateTimestamp() = default;
inline void SignedCertificateTimestamp::SetStatus(const String& value) { m_status = value; }
inline void SignedCertificateTimestamp::SetOrigin(const String& value) { m_origin = value; }
inline void SignedCertificateTimestamp::SetLogDescription(const String& value) { m_logDescription = value; }
inline void SignedCertificateTimestamp::SetLogId(const String& value) { m_logId = value; }
inline void SignedCertificateTimestamp::SetTimestamp(double value) { m_timestamp = value; }
inline void SignedCertificateTimestamp::SetHashAlgorithm(const String& value) { m_hashAlgorithm = value; }
inline void SignedCertificateTimestamp::SetSignatureAlgorithm(const String& value) { m_signatureAlgorithm = value; }
inline void SignedCertificateTimestamp::SetSignatureData(const String& value) { m_signatureData = value; }

template<int STATE>
inline SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE | SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::StatusSet>&
SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SetStatus(const String& value) {
  static_assert(!(STATE & StatusSet), "property status should not be set yet");
  m_result->SetStatus(value);
  return castState<StatusSet>();
}
template<int STATE>
inline SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE | SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::OriginSet>&
SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SetOrigin(const String& value) {
  static_assert(!(STATE & OriginSet), "property origin should not be set yet");
  m_result->SetOrigin(value);
  return castState<OriginSet>();
}
template<int STATE>
inline SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE | SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::LogDescriptionSet>&
SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SetLogDescription(const String& value) {
  static_assert(!(STATE & LogDescriptionSet), "property logDescription should not be set yet");
  m_result->SetLogDescription(value);
  return castState<LogDescriptionSet>();
}
template<int STATE>
inline SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE | SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::LogIdSet>&
SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SetLogId(const String& value) {
  static_assert(!(STATE & LogIdSet), "property logId should not be set yet");
  m_result->SetLogId(value);
  return castState<LogIdSet>();
}
template<int STATE>
inline SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE | SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::TimestampSet>&
SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SetTimestamp(double value) {
  static_assert(!(STATE & TimestampSet), "property timestamp should not be set yet");
  m_result->SetTimestamp(value);
  return castState<TimestampSet>();
}
template<int STATE>
inline SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE | SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::HashAlgorithmSet>&
SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SetHashAlgorithm(const String& value) {
  static_assert(!(STATE & HashAlgorithmSet), "property hashAlgorithm should not be set yet");
  m_result->SetHashAlgorithm(value);
  return castState<HashAlgorithmSet>();
}
template<int STATE>
inline SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE | SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SignatureAlgorithmSet>&
SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SetSignatureAlgorithm(const String& value) {
  static_assert(!(STATE & SignatureAlgorithmSet), "property signatureAlgorithm should not be set yet");
  m_result->SetSignatureAlgorithm(value);
  return castState<SignatureAlgorithmSet>();
}
template<int STATE>
inline SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE | SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SignatureDataSet>&
SignedCertificateTimestamp::SignedCertificateTimestampBuilder<STATE>::SetSignatureData(const String& value) {
  static_assert(!(STATE & SignatureDataSet), "property signatureData should not be set yet");
  m_result->SetSignatureData(value);
  return castState<SignatureDataSet>();
}

inline SignedCertificateTimestamp::SignedCertificateTimestamp() {
  m_timestamp = 0;
}
inline SecurityDetails::~SecurityDetails() = default;
inline void SecurityDetails::SetProtocol(const String& value) { m_protocol = value; }
inline void SecurityDetails::SetKeyExchange(const String& value) { m_keyExchange = value; }
inline void SecurityDetails::SetKeyExchangeGroup(const String& value) { m_keyExchangeGroup = value; }
inline void SecurityDetails::SetCipher(const String& value) { m_cipher = value; }
inline void SecurityDetails::SetMac(const String& value) { m_mac = value; }
inline void SecurityDetails::SetCertificateId(int value) { m_certificateId = value; }
inline void SecurityDetails::SetSubjectName(const String& value) { m_subjectName = value; }
inline void SecurityDetails::SetSanList(std::unique_ptr<protocol::Array<String>> value) { m_sanList = std::move(value); }
inline void SecurityDetails::SetIssuer(const String& value) { m_issuer = value; }
inline void SecurityDetails::SetValidFrom(double value) { m_validFrom = value; }
inline void SecurityDetails::SetValidTo(double value) { m_validTo = value; }
inline void SecurityDetails::SetSignedCertificateTimestampList(std::unique_ptr<protocol::Array<protocol::Network::SignedCertificateTimestamp>> value) { m_signedCertificateTimestampList = std::move(value); }
inline void SecurityDetails::SetCertificateTransparencyCompliance(const String& value) { m_certificateTransparencyCompliance = value; }
inline void SecurityDetails::SetServerSignatureAlgorithm(int value) { m_serverSignatureAlgorithm = value; }
inline void SecurityDetails::SetEncryptedClientHello(bool value) { m_encryptedClientHello = value; }

template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::ProtocolSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetProtocol(const String& value) {
  static_assert(!(STATE & ProtocolSet), "property protocol should not be set yet");
  m_result->SetProtocol(value);
  return castState<ProtocolSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::KeyExchangeSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetKeyExchange(const String& value) {
  static_assert(!(STATE & KeyExchangeSet), "property keyExchange should not be set yet");
  m_result->SetKeyExchange(value);
  return castState<KeyExchangeSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE>& SecurityDetails::SecurityDetailsBuilder<STATE>::SetKeyExchangeGroup(const String& value) {
  m_result->SetKeyExchangeGroup(value);
  return *this;
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::CipherSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetCipher(const String& value) {
  static_assert(!(STATE & CipherSet), "property cipher should not be set yet");
  m_result->SetCipher(value);
  return castState<CipherSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE>& SecurityDetails::SecurityDetailsBuilder<STATE>::SetMac(const String& value) {
  m_result->SetMac(value);
  return *this;
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::CertificateIdSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetCertificateId(int value) {
  static_assert(!(STATE & CertificateIdSet), "property certificateId should not be set yet");
  m_result->SetCertificateId(value);
  return castState<CertificateIdSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::SubjectNameSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetSubjectName(const String& value) {
  static_assert(!(STATE & SubjectNameSet), "property subjectName should not be set yet");
  m_result->SetSubjectName(value);
  return castState<SubjectNameSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::SanListSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetSanList(std::unique_ptr<protocol::Array<String>> value) {
  static_assert(!(STATE & SanListSet), "property sanList should not be set yet");
  m_result->SetSanList(std::move(value));
  return castState<SanListSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::IssuerSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetIssuer(const String& value) {
  static_assert(!(STATE & IssuerSet), "property issuer should not be set yet");
  m_result->SetIssuer(value);
  return castState<IssuerSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::ValidFromSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetValidFrom(double value) {
  static_assert(!(STATE & ValidFromSet), "property validFrom should not be set yet");
  m_result->SetValidFrom(value);
  return castState<ValidFromSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::ValidToSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetValidTo(double value) {
  static_assert(!(STATE & ValidToSet), "property validTo should not be set yet");
  m_result->SetValidTo(value);
  return castState<ValidToSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::SignedCertificateTimestampListSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetSignedCertificateTimestampList(std::unique_ptr<protocol::Array<protocol::Network::SignedCertificateTimestamp>> value) {
  static_assert(!(STATE & SignedCertificateTimestampListSet), "property signedCertificateTimestampList should not be set yet");
  m_result->SetSignedCertificateTimestampList(std::move(value));
  return castState<SignedCertificateTimestampListSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::CertificateTransparencyComplianceSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetCertificateTransparencyCompliance(const String& value) {
  static_assert(!(STATE & CertificateTransparencyComplianceSet), "property certificateTransparencyCompliance should not be set yet");
  m_result->SetCertificateTransparencyCompliance(value);
  return castState<CertificateTransparencyComplianceSet>();
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE>& SecurityDetails::SecurityDetailsBuilder<STATE>::SetServerSignatureAlgorithm(int value) {
  m_result->SetServerSignatureAlgorithm(value);
  return *this;
}
template<int STATE>
inline SecurityDetails::SecurityDetailsBuilder<STATE | SecurityDetails::SecurityDetailsBuilder<STATE>::EncryptedClientHelloSet>&
SecurityDetails::SecurityDetailsBuilder<STATE>::SetEncryptedClientHello(bool value) {
  static_assert(!(STATE & EncryptedClientHelloSet), "property encryptedClientHello should not be set yet");
  m_result->SetEncryptedClientHello(value);
  return castState<EncryptedClientHelloSet>();
}

inline SecurityDetails::SecurityDetails() {
  m_certificateId = 0;
  m_validFrom = 0;
  m_validTo = 0;
  m_encryptedClientHello = false;
}
inline CorsErrorStatus::~CorsErrorStatus() = default;
inline void CorsErrorStatus::SetCorsError(const String& value) { m_corsError = value; }
inline void CorsErrorStatus::SetFailedParameter(const String& value) { m_failedParameter = value; }

template<int STATE>
inline CorsErrorStatus::CorsErrorStatusBuilder<STATE | CorsErrorStatus::CorsErrorStatusBuilder<STATE>::CorsErrorSet>&
CorsErrorStatus::CorsErrorStatusBuilder<STATE>::SetCorsError(const String& value) {
  static_assert(!(STATE & CorsErrorSet), "property corsError should not be set yet");
  m_result->SetCorsError(value);
  return castState<CorsErrorSet>();
}
template<int STATE>
inline CorsErrorStatus::CorsErrorStatusBuilder<STATE | CorsErrorStatus::CorsErrorStatusBuilder<STATE>::FailedParameterSet>&
CorsErrorStatus::CorsErrorStatusBuilder<STATE>::SetFailedParameter(const String& value) {
  static_assert(!(STATE & FailedParameterSet), "property failedParameter should not be set yet");
  m_result->SetFailedParameter(value);
  return castState<FailedParameterSet>();
}

inline CorsErrorStatus::CorsErrorStatus() {
}
inline TrustTokenParams::~TrustTokenParams() = default;
inline void TrustTokenParams::SetOperation(const String& value) { m_operation = value; }
inline void TrustTokenParams::SetRefreshPolicy(const String& value) { m_refreshPolicy = value; }
inline void TrustTokenParams::SetIssuers(std::unique_ptr<protocol::Array<String>> value) { m_issuers = std::move(value); }

template<int STATE>
inline TrustTokenParams::TrustTokenParamsBuilder<STATE | TrustTokenParams::TrustTokenParamsBuilder<STATE>::OperationSet>&
TrustTokenParams::TrustTokenParamsBuilder<STATE>::SetOperation(const String& value) {
  static_assert(!(STATE & OperationSet), "property operation should not be set yet");
  m_result->SetOperation(value);
  return castState<OperationSet>();
}
template<int STATE>
inline TrustTokenParams::TrustTokenParamsBuilder<STATE | TrustTokenParams::TrustTokenParamsBuilder<STATE>::RefreshPolicySet>&
TrustTokenParams::TrustTokenParamsBuilder<STATE>::SetRefreshPolicy(const String& value) {
  static_assert(!(STATE & RefreshPolicySet), "property refreshPolicy should not be set yet");
  m_result->SetRefreshPolicy(value);
  return castState<RefreshPolicySet>();
}
template<int STATE>
inline TrustTokenParams::TrustTokenParamsBuilder<STATE>& TrustTokenParams::TrustTokenParamsBuilder<STATE>::SetIssuers(std::unique_ptr<protocol::Array<String>> value) {
  m_result->SetIssuers(std::move(value));
  return *this;
}

inline TrustTokenParams::TrustTokenParams() {
}
inline ServiceWorkerRouterInfo::~ServiceWorkerRouterInfo() = default;
inline void ServiceWorkerRouterInfo::SetRuleIdMatched(int value) { m_ruleIdMatched = value; }
inline void ServiceWorkerRouterInfo::SetMatchedSourceType(const String& value) { m_matchedSourceType = value; }
inline void ServiceWorkerRouterInfo::SetActualSourceType(const String& value) { m_actualSourceType = value; }

template<int STATE>
inline ServiceWorkerRouterInfo::ServiceWorkerRouterInfoBuilder<STATE>& ServiceWorkerRouterInfo::ServiceWorkerRouterInfoBuilder<STATE>::SetRuleIdMatched(int value) {
  m_result->SetRuleIdMatched(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerRouterInfo::ServiceWorkerRouterInfoBuilder<STATE>& ServiceWorkerRouterInfo::ServiceWorkerRouterInfoBuilder<STATE>::SetMatchedSourceType(const String& value) {
  m_result->SetMatchedSourceType(value);
  return *this;
}
template<int STATE>
inline ServiceWorkerRouterInfo::ServiceWorkerRouterInfoBuilder<STATE>& ServiceWorkerRouterInfo::ServiceWorkerRouterInfoBuilder<STATE>::SetActualSourceType(const String& value) {
  m_result->SetActualSourceType(value);
  return *this;
}

inline ServiceWorkerRouterInfo::ServiceWorkerRouterInfo() {
}
inline Response::~Response() = default;
inline void Response::SetUrl(const String& value) { m_url = value; }
inline void Response::SetStatus(int value) { m_status = value; }
inline void Response::SetStatusText(const String& value) { m_statusText = value; }
inline void Response::SetHeaders(std::unique_ptr<protocol::Network::Headers> value) { m_headers = std::move(value); }
inline void Response::SetHeadersText(const String& value) { m_headersText = value; }
inline void Response::SetMimeType(const String& value) { m_mimeType = value; }
inline void Response::SetCharset(const String& value) { m_charset = value; }
inline void Response::SetRequestHeaders(std::unique_ptr<protocol::Network::Headers> value) { m_requestHeaders = std::move(value); }
inline void Response::SetRequestHeadersText(const String& value) { m_requestHeadersText = value; }
inline void Response::SetConnectionReused(bool value) { m_connectionReused = value; }
inline void Response::SetConnectionId(double value) { m_connectionId = value; }
inline void Response::SetRemoteIPAddress(const String& value) { m_remoteIPAddress = value; }
inline void Response::SetRemotePort(int value) { m_remotePort = value; }
inline void Response::SetFromDiskCache(bool value) { m_fromDiskCache = value; }
inline void Response::SetFromServiceWorker(bool value) { m_fromServiceWorker = value; }
inline void Response::SetFromPrefetchCache(bool value) { m_fromPrefetchCache = value; }
inline void Response::SetFromEarlyHints(bool value) { m_fromEarlyHints = value; }
inline void Response::SetServiceWorkerRouterInfo(std::unique_ptr<protocol::Network::ServiceWorkerRouterInfo> value) { m_serviceWorkerRouterInfo = std::move(value); }
inline void Response::SetEncodedDataLength(double value) { m_encodedDataLength = value; }
inline void Response::SetTiming(std::unique_ptr<protocol::Network::ResourceTiming> value) { m_timing = std::move(value); }
inline void Response::SetServiceWorkerResponseSource(const String& value) { m_serviceWorkerResponseSource = value; }
inline void Response::SetResponseTime(double value) { m_responseTime = value; }
inline void Response::SetCacheStorageCacheName(const String& value) { m_cacheStorageCacheName = value; }
inline void Response::SetProtocol(const String& value) { m_protocol = value; }
inline void Response::SetAlternateProtocolUsage(const String& value) { m_alternateProtocolUsage = value; }
inline void Response::SetSecurityState(const String& value) { m_securityState = value; }
inline void Response::SetSecurityDetails(std::unique_ptr<protocol::Network::SecurityDetails> value) { m_securityDetails = std::move(value); }

template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::UrlSet>&
Response::ResponseBuilder<STATE>::SetUrl(const String& value) {
  static_assert(!(STATE & UrlSet), "property url should not be set yet");
  m_result->SetUrl(value);
  return castState<UrlSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::StatusSet>&
Response::ResponseBuilder<STATE>::SetStatus(int value) {
  static_assert(!(STATE & StatusSet), "property status should not be set yet");
  m_result->SetStatus(value);
  return castState<StatusSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::StatusTextSet>&
Response::ResponseBuilder<STATE>::SetStatusText(const String& value) {
  static_assert(!(STATE & StatusTextSet), "property statusText should not be set yet");
  m_result->SetStatusText(value);
  return castState<StatusTextSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::HeadersSet>&
Response::ResponseBuilder<STATE>::SetHeaders(std::unique_ptr<protocol::Network::Headers> value) {
  static_assert(!(STATE & HeadersSet), "property headers should not be set yet");
  m_result->SetHeaders(std::move(value));
  return castState<HeadersSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetHeadersText(const String& value) {
  m_result->SetHeadersText(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::MimeTypeSet>&
Response::ResponseBuilder<STATE>::SetMimeType(const String& value) {
  static_assert(!(STATE & MimeTypeSet), "property mimeType should not be set yet");
  m_result->SetMimeType(value);
  return castState<MimeTypeSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::CharsetSet>&
Response::ResponseBuilder<STATE>::SetCharset(const String& value) {
  static_assert(!(STATE & CharsetSet), "property charset should not be set yet");
  m_result->SetCharset(value);
  return castState<CharsetSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetRequestHeaders(std::unique_ptr<protocol::Network::Headers> value) {
  m_result->SetRequestHeaders(std::move(value));
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetRequestHeadersText(const String& value) {
  m_result->SetRequestHeadersText(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::ConnectionReusedSet>&
Response::ResponseBuilder<STATE>::SetConnectionReused(bool value) {
  static_assert(!(STATE & ConnectionReusedSet), "property connectionReused should not be set yet");
  m_result->SetConnectionReused(value);
  return castState<ConnectionReusedSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::ConnectionIdSet>&
Response::ResponseBuilder<STATE>::SetConnectionId(double value) {
  static_assert(!(STATE & ConnectionIdSet), "property connectionId should not be set yet");
  m_result->SetConnectionId(value);
  return castState<ConnectionIdSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetRemoteIPAddress(const String& value) {
  m_result->SetRemoteIPAddress(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetRemotePort(int value) {
  m_result->SetRemotePort(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetFromDiskCache(bool value) {
  m_result->SetFromDiskCache(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetFromServiceWorker(bool value) {
  m_result->SetFromServiceWorker(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetFromPrefetchCache(bool value) {
  m_result->SetFromPrefetchCache(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetFromEarlyHints(bool value) {
  m_result->SetFromEarlyHints(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetServiceWorkerRouterInfo(std::unique_ptr<protocol::Network::ServiceWorkerRouterInfo> value) {
  m_result->SetServiceWorkerRouterInfo(std::move(value));
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::EncodedDataLengthSet>&
Response::ResponseBuilder<STATE>::SetEncodedDataLength(double value) {
  static_assert(!(STATE & EncodedDataLengthSet), "property encodedDataLength should not be set yet");
  m_result->SetEncodedDataLength(value);
  return castState<EncodedDataLengthSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetTiming(std::unique_ptr<protocol::Network::ResourceTiming> value) {
  m_result->SetTiming(std::move(value));
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetServiceWorkerResponseSource(const String& value) {
  m_result->SetServiceWorkerResponseSource(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetResponseTime(double value) {
  m_result->SetResponseTime(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetCacheStorageCacheName(const String& value) {
  m_result->SetCacheStorageCacheName(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetProtocol(const String& value) {
  m_result->SetProtocol(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetAlternateProtocolUsage(const String& value) {
  m_result->SetAlternateProtocolUsage(value);
  return *this;
}
template<int STATE>
inline Response::ResponseBuilder<STATE | Response::ResponseBuilder<STATE>::SecurityStateSet>&
Response::ResponseBuilder<STATE>::SetSecurityState(const String& value) {
  static_assert(!(STATE & SecurityStateSet), "property securityState should not be set yet");
  m_result->SetSecurityState(value);
  return castState<SecurityStateSet>();
}
template<int STATE>
inline Response::ResponseBuilder<STATE>& Response::ResponseBuilder<STATE>::SetSecurityDetails(std::unique_ptr<protocol::Network::SecurityDetails> value) {
  m_result->SetSecurityDetails(std::move(value));
  return *this;
}

inline Response::Response() {
  m_status = 0;
  m_connectionReused = false;
  m_connectionId = 0;
  m_encodedDataLength = 0;
}
inline Initiator::~Initiator() = default;
inline void Initiator::SetType(const String& value) { m_type = value; }
inline void Initiator::SetStack(std::unique_ptr<protocol::Runtime::StackTrace> value) { m_stack = std::move(value); }
inline void Initiator::SetUrl(const String& value) { m_url = value; }
inline void Initiator::SetLineNumber(double value) { m_lineNumber = value; }
inline void Initiator::SetColumnNumber(double value) { m_columnNumber = value; }
inline void Initiator::SetRequestId(const String& value) { m_requestId = value; }

template<int STATE>
inline Initiator::InitiatorBuilder<STATE | Initiator::InitiatorBuilder<STATE>::TypeSet>&
Initiator::InitiatorBuilder<STATE>::SetType(const String& value) {
  static_assert(!(STATE & TypeSet), "property type should not be set yet");
  m_result->SetType(value);
  return castState<TypeSet>();
}
template<int STATE>
inline Initiator::InitiatorBuilder<STATE>& Initiator::InitiatorBuilder<STATE>::SetStack(std::unique_ptr<protocol::Runtime::StackTrace> value) {
  m_result->SetStack(std::move(value));
  return *this;
}
template<int STATE>
inline Initiator::InitiatorBuilder<STATE>& Initiator::InitiatorBuilder<STATE>::SetUrl(const String& value) {
  m_result->SetUrl(value);
  return *this;
}
template<int STATE>
inline Initiator::InitiatorBuilder<STATE>& Initiator::InitiatorBuilder<STATE>::SetLineNumber(double value) {
  m_result->SetLineNumber(value);
  return *this;
}
template<int STATE>
inline Initiator::InitiatorBuilder<STATE>& Initiator::InitiatorBuilder<STATE>::SetColumnNumber(double value) {
  m_result->SetColumnNumber(value);
  return *this;
}
template<int STATE>
inline Initiator::InitiatorBuilder<STATE>& Initiator::InitiatorBuilder<STATE>::SetRequestId(const String& value) {
  m_result->SetRequestId(value);
  return *this;
}

inline Initiator::Initiator() {
}
inline CookiePartitionKey::~CookiePartitionKey() = default;
inline void CookiePartitionKey::SetTopLevelSite(const String& value) { m_topLevelSite = value; }
inline void CookiePartitionKey::SetHasCrossSiteAncestor(bool value) { m_hasCrossSiteAncestor = value; }

template<int STATE>
inline CookiePartitionKey::CookiePartitionKeyBuilder<STATE | CookiePartitionKey::CookiePartitionKeyBuilder<STATE>::TopLevelSiteSet>&
CookiePartitionKey::CookiePartitionKeyBuilder<STATE>::SetTopLevelSite(const String& value) {
  static_assert(!(STATE & TopLevelSiteSet), "property topLevelSite should not be set yet");
  m_result->SetTopLevelSite(value);
  return castState<TopLevelSiteSet>();
}
template<int STATE>
inline CookiePartitionKey::CookiePartitionKeyBuilder<STATE | CookiePartitionKey::CookiePartitionKeyBuilder<STATE>::HasCrossSiteAncestorSet>&
CookiePartitionKey::CookiePartitionKeyBuilder<STATE>::SetHasCrossSiteAncestor(bool value) {
  static_assert(!(STATE & HasCrossSiteAncestorSet), "property hasCrossSiteAncestor should not be set yet");
  m_result->SetHasCrossSiteAncestor(value);
  return castState<HasCrossSiteAncestorSet>();
}

inline CookiePartitionKey::CookiePartitionKey() {
  m_hasCrossSiteAncestor = false;
}
inline Cookie::~Cookie() = default;
inline void Cookie::SetName(const String& value) { m_name = value; }
inline void Cookie::SetValue(const String& value) { m_value = value; }
inline void Cookie::SetDomain(const String& value) { m_domain = value; }
inline void Cookie::SetPath(const String& value) { m_path = value; }
inline void Cookie::SetExpires(double value) { m_expires = value; }
inline void Cookie::SetSize(int value) { m_size = value; }
inline void Cookie::SetHttpOnly(bool value) { m_httpOnly = value; }
inline void Cookie::SetSecure(bool value) { m_secure = value; }
inline void Cookie::SetSession(bool value) { m_session = value; }
inline void Cookie::SetSameSite(const String& value) { m_sameSite = value; }
inline void Cookie::SetPriority(const String& value) { m_priority = value; }
inline void Cookie::SetSourceScheme(const String& value) { m_sourceScheme = value; }
inline void Cookie::SetSourcePort(int value) { m_sourcePort = value; }
inline void Cookie::SetPartitionKey(std::unique_ptr<protocol::Network::CookiePartitionKey> value) { m_partitionKey = std::move(value); }
inline void Cookie::SetPartitionKeyOpaque(bool value) { m_partitionKeyOpaque = value; }

template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::NameSet>&
Cookie::CookieBuilder<STATE>::SetName(const String& value) {
  static_assert(!(STATE & NameSet), "property name should not be set yet");
  m_result->SetName(value);
  return castState<NameSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::ValueSet>&
Cookie::CookieBuilder<STATE>::SetValue(const String& value) {
  static_assert(!(STATE & ValueSet), "property value should not be set yet");
  m_result->SetValue(value);
  return castState<ValueSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::DomainSet>&
Cookie::CookieBuilder<STATE>::SetDomain(const String& value) {
  static_assert(!(STATE & DomainSet), "property domain should not be set yet");
  m_result->SetDomain(value);
  return castState<DomainSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::PathSet>&
Cookie::CookieBuilder<STATE>::SetPath(const String& value) {
  static_assert(!(STATE & PathSet), "property path should not be set yet");
  m_result->SetPath(value);
  return castState<PathSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::ExpiresSet>&
Cookie::CookieBuilder<STATE>::SetExpires(double value) {
  static_assert(!(STATE & ExpiresSet), "property expires should not be set yet");
  m_result->SetExpires(value);
  return castState<ExpiresSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::SizeSet>&
Cookie::CookieBuilder<STATE>::SetSize(int value) {
  static_assert(!(STATE & SizeSet), "property size should not be set yet");
  m_result->SetSize(value);
  return castState<SizeSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::HttpOnlySet>&
Cookie::CookieBuilder<STATE>::SetHttpOnly(bool value) {
  static_assert(!(STATE & HttpOnlySet), "property httpOnly should not be set yet");
  m_result->SetHttpOnly(value);
  return castState<HttpOnlySet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::SecureSet>&
Cookie::CookieBuilder<STATE>::SetSecure(bool value) {
  static_assert(!(STATE & SecureSet), "property secure should not be set yet");
  m_result->SetSecure(value);
  return castState<SecureSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::SessionSet>&
Cookie::CookieBuilder<STATE>::SetSession(bool value) {
  static_assert(!(STATE & SessionSet), "property session should not be set yet");
  m_result->SetSession(value);
  return castState<SessionSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE>& Cookie::CookieBuilder<STATE>::SetSameSite(const String& value) {
  m_result->SetSameSite(value);
  return *this;
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::PrioritySet>&
Cookie::CookieBuilder<STATE>::SetPriority(const String& value) {
  static_assert(!(STATE & PrioritySet), "property priority should not be set yet");
  m_result->SetPriority(value);
  return castState<PrioritySet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::SourceSchemeSet>&
Cookie::CookieBuilder<STATE>::SetSourceScheme(const String& value) {
  static_assert(!(STATE & SourceSchemeSet), "property sourceScheme should not be set yet");
  m_result->SetSourceScheme(value);
  return castState<SourceSchemeSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE | Cookie::CookieBuilder<STATE>::SourcePortSet>&
Cookie::CookieBuilder<STATE>::SetSourcePort(int value) {
  static_assert(!(STATE & SourcePortSet), "property sourcePort should not be set yet");
  m_result->SetSourcePort(value);
  return castState<SourcePortSet>();
}
template<int STATE>
inline Cookie::CookieBuilder<STATE>& Cookie::CookieBuilder<STATE>::SetPartitionKey(std::unique_ptr<protocol::Network::CookiePartitionKey> value) {
  m_result->SetPartitionKey(std::move(value));
  return *this;
}
template<int STATE>
inline Cookie::CookieBuilder<STATE>& Cookie::CookieBuilder<STATE>::SetPartitionKeyOpaque(bool value) {
  m_result->SetPartitionKeyOpaque(value);
  return *this;
}

inline Cookie::Cookie() {
  m_expires = 0;
  m_size = 0;
  m_httpOnly = false;
  m_secure = false;
  m_session = false;
  m_sourcePort = 0;
}
inline BlockedSetCookieWithReason::~BlockedSetCookieWithReason() = default;
inline void BlockedSetCookieWithReason::SetBlockedReasons(std::unique_ptr<protocol::Array<String>> value) { m_blockedReasons = std::move(value); }
inline void BlockedSetCookieWithReason::SetCookieLine(const String& value) { m_cookieLine = value; }
inline void BlockedSetCookieWithReason::SetCookie(std::unique_ptr<protocol::Network::Cookie> value) { m_cookie = std::move(value); }

template<int STATE>
inline BlockedSetCookieWithReason::BlockedSetCookieWithReasonBuilder<STATE | BlockedSetCookieWithReason::BlockedSetCookieWithReasonBuilder<STATE>::BlockedReasonsSet>&
BlockedSetCookieWithReason::BlockedSetCookieWithReasonBuilder<STATE>::SetBlockedReasons(std::unique_ptr<protocol::Array<String>> value) {
  static_assert(!(STATE & BlockedReasonsSet), "property blockedReasons should not be set yet");
  m_result->SetBlockedReasons(std::move(value));
  return castState<BlockedReasonsSet>();
}
template<int STATE>
inline BlockedSetCookieWithReason::BlockedSetCookieWithReasonBuilder<STATE | BlockedSetCookieWithReason::BlockedSetCookieWithReasonBuilder<STATE>::CookieLineSet>&
BlockedSetCookieWithReason::BlockedSetCookieWithReasonBuilder<STATE>::SetCookieLine(const String& value) {
  static_assert(!(STATE & CookieLineSet), "property cookieLine should not be set yet");
  m_result->SetCookieLine(value);
  return castState<CookieLineSet>();
}
template<int STATE>
inline BlockedSetCookieWithReason::BlockedSetCookieWithReasonBuilder<STATE>& BlockedSetCookieWithReason::BlockedSetCookieWithReasonBuilder<STATE>::SetCookie(std::unique_ptr<protocol::Network::Cookie> value) {
  m_result->SetCookie(std::move(value));
  return *this;
}

inline BlockedSetCookieWithReason::BlockedSetCookieWithReason() {
}
inline ExemptedSetCookieWithReason::~ExemptedSetCookieWithReason() = default;
inline void ExemptedSetCookieWithReason::SetExemptionReason(const String& value) { m_exemptionReason = value; }
inline void ExemptedSetCookieWithReason::SetCookieLine(const String& value) { m_cookieLine = value; }
inline void ExemptedSetCookieWithReason::SetCookie(std::unique_ptr<protocol::Network::Cookie> value) { m_cookie = std::move(value); }

template<int STATE>
inline ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE | ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE>::ExemptionReasonSet>&
ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE>::SetExemptionReason(const String& value) {
  static_assert(!(STATE & ExemptionReasonSet), "property exemptionReason should not be set yet");
  m_result->SetExemptionReason(value);
  return castState<ExemptionReasonSet>();
}
template<int STATE>
inline ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE | ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE>::CookieLineSet>&
ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE>::SetCookieLine(const String& value) {
  static_assert(!(STATE & CookieLineSet), "property cookieLine should not be set yet");
  m_result->SetCookieLine(value);
  return castState<CookieLineSet>();
}
template<int STATE>
inline ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE | ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE>::CookieSet>&
ExemptedSetCookieWithReason::ExemptedSetCookieWithReasonBuilder<STATE>::SetCookie(std::unique_ptr<protocol::Network::Cookie> value) {
  static_assert(!(STATE & CookieSet), "property cookie should not be set yet");
  m_result->SetCookie(std::move(value));
  return castState<CookieSet>();
}

inline ExemptedSetCookieWithReason::ExemptedSetCookieWithReason() {
}
inline AssociatedCookie::~AssociatedCookie() = default;
inline void AssociatedCookie::SetCookie(std::unique_ptr<protocol::Network::Cookie> value) { m_cookie = std::move(value); }
inline void AssociatedCookie::SetBlockedReasons(std::unique_ptr<protocol::Array<String>> value) { m_blockedReasons = std::move(value); }
inline void AssociatedCookie::SetExemptionReason(const String& value) { m_exemptionReason = value; }

template<int STATE>
inline AssociatedCookie::AssociatedCookieBuilder<STATE | AssociatedCookie::AssociatedCookieBuilder<STATE>::CookieSet>&
AssociatedCookie::AssociatedCookieBuilder<STATE>::SetCookie(std::unique_ptr<protocol::Network::Cookie> value) {
  static_assert(!(STATE & CookieSet), "property cookie should not be set yet");
  m_result->SetCookie(std::move(value));
  return castState<CookieSet>();
}
template<int STATE>
inline AssociatedCookie::AssociatedCookieBuilder<STATE | AssociatedCookie::AssociatedCookieBuilder<STATE>::BlockedReasonsSet>&
AssociatedCookie::AssociatedCookieBuilder<STATE>::SetBlockedReasons(std::unique_ptr<protocol::Array<String>> value) {
  static_assert(!(STATE & BlockedReasonsSet), "property blockedReasons should not be set yet");
  m_result->SetBlockedReasons(std::move(value));
  return castState<BlockedReasonsSet>();
}
template<int STATE>
inline AssociatedCookie::AssociatedCookieBuilder<STATE>& AssociatedCookie::AssociatedCookieBuilder<STATE>::SetExemptionReason(const String& value) {
  m_result->SetExemptionReason(value);
  return *this;
}

inline AssociatedCookie::AssociatedCookie() {
}
inline CookieParam::~CookieParam() = default;
inline void CookieParam::SetName(const String& value) { m_name = value; }
inline void CookieParam::SetValue(const String& value) { m_value = value; }
inline void CookieParam::SetUrl(const String& value) { m_url = value; }
inline void CookieParam::SetDomain(const String& value) { m_domain = value; }
inline void CookieParam::SetPath(const String& value) { m_path = value; }
inline void CookieParam::SetSecure(bool value) { m_secure = value; }
inline void CookieParam::SetHttpOnly(bool value) { m_httpOnly = value; }
inline void CookieParam::SetSameSite(const String& value) { m_sameSite = value; }
inline void CookieParam::SetExpires(double value) { m_expires = value; }
inline void CookieParam::SetPriority(const String& value) { m_priority = value; }
inline void CookieParam::SetSourceScheme(const String& value) { m_sourceScheme = value; }
inline void CookieParam::SetSourcePort(int value) { m_sourcePort = value; }
inline void CookieParam::SetPartitionKey(std::unique_ptr<protocol::Network::CookiePartitionKey> value) { m_partitionKey = std::move(value); }

template<int STATE>
inline CookieParam::CookieParamBuilder<STATE | CookieParam::CookieParamBuilder<STATE>::NameSet>&
CookieParam::CookieParamBuilder<STATE>::SetName(const String& value) {
  static_assert(!(STATE & NameSet), "property name should not be set yet");
  m_result->SetName(value);
  return castState<NameSet>();
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE | CookieParam::CookieParamBuilder<STATE>::ValueSet>&
CookieParam::CookieParamBuilder<STATE>::SetValue(const String& value) {
  static_assert(!(STATE & ValueSet), "property value should not be set yet");
  m_result->SetValue(value);
  return castState<ValueSet>();
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetUrl(const String& value) {
  m_result->SetUrl(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetDomain(const String& value) {
  m_result->SetDomain(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetPath(const String& value) {
  m_result->SetPath(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetSecure(bool value) {
  m_result->SetSecure(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetHttpOnly(bool value) {
  m_result->SetHttpOnly(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetSameSite(const String& value) {
  m_result->SetSameSite(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetExpires(double value) {
  m_result->SetExpires(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetPriority(const String& value) {
  m_result->SetPriority(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetSourceScheme(const String& value) {
  m_result->SetSourceScheme(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetSourcePort(int value) {
  m_result->SetSourcePort(value);
  return *this;
}
template<int STATE>
inline CookieParam::CookieParamBuilder<STATE>& CookieParam::CookieParamBuilder<STATE>::SetPartitionKey(std::unique_ptr<protocol::Network::CookiePartitionKey> value) {
  m_result->SetPartitionKey(std::move(value));
  return *this;
}

inline CookieParam::CookieParam() {
}
inline SignedExchangeSignature::~SignedExchangeSignature() = default;
inline void SignedExchangeSignature::SetLabel(const String& value) { m_label = value; }
inline void SignedExchangeSignature::SetSignature(const String& value) { m_signature = value; }
inline void SignedExchangeSignature::SetIntegrity(const String& value) { m_integrity = value; }
inline void SignedExchangeSignature::SetCertUrl(const String& value) { m_certUrl = value; }
inline void SignedExchangeSignature::SetCertSha256(const String& value) { m_certSha256 = value; }
inline void SignedExchangeSignature::SetValidityUrl(const String& value) { m_validityUrl = value; }
inline void SignedExchangeSignature::SetDate(int value) { m_date = value; }
inline void SignedExchangeSignature::SetExpires(int value) { m_expires = value; }
inline void SignedExchangeSignature::SetCertificates(std::unique_ptr<protocol::Array<String>> value) { m_certificates = std::move(value); }

template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE | SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::LabelSet>&
SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetLabel(const String& value) {
  static_assert(!(STATE & LabelSet), "property label should not be set yet");
  m_result->SetLabel(value);
  return castState<LabelSet>();
}
template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE | SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SignatureSet>&
SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetSignature(const String& value) {
  static_assert(!(STATE & SignatureSet), "property signature should not be set yet");
  m_result->SetSignature(value);
  return castState<SignatureSet>();
}
template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE | SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::IntegritySet>&
SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetIntegrity(const String& value) {
  static_assert(!(STATE & IntegritySet), "property integrity should not be set yet");
  m_result->SetIntegrity(value);
  return castState<IntegritySet>();
}
template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>& SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetCertUrl(const String& value) {
  m_result->SetCertUrl(value);
  return *this;
}
template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>& SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetCertSha256(const String& value) {
  m_result->SetCertSha256(value);
  return *this;
}
template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE | SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::ValidityUrlSet>&
SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetValidityUrl(const String& value) {
  static_assert(!(STATE & ValidityUrlSet), "property validityUrl should not be set yet");
  m_result->SetValidityUrl(value);
  return castState<ValidityUrlSet>();
}
template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE | SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::DateSet>&
SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetDate(int value) {
  static_assert(!(STATE & DateSet), "property date should not be set yet");
  m_result->SetDate(value);
  return castState<DateSet>();
}
template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE | SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::ExpiresSet>&
SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetExpires(int value) {
  static_assert(!(STATE & ExpiresSet), "property expires should not be set yet");
  m_result->SetExpires(value);
  return castState<ExpiresSet>();
}
template<int STATE>
inline SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>& SignedExchangeSignature::SignedExchangeSignatureBuilder<STATE>::SetCertificates(std::unique_ptr<protocol::Array<String>> value) {
  m_result->SetCertificates(std::move(value));
  return *this;
}

inline SignedExchangeSignature::SignedExchangeSignature() {
  m_date = 0;
  m_expires = 0;
}
inline SignedExchangeHeader::~SignedExchangeHeader() = default;
inline void SignedExchangeHeader::SetRequestUrl(const String& value) { m_requestUrl = value; }
inline void SignedExchangeHeader::SetResponseCode(int value) { m_responseCode = value; }
inline void SignedExchangeHeader::SetResponseHeaders(std::unique_ptr<protocol::Network::Headers> value) { m_responseHeaders = std::move(value); }
inline void SignedExchangeHeader::SetSignatures(std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeSignature>> value) { m_signatures = std::move(value); }
inline void SignedExchangeHeader::SetHeaderIntegrity(const String& value) { m_headerIntegrity = value; }

template<int STATE>
inline SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE | SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::RequestUrlSet>&
SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::SetRequestUrl(const String& value) {
  static_assert(!(STATE & RequestUrlSet), "property requestUrl should not be set yet");
  m_result->SetRequestUrl(value);
  return castState<RequestUrlSet>();
}
template<int STATE>
inline SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE | SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::ResponseCodeSet>&
SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::SetResponseCode(int value) {
  static_assert(!(STATE & ResponseCodeSet), "property responseCode should not be set yet");
  m_result->SetResponseCode(value);
  return castState<ResponseCodeSet>();
}
template<int STATE>
inline SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE | SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::ResponseHeadersSet>&
SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::SetResponseHeaders(std::unique_ptr<protocol::Network::Headers> value) {
  static_assert(!(STATE & ResponseHeadersSet), "property responseHeaders should not be set yet");
  m_result->SetResponseHeaders(std::move(value));
  return castState<ResponseHeadersSet>();
}
template<int STATE>
inline SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE | SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::SignaturesSet>&
SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::SetSignatures(std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeSignature>> value) {
  static_assert(!(STATE & SignaturesSet), "property signatures should not be set yet");
  m_result->SetSignatures(std::move(value));
  return castState<SignaturesSet>();
}
template<int STATE>
inline SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE | SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::HeaderIntegritySet>&
SignedExchangeHeader::SignedExchangeHeaderBuilder<STATE>::SetHeaderIntegrity(const String& value) {
  static_assert(!(STATE & HeaderIntegritySet), "property headerIntegrity should not be set yet");
  m_result->SetHeaderIntegrity(value);
  return castState<HeaderIntegritySet>();
}

inline SignedExchangeHeader::SignedExchangeHeader() {
  m_responseCode = 0;
}
inline SignedExchangeError::~SignedExchangeError() = default;
inline void SignedExchangeError::SetMessage(const String& value) { m_message = value; }
inline void SignedExchangeError::SetSignatureIndex(int value) { m_signatureIndex = value; }
inline void SignedExchangeError::SetErrorField(const String& value) { m_errorField = value; }

template<int STATE>
inline SignedExchangeError::SignedExchangeErrorBuilder<STATE | SignedExchangeError::SignedExchangeErrorBuilder<STATE>::MessageSet>&
SignedExchangeError::SignedExchangeErrorBuilder<STATE>::SetMessage(const String& value) {
  static_assert(!(STATE & MessageSet), "property message should not be set yet");
  m_result->SetMessage(value);
  return castState<MessageSet>();
}
template<int STATE>
inline SignedExchangeError::SignedExchangeErrorBuilder<STATE>& SignedExchangeError::SignedExchangeErrorBuilder<STATE>::SetSignatureIndex(int value) {
  m_result->SetSignatureIndex(value);
  return *this;
}
template<int STATE>
inline SignedExchangeError::SignedExchangeErrorBuilder<STATE>& SignedExchangeError::SignedExchangeErrorBuilder<STATE>::SetErrorField(const String& value) {
  m_result->SetErrorField(value);
  return *this;
}

inline SignedExchangeError::SignedExchangeError() {
}
inline SignedExchangeInfo::~SignedExchangeInfo() = default;
inline void SignedExchangeInfo::SetOuterResponse(std::unique_ptr<protocol::Network::Response> value) { m_outerResponse = std::move(value); }
inline void SignedExchangeInfo::SetHasExtraInfo(bool value) { m_hasExtraInfo = value; }
inline void SignedExchangeInfo::SetHeader(std::unique_ptr<protocol::Network::SignedExchangeHeader> value) { m_header = std::move(value); }
inline void SignedExchangeInfo::SetSecurityDetails(std::unique_ptr<protocol::Network::SecurityDetails> value) { m_securityDetails = std::move(value); }
inline void SignedExchangeInfo::SetErrors(std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeError>> value) { m_errors = std::move(value); }

template<int STATE>
inline SignedExchangeInfo::SignedExchangeInfoBuilder<STATE | SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>::OuterResponseSet>&
SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>::SetOuterResponse(std::unique_ptr<protocol::Network::Response> value) {
  static_assert(!(STATE & OuterResponseSet), "property outerResponse should not be set yet");
  m_result->SetOuterResponse(std::move(value));
  return castState<OuterResponseSet>();
}
template<int STATE>
inline SignedExchangeInfo::SignedExchangeInfoBuilder<STATE | SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>::HasExtraInfoSet>&
SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>::SetHasExtraInfo(bool value) {
  static_assert(!(STATE & HasExtraInfoSet), "property hasExtraInfo should not be set yet");
  m_result->SetHasExtraInfo(value);
  return castState<HasExtraInfoSet>();
}
template<int STATE>
inline SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>& SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>::SetHeader(std::unique_ptr<protocol::Network::SignedExchangeHeader> value) {
  m_result->SetHeader(std::move(value));
  return *this;
}
template<int STATE>
inline SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>& SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>::SetSecurityDetails(std::unique_ptr<protocol::Network::SecurityDetails> value) {
  m_result->SetSecurityDetails(std::move(value));
  return *this;
}
template<int STATE>
inline SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>& SignedExchangeInfo::SignedExchangeInfoBuilder<STATE>::SetErrors(std::unique_ptr<protocol::Array<protocol::Network::SignedExchangeError>> value) {
  m_result->SetErrors(std::move(value));
  return *this;
}

inline SignedExchangeInfo::SignedExchangeInfo() {
  m_hasExtraInfo = false;
}
inline NetworkConditions::~NetworkConditions() = default;
inline void NetworkConditions::SetUrlPattern(const String& value) { m_urlPattern = value; }
inline void NetworkConditions::SetLatency(double value) { m_latency = value; }
inline void NetworkConditions::SetDownloadThroughput(double value) { m_downloadThroughput = value; }
inline void NetworkConditions::SetUploadThroughput(double value) { m_uploadThroughput = value; }
inline void NetworkConditions::SetConnectionType(const String& value) { m_connectionType = value; }
inline void NetworkConditions::SetPacketLoss(double value) { m_packetLoss = value; }
inline void NetworkConditions::SetPacketQueueLength(int value) { m_packetQueueLength = value; }
inline void NetworkConditions::SetPacketReordering(bool value) { m_packetReordering = value; }
inline void NetworkConditions::SetOffline(bool value) { m_offline = value; }

template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE | NetworkConditions::NetworkConditionsBuilder<STATE>::UrlPatternSet>&
NetworkConditions::NetworkConditionsBuilder<STATE>::SetUrlPattern(const String& value) {
  static_assert(!(STATE & UrlPatternSet), "property urlPattern should not be set yet");
  m_result->SetUrlPattern(value);
  return castState<UrlPatternSet>();
}
template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE | NetworkConditions::NetworkConditionsBuilder<STATE>::LatencySet>&
NetworkConditions::NetworkConditionsBuilder<STATE>::SetLatency(double value) {
  static_assert(!(STATE & LatencySet), "property latency should not be set yet");
  m_result->SetLatency(value);
  return castState<LatencySet>();
}
template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE | NetworkConditions::NetworkConditionsBuilder<STATE>::DownloadThroughputSet>&
NetworkConditions::NetworkConditionsBuilder<STATE>::SetDownloadThroughput(double value) {
  static_assert(!(STATE & DownloadThroughputSet), "property downloadThroughput should not be set yet");
  m_result->SetDownloadThroughput(value);
  return castState<DownloadThroughputSet>();
}
template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE | NetworkConditions::NetworkConditionsBuilder<STATE>::UploadThroughputSet>&
NetworkConditions::NetworkConditionsBuilder<STATE>::SetUploadThroughput(double value) {
  static_assert(!(STATE & UploadThroughputSet), "property uploadThroughput should not be set yet");
  m_result->SetUploadThroughput(value);
  return castState<UploadThroughputSet>();
}
template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE>& NetworkConditions::NetworkConditionsBuilder<STATE>::SetConnectionType(const String& value) {
  m_result->SetConnectionType(value);
  return *this;
}
template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE>& NetworkConditions::NetworkConditionsBuilder<STATE>::SetPacketLoss(double value) {
  m_result->SetPacketLoss(value);
  return *this;
}
template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE>& NetworkConditions::NetworkConditionsBuilder<STATE>::SetPacketQueueLength(int value) {
  m_result->SetPacketQueueLength(value);
  return *this;
}
template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE>& NetworkConditions::NetworkConditionsBuilder<STATE>::SetPacketReordering(bool value) {
  m_result->SetPacketReordering(value);
  return *this;
}
template<int STATE>
inline NetworkConditions::NetworkConditionsBuilder<STATE>& NetworkConditions::NetworkConditionsBuilder<STATE>::SetOffline(bool value) {
  m_result->SetOffline(value);
  return *this;
}

inline NetworkConditions::NetworkConditions() {
  m_latency = 0;
  m_downloadThroughput = 0;
  m_uploadThroughput = 0;
}
inline ConnectTiming::~ConnectTiming() = default;
inline void ConnectTiming::SetRequestTime(double value) { m_requestTime = value; }

template<int STATE>
inline ConnectTiming::ConnectTimingBuilder<STATE | ConnectTiming::ConnectTimingBuilder<STATE>::RequestTimeSet>&
ConnectTiming::ConnectTimingBuilder<STATE>::SetRequestTime(double value) {
  static_assert(!(STATE & RequestTimeSet), "property requestTime should not be set yet");
  m_result->SetRequestTime(value);
  return castState<RequestTimeSet>();
}

inline ConnectTiming::ConnectTiming() {
  m_requestTime = 0;
}
inline ClientSecurityState::~ClientSecurityState() = default;
inline void ClientSecurityState::SetInitiatorIsSecureContext(bool value) { m_initiatorIsSecureContext = value; }
inline void ClientSecurityState::SetInitiatorIPAddressSpace(const String& value) { m_initiatorIPAddressSpace = value; }
inline void ClientSecurityState::SetLocalNetworkAccessRequestPolicy(const String& value) { m_localNetworkAccessRequestPolicy = value; }

template<int STATE>
inline ClientSecurityState::ClientSecurityStateBuilder<STATE | ClientSecurityState::ClientSecurityStateBuilder<STATE>::InitiatorIsSecureContextSet>&
ClientSecurityState::ClientSecurityStateBuilder<STATE>::SetInitiatorIsSecureContext(bool value) {
  static_assert(!(STATE & InitiatorIsSecureContextSet), "property initiatorIsSecureContext should not be set yet");
  m_result->SetInitiatorIsSecureContext(value);
  return castState<InitiatorIsSecureContextSet>();
}
template<int STATE>
inline ClientSecurityState::ClientSecurityStateBuilder<STATE | ClientSecurityState::ClientSecurityStateBuilder<STATE>::InitiatorIPAddressSpaceSet>&
ClientSecurityState::ClientSecurityStateBuilder<STATE>::SetInitiatorIPAddressSpace(const String& value) {
  static_assert(!(STATE & InitiatorIPAddressSpaceSet), "property initiatorIPAddressSpace should not be set yet");
  m_result->SetInitiatorIPAddressSpace(value);
  return castState<InitiatorIPAddressSpaceSet>();
}
template<int STATE>
inline ClientSecurityState::ClientSecurityStateBuilder<STATE | ClientSecurityState::ClientSecurityStateBuilder<STATE>::LocalNetworkAccessRequestPolicySet>&
ClientSecurityState::ClientSecurityStateBuilder<STATE>::SetLocalNetworkAccessRequestPolicy(const String& value) {
  static_assert(!(STATE & LocalNetworkAccessRequestPolicySet), "property localNetworkAccessRequestPolicy should not be set yet");
  m_result->SetLocalNetworkAccessRequestPolicy(value);
  return castState<LocalNetworkAccessRequestPolicySet>();
}

inline ClientSecurityState::ClientSecurityState() {
  m_initiatorIsSecureContext = false;
}
inline AdScriptIdentifier::~AdScriptIdentifier() = default;
inline void AdScriptIdentifier::SetScriptId(const String& value) { m_scriptId = value; }
inline void AdScriptIdentifier::SetDebuggerId(const String& value) { m_debuggerId = value; }
inline void AdScriptIdentifier::SetName(const String& value) { m_name = value; }

template<int STATE>
inline AdScriptIdentifier::AdScriptIdentifierBuilder<STATE | AdScriptIdentifier::AdScriptIdentifierBuilder<STATE>::ScriptIdSet>&
AdScriptIdentifier::AdScriptIdentifierBuilder<STATE>::SetScriptId(const String& value) {
  static_assert(!(STATE & ScriptIdSet), "property scriptId should not be set yet");
  m_result->SetScriptId(value);
  return castState<ScriptIdSet>();
}
template<int STATE>
inline AdScriptIdentifier::AdScriptIdentifierBuilder<STATE | AdScriptIdentifier::AdScriptIdentifierBuilder<STATE>::DebuggerIdSet>&
AdScriptIdentifier::AdScriptIdentifierBuilder<STATE>::SetDebuggerId(const String& value) {
  static_assert(!(STATE & DebuggerIdSet), "property debuggerId should not be set yet");
  m_result->SetDebuggerId(value);
  return castState<DebuggerIdSet>();
}
template<int STATE>
inline AdScriptIdentifier::AdScriptIdentifierBuilder<STATE | AdScriptIdentifier::AdScriptIdentifierBuilder<STATE>::NameSet>&
AdScriptIdentifier::AdScriptIdentifierBuilder<STATE>::SetName(const String& value) {
  static_assert(!(STATE & NameSet), "property name should not be set yet");
  m_result->SetName(value);
  return castState<NameSet>();
}

inline AdScriptIdentifier::AdScriptIdentifier() {
}
inline AdAncestry::~AdAncestry() = default;
inline void AdAncestry::SetAncestryChain(std::unique_ptr<protocol::Array<protocol::Network::AdScriptIdentifier>> value) { m_ancestryChain = std::move(value); }
inline void AdAncestry::SetRootScriptFilterlistRule(const String& value) { m_rootScriptFilterlistRule = value; }

template<int STATE>
inline AdAncestry::AdAncestryBuilder<STATE | AdAncestry::AdAncestryBuilder<STATE>::AncestryChainSet>&
AdAncestry::AdAncestryBuilder<STATE>::SetAncestryChain(std::unique_ptr<protocol::Array<protocol::Network::AdScriptIdentifier>> value) {
  static_assert(!(STATE & AncestryChainSet), "property ancestryChain should not be set yet");
  m_result->SetAncestryChain(std::move(value));
  return castState<AncestryChainSet>();
}
template<int STATE>
inline AdAncestry::AdAncestryBuilder<STATE>& AdAncestry::AdAncestryBuilder<STATE>::SetRootScriptFilterlistRule(const String& value) {
  m_result->SetRootScriptFilterlistRule(value);
  return *this;
}

inline AdAncestry::AdAncestry() {
}
inline CrossOriginOpenerPolicyStatus::~CrossOriginOpenerPolicyStatus() = default;
inline void CrossOriginOpenerPolicyStatus::SetValue(const String& value) { m_value = value; }
inline void CrossOriginOpenerPolicyStatus::SetReportOnlyValue(const String& value) { m_reportOnlyValue = value; }
inline void CrossOriginOpenerPolicyStatus::SetReportingEndpoint(const String& value) { m_reportingEndpoint = value; }
inline void CrossOriginOpenerPolicyStatus::SetReportOnlyReportingEndpoint(const String& value) { m_reportOnlyReportingEndpoint = value; }

template<int STATE>
inline CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE | CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE>::ValueSet>&
CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE>::SetValue(const String& value) {
  static_assert(!(STATE & ValueSet), "property value should not be set yet");
  m_result->SetValue(value);
  return castState<ValueSet>();
}
template<int STATE>
inline CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE | CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE>::ReportOnlyValueSet>&
CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE>::SetReportOnlyValue(const String& value) {
  static_assert(!(STATE & ReportOnlyValueSet), "property reportOnlyValue should not be set yet");
  m_result->SetReportOnlyValue(value);
  return castState<ReportOnlyValueSet>();
}
template<int STATE>
inline CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE>& CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE>::SetReportingEndpoint(const String& value) {
  m_result->SetReportingEndpoint(value);
  return *this;
}
template<int STATE>
inline CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE>& CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatusBuilder<STATE>::SetReportOnlyReportingEndpoint(const String& value) {
  m_result->SetReportOnlyReportingEndpoint(value);
  return *this;
}

inline CrossOriginOpenerPolicyStatus::CrossOriginOpenerPolicyStatus() {
}
inline CrossOriginEmbedderPolicyStatus::~CrossOriginEmbedderPolicyStatus() = default;
inline void CrossOriginEmbedderPolicyStatus::SetValue(const String& value) { m_value = value; }
inline void CrossOriginEmbedderPolicyStatus::SetReportOnlyValue(const String& value) { m_reportOnlyValue = value; }
inline void CrossOriginEmbedderPolicyStatus::SetReportingEndpoint(const String& value) { m_reportingEndpoint = value; }
inline void CrossOriginEmbedderPolicyStatus::SetReportOnlyReportingEndpoint(const String& value) { m_reportOnlyReportingEndpoint = value; }

template<int STATE>
inline CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE | CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE>::ValueSet>&
CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE>::SetValue(const String& value) {
  static_assert(!(STATE & ValueSet), "property value should not be set yet");
  m_result->SetValue(value);
  return castState<ValueSet>();
}
template<int STATE>
inline CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE | CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE>::ReportOnlyValueSet>&
CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE>::SetReportOnlyValue(const String& value) {
  static_assert(!(STATE & ReportOnlyValueSet), "property reportOnlyValue should not be set yet");
  m_result->SetReportOnlyValue(value);
  return castState<ReportOnlyValueSet>();
}
template<int STATE>
inline CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE>& CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE>::SetReportingEndpoint(const String& value) {
  m_result->SetReportingEndpoint(value);
  return *this;
}
template<int STATE>
inline CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE>& CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatusBuilder<STATE>::SetReportOnlyReportingEndpoint(const String& value) {
  m_result->SetReportOnlyReportingEndpoint(value);
  return *this;
}

inline CrossOriginEmbedderPolicyStatus::CrossOriginEmbedderPolicyStatus() {
}
inline ContentSecurityPolicyStatus::~ContentSecurityPolicyStatus() = default;
inline void ContentSecurityPolicyStatus::SetEffectiveDirectives(const String& value) { m_effectiveDirectives = value; }
inline void ContentSecurityPolicyStatus::SetIsEnforced(bool value) { m_isEnforced = value; }
inline void ContentSecurityPolicyStatus::SetSource(const String& value) { m_source = value; }

template<int STATE>
inline ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE | ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE>::EffectiveDirectivesSet>&
ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE>::SetEffectiveDirectives(const String& value) {
  static_assert(!(STATE & EffectiveDirectivesSet), "property effectiveDirectives should not be set yet");
  m_result->SetEffectiveDirectives(value);
  return castState<EffectiveDirectivesSet>();
}
template<int STATE>
inline ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE | ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE>::IsEnforcedSet>&
ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE>::SetIsEnforced(bool value) {
  static_assert(!(STATE & IsEnforcedSet), "property isEnforced should not be set yet");
  m_result->SetIsEnforced(value);
  return castState<IsEnforcedSet>();
}
template<int STATE>
inline ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE | ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE>::SourceSet>&
ContentSecurityPolicyStatus::ContentSecurityPolicyStatusBuilder<STATE>::SetSource(const String& value) {
  static_assert(!(STATE & SourceSet), "property source should not be set yet");
  m_result->SetSource(value);
  return castState<SourceSet>();
}

inline ContentSecurityPolicyStatus::ContentSecurityPolicyStatus() {
  m_isEnforced = false;
}
inline SecurityIsolationStatus::~SecurityIsolationStatus() = default;
inline void SecurityIsolationStatus::SetCoop(std::unique_ptr<protocol::Network::CrossOriginOpenerPolicyStatus> value) { m_coop = std::move(value); }
inline void SecurityIsolationStatus::SetCoep(std::unique_ptr<protocol::Network::CrossOriginEmbedderPolicyStatus> value) { m_coep = std::move(value); }
inline void SecurityIsolationStatus::SetCsp(std::unique_ptr<protocol::Array<protocol::Network::ContentSecurityPolicyStatus>> value) { m_csp = std::move(value); }

template<int STATE>
inline SecurityIsolationStatus::SecurityIsolationStatusBuilder<STATE>& SecurityIsolationStatus::SecurityIsolationStatusBuilder<STATE>::SetCoop(std::unique_ptr<protocol::Network::CrossOriginOpenerPolicyStatus> value) {
  m_result->SetCoop(std::move(value));
  return *this;
}
template<int STATE>
inline SecurityIsolationStatus::SecurityIsolationStatusBuilder<STATE>& SecurityIsolationStatus::SecurityIsolationStatusBuilder<STATE>::SetCoep(std::unique_ptr<protocol::Network::CrossOriginEmbedderPolicyStatus> value) {
  m_result->SetCoep(std::move(value));
  return *this;
}
template<int STATE>
inline SecurityIsolationStatus::SecurityIsolationStatusBuilder<STATE>& SecurityIsolationStatus::SecurityIsolationStatusBuilder<STATE>::SetCsp(std::unique_ptr<protocol::Array<protocol::Network::ContentSecurityPolicyStatus>> value) {
  m_result->SetCsp(std::move(value));
  return *this;
}

inline SecurityIsolationStatus::SecurityIsolationStatus() {
}
inline ReportingApiReport::~ReportingApiReport() = default;
inline void ReportingApiReport::SetId(const String& value) { m_id = value; }
inline void ReportingApiReport::SetInitiatorUrl(const String& value) { m_initiatorUrl = value; }
inline void ReportingApiReport::SetDestination(const String& value) { m_destination = value; }
inline void ReportingApiReport::SetType(const String& value) { m_type = value; }
inline void ReportingApiReport::SetTimestamp(double value) { m_timestamp = value; }
inline void ReportingApiReport::SetDepth(int value) { m_depth = value; }
inline void ReportingApiReport::SetCompletedAttempts(int value) { m_completedAttempts = value; }
inline void ReportingApiReport::SetBody(std::unique_ptr<protocol::DictionaryValue> value) { m_body = std::move(value); }
inline void ReportingApiReport::SetStatus(const String& value) { m_status = value; }

template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::IdSet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetId(const String& value) {
  static_assert(!(STATE & IdSet), "property id should not be set yet");
  m_result->SetId(value);
  return castState<IdSet>();
}
template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::InitiatorUrlSet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetInitiatorUrl(const String& value) {
  static_assert(!(STATE & InitiatorUrlSet), "property initiatorUrl should not be set yet");
  m_result->SetInitiatorUrl(value);
  return castState<InitiatorUrlSet>();
}
template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::DestinationSet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetDestination(const String& value) {
  static_assert(!(STATE & DestinationSet), "property destination should not be set yet");
  m_result->SetDestination(value);
  return castState<DestinationSet>();
}
template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::TypeSet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetType(const String& value) {
  static_assert(!(STATE & TypeSet), "property type should not be set yet");
  m_result->SetType(value);
  return castState<TypeSet>();
}
template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::TimestampSet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetTimestamp(double value) {
  static_assert(!(STATE & TimestampSet), "property timestamp should not be set yet");
  m_result->SetTimestamp(value);
  return castState<TimestampSet>();
}
template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::DepthSet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetDepth(int value) {
  static_assert(!(STATE & DepthSet), "property depth should not be set yet");
  m_result->SetDepth(value);
  return castState<DepthSet>();
}
template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::CompletedAttemptsSet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetCompletedAttempts(int value) {
  static_assert(!(STATE & CompletedAttemptsSet), "property completedAttempts should not be set yet");
  m_result->SetCompletedAttempts(value);
  return castState<CompletedAttemptsSet>();
}
template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::BodySet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetBody(std::unique_ptr<protocol::DictionaryValue> value) {
  static_assert(!(STATE & BodySet), "property body should not be set yet");
  m_result->SetBody(std::move(value));
  return castState<BodySet>();
}
template<int STATE>
inline ReportingApiReport::ReportingApiReportBuilder<STATE | ReportingApiReport::ReportingApiReportBuilder<STATE>::StatusSet>&
ReportingApiReport::ReportingApiReportBuilder<STATE>::SetStatus(const String& value) {
  static_assert(!(STATE & StatusSet), "property status should not be set yet");
  m_result->SetStatus(value);
  return castState<StatusSet>();
}

inline ReportingApiReport::ReportingApiReport() {
  m_timestamp = 0;
  m_depth = 0;
  m_completedAttempts = 0;
}
inline ReportingApiEndpoint::~ReportingApiEndpoint() = default;
inline void ReportingApiEndpoint::SetUrl(const String& value) { m_url = value; }
inline void ReportingApiEndpoint::SetGroupName(const String& value) { m_groupName = value; }

template<int STATE>
inline ReportingApiEndpoint::ReportingApiEndpointBuilder<STATE | ReportingApiEndpoint::ReportingApiEndpointBuilder<STATE>::UrlSet>&
ReportingApiEndpoint::ReportingApiEndpointBuilder<STATE>::SetUrl(const String& value) {
  static_assert(!(STATE & UrlSet), "property url should not be set yet");
  m_result->SetUrl(value);
  return castState<UrlSet>();
}
template<int STATE>
inline ReportingApiEndpoint::ReportingApiEndpointBuilder<STATE | ReportingApiEndpoint::ReportingApiEndpointBuilder<STATE>::GroupNameSet>&
ReportingApiEndpoint::ReportingApiEndpointBuilder<STATE>::SetGroupName(const String& value) {
  static_assert(!(STATE & GroupNameSet), "property groupName should not be set yet");
  m_result->SetGroupName(value);
  return castState<GroupNameSet>();
}

inline ReportingApiEndpoint::ReportingApiEndpoint() {
}
inline DeviceBoundSessionKey::~DeviceBoundSessionKey() = default;
inline void DeviceBoundSessionKey::SetSite(const String& value) { m_site = value; }
inline void DeviceBoundSessionKey::SetId(const String& value) { m_id = value; }

template<int STATE>
inline DeviceBoundSessionKey::DeviceBoundSessionKeyBuilder<STATE | DeviceBoundSessionKey::DeviceBoundSessionKeyBuilder<STATE>::SiteSet>&
DeviceBoundSessionKey::DeviceBoundSessionKeyBuilder<STATE>::SetSite(const String& value) {
  static_assert(!(STATE & SiteSet), "property site should not be set yet");
  m_result->SetSite(value);
  return castState<SiteSet>();
}
template<int STATE>
inline DeviceBoundSessionKey::DeviceBoundSessionKeyBuilder<STATE | DeviceBoundSessionKey::DeviceBoundSessionKeyBuilder<STATE>::IdSet>&
DeviceBoundSessionKey::DeviceBoundSessionKeyBuilder<STATE>::SetId(const String& value) {
  static_assert(!(STATE & IdSet), "property id should not be set yet");
  m_result->SetId(value);
  return castState<IdSet>();
}

inline DeviceBoundSessionKey::DeviceBoundSessionKey() {
}
inline DeviceBoundSessionWithUsage::~DeviceBoundSessionWithUsage() = default;
inline void DeviceBoundSessionWithUsage::SetSessionKey(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> value) { m_sessionKey = std::move(value); }
inline void DeviceBoundSessionWithUsage::SetUsage(const String& value) { m_usage = value; }

template<int STATE>
inline DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsageBuilder<STATE | DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsageBuilder<STATE>::SessionKeySet>&
DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsageBuilder<STATE>::SetSessionKey(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> value) {
  static_assert(!(STATE & SessionKeySet), "property sessionKey should not be set yet");
  m_result->SetSessionKey(std::move(value));
  return castState<SessionKeySet>();
}
template<int STATE>
inline DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsageBuilder<STATE | DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsageBuilder<STATE>::UsageSet>&
DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsageBuilder<STATE>::SetUsage(const String& value) {
  static_assert(!(STATE & UsageSet), "property usage should not be set yet");
  m_result->SetUsage(value);
  return castState<UsageSet>();
}

inline DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsage() {
}
inline DeviceBoundSessionCookieCraving::~DeviceBoundSessionCookieCraving() = default;
inline void DeviceBoundSessionCookieCraving::SetName(const String& value) { m_name = value; }
inline void DeviceBoundSessionCookieCraving::SetDomain(const String& value) { m_domain = value; }
inline void DeviceBoundSessionCookieCraving::SetPath(const String& value) { m_path = value; }
inline void DeviceBoundSessionCookieCraving::SetSecure(bool value) { m_secure = value; }
inline void DeviceBoundSessionCookieCraving::SetHttpOnly(bool value) { m_httpOnly = value; }
inline void DeviceBoundSessionCookieCraving::SetSameSite(const String& value) { m_sameSite = value; }

template<int STATE>
inline DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE | DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::NameSet>&
DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::SetName(const String& value) {
  static_assert(!(STATE & NameSet), "property name should not be set yet");
  m_result->SetName(value);
  return castState<NameSet>();
}
template<int STATE>
inline DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE | DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::DomainSet>&
DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::SetDomain(const String& value) {
  static_assert(!(STATE & DomainSet), "property domain should not be set yet");
  m_result->SetDomain(value);
  return castState<DomainSet>();
}
template<int STATE>
inline DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE | DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::PathSet>&
DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::SetPath(const String& value) {
  static_assert(!(STATE & PathSet), "property path should not be set yet");
  m_result->SetPath(value);
  return castState<PathSet>();
}
template<int STATE>
inline DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE | DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::SecureSet>&
DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::SetSecure(bool value) {
  static_assert(!(STATE & SecureSet), "property secure should not be set yet");
  m_result->SetSecure(value);
  return castState<SecureSet>();
}
template<int STATE>
inline DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE | DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::HttpOnlySet>&
DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::SetHttpOnly(bool value) {
  static_assert(!(STATE & HttpOnlySet), "property httpOnly should not be set yet");
  m_result->SetHttpOnly(value);
  return castState<HttpOnlySet>();
}
template<int STATE>
inline DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>& DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCravingBuilder<STATE>::SetSameSite(const String& value) {
  m_result->SetSameSite(value);
  return *this;
}

inline DeviceBoundSessionCookieCraving::DeviceBoundSessionCookieCraving() {
  m_secure = false;
  m_httpOnly = false;
}
inline DeviceBoundSessionUrlRule::~DeviceBoundSessionUrlRule() = default;
inline void DeviceBoundSessionUrlRule::SetRuleType(const String& value) { m_ruleType = value; }
inline void DeviceBoundSessionUrlRule::SetHostPattern(const String& value) { m_hostPattern = value; }
inline void DeviceBoundSessionUrlRule::SetPathPrefix(const String& value) { m_pathPrefix = value; }

template<int STATE>
inline DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE | DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE>::RuleTypeSet>&
DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE>::SetRuleType(const String& value) {
  static_assert(!(STATE & RuleTypeSet), "property ruleType should not be set yet");
  m_result->SetRuleType(value);
  return castState<RuleTypeSet>();
}
template<int STATE>
inline DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE | DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE>::HostPatternSet>&
DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE>::SetHostPattern(const String& value) {
  static_assert(!(STATE & HostPatternSet), "property hostPattern should not be set yet");
  m_result->SetHostPattern(value);
  return castState<HostPatternSet>();
}
template<int STATE>
inline DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE | DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE>::PathPrefixSet>&
DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRuleBuilder<STATE>::SetPathPrefix(const String& value) {
  static_assert(!(STATE & PathPrefixSet), "property pathPrefix should not be set yet");
  m_result->SetPathPrefix(value);
  return castState<PathPrefixSet>();
}

inline DeviceBoundSessionUrlRule::DeviceBoundSessionUrlRule() {
}
inline DeviceBoundSessionInclusionRules::~DeviceBoundSessionInclusionRules() = default;
inline void DeviceBoundSessionInclusionRules::SetOrigin(const String& value) { m_origin = value; }
inline void DeviceBoundSessionInclusionRules::SetIncludeSite(bool value) { m_includeSite = value; }
inline void DeviceBoundSessionInclusionRules::SetUrlRules(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionUrlRule>> value) { m_urlRules = std::move(value); }

template<int STATE>
inline DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE | DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE>::OriginSet>&
DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE>::SetOrigin(const String& value) {
  static_assert(!(STATE & OriginSet), "property origin should not be set yet");
  m_result->SetOrigin(value);
  return castState<OriginSet>();
}
template<int STATE>
inline DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE | DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE>::IncludeSiteSet>&
DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE>::SetIncludeSite(bool value) {
  static_assert(!(STATE & IncludeSiteSet), "property includeSite should not be set yet");
  m_result->SetIncludeSite(value);
  return castState<IncludeSiteSet>();
}
template<int STATE>
inline DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE | DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE>::UrlRulesSet>&
DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRulesBuilder<STATE>::SetUrlRules(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionUrlRule>> value) {
  static_assert(!(STATE & UrlRulesSet), "property urlRules should not be set yet");
  m_result->SetUrlRules(std::move(value));
  return castState<UrlRulesSet>();
}

inline DeviceBoundSessionInclusionRules::DeviceBoundSessionInclusionRules() {
  m_includeSite = false;
}
inline DeviceBoundSession::~DeviceBoundSession() = default;
inline void DeviceBoundSession::SetKey(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> value) { m_key = std::move(value); }
inline void DeviceBoundSession::SetRefreshUrl(const String& value) { m_refreshUrl = value; }
inline void DeviceBoundSession::SetInclusionRules(std::unique_ptr<protocol::Network::DeviceBoundSessionInclusionRules> value) { m_inclusionRules = std::move(value); }
inline void DeviceBoundSession::SetCookieCravings(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionCookieCraving>> value) { m_cookieCravings = std::move(value); }
inline void DeviceBoundSession::SetExpiryDate(double value) { m_expiryDate = value; }
inline void DeviceBoundSession::SetCachedChallenge(const String& value) { m_cachedChallenge = value; }
inline void DeviceBoundSession::SetAllowedRefreshInitiators(std::unique_ptr<protocol::Array<String>> value) { m_allowedRefreshInitiators = std::move(value); }

template<int STATE>
inline DeviceBoundSession::DeviceBoundSessionBuilder<STATE | DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::KeySet>&
DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::SetKey(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> value) {
  static_assert(!(STATE & KeySet), "property key should not be set yet");
  m_result->SetKey(std::move(value));
  return castState<KeySet>();
}
template<int STATE>
inline DeviceBoundSession::DeviceBoundSessionBuilder<STATE | DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::RefreshUrlSet>&
DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::SetRefreshUrl(const String& value) {
  static_assert(!(STATE & RefreshUrlSet), "property refreshUrl should not be set yet");
  m_result->SetRefreshUrl(value);
  return castState<RefreshUrlSet>();
}
template<int STATE>
inline DeviceBoundSession::DeviceBoundSessionBuilder<STATE | DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::InclusionRulesSet>&
DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::SetInclusionRules(std::unique_ptr<protocol::Network::DeviceBoundSessionInclusionRules> value) {
  static_assert(!(STATE & InclusionRulesSet), "property inclusionRules should not be set yet");
  m_result->SetInclusionRules(std::move(value));
  return castState<InclusionRulesSet>();
}
template<int STATE>
inline DeviceBoundSession::DeviceBoundSessionBuilder<STATE | DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::CookieCravingsSet>&
DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::SetCookieCravings(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionCookieCraving>> value) {
  static_assert(!(STATE & CookieCravingsSet), "property cookieCravings should not be set yet");
  m_result->SetCookieCravings(std::move(value));
  return castState<CookieCravingsSet>();
}
template<int STATE>
inline DeviceBoundSession::DeviceBoundSessionBuilder<STATE | DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::ExpiryDateSet>&
DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::SetExpiryDate(double value) {
  static_assert(!(STATE & ExpiryDateSet), "property expiryDate should not be set yet");
  m_result->SetExpiryDate(value);
  return castState<ExpiryDateSet>();
}
template<int STATE>
inline DeviceBoundSession::DeviceBoundSessionBuilder<STATE>& DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::SetCachedChallenge(const String& value) {
  m_result->SetCachedChallenge(value);
  return *this;
}
template<int STATE>
inline DeviceBoundSession::DeviceBoundSessionBuilder<STATE | DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::AllowedRefreshInitiatorsSet>&
DeviceBoundSession::DeviceBoundSessionBuilder<STATE>::SetAllowedRefreshInitiators(std::unique_ptr<protocol::Array<String>> value) {
  static_assert(!(STATE & AllowedRefreshInitiatorsSet), "property allowedRefreshInitiators should not be set yet");
  m_result->SetAllowedRefreshInitiators(std::move(value));
  return castState<AllowedRefreshInitiatorsSet>();
}

inline DeviceBoundSession::DeviceBoundSession() {
  m_expiryDate = 0;
}
inline DeviceBoundSessionFailedRequest::~DeviceBoundSessionFailedRequest() = default;
inline void DeviceBoundSessionFailedRequest::SetRequestUrl(const String& value) { m_requestUrl = value; }
inline void DeviceBoundSessionFailedRequest::SetNetError(const String& value) { m_netError = value; }
inline void DeviceBoundSessionFailedRequest::SetResponseError(int value) { m_responseError = value; }
inline void DeviceBoundSessionFailedRequest::SetResponseErrorBody(const String& value) { m_responseErrorBody = value; }

template<int STATE>
inline DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE | DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE>::RequestUrlSet>&
DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE>::SetRequestUrl(const String& value) {
  static_assert(!(STATE & RequestUrlSet), "property requestUrl should not be set yet");
  m_result->SetRequestUrl(value);
  return castState<RequestUrlSet>();
}
template<int STATE>
inline DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE>& DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE>::SetNetError(const String& value) {
  m_result->SetNetError(value);
  return *this;
}
template<int STATE>
inline DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE>& DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE>::SetResponseError(int value) {
  m_result->SetResponseError(value);
  return *this;
}
template<int STATE>
inline DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE>& DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequestBuilder<STATE>::SetResponseErrorBody(const String& value) {
  m_result->SetResponseErrorBody(value);
  return *this;
}

inline DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequest() {
}
inline CreationEventDetails::~CreationEventDetails() = default;
inline void CreationEventDetails::SetFetchResult(const String& value) { m_fetchResult = value; }
inline void CreationEventDetails::SetNewSession(std::unique_ptr<protocol::Network::DeviceBoundSession> value) { m_newSession = std::move(value); }
inline void CreationEventDetails::SetFailedRequest(std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> value) { m_failedRequest = std::move(value); }

template<int STATE>
inline CreationEventDetails::CreationEventDetailsBuilder<STATE | CreationEventDetails::CreationEventDetailsBuilder<STATE>::FetchResultSet>&
CreationEventDetails::CreationEventDetailsBuilder<STATE>::SetFetchResult(const String& value) {
  static_assert(!(STATE & FetchResultSet), "property fetchResult should not be set yet");
  m_result->SetFetchResult(value);
  return castState<FetchResultSet>();
}
template<int STATE>
inline CreationEventDetails::CreationEventDetailsBuilder<STATE>& CreationEventDetails::CreationEventDetailsBuilder<STATE>::SetNewSession(std::unique_ptr<protocol::Network::DeviceBoundSession> value) {
  m_result->SetNewSession(std::move(value));
  return *this;
}
template<int STATE>
inline CreationEventDetails::CreationEventDetailsBuilder<STATE>& CreationEventDetails::CreationEventDetailsBuilder<STATE>::SetFailedRequest(std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> value) {
  m_result->SetFailedRequest(std::move(value));
  return *this;
}

inline CreationEventDetails::CreationEventDetails() {
}
inline RefreshEventDetails::~RefreshEventDetails() = default;
inline void RefreshEventDetails::SetRefreshResult(const String& value) { m_refreshResult = value; }
inline void RefreshEventDetails::SetFetchResult(const String& value) { m_fetchResult = value; }
inline void RefreshEventDetails::SetNewSession(std::unique_ptr<protocol::Network::DeviceBoundSession> value) { m_newSession = std::move(value); }
inline void RefreshEventDetails::SetWasFullyProactiveRefresh(bool value) { m_wasFullyProactiveRefresh = value; }
inline void RefreshEventDetails::SetFailedRequest(std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> value) { m_failedRequest = std::move(value); }

template<int STATE>
inline RefreshEventDetails::RefreshEventDetailsBuilder<STATE | RefreshEventDetails::RefreshEventDetailsBuilder<STATE>::RefreshResultSet>&
RefreshEventDetails::RefreshEventDetailsBuilder<STATE>::SetRefreshResult(const String& value) {
  static_assert(!(STATE & RefreshResultSet), "property refreshResult should not be set yet");
  m_result->SetRefreshResult(value);
  return castState<RefreshResultSet>();
}
template<int STATE>
inline RefreshEventDetails::RefreshEventDetailsBuilder<STATE>& RefreshEventDetails::RefreshEventDetailsBuilder<STATE>::SetFetchResult(const String& value) {
  m_result->SetFetchResult(value);
  return *this;
}
template<int STATE>
inline RefreshEventDetails::RefreshEventDetailsBuilder<STATE>& RefreshEventDetails::RefreshEventDetailsBuilder<STATE>::SetNewSession(std::unique_ptr<protocol::Network::DeviceBoundSession> value) {
  m_result->SetNewSession(std::move(value));
  return *this;
}
template<int STATE>
inline RefreshEventDetails::RefreshEventDetailsBuilder<STATE | RefreshEventDetails::RefreshEventDetailsBuilder<STATE>::WasFullyProactiveRefreshSet>&
RefreshEventDetails::RefreshEventDetailsBuilder<STATE>::SetWasFullyProactiveRefresh(bool value) {
  static_assert(!(STATE & WasFullyProactiveRefreshSet), "property wasFullyProactiveRefresh should not be set yet");
  m_result->SetWasFullyProactiveRefresh(value);
  return castState<WasFullyProactiveRefreshSet>();
}
template<int STATE>
inline RefreshEventDetails::RefreshEventDetailsBuilder<STATE>& RefreshEventDetails::RefreshEventDetailsBuilder<STATE>::SetFailedRequest(std::unique_ptr<protocol::Network::DeviceBoundSessionFailedRequest> value) {
  m_result->SetFailedRequest(std::move(value));
  return *this;
}

inline RefreshEventDetails::RefreshEventDetails() {
  m_wasFullyProactiveRefresh = false;
}
inline TerminationEventDetails::~TerminationEventDetails() = default;
inline void TerminationEventDetails::SetDeletionReason(const String& value) { m_deletionReason = value; }

template<int STATE>
inline TerminationEventDetails::TerminationEventDetailsBuilder<STATE | TerminationEventDetails::TerminationEventDetailsBuilder<STATE>::DeletionReasonSet>&
TerminationEventDetails::TerminationEventDetailsBuilder<STATE>::SetDeletionReason(const String& value) {
  static_assert(!(STATE & DeletionReasonSet), "property deletionReason should not be set yet");
  m_result->SetDeletionReason(value);
  return castState<DeletionReasonSet>();
}

inline TerminationEventDetails::TerminationEventDetails() {
}
inline ChallengeEventDetails::~ChallengeEventDetails() = default;
inline void ChallengeEventDetails::SetChallengeResult(const String& value) { m_challengeResult = value; }
inline void ChallengeEventDetails::SetChallenge(const String& value) { m_challenge = value; }

template<int STATE>
inline ChallengeEventDetails::ChallengeEventDetailsBuilder<STATE | ChallengeEventDetails::ChallengeEventDetailsBuilder<STATE>::ChallengeResultSet>&
ChallengeEventDetails::ChallengeEventDetailsBuilder<STATE>::SetChallengeResult(const String& value) {
  static_assert(!(STATE & ChallengeResultSet), "property challengeResult should not be set yet");
  m_result->SetChallengeResult(value);
  return castState<ChallengeResultSet>();
}
template<int STATE>
inline ChallengeEventDetails::ChallengeEventDetailsBuilder<STATE | ChallengeEventDetails::ChallengeEventDetailsBuilder<STATE>::ChallengeSet>&
ChallengeEventDetails::ChallengeEventDetailsBuilder<STATE>::SetChallenge(const String& value) {
  static_assert(!(STATE & ChallengeSet), "property challenge should not be set yet");
  m_result->SetChallenge(value);
  return castState<ChallengeSet>();
}

inline ChallengeEventDetails::ChallengeEventDetails() {
}
inline LoadNetworkResourcePageResult::~LoadNetworkResourcePageResult() = default;
inline void LoadNetworkResourcePageResult::SetSuccess(bool value) { m_success = value; }
inline void LoadNetworkResourcePageResult::SetNetError(double value) { m_netError = value; }
inline void LoadNetworkResourcePageResult::SetNetErrorName(const String& value) { m_netErrorName = value; }
inline void LoadNetworkResourcePageResult::SetHttpStatusCode(double value) { m_httpStatusCode = value; }
inline void LoadNetworkResourcePageResult::SetStream(const String& value) { m_stream = value; }
inline void LoadNetworkResourcePageResult::SetHeaders(std::unique_ptr<protocol::Network::Headers> value) { m_headers = std::move(value); }

template<int STATE>
inline LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE | LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>::SuccessSet>&
LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>::SetSuccess(bool value) {
  static_assert(!(STATE & SuccessSet), "property success should not be set yet");
  m_result->SetSuccess(value);
  return castState<SuccessSet>();
}
template<int STATE>
inline LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>& LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>::SetNetError(double value) {
  m_result->SetNetError(value);
  return *this;
}
template<int STATE>
inline LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>& LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>::SetNetErrorName(const String& value) {
  m_result->SetNetErrorName(value);
  return *this;
}
template<int STATE>
inline LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>& LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>::SetHttpStatusCode(double value) {
  m_result->SetHttpStatusCode(value);
  return *this;
}
template<int STATE>
inline LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>& LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>::SetStream(const String& value) {
  m_result->SetStream(value);
  return *this;
}
template<int STATE>
inline LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>& LoadNetworkResourcePageResult::LoadNetworkResourcePageResultBuilder<STATE>::SetHeaders(std::unique_ptr<protocol::Network::Headers> value) {
  m_result->SetHeaders(std::move(value));
  return *this;
}

inline LoadNetworkResourcePageResult::LoadNetworkResourcePageResult() {
  m_success = false;
}
inline LoadNetworkResourceOptions::~LoadNetworkResourceOptions() = default;
inline void LoadNetworkResourceOptions::SetDisableCache(bool value) { m_disableCache = value; }
inline void LoadNetworkResourceOptions::SetIncludeCredentials(bool value) { m_includeCredentials = value; }

template<int STATE>
inline LoadNetworkResourceOptions::LoadNetworkResourceOptionsBuilder<STATE | LoadNetworkResourceOptions::LoadNetworkResourceOptionsBuilder<STATE>::DisableCacheSet>&
LoadNetworkResourceOptions::LoadNetworkResourceOptionsBuilder<STATE>::SetDisableCache(bool value) {
  static_assert(!(STATE & DisableCacheSet), "property disableCache should not be set yet");
  m_result->SetDisableCache(value);
  return castState<DisableCacheSet>();
}
template<int STATE>
inline LoadNetworkResourceOptions::LoadNetworkResourceOptionsBuilder<STATE | LoadNetworkResourceOptions::LoadNetworkResourceOptionsBuilder<STATE>::IncludeCredentialsSet>&
LoadNetworkResourceOptions::LoadNetworkResourceOptionsBuilder<STATE>::SetIncludeCredentials(bool value) {
  static_assert(!(STATE & IncludeCredentialsSet), "property includeCredentials should not be set yet");
  m_result->SetIncludeCredentials(value);
  return castState<IncludeCredentialsSet>();
}

inline LoadNetworkResourceOptions::LoadNetworkResourceOptions() {
  m_disableCache = false;
  m_includeCredentials = false;
}

// ------------- Backend interface.

class CONTENT_EXPORT Backend {
public:
    virtual ~Backend() { }

    virtual DispatchResponse CanEmulateNetworkConditions(bool* out_result) = 0;
    class CONTENT_EXPORT ClearBrowserCacheCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~ClearBrowserCacheCallback() { }
    };
    virtual void ClearBrowserCache(std::unique_ptr<ClearBrowserCacheCallback> callback) = 0;
    class CONTENT_EXPORT ClearBrowserCookiesCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~ClearBrowserCookiesCallback() { }
    };
    virtual void ClearBrowserCookies(std::unique_ptr<ClearBrowserCookiesCallback> callback) = 0;
    class CONTENT_EXPORT DeleteCookiesCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~DeleteCookiesCallback() { }
    };
    virtual void DeleteCookies(const String& in_name, std::optional<String> in_url, std::optional<String> in_domain, std::optional<String> in_path, std::unique_ptr<protocol::Network::CookiePartitionKey> in_partitionKey, std::unique_ptr<DeleteCookiesCallback> callback) = 0;
    virtual DispatchResponse Disable() = 0;
    virtual DispatchResponse EmulateNetworkConditions(bool in_offline, double in_latency, double in_downloadThroughput, double in_uploadThroughput, std::optional<String> in_connectionType, std::optional<double> in_packetLoss, std::optional<int> in_packetQueueLength, std::optional<bool> in_packetReordering) = 0;
    virtual DispatchResponse EmulateNetworkConditionsByRule(std::optional<bool> in_offline, std::optional<bool> in_emulateOfflineServiceWorker, std::unique_ptr<protocol::Array<protocol::Network::NetworkConditions>> in_matchedNetworkConditions, std::unique_ptr<protocol::Array<String>>* out_ruleIds) = 0;
    virtual DispatchResponse Enable(std::optional<int> in_maxTotalBufferSize, std::optional<int> in_maxResourceBufferSize, std::optional<int> in_maxPostDataSize, std::optional<bool> in_reportDirectSocketTraffic, std::optional<bool> in_enableDurableMessages) = 0;
    class CONTENT_EXPORT ConfigureDurableMessagesCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~ConfigureDurableMessagesCallback() { }
    };
    virtual void ConfigureDurableMessages(std::optional<int> in_maxTotalBufferSize, std::optional<int> in_maxResourceBufferSize, std::unique_ptr<ConfigureDurableMessagesCallback> callback) = 0;
    class CONTENT_EXPORT GetAllCookiesCallback {
    public:
        virtual void sendSuccess(std::unique_ptr<protocol::Array<protocol::Network::Cookie>> cookies) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~GetAllCookiesCallback() { }
    };
    virtual void GetAllCookies(std::unique_ptr<GetAllCookiesCallback> callback) = 0;
    class CONTENT_EXPORT GetCookiesCallback {
    public:
        virtual void sendSuccess(std::unique_ptr<protocol::Array<protocol::Network::Cookie>> cookies) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~GetCookiesCallback() { }
    };
    virtual void GetCookies(std::unique_ptr<protocol::Array<String>> in_urls, std::unique_ptr<GetCookiesCallback> callback) = 0;
    class CONTENT_EXPORT GetResponseBodyCallback {
    public:
        virtual void sendSuccess(const String& body, bool base64Encoded) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~GetResponseBodyCallback() { }
    };
    virtual void GetResponseBody(const String& in_requestId, std::unique_ptr<GetResponseBodyCallback> callback) = 0;
    virtual DispatchResponse SetBypassServiceWorker(bool in_bypass) = 0;
    virtual DispatchResponse SetCacheDisabled(bool in_cacheDisabled) = 0;
    class CONTENT_EXPORT SetCookieCallback {
    public:
        virtual void sendSuccess(bool success) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~SetCookieCallback() { }
    };
    virtual void SetCookie(const String& in_name, const String& in_value, std::optional<String> in_url, std::optional<String> in_domain, std::optional<String> in_path, std::optional<bool> in_secure, std::optional<bool> in_httpOnly, std::optional<String> in_sameSite, std::optional<double> in_expires, std::optional<String> in_priority, std::optional<String> in_sourceScheme, std::optional<int> in_sourcePort, std::unique_ptr<protocol::Network::CookiePartitionKey> in_partitionKey, std::unique_ptr<SetCookieCallback> callback) = 0;
    class CONTENT_EXPORT SetCookiesCallback {
    public:
        virtual void sendSuccess() = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~SetCookiesCallback() { }
    };
    virtual void SetCookies(std::unique_ptr<protocol::Array<protocol::Network::CookieParam>> in_cookies, std::unique_ptr<SetCookiesCallback> callback) = 0;
    virtual DispatchResponse SetExtraHTTPHeaders(std::unique_ptr<protocol::Network::Headers> in_headers) = 0;
    virtual DispatchResponse GetSecurityIsolationStatus(std::optional<String> in_frameId, std::unique_ptr<protocol::Network::SecurityIsolationStatus>* out_status) = 0;
    virtual DispatchResponse EnableReportingApi(bool in_enable) = 0;
    virtual DispatchResponse EnableDeviceBoundSessions(bool in_enable) = 0;
    virtual DispatchResponse DeleteDeviceBoundSession(std::unique_ptr<protocol::Network::DeviceBoundSessionKey> in_key) = 0;
    virtual DispatchResponse FetchSchemefulSite(const String& in_origin, String* out_schemefulSite) = 0;
    class CONTENT_EXPORT LoadNetworkResourceCallback {
    public:
        virtual void sendSuccess(std::unique_ptr<protocol::Network::LoadNetworkResourcePageResult> resource) = 0;
        virtual void sendFailure(const DispatchResponse&) = 0;
        virtual void fallThrough() = 0;
        virtual ~LoadNetworkResourceCallback() { }
    };
    virtual void LoadNetworkResource(std::optional<String> in_frameId, const String& in_url, std::unique_ptr<protocol::Network::LoadNetworkResourceOptions> in_options, std::unique_ptr<LoadNetworkResourceCallback> callback) = 0;
    virtual DispatchResponse SetCookieControls(bool in_enableThirdPartyCookieRestriction) = 0;

};

// ------------- Frontend interface.

class CONTENT_EXPORT Frontend {
public:
  explicit Frontend(FrontendChannel* frontend_channel) : frontend_channel_(frontend_channel) {}
    void LoadingFailed(const String& requestId, double timestamp, const String& type, const String& errorText, std::optional<bool> canceled = {}, std::optional<String> blockedReason = {}, std::unique_ptr<protocol::Network::CorsErrorStatus> corsErrorStatus = {});
    void LoadingFinished(const String& requestId, double timestamp, double encodedDataLength);
    void RequestWillBeSent(const String& requestId, const String& loaderId, const String& documentURL, std::unique_ptr<protocol::Network::Request> request, double timestamp, double wallTime, std::unique_ptr<protocol::Network::Initiator> initiator, bool redirectHasExtraInfo, std::unique_ptr<protocol::Network::Response> redirectResponse = {}, std::optional<String> type = {}, std::optional<String> frameId = {}, std::optional<bool> hasUserGesture = {}, std::optional<String> renderBlockingBehavior = {});
    void SignedExchangeReceived(const String& requestId, std::unique_ptr<protocol::Network::SignedExchangeInfo> info);
    void ResponseReceived(const String& requestId, const String& loaderId, double timestamp, const String& type, std::unique_ptr<protocol::Network::Response> response, bool hasExtraInfo, std::optional<String> frameId = {});
    void RequestWillBeSentExtraInfo(const String& requestId, std::unique_ptr<protocol::Array<protocol::Network::AssociatedCookie>> associatedCookies, std::unique_ptr<protocol::Network::Headers> headers, std::unique_ptr<protocol::Network::ConnectTiming> connectTiming, std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSessionWithUsage>> deviceBoundSessionUsages = {}, std::unique_ptr<protocol::Network::ClientSecurityState> clientSecurityState = {}, std::optional<bool> siteHasCookieInOtherPartition = {}, std::optional<String> appliedNetworkConditionsId = {});
    void ResponseReceivedExtraInfo(const String& requestId, std::unique_ptr<protocol::Array<protocol::Network::BlockedSetCookieWithReason>> blockedCookies, std::unique_ptr<protocol::Network::Headers> headers, const String& resourceIPAddressSpace, int statusCode, std::optional<String> headersText = {}, std::unique_ptr<protocol::Network::CookiePartitionKey> cookiePartitionKey = {}, std::optional<bool> cookiePartitionKeyOpaque = {}, std::unique_ptr<protocol::Array<protocol::Network::ExemptedSetCookieWithReason>> exemptedCookies = {});
    void ResponseReceivedEarlyHints(const String& requestId, std::unique_ptr<protocol::Network::Headers> headers);
    void TrustTokenOperationDone(const String& status, const String& type, const String& requestId, std::optional<String> topLevelOrigin = {}, std::optional<String> issuerOrigin = {}, std::optional<int> issuedTokenCount = {});
    void PolicyUpdated();
    void ReportingApiReportAdded(std::unique_ptr<protocol::Network::ReportingApiReport> report);
    void ReportingApiReportUpdated(std::unique_ptr<protocol::Network::ReportingApiReport> report);
    void ReportingApiEndpointsChangedForOrigin(const String& origin, std::unique_ptr<protocol::Array<protocol::Network::ReportingApiEndpoint>> endpoints);
    void DeviceBoundSessionsAdded(std::unique_ptr<protocol::Array<protocol::Network::DeviceBoundSession>> sessions);
    void DeviceBoundSessionEventOccurred(const String& eventId, const String& site, bool succeeded, std::optional<String> sessionId = {}, std::unique_ptr<protocol::Network::CreationEventDetails> creationEventDetails = {}, std::unique_ptr<protocol::Network::RefreshEventDetails> refreshEventDetails = {}, std::unique_ptr<protocol::Network::TerminationEventDetails> terminationEventDetails = {}, std::unique_ptr<protocol::Network::ChallengeEventDetails> challengeEventDetails = {});

  void flush();
  void sendRawNotification(std::unique_ptr<Serializable>);
 private:
  FrontendChannel* frontend_channel_;
};

// ------------- Dispatcher.

class CONTENT_EXPORT Dispatcher {
public:
    static void wire(UberDispatcher*, Backend*);

private:
    Dispatcher() { }
};

// ------------- Metainfo.

class CONTENT_EXPORT Metainfo {
public:
    using BackendClass = Backend;
    using FrontendClass = Frontend;
    using DispatcherClass = Dispatcher;
    static const char domainName[];
    static const char commandPrefix[];
    static const char version[];
};

} // namespace Network
} // namespace content
} // namespace protocol

#endif // !defined(content_protocol_Network_h)