//
// Automatically generated by ipdlc.
// Edit at your own risk
//

#ifndef NeckoChannelParams_h
#define NeckoChannelParams_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/FeaturePolicy.h"
#include "mozilla/dom/LoadURIOptionsBinding.h"
#include "mozilla/dom/RequestBinding.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/UserNavigationInvolvement.h"
#include "mozilla/ipc/BackgroundUtils.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/net/PHttpChannelParams.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsICacheInfoChannel.h"
#include "nsIContentPolicy.h"
#include "nsILoadInfo.h"
#include "nsIPropertyBag2.h"
#include "nsNetUtil.h"
#include "nsRFPService.h"
#include "mozilla/dom/ClientIPCTypes.h"
#include "mozilla/ipc/URIParams.h"
#include "mozilla/dom/IPCServiceWorkerDescriptor.h"
#include "mozilla/ipc/IPCStream.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "mozilla/dom/DOMTypes.h"
#include "mozilla/ipc/ProtocolTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CookiePermissionData|
//
namespace mozilla {
namespace net {
class CookiePermissionData final
{
private:
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    CookiePermissionData() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT CookiePermissionData(
            const PrincipalInfo& _principalInfo,
            const uint32_t& _cookiePermission) :
        principalInfo_(_principalInfo),
        cookiePermission_(_cookiePermission)
    {
    }

    MOZ_IMPLICIT CookiePermissionData(
            PrincipalInfo&& _principalInfo,
            uint32_t&& _cookiePermission) :
        principalInfo_(std::move(_principalInfo)),
        cookiePermission_(std::move(_cookiePermission))
    {
    }

    PrincipalInfo&
    principalInfo()
    {
        return principalInfo_;
    }
    const PrincipalInfo&
    principalInfo() const
    {
        return principalInfo_;
    }

    uint32_t&
    cookiePermission()
    {
        return cookiePermission_;
    }
    const uint32_t&
    cookiePermission() const
    {
        return cookiePermission_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> cookiePermission_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookiePermissionData>
{
    typedef ::mozilla::net::CookiePermissionData paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CookieJarSettingsArgs|
//
namespace mozilla {
namespace net {
class CookieJarSettingsArgs final
{
private:
    typedef ::uint32_t uint32_t;
    typedef ::mozilla::net::CookiePermissionData CookiePermissionData;
    typedef ::nsString nsString;
    typedef ::uint8_t uint8_t;
    typedef ::uint64_t uint64_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    CookieJarSettingsArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT CookieJarSettingsArgs(
            const uint32_t& _cookieBehavior,
            const bool& _isFirstPartyIsolated,
            const bool& _shouldResistFingerprinting,
            const bool& _isOnContentBlockingAllowList,
            const nsTArray<CookiePermissionData>& _cookiePermissions,
            const bool& _isFixed,
            const nsString& _partitionKey,
            const bool& _hasFingerprintingRandomizationKey,
            const nsTArray<uint8_t>& _fingerprintingRandomizationKey,
            const uint64_t& _topLevelWindowContextId) :
        isFirstPartyIsolated_(_isFirstPartyIsolated),
        shouldResistFingerprinting_(_shouldResistFingerprinting),
        isOnContentBlockingAllowList_(_isOnContentBlockingAllowList),
        cookiePermissions_(_cookiePermissions),
        isFixed_(_isFixed),
        partitionKey_(_partitionKey),
        hasFingerprintingRandomizationKey_(_hasFingerprintingRandomizationKey),
        fingerprintingRandomizationKey_(_fingerprintingRandomizationKey),
        topLevelWindowContextId_(_topLevelWindowContextId),
        cookieBehavior_(_cookieBehavior)
    {
    }

    MOZ_IMPLICIT CookieJarSettingsArgs(
            uint32_t&& _cookieBehavior,
            bool&& _isFirstPartyIsolated,
            bool&& _shouldResistFingerprinting,
            bool&& _isOnContentBlockingAllowList,
            nsTArray<CookiePermissionData>&& _cookiePermissions,
            bool&& _isFixed,
            nsString&& _partitionKey,
            bool&& _hasFingerprintingRandomizationKey,
            nsTArray<uint8_t>&& _fingerprintingRandomizationKey,
            uint64_t&& _topLevelWindowContextId) :
        isFirstPartyIsolated_(std::move(_isFirstPartyIsolated)),
        shouldResistFingerprinting_(std::move(_shouldResistFingerprinting)),
        isOnContentBlockingAllowList_(std::move(_isOnContentBlockingAllowList)),
        cookiePermissions_(std::move(_cookiePermissions)),
        isFixed_(std::move(_isFixed)),
        partitionKey_(std::move(_partitionKey)),
        hasFingerprintingRandomizationKey_(std::move(_hasFingerprintingRandomizationKey)),
        fingerprintingRandomizationKey_(std::move(_fingerprintingRandomizationKey)),
        topLevelWindowContextId_(std::move(_topLevelWindowContextId)),
        cookieBehavior_(std::move(_cookieBehavior))
    {
    }

    uint32_t&
    cookieBehavior()
    {
        return cookieBehavior_;
    }
    const uint32_t&
    cookieBehavior() const
    {
        return cookieBehavior_;
    }

    bool&
    isFirstPartyIsolated()
    {
        return isFirstPartyIsolated_;
    }
    const bool&
    isFirstPartyIsolated() const
    {
        return isFirstPartyIsolated_;
    }

    bool&
    shouldResistFingerprinting()
    {
        return shouldResistFingerprinting_;
    }
    const bool&
    shouldResistFingerprinting() const
    {
        return shouldResistFingerprinting_;
    }

    bool&
    isOnContentBlockingAllowList()
    {
        return isOnContentBlockingAllowList_;
    }
    const bool&
    isOnContentBlockingAllowList() const
    {
        return isOnContentBlockingAllowList_;
    }

    nsTArray<CookiePermissionData>&
    cookiePermissions()
    {
        return cookiePermissions_;
    }
    const nsTArray<CookiePermissionData>&
    cookiePermissions() const
    {
        return cookiePermissions_;
    }

    bool&
    isFixed()
    {
        return isFixed_;
    }
    const bool&
    isFixed() const
    {
        return isFixed_;
    }

    nsString&
    partitionKey()
    {
        return partitionKey_;
    }
    const nsString&
    partitionKey() const
    {
        return partitionKey_;
    }

    bool&
    hasFingerprintingRandomizationKey()
    {
        return hasFingerprintingRandomizationKey_;
    }
    const bool&
    hasFingerprintingRandomizationKey() const
    {
        return hasFingerprintingRandomizationKey_;
    }

    nsTArray<uint8_t>&
    fingerprintingRandomizationKey()
    {
        return fingerprintingRandomizationKey_;
    }
    const nsTArray<uint8_t>&
    fingerprintingRandomizationKey() const
    {
        return fingerprintingRandomizationKey_;
    }

    uint64_t&
    topLevelWindowContextId()
    {
        return topLevelWindowContextId_;
    }
    const uint64_t&
    topLevelWindowContextId() const
    {
        return topLevelWindowContextId_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> isFirstPartyIsolated_;
    ::mozilla::ipc::IPDLStructMember<bool> shouldResistFingerprinting_;
    ::mozilla::ipc::IPDLStructMember<bool> isOnContentBlockingAllowList_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<CookiePermissionData>> cookiePermissions_;
    ::mozilla::ipc::IPDLStructMember<bool> isFixed_;
    ::mozilla::ipc::IPDLStructMember<nsString> partitionKey_;
    ::mozilla::ipc::IPDLStructMember<bool> hasFingerprintingRandomizationKey_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> fingerprintingRandomizationKey_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> topLevelWindowContextId_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> cookieBehavior_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookieJarSettingsArgs>
{
    typedef ::mozilla::net::CookieJarSettingsArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CookieStruct|
//
namespace mozilla {
namespace net {
class CookieStruct final
{
private:
    typedef ::nsCString nsCString;
    typedef ::int64_t int64_t;
    typedef ::int32_t int32_t;
    typedef ::uint8_t uint8_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    CookieStruct() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT CookieStruct(
            const nsCString& _name,
            const nsCString& _value,
            const nsCString& _host,
            const nsCString& _path,
            const int64_t& _expiryInMSec,
            const int64_t& _lastAccessedInUSec,
            const int64_t& _creationTimeInUSec,
            const int64_t& _updateTimeInUSec,
            const bool& _isHttpOnly,
            const bool& _isSession,
            const bool& _isSecure,
            const bool& _isPartitioned,
            const int32_t& _sameSite,
            const uint8_t& _schemeMap) :
        name_(_name),
        value_(_value),
        host_(_host),
        path_(_path),
        isHttpOnly_(_isHttpOnly),
        isSession_(_isSession),
        isSecure_(_isSecure),
        isPartitioned_(_isPartitioned),
        expiryInMSec_(_expiryInMSec),
        lastAccessedInUSec_(_lastAccessedInUSec),
        creationTimeInUSec_(_creationTimeInUSec),
        updateTimeInUSec_(_updateTimeInUSec),
        sameSite_(_sameSite),
        schemeMap_(_schemeMap)
    {
    }

    MOZ_IMPLICIT CookieStruct(
            nsCString&& _name,
            nsCString&& _value,
            nsCString&& _host,
            nsCString&& _path,
            int64_t&& _expiryInMSec,
            int64_t&& _lastAccessedInUSec,
            int64_t&& _creationTimeInUSec,
            int64_t&& _updateTimeInUSec,
            bool&& _isHttpOnly,
            bool&& _isSession,
            bool&& _isSecure,
            bool&& _isPartitioned,
            int32_t&& _sameSite,
            uint8_t&& _schemeMap) :
        name_(std::move(_name)),
        value_(std::move(_value)),
        host_(std::move(_host)),
        path_(std::move(_path)),
        isHttpOnly_(std::move(_isHttpOnly)),
        isSession_(std::move(_isSession)),
        isSecure_(std::move(_isSecure)),
        isPartitioned_(std::move(_isPartitioned)),
        expiryInMSec_(std::move(_expiryInMSec)),
        lastAccessedInUSec_(std::move(_lastAccessedInUSec)),
        creationTimeInUSec_(std::move(_creationTimeInUSec)),
        updateTimeInUSec_(std::move(_updateTimeInUSec)),
        sameSite_(std::move(_sameSite)),
        schemeMap_(std::move(_schemeMap))
    {
    }

    nsCString&
    name()
    {
        return name_;
    }
    const nsCString&
    name() const
    {
        return name_;
    }

    nsCString&
    value()
    {
        return value_;
    }
    const nsCString&
    value() const
    {
        return value_;
    }

    nsCString&
    host()
    {
        return host_;
    }
    const nsCString&
    host() const
    {
        return host_;
    }

    nsCString&
    path()
    {
        return path_;
    }
    const nsCString&
    path() const
    {
        return path_;
    }

    int64_t&
    expiryInMSec()
    {
        return expiryInMSec_;
    }
    const int64_t&
    expiryInMSec() const
    {
        return expiryInMSec_;
    }

    int64_t&
    lastAccessedInUSec()
    {
        return lastAccessedInUSec_;
    }
    const int64_t&
    lastAccessedInUSec() const
    {
        return lastAccessedInUSec_;
    }

    int64_t&
    creationTimeInUSec()
    {
        return creationTimeInUSec_;
    }
    const int64_t&
    creationTimeInUSec() const
    {
        return creationTimeInUSec_;
    }

    int64_t&
    updateTimeInUSec()
    {
        return updateTimeInUSec_;
    }
    const int64_t&
    updateTimeInUSec() const
    {
        return updateTimeInUSec_;
    }

    bool&
    isHttpOnly()
    {
        return isHttpOnly_;
    }
    const bool&
    isHttpOnly() const
    {
        return isHttpOnly_;
    }

    bool&
    isSession()
    {
        return isSession_;
    }
    const bool&
    isSession() const
    {
        return isSession_;
    }

    bool&
    isSecure()
    {
        return isSecure_;
    }
    const bool&
    isSecure() const
    {
        return isSecure_;
    }

    bool&
    isPartitioned()
    {
        return isPartitioned_;
    }
    const bool&
    isPartitioned() const
    {
        return isPartitioned_;
    }

    int32_t&
    sameSite()
    {
        return sameSite_;
    }
    const int32_t&
    sameSite() const
    {
        return sameSite_;
    }

    uint8_t&
    schemeMap()
    {
        return schemeMap_;
    }
    const uint8_t&
    schemeMap() const
    {
        return schemeMap_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<nsCString> name_;
    ::mozilla::ipc::IPDLStructMember<nsCString> value_;
    ::mozilla::ipc::IPDLStructMember<nsCString> host_;
    ::mozilla::ipc::IPDLStructMember<nsCString> path_;
    ::mozilla::ipc::IPDLStructMember<bool> isHttpOnly_;
    ::mozilla::ipc::IPDLStructMember<bool> isSession_;
    ::mozilla::ipc::IPDLStructMember<bool> isSecure_;
    ::mozilla::ipc::IPDLStructMember<bool> isPartitioned_;
    ::mozilla::ipc::IPDLStructMember<int64_t> expiryInMSec_;
    ::mozilla::ipc::IPDLStructMember<int64_t> lastAccessedInUSec_;
    ::mozilla::ipc::IPDLStructMember<int64_t> creationTimeInUSec_;
    ::mozilla::ipc::IPDLStructMember<int64_t> updateTimeInUSec_;
    ::mozilla::ipc::IPDLStructMember<int32_t> sameSite_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> schemeMap_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookieStruct>
{
    typedef ::mozilla::net::CookieStruct paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CookieChange|
//
namespace mozilla {
namespace net {
class CookieChange final
{
private:
    typedef ::mozilla::net::CookieStruct CookieStruct;
    typedef ::mozilla::OriginAttributes OriginAttributes;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    CookieChange() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT CookieChange(
            const bool& _added,
            const CookieStruct& _cookie,
            const OriginAttributes& _originAttributes) :
        added_(_added),
        cookie_(_cookie),
        originAttributes_(_originAttributes)
    {
    }

    MOZ_IMPLICIT CookieChange(
            bool&& _added,
            CookieStruct&& _cookie,
            OriginAttributes&& _originAttributes) :
        added_(std::move(_added)),
        cookie_(std::move(_cookie)),
        originAttributes_(std::move(_originAttributes))
    {
    }

    bool&
    added()
    {
        return added_;
    }
    const bool&
    added() const
    {
        return added_;
    }

    CookieStruct&
    cookie()
    {
        return cookie_;
    }
    const CookieStruct&
    cookie() const
    {
        return cookie_;
    }

    OriginAttributes&
    originAttributes()
    {
        return originAttributes_;
    }
    const OriginAttributes&
    originAttributes() const
    {
        return originAttributes_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> added_;
    ::mozilla::ipc::IPDLStructMember<CookieStruct> cookie_;
    ::mozilla::ipc::IPDLStructMember<OriginAttributes> originAttributes_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookieChange>
{
    typedef ::mozilla::net::CookieChange paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct PreferredAlternativeDataTypeParams|
//
namespace mozilla {
namespace net {
class PreferredAlternativeDataTypeParams final
{
private:
    typedef ::nsCString nsCString;
    typedef ::mozilla::net::PreferredAlternativeDataDeliveryTypeIPC PreferredAlternativeDataDeliveryTypeIPC;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    PreferredAlternativeDataTypeParams() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT PreferredAlternativeDataTypeParams(
            const nsCString& _type,
            const nsCString& _contentType,
            const PreferredAlternativeDataDeliveryTypeIPC& _deliverAltData) :
        type_(_type),
        contentType_(_contentType),
        deliverAltData_(_deliverAltData)
    {
    }

    MOZ_IMPLICIT PreferredAlternativeDataTypeParams(
            nsCString&& _type,
            nsCString&& _contentType,
            PreferredAlternativeDataDeliveryTypeIPC&& _deliverAltData) :
        type_(std::move(_type)),
        contentType_(std::move(_contentType)),
        deliverAltData_(std::move(_deliverAltData))
    {
    }

    nsCString&
    type()
    {
        return type_;
    }
    const nsCString&
    type() const
    {
        return type_;
    }

    nsCString&
    contentType()
    {
        return contentType_;
    }
    const nsCString&
    contentType() const
    {
        return contentType_;
    }

    PreferredAlternativeDataDeliveryTypeIPC&
    deliverAltData()
    {
        return deliverAltData_;
    }
    const PreferredAlternativeDataDeliveryTypeIPC&
    deliverAltData() const
    {
        return deliverAltData_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> type_;
    ::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
    ::mozilla::ipc::IPDLStructMember<PreferredAlternativeDataDeliveryTypeIPC> deliverAltData_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::PreferredAlternativeDataTypeParams>
{
    typedef ::mozilla::net::PreferredAlternativeDataTypeParams paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct RedirectHistoryEntryInfo|
//
namespace mozilla {
namespace net {
class RedirectHistoryEntryInfo final
{
private:
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef ::mozilla::ipc::URIParams URIParams;
    typedef ::nsCString nsCString;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    RedirectHistoryEntryInfo() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT RedirectHistoryEntryInfo(
            const PrincipalInfo& _principalInfo,
            const mozilla::Maybe<URIParams>& _referrerUri,
            const nsCString& _remoteAddress) :
        principalInfo_(_principalInfo),
        referrerUri_(_referrerUri),
        remoteAddress_(_remoteAddress)
    {
    }

    MOZ_IMPLICIT RedirectHistoryEntryInfo(
            PrincipalInfo&& _principalInfo,
            mozilla::Maybe<URIParams>&& _referrerUri,
            nsCString&& _remoteAddress) :
        principalInfo_(std::move(_principalInfo)),
        referrerUri_(std::move(_referrerUri)),
        remoteAddress_(std::move(_remoteAddress))
    {
    }

    PrincipalInfo&
    principalInfo()
    {
        return principalInfo_;
    }
    const PrincipalInfo&
    principalInfo() const
    {
        return principalInfo_;
    }

    mozilla::Maybe<URIParams>&
    referrerUri()
    {
        return referrerUri_;
    }
    const mozilla::Maybe<URIParams>&
    referrerUri() const
    {
        return referrerUri_;
    }

    nsCString&
    remoteAddress()
    {
        return remoteAddress_;
    }
    const nsCString&
    remoteAddress() const
    {
        return remoteAddress_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> referrerUri_;
    ::mozilla::ipc::IPDLStructMember<nsCString> remoteAddress_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::RedirectHistoryEntryInfo>
{
    typedef ::mozilla::net::RedirectHistoryEntryInfo paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct InterceptionInfoArg|
//
namespace mozilla {
namespace net {
class InterceptionInfoArg final
{
private:
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef ::nsContentPolicyType nsContentPolicyType;
    typedef ::mozilla::net::RedirectHistoryEntryInfo RedirectHistoryEntryInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    InterceptionInfoArg() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT InterceptionInfoArg(
            const mozilla::Maybe<PrincipalInfo>& _triggeringPrincipalInfo,
            const nsContentPolicyType& _contentPolicyType,
            const nsTArray<RedirectHistoryEntryInfo>& _redirectChain,
            const bool& _fromThirdParty) :
        triggeringPrincipalInfo_(_triggeringPrincipalInfo),
        contentPolicyType_(_contentPolicyType),
        redirectChain_(_redirectChain),
        fromThirdParty_(_fromThirdParty)
    {
    }

    MOZ_IMPLICIT InterceptionInfoArg(
            mozilla::Maybe<PrincipalInfo>&& _triggeringPrincipalInfo,
            nsContentPolicyType&& _contentPolicyType,
            nsTArray<RedirectHistoryEntryInfo>&& _redirectChain,
            bool&& _fromThirdParty) :
        triggeringPrincipalInfo_(std::move(_triggeringPrincipalInfo)),
        contentPolicyType_(std::move(_contentPolicyType)),
        redirectChain_(std::move(_redirectChain)),
        fromThirdParty_(std::move(_fromThirdParty))
    {
    }

    mozilla::Maybe<PrincipalInfo>&
    triggeringPrincipalInfo()
    {
        return triggeringPrincipalInfo_;
    }
    const mozilla::Maybe<PrincipalInfo>&
    triggeringPrincipalInfo() const
    {
        return triggeringPrincipalInfo_;
    }

    nsContentPolicyType&
    contentPolicyType()
    {
        return contentPolicyType_;
    }
    const nsContentPolicyType&
    contentPolicyType() const
    {
        return contentPolicyType_;
    }

    nsTArray<RedirectHistoryEntryInfo>&
    redirectChain()
    {
        return redirectChain_;
    }
    const nsTArray<RedirectHistoryEntryInfo>&
    redirectChain() const
    {
        return redirectChain_;
    }

    bool&
    fromThirdParty()
    {
        return fromThirdParty_;
    }
    const bool&
    fromThirdParty() const
    {
        return fromThirdParty_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> triggeringPrincipalInfo_;
    ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChain_;
    ::mozilla::ipc::IPDLStructMember<bool> fromThirdParty_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::InterceptionInfoArg>
{
    typedef ::mozilla::net::InterceptionInfoArg paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct LoadInfoArgs|
//
namespace mozilla {
namespace net {
class LoadInfoArgs final
{
private:
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef ::mozilla::ipc::URIParams URIParams;
    typedef ::nsCString nsCString;
    typedef ::nsID nsID;
    typedef ::uint32_t uint32_t;
    typedef ::uint64_t uint64_t;
    typedef ::nsContentPolicyType nsContentPolicyType;
    typedef ::mozilla::dom::ForceMediaDocument ForceMediaDocument;
    typedef ::mozilla::OriginAttributes OriginAttributes;
    typedef ::mozilla::net::RedirectHistoryEntryInfo RedirectHistoryEntryInfo;
    typedef ::nsILoadInfo::SchemelessInputType SchemelessInputType;
    typedef ::nsILoadInfo::HTTPSUpgradeTelemetryType HTTPSUpgradeTelemetryType;
    typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
    typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
    typedef ::nsString nsString;
    typedef ::mozilla::dom::RequestMode RequestMode;
    typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
    typedef ::mozilla::ipc::PolicyContainerArgs PolicyContainerArgs;
    typedef ::nsILoadInfo::StoragePermissionState StoragePermissionState;
    typedef ::nsILoadInfo::IPAddressSpace IPAddressSpace;
    typedef ::mozilla::RFPTargetSet RFPTargetSet;
    typedef ::nsILoadInfo::CrossOriginEmbedderPolicy CrossOriginEmbedderPolicy;
    typedef ::nsIURI nsIURI;
    typedef ::mozilla::net::InterceptionInfoArg InterceptionInfoArg;
    typedef ::mozilla::dom::UserNavigationInvolvement UserNavigationInvolvement;
    typedef ::mozilla::dom::FeaturePolicyInfo FeaturePolicyInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    LoadInfoArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT LoadInfoArgs(
            const mozilla::Maybe<PrincipalInfo>& _requestingPrincipalInfo,
            const PrincipalInfo& _triggeringPrincipalInfo,
            const mozilla::Maybe<PrincipalInfo>& _principalToInheritInfo,
            const mozilla::Maybe<PrincipalInfo>& _topLevelPrincipalInfo,
            const mozilla::Maybe<URIParams>& _resultPrincipalURI,
            const nsCString& _triggeringRemoteType,
            const nsID& _sandboxedNullPrincipalID,
            const uint32_t& _securityFlags,
            const uint32_t& _sandboxFlags,
            const uint32_t& _triggeringSandboxFlags,
            const uint64_t& _triggeringWindowId,
            const bool& _triggeringStorageAccess,
            const uint32_t& _triggeringFirstPartyClassificationFlags,
            const uint32_t& _triggeringThirdPartyClassificationFlags,
            const nsContentPolicyType& _contentPolicyType,
            const uint32_t& _tainting,
            const bool& _blockAllMixedContent,
            const bool& _upgradeInsecureRequests,
            const bool& _browserUpgradeInsecureRequests,
            const bool& _browserDidUpgradeInsecureRequests,
            const bool& _browserWouldUpgradeInsecureRequests,
            const bool& _forceAllowDataURI,
            const bool& _allowInsecureRedirectToDataURI,
            const ForceMediaDocument& _forceMediaDocument,
            const bool& _skipContentPolicyCheckForWebRequest,
            const bool& _originalFrameSrcLoad,
            const bool& _forceInheritPrincipalDropped,
            const uint64_t& _innerWindowID,
            const uint64_t& _browsingContextID,
            const uint64_t& _frameBrowsingContextID,
            const bool& _initialSecurityCheckDone,
            const bool& _isInThirdPartyContext,
            const mozilla::Maybe<bool>& _isThirdPartyContextToTopWindow,
            const bool& _isOn3PCBExceptionList,
            const bool& _isFormSubmission,
            const bool& _isGETRequest,
            const bool& _sendCSPViolationEvents,
            const OriginAttributes& _originAttributes,
            const nsTArray<RedirectHistoryEntryInfo>& _redirectChainIncludingInternalRedirects,
            const nsTArray<RedirectHistoryEntryInfo>& _redirectChain,
            const bool& _hasInjectedCookieForCookieBannerHandling,
            const SchemelessInputType& _schemelessInput,
            const HTTPSUpgradeTelemetryType& _httpsUpgradeTelemetry,
            const mozilla::Maybe<IPCClientInfo>& _clientInfo,
            const mozilla::Maybe<IPCClientInfo>& _reservedClientInfo,
            const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
            const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
            const nsTArray<nsCString>& _corsUnsafeHeaders,
            const bool& _forcePreflight,
            const bool& _isPreflight,
            const bool& _loadTriggeredFromExternal,
            const bool& _serviceWorkerTaintingSynthesized,
            const bool& _documentHasUserInteracted,
            const bool& _allowListFutureDocumentsCreatedFromThisRedirectChain,
            const bool& _needForCheckingAntiTrackingHeuristic,
            const nsString& _cspNonce,
            const nsString& _integrityMetadata,
            const bool& _skipContentSniffing,
            const uint32_t& _httpsOnlyStatus,
            const bool& _hstsStatus,
            const bool& _hasValidUserGestureActivation,
            const bool& _textDirectiveUserActivation,
            const bool& _allowDeprecatedSystemRequests,
            const bool& _isInDevToolsContext,
            const bool& _parserCreatedScript,
            const mozilla::Maybe<RequestMode>& _requestMode,
            const bool& _isFromProcessingFrameAttributes,
            const bool& _isMediaRequest,
            const bool& _isMediaInitialRequest,
            const bool& _isFromObjectOrEmbed,
            const CookieJarSettingsArgs& _cookieJarSettings,
            const uint32_t& _requestBlockingReason,
            const mozilla::Maybe<PolicyContainerArgs>& _policyContainerToInherit,
            const StoragePermissionState& _storagePermission,
            const IPAddressSpace& _parentIPAddressSpace,
            const IPAddressSpace& _ipAddressSpace,
            const mozilla::Maybe<RFPTargetSet>& _overriddenFingerprintingSettings,
            const bool& _isMetaRefresh,
            const CrossOriginEmbedderPolicy& _loadingEmbedderPolicy,
            const bool& _originTrialCoepCredentiallessEnabledForTopLevel,
            nsIURI* _unstrippedURI,
            const mozilla::Maybe<InterceptionInfoArg>& _interceptionInfo,
            const bool& _isNewWindowTarget,
            const UserNavigationInvolvement& _userNavigationInvolvement,
            const mozilla::Maybe<FeaturePolicyInfo>& _containerFeaturePolicyInfo) :
        requestingPrincipalInfo_(_requestingPrincipalInfo),
        triggeringPrincipalInfo_(_triggeringPrincipalInfo),
        principalToInheritInfo_(_principalToInheritInfo),
        topLevelPrincipalInfo_(_topLevelPrincipalInfo),
        resultPrincipalURI_(_resultPrincipalURI),
        triggeringRemoteType_(_triggeringRemoteType),
        sandboxedNullPrincipalID_(_sandboxedNullPrincipalID),
        triggeringStorageAccess_(_triggeringStorageAccess),
        contentPolicyType_(_contentPolicyType),
        blockAllMixedContent_(_blockAllMixedContent),
        upgradeInsecureRequests_(_upgradeInsecureRequests),
        browserUpgradeInsecureRequests_(_browserUpgradeInsecureRequests),
        browserDidUpgradeInsecureRequests_(_browserDidUpgradeInsecureRequests),
        browserWouldUpgradeInsecureRequests_(_browserWouldUpgradeInsecureRequests),
        forceAllowDataURI_(_forceAllowDataURI),
        allowInsecureRedirectToDataURI_(_allowInsecureRedirectToDataURI),
        forceMediaDocument_(_forceMediaDocument),
        skipContentPolicyCheckForWebRequest_(_skipContentPolicyCheckForWebRequest),
        originalFrameSrcLoad_(_originalFrameSrcLoad),
        forceInheritPrincipalDropped_(_forceInheritPrincipalDropped),
        initialSecurityCheckDone_(_initialSecurityCheckDone),
        isInThirdPartyContext_(_isInThirdPartyContext),
        isThirdPartyContextToTopWindow_(_isThirdPartyContextToTopWindow),
        isOn3PCBExceptionList_(_isOn3PCBExceptionList),
        isFormSubmission_(_isFormSubmission),
        isGETRequest_(_isGETRequest),
        sendCSPViolationEvents_(_sendCSPViolationEvents),
        originAttributes_(_originAttributes),
        redirectChainIncludingInternalRedirects_(_redirectChainIncludingInternalRedirects),
        redirectChain_(_redirectChain),
        hasInjectedCookieForCookieBannerHandling_(_hasInjectedCookieForCookieBannerHandling),
        schemelessInput_(_schemelessInput),
        httpsUpgradeTelemetry_(_httpsUpgradeTelemetry),
        clientInfo_(_clientInfo),
        reservedClientInfo_(_reservedClientInfo),
        initialClientInfo_(_initialClientInfo),
        controller_(_controller),
        corsUnsafeHeaders_(_corsUnsafeHeaders),
        forcePreflight_(_forcePreflight),
        isPreflight_(_isPreflight),
        loadTriggeredFromExternal_(_loadTriggeredFromExternal),
        serviceWorkerTaintingSynthesized_(_serviceWorkerTaintingSynthesized),
        documentHasUserInteracted_(_documentHasUserInteracted),
        allowListFutureDocumentsCreatedFromThisRedirectChain_(_allowListFutureDocumentsCreatedFromThisRedirectChain),
        needForCheckingAntiTrackingHeuristic_(_needForCheckingAntiTrackingHeuristic),
        cspNonce_(_cspNonce),
        integrityMetadata_(_integrityMetadata),
        skipContentSniffing_(_skipContentSniffing),
        hstsStatus_(_hstsStatus),
        hasValidUserGestureActivation_(_hasValidUserGestureActivation),
        textDirectiveUserActivation_(_textDirectiveUserActivation),
        allowDeprecatedSystemRequests_(_allowDeprecatedSystemRequests),
        isInDevToolsContext_(_isInDevToolsContext),
        parserCreatedScript_(_parserCreatedScript),
        requestMode_(_requestMode),
        isFromProcessingFrameAttributes_(_isFromProcessingFrameAttributes),
        isMediaRequest_(_isMediaRequest),
        isMediaInitialRequest_(_isMediaInitialRequest),
        isFromObjectOrEmbed_(_isFromObjectOrEmbed),
        cookieJarSettings_(_cookieJarSettings),
        policyContainerToInherit_(_policyContainerToInherit),
        storagePermission_(_storagePermission),
        parentIPAddressSpace_(_parentIPAddressSpace),
        ipAddressSpace_(_ipAddressSpace),
        overriddenFingerprintingSettings_(_overriddenFingerprintingSettings),
        isMetaRefresh_(_isMetaRefresh),
        loadingEmbedderPolicy_(_loadingEmbedderPolicy),
        originTrialCoepCredentiallessEnabledForTopLevel_(_originTrialCoepCredentiallessEnabledForTopLevel),
        unstrippedURI_(_unstrippedURI),
        interceptionInfo_(_interceptionInfo),
        isNewWindowTarget_(_isNewWindowTarget),
        userNavigationInvolvement_(_userNavigationInvolvement),
        containerFeaturePolicyInfo_(_containerFeaturePolicyInfo),
        triggeringWindowId_(_triggeringWindowId),
        innerWindowID_(_innerWindowID),
        browsingContextID_(_browsingContextID),
        frameBrowsingContextID_(_frameBrowsingContextID),
        securityFlags_(_securityFlags),
        sandboxFlags_(_sandboxFlags),
        triggeringSandboxFlags_(_triggeringSandboxFlags),
        triggeringFirstPartyClassificationFlags_(_triggeringFirstPartyClassificationFlags),
        triggeringThirdPartyClassificationFlags_(_triggeringThirdPartyClassificationFlags),
        tainting_(_tainting),
        httpsOnlyStatus_(_httpsOnlyStatus),
        requestBlockingReason_(_requestBlockingReason)
    {
    }

    MOZ_IMPLICIT LoadInfoArgs(
            mozilla::Maybe<PrincipalInfo>&& _requestingPrincipalInfo,
            PrincipalInfo&& _triggeringPrincipalInfo,
            mozilla::Maybe<PrincipalInfo>&& _principalToInheritInfo,
            mozilla::Maybe<PrincipalInfo>&& _topLevelPrincipalInfo,
            mozilla::Maybe<URIParams>&& _resultPrincipalURI,
            nsCString&& _triggeringRemoteType,
            nsID&& _sandboxedNullPrincipalID,
            uint32_t&& _securityFlags,
            uint32_t&& _sandboxFlags,
            uint32_t&& _triggeringSandboxFlags,
            uint64_t&& _triggeringWindowId,
            bool&& _triggeringStorageAccess,
            uint32_t&& _triggeringFirstPartyClassificationFlags,
            uint32_t&& _triggeringThirdPartyClassificationFlags,
            nsContentPolicyType&& _contentPolicyType,
            uint32_t&& _tainting,
            bool&& _blockAllMixedContent,
            bool&& _upgradeInsecureRequests,
            bool&& _browserUpgradeInsecureRequests,
            bool&& _browserDidUpgradeInsecureRequests,
            bool&& _browserWouldUpgradeInsecureRequests,
            bool&& _forceAllowDataURI,
            bool&& _allowInsecureRedirectToDataURI,
            ForceMediaDocument&& _forceMediaDocument,
            bool&& _skipContentPolicyCheckForWebRequest,
            bool&& _originalFrameSrcLoad,
            bool&& _forceInheritPrincipalDropped,
            uint64_t&& _innerWindowID,
            uint64_t&& _browsingContextID,
            uint64_t&& _frameBrowsingContextID,
            bool&& _initialSecurityCheckDone,
            bool&& _isInThirdPartyContext,
            mozilla::Maybe<bool>&& _isThirdPartyContextToTopWindow,
            bool&& _isOn3PCBExceptionList,
            bool&& _isFormSubmission,
            bool&& _isGETRequest,
            bool&& _sendCSPViolationEvents,
            OriginAttributes&& _originAttributes,
            nsTArray<RedirectHistoryEntryInfo>&& _redirectChainIncludingInternalRedirects,
            nsTArray<RedirectHistoryEntryInfo>&& _redirectChain,
            bool&& _hasInjectedCookieForCookieBannerHandling,
            SchemelessInputType&& _schemelessInput,
            HTTPSUpgradeTelemetryType&& _httpsUpgradeTelemetry,
            mozilla::Maybe<IPCClientInfo>&& _clientInfo,
            mozilla::Maybe<IPCClientInfo>&& _reservedClientInfo,
            mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
            mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
            nsTArray<nsCString>&& _corsUnsafeHeaders,
            bool&& _forcePreflight,
            bool&& _isPreflight,
            bool&& _loadTriggeredFromExternal,
            bool&& _serviceWorkerTaintingSynthesized,
            bool&& _documentHasUserInteracted,
            bool&& _allowListFutureDocumentsCreatedFromThisRedirectChain,
            bool&& _needForCheckingAntiTrackingHeuristic,
            nsString&& _cspNonce,
            nsString&& _integrityMetadata,
            bool&& _skipContentSniffing,
            uint32_t&& _httpsOnlyStatus,
            bool&& _hstsStatus,
            bool&& _hasValidUserGestureActivation,
            bool&& _textDirectiveUserActivation,
            bool&& _allowDeprecatedSystemRequests,
            bool&& _isInDevToolsContext,
            bool&& _parserCreatedScript,
            mozilla::Maybe<RequestMode>&& _requestMode,
            bool&& _isFromProcessingFrameAttributes,
            bool&& _isMediaRequest,
            bool&& _isMediaInitialRequest,
            bool&& _isFromObjectOrEmbed,
            CookieJarSettingsArgs&& _cookieJarSettings,
            uint32_t&& _requestBlockingReason,
            mozilla::Maybe<PolicyContainerArgs>&& _policyContainerToInherit,
            StoragePermissionState&& _storagePermission,
            IPAddressSpace&& _parentIPAddressSpace,
            IPAddressSpace&& _ipAddressSpace,
            mozilla::Maybe<RFPTargetSet>&& _overriddenFingerprintingSettings,
            bool&& _isMetaRefresh,
            CrossOriginEmbedderPolicy&& _loadingEmbedderPolicy,
            bool&& _originTrialCoepCredentiallessEnabledForTopLevel,
            RefPtr<nsIURI>&& _unstrippedURI,
            mozilla::Maybe<InterceptionInfoArg>&& _interceptionInfo,
            bool&& _isNewWindowTarget,
            UserNavigationInvolvement&& _userNavigationInvolvement,
            mozilla::Maybe<FeaturePolicyInfo>&& _containerFeaturePolicyInfo) :
        requestingPrincipalInfo_(std::move(_requestingPrincipalInfo)),
        triggeringPrincipalInfo_(std::move(_triggeringPrincipalInfo)),
        principalToInheritInfo_(std::move(_principalToInheritInfo)),
        topLevelPrincipalInfo_(std::move(_topLevelPrincipalInfo)),
        resultPrincipalURI_(std::move(_resultPrincipalURI)),
        triggeringRemoteType_(std::move(_triggeringRemoteType)),
        sandboxedNullPrincipalID_(std::move(_sandboxedNullPrincipalID)),
        triggeringStorageAccess_(std::move(_triggeringStorageAccess)),
        contentPolicyType_(std::move(_contentPolicyType)),
        blockAllMixedContent_(std::move(_blockAllMixedContent)),
        upgradeInsecureRequests_(std::move(_upgradeInsecureRequests)),
        browserUpgradeInsecureRequests_(std::move(_browserUpgradeInsecureRequests)),
        browserDidUpgradeInsecureRequests_(std::move(_browserDidUpgradeInsecureRequests)),
        browserWouldUpgradeInsecureRequests_(std::move(_browserWouldUpgradeInsecureRequests)),
        forceAllowDataURI_(std::move(_forceAllowDataURI)),
        allowInsecureRedirectToDataURI_(std::move(_allowInsecureRedirectToDataURI)),
        forceMediaDocument_(std::move(_forceMediaDocument)),
        skipContentPolicyCheckForWebRequest_(std::move(_skipContentPolicyCheckForWebRequest)),
        originalFrameSrcLoad_(std::move(_originalFrameSrcLoad)),
        forceInheritPrincipalDropped_(std::move(_forceInheritPrincipalDropped)),
        initialSecurityCheckDone_(std::move(_initialSecurityCheckDone)),
        isInThirdPartyContext_(std::move(_isInThirdPartyContext)),
        isThirdPartyContextToTopWindow_(std::move(_isThirdPartyContextToTopWindow)),
        isOn3PCBExceptionList_(std::move(_isOn3PCBExceptionList)),
        isFormSubmission_(std::move(_isFormSubmission)),
        isGETRequest_(std::move(_isGETRequest)),
        sendCSPViolationEvents_(std::move(_sendCSPViolationEvents)),
        originAttributes_(std::move(_originAttributes)),
        redirectChainIncludingInternalRedirects_(std::move(_redirectChainIncludingInternalRedirects)),
        redirectChain_(std::move(_redirectChain)),
        hasInjectedCookieForCookieBannerHandling_(std::move(_hasInjectedCookieForCookieBannerHandling)),
        schemelessInput_(std::move(_schemelessInput)),
        httpsUpgradeTelemetry_(std::move(_httpsUpgradeTelemetry)),
        clientInfo_(std::move(_clientInfo)),
        reservedClientInfo_(std::move(_reservedClientInfo)),
        initialClientInfo_(std::move(_initialClientInfo)),
        controller_(std::move(_controller)),
        corsUnsafeHeaders_(std::move(_corsUnsafeHeaders)),
        forcePreflight_(std::move(_forcePreflight)),
        isPreflight_(std::move(_isPreflight)),
        loadTriggeredFromExternal_(std::move(_loadTriggeredFromExternal)),
        serviceWorkerTaintingSynthesized_(std::move(_serviceWorkerTaintingSynthesized)),
        documentHasUserInteracted_(std::move(_documentHasUserInteracted)),
        allowListFutureDocumentsCreatedFromThisRedirectChain_(std::move(_allowListFutureDocumentsCreatedFromThisRedirectChain)),
        needForCheckingAntiTrackingHeuristic_(std::move(_needForCheckingAntiTrackingHeuristic)),
        cspNonce_(std::move(_cspNonce)),
        integrityMetadata_(std::move(_integrityMetadata)),
        skipContentSniffing_(std::move(_skipContentSniffing)),
        hstsStatus_(std::move(_hstsStatus)),
        hasValidUserGestureActivation_(std::move(_hasValidUserGestureActivation)),
        textDirectiveUserActivation_(std::move(_textDirectiveUserActivation)),
        allowDeprecatedSystemRequests_(std::move(_allowDeprecatedSystemRequests)),
        isInDevToolsContext_(std::move(_isInDevToolsContext)),
        parserCreatedScript_(std::move(_parserCreatedScript)),
        requestMode_(std::move(_requestMode)),
        isFromProcessingFrameAttributes_(std::move(_isFromProcessingFrameAttributes)),
        isMediaRequest_(std::move(_isMediaRequest)),
        isMediaInitialRequest_(std::move(_isMediaInitialRequest)),
        isFromObjectOrEmbed_(std::move(_isFromObjectOrEmbed)),
        cookieJarSettings_(std::move(_cookieJarSettings)),
        policyContainerToInherit_(std::move(_policyContainerToInherit)),
        storagePermission_(std::move(_storagePermission)),
        parentIPAddressSpace_(std::move(_parentIPAddressSpace)),
        ipAddressSpace_(std::move(_ipAddressSpace)),
        overriddenFingerprintingSettings_(std::move(_overriddenFingerprintingSettings)),
        isMetaRefresh_(std::move(_isMetaRefresh)),
        loadingEmbedderPolicy_(std::move(_loadingEmbedderPolicy)),
        originTrialCoepCredentiallessEnabledForTopLevel_(std::move(_originTrialCoepCredentiallessEnabledForTopLevel)),
        unstrippedURI_(std::move(_unstrippedURI)),
        interceptionInfo_(std::move(_interceptionInfo)),
        isNewWindowTarget_(std::move(_isNewWindowTarget)),
        userNavigationInvolvement_(std::move(_userNavigationInvolvement)),
        containerFeaturePolicyInfo_(std::move(_containerFeaturePolicyInfo)),
        triggeringWindowId_(std::move(_triggeringWindowId)),
        innerWindowID_(std::move(_innerWindowID)),
        browsingContextID_(std::move(_browsingContextID)),
        frameBrowsingContextID_(std::move(_frameBrowsingContextID)),
        securityFlags_(std::move(_securityFlags)),
        sandboxFlags_(std::move(_sandboxFlags)),
        triggeringSandboxFlags_(std::move(_triggeringSandboxFlags)),
        triggeringFirstPartyClassificationFlags_(std::move(_triggeringFirstPartyClassificationFlags)),
        triggeringThirdPartyClassificationFlags_(std::move(_triggeringThirdPartyClassificationFlags)),
        tainting_(std::move(_tainting)),
        httpsOnlyStatus_(std::move(_httpsOnlyStatus)),
        requestBlockingReason_(std::move(_requestBlockingReason))
    {
    }

    mozilla::Maybe<PrincipalInfo>&
    requestingPrincipalInfo()
    {
        return requestingPrincipalInfo_;
    }
    const mozilla::Maybe<PrincipalInfo>&
    requestingPrincipalInfo() const
    {
        return requestingPrincipalInfo_;
    }

    PrincipalInfo&
    triggeringPrincipalInfo()
    {
        return triggeringPrincipalInfo_;
    }
    const PrincipalInfo&
    triggeringPrincipalInfo() const
    {
        return triggeringPrincipalInfo_;
    }

    mozilla::Maybe<PrincipalInfo>&
    principalToInheritInfo()
    {
        return principalToInheritInfo_;
    }
    const mozilla::Maybe<PrincipalInfo>&
    principalToInheritInfo() const
    {
        return principalToInheritInfo_;
    }

    mozilla::Maybe<PrincipalInfo>&
    topLevelPrincipalInfo()
    {
        return topLevelPrincipalInfo_;
    }
    const mozilla::Maybe<PrincipalInfo>&
    topLevelPrincipalInfo() const
    {
        return topLevelPrincipalInfo_;
    }

    mozilla::Maybe<URIParams>&
    resultPrincipalURI()
    {
        return resultPrincipalURI_;
    }
    const mozilla::Maybe<URIParams>&
    resultPrincipalURI() const
    {
        return resultPrincipalURI_;
    }

    nsCString&
    triggeringRemoteType()
    {
        return triggeringRemoteType_;
    }
    const nsCString&
    triggeringRemoteType() const
    {
        return triggeringRemoteType_;
    }

    nsID&
    sandboxedNullPrincipalID()
    {
        return sandboxedNullPrincipalID_;
    }
    const nsID&
    sandboxedNullPrincipalID() const
    {
        return sandboxedNullPrincipalID_;
    }

    uint32_t&
    securityFlags()
    {
        return securityFlags_;
    }
    const uint32_t&
    securityFlags() const
    {
        return securityFlags_;
    }

    uint32_t&
    sandboxFlags()
    {
        return sandboxFlags_;
    }
    const uint32_t&
    sandboxFlags() const
    {
        return sandboxFlags_;
    }

    uint32_t&
    triggeringSandboxFlags()
    {
        return triggeringSandboxFlags_;
    }
    const uint32_t&
    triggeringSandboxFlags() const
    {
        return triggeringSandboxFlags_;
    }

    uint64_t&
    triggeringWindowId()
    {
        return triggeringWindowId_;
    }
    const uint64_t&
    triggeringWindowId() const
    {
        return triggeringWindowId_;
    }

    bool&
    triggeringStorageAccess()
    {
        return triggeringStorageAccess_;
    }
    const bool&
    triggeringStorageAccess() const
    {
        return triggeringStorageAccess_;
    }

    uint32_t&
    triggeringFirstPartyClassificationFlags()
    {
        return triggeringFirstPartyClassificationFlags_;
    }
    const uint32_t&
    triggeringFirstPartyClassificationFlags() const
    {
        return triggeringFirstPartyClassificationFlags_;
    }

    uint32_t&
    triggeringThirdPartyClassificationFlags()
    {
        return triggeringThirdPartyClassificationFlags_;
    }
    const uint32_t&
    triggeringThirdPartyClassificationFlags() const
    {
        return triggeringThirdPartyClassificationFlags_;
    }

    nsContentPolicyType&
    contentPolicyType()
    {
        return contentPolicyType_;
    }
    const nsContentPolicyType&
    contentPolicyType() const
    {
        return contentPolicyType_;
    }

    uint32_t&
    tainting()
    {
        return tainting_;
    }
    const uint32_t&
    tainting() const
    {
        return tainting_;
    }

    bool&
    blockAllMixedContent()
    {
        return blockAllMixedContent_;
    }
    const bool&
    blockAllMixedContent() const
    {
        return blockAllMixedContent_;
    }

    bool&
    upgradeInsecureRequests()
    {
        return upgradeInsecureRequests_;
    }
    const bool&
    upgradeInsecureRequests() const
    {
        return upgradeInsecureRequests_;
    }

    bool&
    browserUpgradeInsecureRequests()
    {
        return browserUpgradeInsecureRequests_;
    }
    const bool&
    browserUpgradeInsecureRequests() const
    {
        return browserUpgradeInsecureRequests_;
    }

    bool&
    browserDidUpgradeInsecureRequests()
    {
        return browserDidUpgradeInsecureRequests_;
    }
    const bool&
    browserDidUpgradeInsecureRequests() const
    {
        return browserDidUpgradeInsecureRequests_;
    }

    bool&
    browserWouldUpgradeInsecureRequests()
    {
        return browserWouldUpgradeInsecureRequests_;
    }
    const bool&
    browserWouldUpgradeInsecureRequests() const
    {
        return browserWouldUpgradeInsecureRequests_;
    }

    bool&
    forceAllowDataURI()
    {
        return forceAllowDataURI_;
    }
    const bool&
    forceAllowDataURI() const
    {
        return forceAllowDataURI_;
    }

    bool&
    allowInsecureRedirectToDataURI()
    {
        return allowInsecureRedirectToDataURI_;
    }
    const bool&
    allowInsecureRedirectToDataURI() const
    {
        return allowInsecureRedirectToDataURI_;
    }

    ForceMediaDocument&
    forceMediaDocument()
    {
        return forceMediaDocument_;
    }
    const ForceMediaDocument&
    forceMediaDocument() const
    {
        return forceMediaDocument_;
    }

    bool&
    skipContentPolicyCheckForWebRequest()
    {
        return skipContentPolicyCheckForWebRequest_;
    }
    const bool&
    skipContentPolicyCheckForWebRequest() const
    {
        return skipContentPolicyCheckForWebRequest_;
    }

    bool&
    originalFrameSrcLoad()
    {
        return originalFrameSrcLoad_;
    }
    const bool&
    originalFrameSrcLoad() const
    {
        return originalFrameSrcLoad_;
    }

    bool&
    forceInheritPrincipalDropped()
    {
        return forceInheritPrincipalDropped_;
    }
    const bool&
    forceInheritPrincipalDropped() const
    {
        return forceInheritPrincipalDropped_;
    }

    uint64_t&
    innerWindowID()
    {
        return innerWindowID_;
    }
    const uint64_t&
    innerWindowID() const
    {
        return innerWindowID_;
    }

    uint64_t&
    browsingContextID()
    {
        return browsingContextID_;
    }
    const uint64_t&
    browsingContextID() const
    {
        return browsingContextID_;
    }

    uint64_t&
    frameBrowsingContextID()
    {
        return frameBrowsingContextID_;
    }
    const uint64_t&
    frameBrowsingContextID() const
    {
        return frameBrowsingContextID_;
    }

    bool&
    initialSecurityCheckDone()
    {
        return initialSecurityCheckDone_;
    }
    const bool&
    initialSecurityCheckDone() const
    {
        return initialSecurityCheckDone_;
    }

    bool&
    isInThirdPartyContext()
    {
        return isInThirdPartyContext_;
    }
    const bool&
    isInThirdPartyContext() const
    {
        return isInThirdPartyContext_;
    }

    mozilla::Maybe<bool>&
    isThirdPartyContextToTopWindow()
    {
        return isThirdPartyContextToTopWindow_;
    }
    const mozilla::Maybe<bool>&
    isThirdPartyContextToTopWindow() const
    {
        return isThirdPartyContextToTopWindow_;
    }

    bool&
    isOn3PCBExceptionList()
    {
        return isOn3PCBExceptionList_;
    }
    const bool&
    isOn3PCBExceptionList() const
    {
        return isOn3PCBExceptionList_;
    }

    bool&
    isFormSubmission()
    {
        return isFormSubmission_;
    }
    const bool&
    isFormSubmission() const
    {
        return isFormSubmission_;
    }

    bool&
    isGETRequest()
    {
        return isGETRequest_;
    }
    const bool&
    isGETRequest() const
    {
        return isGETRequest_;
    }

    bool&
    sendCSPViolationEvents()
    {
        return sendCSPViolationEvents_;
    }
    const bool&
    sendCSPViolationEvents() const
    {
        return sendCSPViolationEvents_;
    }

    OriginAttributes&
    originAttributes()
    {
        return originAttributes_;
    }
    const OriginAttributes&
    originAttributes() const
    {
        return originAttributes_;
    }

    nsTArray<RedirectHistoryEntryInfo>&
    redirectChainIncludingInternalRedirects()
    {
        return redirectChainIncludingInternalRedirects_;
    }
    const nsTArray<RedirectHistoryEntryInfo>&
    redirectChainIncludingInternalRedirects() const
    {
        return redirectChainIncludingInternalRedirects_;
    }

    nsTArray<RedirectHistoryEntryInfo>&
    redirectChain()
    {
        return redirectChain_;
    }
    const nsTArray<RedirectHistoryEntryInfo>&
    redirectChain() const
    {
        return redirectChain_;
    }

    bool&
    hasInjectedCookieForCookieBannerHandling()
    {
        return hasInjectedCookieForCookieBannerHandling_;
    }
    const bool&
    hasInjectedCookieForCookieBannerHandling() const
    {
        return hasInjectedCookieForCookieBannerHandling_;
    }

    SchemelessInputType&
    schemelessInput()
    {
        return schemelessInput_;
    }
    const SchemelessInputType&
    schemelessInput() const
    {
        return schemelessInput_;
    }

    HTTPSUpgradeTelemetryType&
    httpsUpgradeTelemetry()
    {
        return httpsUpgradeTelemetry_;
    }
    const HTTPSUpgradeTelemetryType&
    httpsUpgradeTelemetry() const
    {
        return httpsUpgradeTelemetry_;
    }

    mozilla::Maybe<IPCClientInfo>&
    clientInfo()
    {
        return clientInfo_;
    }
    const mozilla::Maybe<IPCClientInfo>&
    clientInfo() const
    {
        return clientInfo_;
    }

    mozilla::Maybe<IPCClientInfo>&
    reservedClientInfo()
    {
        return reservedClientInfo_;
    }
    const mozilla::Maybe<IPCClientInfo>&
    reservedClientInfo() const
    {
        return reservedClientInfo_;
    }

    mozilla::Maybe<IPCClientInfo>&
    initialClientInfo()
    {
        return initialClientInfo_;
    }
    const mozilla::Maybe<IPCClientInfo>&
    initialClientInfo() const
    {
        return initialClientInfo_;
    }

    mozilla::Maybe<IPCServiceWorkerDescriptor>&
    controller()
    {
        return controller_;
    }
    const mozilla::Maybe<IPCServiceWorkerDescriptor>&
    controller() const
    {
        return controller_;
    }

    nsTArray<nsCString>&
    corsUnsafeHeaders()
    {
        return corsUnsafeHeaders_;
    }
    const nsTArray<nsCString>&
    corsUnsafeHeaders() const
    {
        return corsUnsafeHeaders_;
    }

    bool&
    forcePreflight()
    {
        return forcePreflight_;
    }
    const bool&
    forcePreflight() const
    {
        return forcePreflight_;
    }

    bool&
    isPreflight()
    {
        return isPreflight_;
    }
    const bool&
    isPreflight() const
    {
        return isPreflight_;
    }

    bool&
    loadTriggeredFromExternal()
    {
        return loadTriggeredFromExternal_;
    }
    const bool&
    loadTriggeredFromExternal() const
    {
        return loadTriggeredFromExternal_;
    }

    bool&
    serviceWorkerTaintingSynthesized()
    {
        return serviceWorkerTaintingSynthesized_;
    }
    const bool&
    serviceWorkerTaintingSynthesized() const
    {
        return serviceWorkerTaintingSynthesized_;
    }

    bool&
    documentHasUserInteracted()
    {
        return documentHasUserInteracted_;
    }
    const bool&
    documentHasUserInteracted() const
    {
        return documentHasUserInteracted_;
    }

    bool&
    allowListFutureDocumentsCreatedFromThisRedirectChain()
    {
        return allowListFutureDocumentsCreatedFromThisRedirectChain_;
    }
    const bool&
    allowListFutureDocumentsCreatedFromThisRedirectChain() const
    {
        return allowListFutureDocumentsCreatedFromThisRedirectChain_;
    }

    bool&
    needForCheckingAntiTrackingHeuristic()
    {
        return needForCheckingAntiTrackingHeuristic_;
    }
    const bool&
    needForCheckingAntiTrackingHeuristic() const
    {
        return needForCheckingAntiTrackingHeuristic_;
    }

    nsString&
    cspNonce()
    {
        return cspNonce_;
    }
    const nsString&
    cspNonce() const
    {
        return cspNonce_;
    }

    nsString&
    integrityMetadata()
    {
        return integrityMetadata_;
    }
    const nsString&
    integrityMetadata() const
    {
        return integrityMetadata_;
    }

    bool&
    skipContentSniffing()
    {
        return skipContentSniffing_;
    }
    const bool&
    skipContentSniffing() const
    {
        return skipContentSniffing_;
    }

    uint32_t&
    httpsOnlyStatus()
    {
        return httpsOnlyStatus_;
    }
    const uint32_t&
    httpsOnlyStatus() const
    {
        return httpsOnlyStatus_;
    }

    bool&
    hstsStatus()
    {
        return hstsStatus_;
    }
    const bool&
    hstsStatus() const
    {
        return hstsStatus_;
    }

    bool&
    hasValidUserGestureActivation()
    {
        return hasValidUserGestureActivation_;
    }
    const bool&
    hasValidUserGestureActivation() const
    {
        return hasValidUserGestureActivation_;
    }

    bool&
    textDirectiveUserActivation()
    {
        return textDirectiveUserActivation_;
    }
    const bool&
    textDirectiveUserActivation() const
    {
        return textDirectiveUserActivation_;
    }

    bool&
    allowDeprecatedSystemRequests()
    {
        return allowDeprecatedSystemRequests_;
    }
    const bool&
    allowDeprecatedSystemRequests() const
    {
        return allowDeprecatedSystemRequests_;
    }

    bool&
    isInDevToolsContext()
    {
        return isInDevToolsContext_;
    }
    const bool&
    isInDevToolsContext() const
    {
        return isInDevToolsContext_;
    }

    bool&
    parserCreatedScript()
    {
        return parserCreatedScript_;
    }
    const bool&
    parserCreatedScript() const
    {
        return parserCreatedScript_;
    }

    mozilla::Maybe<RequestMode>&
    requestMode()
    {
        return requestMode_;
    }
    const mozilla::Maybe<RequestMode>&
    requestMode() const
    {
        return requestMode_;
    }

    bool&
    isFromProcessingFrameAttributes()
    {
        return isFromProcessingFrameAttributes_;
    }
    const bool&
    isFromProcessingFrameAttributes() const
    {
        return isFromProcessingFrameAttributes_;
    }

    bool&
    isMediaRequest()
    {
        return isMediaRequest_;
    }
    const bool&
    isMediaRequest() const
    {
        return isMediaRequest_;
    }

    bool&
    isMediaInitialRequest()
    {
        return isMediaInitialRequest_;
    }
    const bool&
    isMediaInitialRequest() const
    {
        return isMediaInitialRequest_;
    }

    bool&
    isFromObjectOrEmbed()
    {
        return isFromObjectOrEmbed_;
    }
    const bool&
    isFromObjectOrEmbed() const
    {
        return isFromObjectOrEmbed_;
    }

    CookieJarSettingsArgs&
    cookieJarSettings()
    {
        return cookieJarSettings_;
    }
    const CookieJarSettingsArgs&
    cookieJarSettings() const
    {
        return cookieJarSettings_;
    }

    uint32_t&
    requestBlockingReason()
    {
        return requestBlockingReason_;
    }
    const uint32_t&
    requestBlockingReason() const
    {
        return requestBlockingReason_;
    }

    mozilla::Maybe<PolicyContainerArgs>&
    policyContainerToInherit()
    {
        return policyContainerToInherit_;
    }
    const mozilla::Maybe<PolicyContainerArgs>&
    policyContainerToInherit() const
    {
        return policyContainerToInherit_;
    }

    StoragePermissionState&
    storagePermission()
    {
        return storagePermission_;
    }
    const StoragePermissionState&
    storagePermission() const
    {
        return storagePermission_;
    }

    IPAddressSpace&
    parentIPAddressSpace()
    {
        return parentIPAddressSpace_;
    }
    const IPAddressSpace&
    parentIPAddressSpace() const
    {
        return parentIPAddressSpace_;
    }

    IPAddressSpace&
    ipAddressSpace()
    {
        return ipAddressSpace_;
    }
    const IPAddressSpace&
    ipAddressSpace() const
    {
        return ipAddressSpace_;
    }

    mozilla::Maybe<RFPTargetSet>&
    overriddenFingerprintingSettings()
    {
        return overriddenFingerprintingSettings_;
    }
    const mozilla::Maybe<RFPTargetSet>&
    overriddenFingerprintingSettings() const
    {
        return overriddenFingerprintingSettings_;
    }

    bool&
    isMetaRefresh()
    {
        return isMetaRefresh_;
    }
    const bool&
    isMetaRefresh() const
    {
        return isMetaRefresh_;
    }

    CrossOriginEmbedderPolicy&
    loadingEmbedderPolicy()
    {
        return loadingEmbedderPolicy_;
    }
    const CrossOriginEmbedderPolicy&
    loadingEmbedderPolicy() const
    {
        return loadingEmbedderPolicy_;
    }

    bool&
    originTrialCoepCredentiallessEnabledForTopLevel()
    {
        return originTrialCoepCredentiallessEnabledForTopLevel_;
    }
    const bool&
    originTrialCoepCredentiallessEnabledForTopLevel() const
    {
        return originTrialCoepCredentiallessEnabledForTopLevel_;
    }

    RefPtr<nsIURI>&
    unstrippedURI()
    {
        return unstrippedURI_;
    }
    nsIURI*
    unstrippedURI() const
    {
        return unstrippedURI_;
    }

    mozilla::Maybe<InterceptionInfoArg>&
    interceptionInfo()
    {
        return interceptionInfo_;
    }
    const mozilla::Maybe<InterceptionInfoArg>&
    interceptionInfo() const
    {
        return interceptionInfo_;
    }

    bool&
    isNewWindowTarget()
    {
        return isNewWindowTarget_;
    }
    const bool&
    isNewWindowTarget() const
    {
        return isNewWindowTarget_;
    }

    UserNavigationInvolvement&
    userNavigationInvolvement()
    {
        return userNavigationInvolvement_;
    }
    const UserNavigationInvolvement&
    userNavigationInvolvement() const
    {
        return userNavigationInvolvement_;
    }

    mozilla::Maybe<FeaturePolicyInfo>&
    containerFeaturePolicyInfo()
    {
        return containerFeaturePolicyInfo_;
    }
    const mozilla::Maybe<FeaturePolicyInfo>&
    containerFeaturePolicyInfo() const
    {
        return containerFeaturePolicyInfo_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> requestingPrincipalInfo_;
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> triggeringPrincipalInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> principalToInheritInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> topLevelPrincipalInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> resultPrincipalURI_;
    ::mozilla::ipc::IPDLStructMember<nsCString> triggeringRemoteType_;
    ::mozilla::ipc::IPDLStructMember<nsID> sandboxedNullPrincipalID_;
    ::mozilla::ipc::IPDLStructMember<bool> triggeringStorageAccess_;
    ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
    ::mozilla::ipc::IPDLStructMember<bool> blockAllMixedContent_;
    ::mozilla::ipc::IPDLStructMember<bool> upgradeInsecureRequests_;
    ::mozilla::ipc::IPDLStructMember<bool> browserUpgradeInsecureRequests_;
    ::mozilla::ipc::IPDLStructMember<bool> browserDidUpgradeInsecureRequests_;
    ::mozilla::ipc::IPDLStructMember<bool> browserWouldUpgradeInsecureRequests_;
    ::mozilla::ipc::IPDLStructMember<bool> forceAllowDataURI_;
    ::mozilla::ipc::IPDLStructMember<bool> allowInsecureRedirectToDataURI_;
    ::mozilla::ipc::IPDLStructMember<ForceMediaDocument> forceMediaDocument_;
    ::mozilla::ipc::IPDLStructMember<bool> skipContentPolicyCheckForWebRequest_;
    ::mozilla::ipc::IPDLStructMember<bool> originalFrameSrcLoad_;
    ::mozilla::ipc::IPDLStructMember<bool> forceInheritPrincipalDropped_;
    ::mozilla::ipc::IPDLStructMember<bool> initialSecurityCheckDone_;
    ::mozilla::ipc::IPDLStructMember<bool> isInThirdPartyContext_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> isThirdPartyContextToTopWindow_;
    ::mozilla::ipc::IPDLStructMember<bool> isOn3PCBExceptionList_;
    ::mozilla::ipc::IPDLStructMember<bool> isFormSubmission_;
    ::mozilla::ipc::IPDLStructMember<bool> isGETRequest_;
    ::mozilla::ipc::IPDLStructMember<bool> sendCSPViolationEvents_;
    ::mozilla::ipc::IPDLStructMember<OriginAttributes> originAttributes_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChainIncludingInternalRedirects_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<RedirectHistoryEntryInfo>> redirectChain_;
    ::mozilla::ipc::IPDLStructMember<bool> hasInjectedCookieForCookieBannerHandling_;
    ::mozilla::ipc::IPDLStructMember<SchemelessInputType> schemelessInput_;
    ::mozilla::ipc::IPDLStructMember<HTTPSUpgradeTelemetryType> httpsUpgradeTelemetry_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> clientInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> reservedClientInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> corsUnsafeHeaders_;
    ::mozilla::ipc::IPDLStructMember<bool> forcePreflight_;
    ::mozilla::ipc::IPDLStructMember<bool> isPreflight_;
    ::mozilla::ipc::IPDLStructMember<bool> loadTriggeredFromExternal_;
    ::mozilla::ipc::IPDLStructMember<bool> serviceWorkerTaintingSynthesized_;
    ::mozilla::ipc::IPDLStructMember<bool> documentHasUserInteracted_;
    ::mozilla::ipc::IPDLStructMember<bool> allowListFutureDocumentsCreatedFromThisRedirectChain_;
    ::mozilla::ipc::IPDLStructMember<bool> needForCheckingAntiTrackingHeuristic_;
    ::mozilla::ipc::IPDLStructMember<nsString> cspNonce_;
    ::mozilla::ipc::IPDLStructMember<nsString> integrityMetadata_;
    ::mozilla::ipc::IPDLStructMember<bool> skipContentSniffing_;
    ::mozilla::ipc::IPDLStructMember<bool> hstsStatus_;
    ::mozilla::ipc::IPDLStructMember<bool> hasValidUserGestureActivation_;
    ::mozilla::ipc::IPDLStructMember<bool> textDirectiveUserActivation_;
    ::mozilla::ipc::IPDLStructMember<bool> allowDeprecatedSystemRequests_;
    ::mozilla::ipc::IPDLStructMember<bool> isInDevToolsContext_;
    ::mozilla::ipc::IPDLStructMember<bool> parserCreatedScript_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<RequestMode>> requestMode_;
    ::mozilla::ipc::IPDLStructMember<bool> isFromProcessingFrameAttributes_;
    ::mozilla::ipc::IPDLStructMember<bool> isMediaRequest_;
    ::mozilla::ipc::IPDLStructMember<bool> isMediaInitialRequest_;
    ::mozilla::ipc::IPDLStructMember<bool> isFromObjectOrEmbed_;
    ::mozilla::ipc::IPDLStructMember<CookieJarSettingsArgs> cookieJarSettings_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PolicyContainerArgs>> policyContainerToInherit_;
    ::mozilla::ipc::IPDLStructMember<StoragePermissionState> storagePermission_;
    ::mozilla::ipc::IPDLStructMember<IPAddressSpace> parentIPAddressSpace_;
    ::mozilla::ipc::IPDLStructMember<IPAddressSpace> ipAddressSpace_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<RFPTargetSet>> overriddenFingerprintingSettings_;
    ::mozilla::ipc::IPDLStructMember<bool> isMetaRefresh_;
    ::mozilla::ipc::IPDLStructMember<CrossOriginEmbedderPolicy> loadingEmbedderPolicy_;
    ::mozilla::ipc::IPDLStructMember<bool> originTrialCoepCredentiallessEnabledForTopLevel_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> unstrippedURI_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<InterceptionInfoArg>> interceptionInfo_;
    ::mozilla::ipc::IPDLStructMember<bool> isNewWindowTarget_;
    ::mozilla::ipc::IPDLStructMember<UserNavigationInvolvement> userNavigationInvolvement_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<FeaturePolicyInfo>> containerFeaturePolicyInfo_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> triggeringWindowId_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> innerWindowID_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> browsingContextID_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> frameBrowsingContextID_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> securityFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> sandboxFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> triggeringSandboxFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> triggeringFirstPartyClassificationFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> triggeringThirdPartyClassificationFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> tainting_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> httpsOnlyStatus_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::LoadInfoArgs>
{
    typedef ::mozilla::net::LoadInfoArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ParentLoadInfoForwarderArgs|
//
namespace mozilla {
namespace net {
class ParentLoadInfoForwarderArgs final
{
private:
    typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
    typedef ::uint32_t uint32_t;
    typedef ::nsILoadInfo::SchemelessInputType SchemelessInputType;
    typedef ::nsILoadInfo::HTTPSUpgradeTelemetryType HTTPSUpgradeTelemetryType;
    typedef ::mozilla::dom::RequestMode RequestMode;
    typedef ::uint64_t uint64_t;
    typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
    typedef ::mozilla::dom::FeaturePolicyInfo FeaturePolicyInfo;
    typedef ::nsILoadInfo::StoragePermissionState StoragePermissionState;
    typedef ::mozilla::RFPTargetSet RFPTargetSet;
    typedef ::nsIURI nsIURI;
    typedef ::mozilla::dom::UserNavigationInvolvement UserNavigationInvolvement;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ParentLoadInfoForwarderArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ParentLoadInfoForwarderArgs(
            const bool& _allowInsecureRedirectToDataURI,
            const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
            const uint32_t& _tainting,
            const bool& _skipContentSniffing,
            const uint32_t& _httpsOnlyStatus,
            const SchemelessInputType& _schemelessInput,
            const HTTPSUpgradeTelemetryType& _httpsUpgradeTelemetry,
            const bool& _hstsStatus,
            const bool& _hasValidUserGestureActivation,
            const bool& _textDirectiveUserActivation,
            const bool& _allowDeprecatedSystemRequests,
            const bool& _isInDevToolsContext,
            const bool& _parserCreatedScript,
            const mozilla::Maybe<RequestMode>& _requestMode,
            const uint32_t& _triggeringSandboxFlags,
            const uint64_t& _triggeringWindowId,
            const bool& _triggeringStorageAccess,
            const bool& _serviceWorkerTaintingSynthesized,
            const bool& _documentHasUserInteracted,
            const bool& _allowListFutureDocumentsCreatedFromThisRedirectChain,
            const mozilla::Maybe<CookieJarSettingsArgs>& _cookieJarSettings,
            const mozilla::Maybe<FeaturePolicyInfo>& _containerFeaturePolicyInfo,
            const uint32_t& _requestBlockingReason,
            const StoragePermissionState& _storagePermission,
            const mozilla::Maybe<RFPTargetSet>& _overriddenFingerprintingSettings,
            const bool& _isMetaRefresh,
            const mozilla::Maybe<bool>& _isThirdPartyContextToTopWindow,
            const bool& _isInThirdPartyContext,
            const bool& _isOn3PCBExceptionList,
            nsIURI* _unstrippedURI,
            const UserNavigationInvolvement& _userNavigationInvolvement) :
        allowInsecureRedirectToDataURI_(_allowInsecureRedirectToDataURI),
        controller_(_controller),
        skipContentSniffing_(_skipContentSniffing),
        schemelessInput_(_schemelessInput),
        httpsUpgradeTelemetry_(_httpsUpgradeTelemetry),
        hstsStatus_(_hstsStatus),
        hasValidUserGestureActivation_(_hasValidUserGestureActivation),
        textDirectiveUserActivation_(_textDirectiveUserActivation),
        allowDeprecatedSystemRequests_(_allowDeprecatedSystemRequests),
        isInDevToolsContext_(_isInDevToolsContext),
        parserCreatedScript_(_parserCreatedScript),
        requestMode_(_requestMode),
        triggeringStorageAccess_(_triggeringStorageAccess),
        serviceWorkerTaintingSynthesized_(_serviceWorkerTaintingSynthesized),
        documentHasUserInteracted_(_documentHasUserInteracted),
        allowListFutureDocumentsCreatedFromThisRedirectChain_(_allowListFutureDocumentsCreatedFromThisRedirectChain),
        cookieJarSettings_(_cookieJarSettings),
        containerFeaturePolicyInfo_(_containerFeaturePolicyInfo),
        storagePermission_(_storagePermission),
        overriddenFingerprintingSettings_(_overriddenFingerprintingSettings),
        isMetaRefresh_(_isMetaRefresh),
        isThirdPartyContextToTopWindow_(_isThirdPartyContextToTopWindow),
        isInThirdPartyContext_(_isInThirdPartyContext),
        isOn3PCBExceptionList_(_isOn3PCBExceptionList),
        unstrippedURI_(_unstrippedURI),
        userNavigationInvolvement_(_userNavigationInvolvement),
        triggeringWindowId_(_triggeringWindowId),
        tainting_(_tainting),
        httpsOnlyStatus_(_httpsOnlyStatus),
        triggeringSandboxFlags_(_triggeringSandboxFlags),
        requestBlockingReason_(_requestBlockingReason)
    {
    }

    MOZ_IMPLICIT ParentLoadInfoForwarderArgs(
            bool&& _allowInsecureRedirectToDataURI,
            mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
            uint32_t&& _tainting,
            bool&& _skipContentSniffing,
            uint32_t&& _httpsOnlyStatus,
            SchemelessInputType&& _schemelessInput,
            HTTPSUpgradeTelemetryType&& _httpsUpgradeTelemetry,
            bool&& _hstsStatus,
            bool&& _hasValidUserGestureActivation,
            bool&& _textDirectiveUserActivation,
            bool&& _allowDeprecatedSystemRequests,
            bool&& _isInDevToolsContext,
            bool&& _parserCreatedScript,
            mozilla::Maybe<RequestMode>&& _requestMode,
            uint32_t&& _triggeringSandboxFlags,
            uint64_t&& _triggeringWindowId,
            bool&& _triggeringStorageAccess,
            bool&& _serviceWorkerTaintingSynthesized,
            bool&& _documentHasUserInteracted,
            bool&& _allowListFutureDocumentsCreatedFromThisRedirectChain,
            mozilla::Maybe<CookieJarSettingsArgs>&& _cookieJarSettings,
            mozilla::Maybe<FeaturePolicyInfo>&& _containerFeaturePolicyInfo,
            uint32_t&& _requestBlockingReason,
            StoragePermissionState&& _storagePermission,
            mozilla::Maybe<RFPTargetSet>&& _overriddenFingerprintingSettings,
            bool&& _isMetaRefresh,
            mozilla::Maybe<bool>&& _isThirdPartyContextToTopWindow,
            bool&& _isInThirdPartyContext,
            bool&& _isOn3PCBExceptionList,
            RefPtr<nsIURI>&& _unstrippedURI,
            UserNavigationInvolvement&& _userNavigationInvolvement) :
        allowInsecureRedirectToDataURI_(std::move(_allowInsecureRedirectToDataURI)),
        controller_(std::move(_controller)),
        skipContentSniffing_(std::move(_skipContentSniffing)),
        schemelessInput_(std::move(_schemelessInput)),
        httpsUpgradeTelemetry_(std::move(_httpsUpgradeTelemetry)),
        hstsStatus_(std::move(_hstsStatus)),
        hasValidUserGestureActivation_(std::move(_hasValidUserGestureActivation)),
        textDirectiveUserActivation_(std::move(_textDirectiveUserActivation)),
        allowDeprecatedSystemRequests_(std::move(_allowDeprecatedSystemRequests)),
        isInDevToolsContext_(std::move(_isInDevToolsContext)),
        parserCreatedScript_(std::move(_parserCreatedScript)),
        requestMode_(std::move(_requestMode)),
        triggeringStorageAccess_(std::move(_triggeringStorageAccess)),
        serviceWorkerTaintingSynthesized_(std::move(_serviceWorkerTaintingSynthesized)),
        documentHasUserInteracted_(std::move(_documentHasUserInteracted)),
        allowListFutureDocumentsCreatedFromThisRedirectChain_(std::move(_allowListFutureDocumentsCreatedFromThisRedirectChain)),
        cookieJarSettings_(std::move(_cookieJarSettings)),
        containerFeaturePolicyInfo_(std::move(_containerFeaturePolicyInfo)),
        storagePermission_(std::move(_storagePermission)),
        overriddenFingerprintingSettings_(std::move(_overriddenFingerprintingSettings)),
        isMetaRefresh_(std::move(_isMetaRefresh)),
        isThirdPartyContextToTopWindow_(std::move(_isThirdPartyContextToTopWindow)),
        isInThirdPartyContext_(std::move(_isInThirdPartyContext)),
        isOn3PCBExceptionList_(std::move(_isOn3PCBExceptionList)),
        unstrippedURI_(std::move(_unstrippedURI)),
        userNavigationInvolvement_(std::move(_userNavigationInvolvement)),
        triggeringWindowId_(std::move(_triggeringWindowId)),
        tainting_(std::move(_tainting)),
        httpsOnlyStatus_(std::move(_httpsOnlyStatus)),
        triggeringSandboxFlags_(std::move(_triggeringSandboxFlags)),
        requestBlockingReason_(std::move(_requestBlockingReason))
    {
    }

    bool&
    allowInsecureRedirectToDataURI()
    {
        return allowInsecureRedirectToDataURI_;
    }
    const bool&
    allowInsecureRedirectToDataURI() const
    {
        return allowInsecureRedirectToDataURI_;
    }

    mozilla::Maybe<IPCServiceWorkerDescriptor>&
    controller()
    {
        return controller_;
    }
    const mozilla::Maybe<IPCServiceWorkerDescriptor>&
    controller() const
    {
        return controller_;
    }

    uint32_t&
    tainting()
    {
        return tainting_;
    }
    const uint32_t&
    tainting() const
    {
        return tainting_;
    }

    bool&
    skipContentSniffing()
    {
        return skipContentSniffing_;
    }
    const bool&
    skipContentSniffing() const
    {
        return skipContentSniffing_;
    }

    uint32_t&
    httpsOnlyStatus()
    {
        return httpsOnlyStatus_;
    }
    const uint32_t&
    httpsOnlyStatus() const
    {
        return httpsOnlyStatus_;
    }

    SchemelessInputType&
    schemelessInput()
    {
        return schemelessInput_;
    }
    const SchemelessInputType&
    schemelessInput() const
    {
        return schemelessInput_;
    }

    HTTPSUpgradeTelemetryType&
    httpsUpgradeTelemetry()
    {
        return httpsUpgradeTelemetry_;
    }
    const HTTPSUpgradeTelemetryType&
    httpsUpgradeTelemetry() const
    {
        return httpsUpgradeTelemetry_;
    }

    bool&
    hstsStatus()
    {
        return hstsStatus_;
    }
    const bool&
    hstsStatus() const
    {
        return hstsStatus_;
    }

    bool&
    hasValidUserGestureActivation()
    {
        return hasValidUserGestureActivation_;
    }
    const bool&
    hasValidUserGestureActivation() const
    {
        return hasValidUserGestureActivation_;
    }

    bool&
    textDirectiveUserActivation()
    {
        return textDirectiveUserActivation_;
    }
    const bool&
    textDirectiveUserActivation() const
    {
        return textDirectiveUserActivation_;
    }

    bool&
    allowDeprecatedSystemRequests()
    {
        return allowDeprecatedSystemRequests_;
    }
    const bool&
    allowDeprecatedSystemRequests() const
    {
        return allowDeprecatedSystemRequests_;
    }

    bool&
    isInDevToolsContext()
    {
        return isInDevToolsContext_;
    }
    const bool&
    isInDevToolsContext() const
    {
        return isInDevToolsContext_;
    }

    bool&
    parserCreatedScript()
    {
        return parserCreatedScript_;
    }
    const bool&
    parserCreatedScript() const
    {
        return parserCreatedScript_;
    }

    mozilla::Maybe<RequestMode>&
    requestMode()
    {
        return requestMode_;
    }
    const mozilla::Maybe<RequestMode>&
    requestMode() const
    {
        return requestMode_;
    }

    uint32_t&
    triggeringSandboxFlags()
    {
        return triggeringSandboxFlags_;
    }
    const uint32_t&
    triggeringSandboxFlags() const
    {
        return triggeringSandboxFlags_;
    }

    uint64_t&
    triggeringWindowId()
    {
        return triggeringWindowId_;
    }
    const uint64_t&
    triggeringWindowId() const
    {
        return triggeringWindowId_;
    }

    bool&
    triggeringStorageAccess()
    {
        return triggeringStorageAccess_;
    }
    const bool&
    triggeringStorageAccess() const
    {
        return triggeringStorageAccess_;
    }

    bool&
    serviceWorkerTaintingSynthesized()
    {
        return serviceWorkerTaintingSynthesized_;
    }
    const bool&
    serviceWorkerTaintingSynthesized() const
    {
        return serviceWorkerTaintingSynthesized_;
    }

    bool&
    documentHasUserInteracted()
    {
        return documentHasUserInteracted_;
    }
    const bool&
    documentHasUserInteracted() const
    {
        return documentHasUserInteracted_;
    }

    bool&
    allowListFutureDocumentsCreatedFromThisRedirectChain()
    {
        return allowListFutureDocumentsCreatedFromThisRedirectChain_;
    }
    const bool&
    allowListFutureDocumentsCreatedFromThisRedirectChain() const
    {
        return allowListFutureDocumentsCreatedFromThisRedirectChain_;
    }

    mozilla::Maybe<CookieJarSettingsArgs>&
    cookieJarSettings()
    {
        return cookieJarSettings_;
    }
    const mozilla::Maybe<CookieJarSettingsArgs>&
    cookieJarSettings() const
    {
        return cookieJarSettings_;
    }

    mozilla::Maybe<FeaturePolicyInfo>&
    containerFeaturePolicyInfo()
    {
        return containerFeaturePolicyInfo_;
    }
    const mozilla::Maybe<FeaturePolicyInfo>&
    containerFeaturePolicyInfo() const
    {
        return containerFeaturePolicyInfo_;
    }

    uint32_t&
    requestBlockingReason()
    {
        return requestBlockingReason_;
    }
    const uint32_t&
    requestBlockingReason() const
    {
        return requestBlockingReason_;
    }

    StoragePermissionState&
    storagePermission()
    {
        return storagePermission_;
    }
    const StoragePermissionState&
    storagePermission() const
    {
        return storagePermission_;
    }

    mozilla::Maybe<RFPTargetSet>&
    overriddenFingerprintingSettings()
    {
        return overriddenFingerprintingSettings_;
    }
    const mozilla::Maybe<RFPTargetSet>&
    overriddenFingerprintingSettings() const
    {
        return overriddenFingerprintingSettings_;
    }

    bool&
    isMetaRefresh()
    {
        return isMetaRefresh_;
    }
    const bool&
    isMetaRefresh() const
    {
        return isMetaRefresh_;
    }

    mozilla::Maybe<bool>&
    isThirdPartyContextToTopWindow()
    {
        return isThirdPartyContextToTopWindow_;
    }
    const mozilla::Maybe<bool>&
    isThirdPartyContextToTopWindow() const
    {
        return isThirdPartyContextToTopWindow_;
    }

    bool&
    isInThirdPartyContext()
    {
        return isInThirdPartyContext_;
    }
    const bool&
    isInThirdPartyContext() const
    {
        return isInThirdPartyContext_;
    }

    bool&
    isOn3PCBExceptionList()
    {
        return isOn3PCBExceptionList_;
    }
    const bool&
    isOn3PCBExceptionList() const
    {
        return isOn3PCBExceptionList_;
    }

    RefPtr<nsIURI>&
    unstrippedURI()
    {
        return unstrippedURI_;
    }
    nsIURI*
    unstrippedURI() const
    {
        return unstrippedURI_;
    }

    UserNavigationInvolvement&
    userNavigationInvolvement()
    {
        return userNavigationInvolvement_;
    }
    const UserNavigationInvolvement&
    userNavigationInvolvement() const
    {
        return userNavigationInvolvement_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<bool> allowInsecureRedirectToDataURI_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
    ::mozilla::ipc::IPDLStructMember<bool> skipContentSniffing_;
    ::mozilla::ipc::IPDLStructMember<SchemelessInputType> schemelessInput_;
    ::mozilla::ipc::IPDLStructMember<HTTPSUpgradeTelemetryType> httpsUpgradeTelemetry_;
    ::mozilla::ipc::IPDLStructMember<bool> hstsStatus_;
    ::mozilla::ipc::IPDLStructMember<bool> hasValidUserGestureActivation_;
    ::mozilla::ipc::IPDLStructMember<bool> textDirectiveUserActivation_;
    ::mozilla::ipc::IPDLStructMember<bool> allowDeprecatedSystemRequests_;
    ::mozilla::ipc::IPDLStructMember<bool> isInDevToolsContext_;
    ::mozilla::ipc::IPDLStructMember<bool> parserCreatedScript_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<RequestMode>> requestMode_;
    ::mozilla::ipc::IPDLStructMember<bool> triggeringStorageAccess_;
    ::mozilla::ipc::IPDLStructMember<bool> serviceWorkerTaintingSynthesized_;
    ::mozilla::ipc::IPDLStructMember<bool> documentHasUserInteracted_;
    ::mozilla::ipc::IPDLStructMember<bool> allowListFutureDocumentsCreatedFromThisRedirectChain_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CookieJarSettingsArgs>> cookieJarSettings_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<FeaturePolicyInfo>> containerFeaturePolicyInfo_;
    ::mozilla::ipc::IPDLStructMember<StoragePermissionState> storagePermission_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<RFPTargetSet>> overriddenFingerprintingSettings_;
    ::mozilla::ipc::IPDLStructMember<bool> isMetaRefresh_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> isThirdPartyContextToTopWindow_;
    ::mozilla::ipc::IPDLStructMember<bool> isInThirdPartyContext_;
    ::mozilla::ipc::IPDLStructMember<bool> isOn3PCBExceptionList_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> unstrippedURI_;
    ::mozilla::ipc::IPDLStructMember<UserNavigationInvolvement> userNavigationInvolvement_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> triggeringWindowId_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> tainting_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> httpsOnlyStatus_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> triggeringSandboxFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ParentLoadInfoForwarderArgs>
{
    typedef ::mozilla::net::ParentLoadInfoForwarderArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ChildLoadInfoForwarderArgs|
//
namespace mozilla {
namespace net {
class ChildLoadInfoForwarderArgs final
{
private:
    typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
    typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ChildLoadInfoForwarderArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ChildLoadInfoForwarderArgs(
            const mozilla::Maybe<IPCClientInfo>& _reservedClientInfo,
            const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
            const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
            const uint32_t& _requestBlockingReason) :
        reservedClientInfo_(_reservedClientInfo),
        initialClientInfo_(_initialClientInfo),
        controller_(_controller),
        requestBlockingReason_(_requestBlockingReason)
    {
    }

    MOZ_IMPLICIT ChildLoadInfoForwarderArgs(
            mozilla::Maybe<IPCClientInfo>&& _reservedClientInfo,
            mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
            mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
            uint32_t&& _requestBlockingReason) :
        reservedClientInfo_(std::move(_reservedClientInfo)),
        initialClientInfo_(std::move(_initialClientInfo)),
        controller_(std::move(_controller)),
        requestBlockingReason_(std::move(_requestBlockingReason))
    {
    }

    mozilla::Maybe<IPCClientInfo>&
    reservedClientInfo()
    {
        return reservedClientInfo_;
    }
    const mozilla::Maybe<IPCClientInfo>&
    reservedClientInfo() const
    {
        return reservedClientInfo_;
    }

    mozilla::Maybe<IPCClientInfo>&
    initialClientInfo()
    {
        return initialClientInfo_;
    }
    const mozilla::Maybe<IPCClientInfo>&
    initialClientInfo() const
    {
        return initialClientInfo_;
    }

    mozilla::Maybe<IPCServiceWorkerDescriptor>&
    controller()
    {
        return controller_;
    }
    const mozilla::Maybe<IPCServiceWorkerDescriptor>&
    controller() const
    {
        return controller_;
    }

    uint32_t&
    requestBlockingReason()
    {
        return requestBlockingReason_;
    }
    const uint32_t&
    requestBlockingReason() const
    {
        return requestBlockingReason_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> reservedClientInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> requestBlockingReason_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ChildLoadInfoForwarderArgs>
{
    typedef ::mozilla::net::ChildLoadInfoForwarderArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CorsPreflightArgs|
//
namespace mozilla {
namespace net {
class CorsPreflightArgs final
{
private:
    typedef ::nsCString nsCString;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    CorsPreflightArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT CorsPreflightArgs(const nsTArray<nsCString>& _unsafeHeaders) :
        unsafeHeaders_(_unsafeHeaders)
    {
    }

    MOZ_IMPLICIT CorsPreflightArgs(nsTArray<nsCString>&& _unsafeHeaders) :
        unsafeHeaders_(std::move(_unsafeHeaders))
    {
    }

    nsTArray<nsCString>&
    unsafeHeaders()
    {
        return unsafeHeaders_;
    }
    const nsTArray<nsCString>&
    unsafeHeaders() const
    {
        return unsafeHeaders_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> unsafeHeaders_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CorsPreflightArgs>
{
    typedef ::mozilla::net::CorsPreflightArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpChannelOpenArgs|
//
namespace mozilla {
namespace net {
class HttpChannelOpenArgs final
{
private:
    typedef ::nsIURI nsIURI;
    typedef ::nsIReferrerInfo nsIReferrerInfo;
    typedef ::mozilla::net::RequestHeaderTuples RequestHeaderTuples;
    typedef ::mozilla::net::PreferredAlternativeDataTypeParams PreferredAlternativeDataTypeParams;
    typedef ::mozilla::TimeStamp TimeStamp;
    typedef ::uint64_t uint64_t;
    typedef ::nsCString nsCString;
    typedef ::mozilla::net::ClassOfService ClassOfService;
    typedef ::mozilla::net::CorsPreflightArgs CorsPreflightArgs;
    typedef ::mozilla::ipc::IPCStream IPCStream;
    typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
    typedef ::uint32_t uint32_t;
    typedef ::int16_t int16_t;
    typedef ::mozilla::dom::RequestMode RequestMode;
    typedef ::uint8_t uint8_t;
    typedef ::nsString nsString;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    HttpChannelOpenArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT HttpChannelOpenArgs(
            nsIURI* _uri,
            nsIURI* _original,
            nsIURI* _doc,
            nsIReferrerInfo* _referrerInfo,
            nsIURI* _apiRedirectTo,
            nsIURI* _topWindowURI,
            const RequestHeaderTuples& _requestHeaders,
            const nsTArray<PreferredAlternativeDataTypeParams>& _preferredAlternativeTypes,
            const TimeStamp& _launchServiceWorkerStart,
            const TimeStamp& _launchServiceWorkerEnd,
            const TimeStamp& _dispatchFetchEventStart,
            const TimeStamp& _dispatchFetchEventEnd,
            const TimeStamp& _handleFetchEventStart,
            const TimeStamp& _handleFetchEventEnd,
            const TimeStamp& _navigationStartTimeStamp,
            const uint64_t& _startPos,
            const uint64_t& _requestContextID,
            const uint64_t& _channelId,
            const uint64_t& _contentWindowId,
            const uint64_t& _browserId,
            const uint64_t& _earlyHintPreloaderId,
            const nsCString& _requestMethod,
            const ClassOfService& _classOfService,
            const nsCString& _entityID,
            const nsCString& _appCacheClientID,
            const mozilla::Maybe<CorsPreflightArgs>& _preflightArgs,
            const nsCString& _contentTypeHint,
            const mozilla::Maybe<IPCStream>& _uploadStream,
            const LoadInfoArgs& _loadInfo,
            const uint32_t& _loadFlags,
            const uint32_t& _thirdPartyFlags,
            const uint32_t& _tlsFlags,
            const uint32_t& _cacheKey,
            const uint32_t& _initialRwin,
            const uint32_t& _redirectMode,
            const int16_t& _priority,
            const bool& _uploadStreamHasHeaders,
            const bool& _allowSTS,
            const bool& _resumeAt,
            const bool& _allowSpdy,
            const bool& _allowHttp3,
            const bool& _allowAltSvc,
            const bool& _beConservative,
            const bool& _bypassProxy,
            const bool& _blockAuthPrompt,
            const bool& _allowStaleCacheContent,
            const RequestMode& _requestMode,
            const bool& _forceValidateCacheContent,
            const bool& _preferCacheLoadOverBypass,
            const bool& _forceMainDocumentChannel,
            const uint8_t& _redirectionLimit,
            const nsString& _classicScriptHintCharset,
            const nsString& _documentCharacterSet,
            const bool& _isUserAgentHeaderModified,
            const nsString& _initiatorType) :
        uri_(_uri),
        original_(_original),
        doc_(_doc),
        referrerInfo_(_referrerInfo),
        apiRedirectTo_(_apiRedirectTo),
        topWindowURI_(_topWindowURI),
        requestHeaders_(_requestHeaders),
        preferredAlternativeTypes_(_preferredAlternativeTypes),
        launchServiceWorkerStart_(_launchServiceWorkerStart),
        launchServiceWorkerEnd_(_launchServiceWorkerEnd),
        dispatchFetchEventStart_(_dispatchFetchEventStart),
        dispatchFetchEventEnd_(_dispatchFetchEventEnd),
        handleFetchEventStart_(_handleFetchEventStart),
        handleFetchEventEnd_(_handleFetchEventEnd),
        navigationStartTimeStamp_(_navigationStartTimeStamp),
        requestMethod_(_requestMethod),
        classOfService_(_classOfService),
        entityID_(_entityID),
        appCacheClientID_(_appCacheClientID),
        preflightArgs_(_preflightArgs),
        contentTypeHint_(_contentTypeHint),
        uploadStream_(_uploadStream),
        loadInfo_(_loadInfo),
        uploadStreamHasHeaders_(_uploadStreamHasHeaders),
        allowSTS_(_allowSTS),
        resumeAt_(_resumeAt),
        allowSpdy_(_allowSpdy),
        allowHttp3_(_allowHttp3),
        allowAltSvc_(_allowAltSvc),
        beConservative_(_beConservative),
        bypassProxy_(_bypassProxy),
        blockAuthPrompt_(_blockAuthPrompt),
        allowStaleCacheContent_(_allowStaleCacheContent),
        requestMode_(_requestMode),
        forceValidateCacheContent_(_forceValidateCacheContent),
        preferCacheLoadOverBypass_(_preferCacheLoadOverBypass),
        forceMainDocumentChannel_(_forceMainDocumentChannel),
        classicScriptHintCharset_(_classicScriptHintCharset),
        documentCharacterSet_(_documentCharacterSet),
        isUserAgentHeaderModified_(_isUserAgentHeaderModified),
        initiatorType_(_initiatorType),
        startPos_(_startPos),
        requestContextID_(_requestContextID),
        channelId_(_channelId),
        contentWindowId_(_contentWindowId),
        browserId_(_browserId),
        earlyHintPreloaderId_(_earlyHintPreloaderId),
        loadFlags_(_loadFlags),
        thirdPartyFlags_(_thirdPartyFlags),
        tlsFlags_(_tlsFlags),
        cacheKey_(_cacheKey),
        initialRwin_(_initialRwin),
        redirectMode_(_redirectMode),
        priority_(_priority),
        redirectionLimit_(_redirectionLimit)
    {
    }

    MOZ_IMPLICIT HttpChannelOpenArgs(
            RefPtr<nsIURI>&& _uri,
            RefPtr<nsIURI>&& _original,
            RefPtr<nsIURI>&& _doc,
            RefPtr<nsIReferrerInfo>&& _referrerInfo,
            RefPtr<nsIURI>&& _apiRedirectTo,
            RefPtr<nsIURI>&& _topWindowURI,
            RequestHeaderTuples&& _requestHeaders,
            nsTArray<PreferredAlternativeDataTypeParams>&& _preferredAlternativeTypes,
            TimeStamp&& _launchServiceWorkerStart,
            TimeStamp&& _launchServiceWorkerEnd,
            TimeStamp&& _dispatchFetchEventStart,
            TimeStamp&& _dispatchFetchEventEnd,
            TimeStamp&& _handleFetchEventStart,
            TimeStamp&& _handleFetchEventEnd,
            TimeStamp&& _navigationStartTimeStamp,
            uint64_t&& _startPos,
            uint64_t&& _requestContextID,
            uint64_t&& _channelId,
            uint64_t&& _contentWindowId,
            uint64_t&& _browserId,
            uint64_t&& _earlyHintPreloaderId,
            nsCString&& _requestMethod,
            ClassOfService&& _classOfService,
            nsCString&& _entityID,
            nsCString&& _appCacheClientID,
            mozilla::Maybe<CorsPreflightArgs>&& _preflightArgs,
            nsCString&& _contentTypeHint,
            mozilla::Maybe<IPCStream>&& _uploadStream,
            LoadInfoArgs&& _loadInfo,
            uint32_t&& _loadFlags,
            uint32_t&& _thirdPartyFlags,
            uint32_t&& _tlsFlags,
            uint32_t&& _cacheKey,
            uint32_t&& _initialRwin,
            uint32_t&& _redirectMode,
            int16_t&& _priority,
            bool&& _uploadStreamHasHeaders,
            bool&& _allowSTS,
            bool&& _resumeAt,
            bool&& _allowSpdy,
            bool&& _allowHttp3,
            bool&& _allowAltSvc,
            bool&& _beConservative,
            bool&& _bypassProxy,
            bool&& _blockAuthPrompt,
            bool&& _allowStaleCacheContent,
            RequestMode&& _requestMode,
            bool&& _forceValidateCacheContent,
            bool&& _preferCacheLoadOverBypass,
            bool&& _forceMainDocumentChannel,
            uint8_t&& _redirectionLimit,
            nsString&& _classicScriptHintCharset,
            nsString&& _documentCharacterSet,
            bool&& _isUserAgentHeaderModified,
            nsString&& _initiatorType) :
        uri_(std::move(_uri)),
        original_(std::move(_original)),
        doc_(std::move(_doc)),
        referrerInfo_(std::move(_referrerInfo)),
        apiRedirectTo_(std::move(_apiRedirectTo)),
        topWindowURI_(std::move(_topWindowURI)),
        requestHeaders_(std::move(_requestHeaders)),
        preferredAlternativeTypes_(std::move(_preferredAlternativeTypes)),
        launchServiceWorkerStart_(std::move(_launchServiceWorkerStart)),
        launchServiceWorkerEnd_(std::move(_launchServiceWorkerEnd)),
        dispatchFetchEventStart_(std::move(_dispatchFetchEventStart)),
        dispatchFetchEventEnd_(std::move(_dispatchFetchEventEnd)),
        handleFetchEventStart_(std::move(_handleFetchEventStart)),
        handleFetchEventEnd_(std::move(_handleFetchEventEnd)),
        navigationStartTimeStamp_(std::move(_navigationStartTimeStamp)),
        requestMethod_(std::move(_requestMethod)),
        classOfService_(std::move(_classOfService)),
        entityID_(std::move(_entityID)),
        appCacheClientID_(std::move(_appCacheClientID)),
        preflightArgs_(std::move(_preflightArgs)),
        contentTypeHint_(std::move(_contentTypeHint)),
        uploadStream_(std::move(_uploadStream)),
        loadInfo_(std::move(_loadInfo)),
        uploadStreamHasHeaders_(std::move(_uploadStreamHasHeaders)),
        allowSTS_(std::move(_allowSTS)),
        resumeAt_(std::move(_resumeAt)),
        allowSpdy_(std::move(_allowSpdy)),
        allowHttp3_(std::move(_allowHttp3)),
        allowAltSvc_(std::move(_allowAltSvc)),
        beConservative_(std::move(_beConservative)),
        bypassProxy_(std::move(_bypassProxy)),
        blockAuthPrompt_(std::move(_blockAuthPrompt)),
        allowStaleCacheContent_(std::move(_allowStaleCacheContent)),
        requestMode_(std::move(_requestMode)),
        forceValidateCacheContent_(std::move(_forceValidateCacheContent)),
        preferCacheLoadOverBypass_(std::move(_preferCacheLoadOverBypass)),
        forceMainDocumentChannel_(std::move(_forceMainDocumentChannel)),
        classicScriptHintCharset_(std::move(_classicScriptHintCharset)),
        documentCharacterSet_(std::move(_documentCharacterSet)),
        isUserAgentHeaderModified_(std::move(_isUserAgentHeaderModified)),
        initiatorType_(std::move(_initiatorType)),
        startPos_(std::move(_startPos)),
        requestContextID_(std::move(_requestContextID)),
        channelId_(std::move(_channelId)),
        contentWindowId_(std::move(_contentWindowId)),
        browserId_(std::move(_browserId)),
        earlyHintPreloaderId_(std::move(_earlyHintPreloaderId)),
        loadFlags_(std::move(_loadFlags)),
        thirdPartyFlags_(std::move(_thirdPartyFlags)),
        tlsFlags_(std::move(_tlsFlags)),
        cacheKey_(std::move(_cacheKey)),
        initialRwin_(std::move(_initialRwin)),
        redirectMode_(std::move(_redirectMode)),
        priority_(std::move(_priority)),
        redirectionLimit_(std::move(_redirectionLimit))
    {
    }

    RefPtr<nsIURI>&
    uri()
    {
        return uri_;
    }
    nsIURI*
    uri() const
    {
        return uri_;
    }

    RefPtr<nsIURI>&
    original()
    {
        return original_;
    }
    nsIURI*
    original() const
    {
        return original_;
    }

    RefPtr<nsIURI>&
    doc()
    {
        return doc_;
    }
    nsIURI*
    doc() const
    {
        return doc_;
    }

    RefPtr<nsIReferrerInfo>&
    referrerInfo()
    {
        return referrerInfo_;
    }
    nsIReferrerInfo*
    referrerInfo() const
    {
        return referrerInfo_;
    }

    RefPtr<nsIURI>&
    apiRedirectTo()
    {
        return apiRedirectTo_;
    }
    nsIURI*
    apiRedirectTo() const
    {
        return apiRedirectTo_;
    }

    RefPtr<nsIURI>&
    topWindowURI()
    {
        return topWindowURI_;
    }
    nsIURI*
    topWindowURI() const
    {
        return topWindowURI_;
    }

    RequestHeaderTuples&
    requestHeaders()
    {
        return requestHeaders_;
    }
    const RequestHeaderTuples&
    requestHeaders() const
    {
        return requestHeaders_;
    }

    nsTArray<PreferredAlternativeDataTypeParams>&
    preferredAlternativeTypes()
    {
        return preferredAlternativeTypes_;
    }
    const nsTArray<PreferredAlternativeDataTypeParams>&
    preferredAlternativeTypes() const
    {
        return preferredAlternativeTypes_;
    }

    TimeStamp&
    launchServiceWorkerStart()
    {
        return launchServiceWorkerStart_;
    }
    const TimeStamp&
    launchServiceWorkerStart() const
    {
        return launchServiceWorkerStart_;
    }

    TimeStamp&
    launchServiceWorkerEnd()
    {
        return launchServiceWorkerEnd_;
    }
    const TimeStamp&
    launchServiceWorkerEnd() const
    {
        return launchServiceWorkerEnd_;
    }

    TimeStamp&
    dispatchFetchEventStart()
    {
        return dispatchFetchEventStart_;
    }
    const TimeStamp&
    dispatchFetchEventStart() const
    {
        return dispatchFetchEventStart_;
    }

    TimeStamp&
    dispatchFetchEventEnd()
    {
        return dispatchFetchEventEnd_;
    }
    const TimeStamp&
    dispatchFetchEventEnd() const
    {
        return dispatchFetchEventEnd_;
    }

    TimeStamp&
    handleFetchEventStart()
    {
        return handleFetchEventStart_;
    }
    const TimeStamp&
    handleFetchEventStart() const
    {
        return handleFetchEventStart_;
    }

    TimeStamp&
    handleFetchEventEnd()
    {
        return handleFetchEventEnd_;
    }
    const TimeStamp&
    handleFetchEventEnd() const
    {
        return handleFetchEventEnd_;
    }

    TimeStamp&
    navigationStartTimeStamp()
    {
        return navigationStartTimeStamp_;
    }
    const TimeStamp&
    navigationStartTimeStamp() const
    {
        return navigationStartTimeStamp_;
    }

    uint64_t&
    startPos()
    {
        return startPos_;
    }
    const uint64_t&
    startPos() const
    {
        return startPos_;
    }

    uint64_t&
    requestContextID()
    {
        return requestContextID_;
    }
    const uint64_t&
    requestContextID() const
    {
        return requestContextID_;
    }

    uint64_t&
    channelId()
    {
        return channelId_;
    }
    const uint64_t&
    channelId() const
    {
        return channelId_;
    }

    uint64_t&
    contentWindowId()
    {
        return contentWindowId_;
    }
    const uint64_t&
    contentWindowId() const
    {
        return contentWindowId_;
    }

    uint64_t&
    browserId()
    {
        return browserId_;
    }
    const uint64_t&
    browserId() const
    {
        return browserId_;
    }

    uint64_t&
    earlyHintPreloaderId()
    {
        return earlyHintPreloaderId_;
    }
    const uint64_t&
    earlyHintPreloaderId() const
    {
        return earlyHintPreloaderId_;
    }

    nsCString&
    requestMethod()
    {
        return requestMethod_;
    }
    const nsCString&
    requestMethod() const
    {
        return requestMethod_;
    }

    ClassOfService&
    classOfService()
    {
        return classOfService_;
    }
    const ClassOfService&
    classOfService() const
    {
        return classOfService_;
    }

    nsCString&
    entityID()
    {
        return entityID_;
    }
    const nsCString&
    entityID() const
    {
        return entityID_;
    }

    nsCString&
    appCacheClientID()
    {
        return appCacheClientID_;
    }
    const nsCString&
    appCacheClientID() const
    {
        return appCacheClientID_;
    }

    mozilla::Maybe<CorsPreflightArgs>&
    preflightArgs()
    {
        return preflightArgs_;
    }
    const mozilla::Maybe<CorsPreflightArgs>&
    preflightArgs() const
    {
        return preflightArgs_;
    }

    nsCString&
    contentTypeHint()
    {
        return contentTypeHint_;
    }
    const nsCString&
    contentTypeHint() const
    {
        return contentTypeHint_;
    }

    mozilla::Maybe<IPCStream>&
    uploadStream()
    {
        return uploadStream_;
    }
    const mozilla::Maybe<IPCStream>&
    uploadStream() const
    {
        return uploadStream_;
    }

    LoadInfoArgs&
    loadInfo()
    {
        return loadInfo_;
    }
    const LoadInfoArgs&
    loadInfo() const
    {
        return loadInfo_;
    }

    uint32_t&
    loadFlags()
    {
        return loadFlags_;
    }
    const uint32_t&
    loadFlags() const
    {
        return loadFlags_;
    }

    uint32_t&
    thirdPartyFlags()
    {
        return thirdPartyFlags_;
    }
    const uint32_t&
    thirdPartyFlags() const
    {
        return thirdPartyFlags_;
    }

    uint32_t&
    tlsFlags()
    {
        return tlsFlags_;
    }
    const uint32_t&
    tlsFlags() const
    {
        return tlsFlags_;
    }

    uint32_t&
    cacheKey()
    {
        return cacheKey_;
    }
    const uint32_t&
    cacheKey() const
    {
        return cacheKey_;
    }

    uint32_t&
    initialRwin()
    {
        return initialRwin_;
    }
    const uint32_t&
    initialRwin() const
    {
        return initialRwin_;
    }

    uint32_t&
    redirectMode()
    {
        return redirectMode_;
    }
    const uint32_t&
    redirectMode() const
    {
        return redirectMode_;
    }

    int16_t&
    priority()
    {
        return priority_;
    }
    const int16_t&
    priority() const
    {
        return priority_;
    }

    bool&
    uploadStreamHasHeaders()
    {
        return uploadStreamHasHeaders_;
    }
    const bool&
    uploadStreamHasHeaders() const
    {
        return uploadStreamHasHeaders_;
    }

    bool&
    allowSTS()
    {
        return allowSTS_;
    }
    const bool&
    allowSTS() const
    {
        return allowSTS_;
    }

    bool&
    resumeAt()
    {
        return resumeAt_;
    }
    const bool&
    resumeAt() const
    {
        return resumeAt_;
    }

    bool&
    allowSpdy()
    {
        return allowSpdy_;
    }
    const bool&
    allowSpdy() const
    {
        return allowSpdy_;
    }

    bool&
    allowHttp3()
    {
        return allowHttp3_;
    }
    const bool&
    allowHttp3() const
    {
        return allowHttp3_;
    }

    bool&
    allowAltSvc()
    {
        return allowAltSvc_;
    }
    const bool&
    allowAltSvc() const
    {
        return allowAltSvc_;
    }

    bool&
    beConservative()
    {
        return beConservative_;
    }
    const bool&
    beConservative() const
    {
        return beConservative_;
    }

    bool&
    bypassProxy()
    {
        return bypassProxy_;
    }
    const bool&
    bypassProxy() const
    {
        return bypassProxy_;
    }

    bool&
    blockAuthPrompt()
    {
        return blockAuthPrompt_;
    }
    const bool&
    blockAuthPrompt() const
    {
        return blockAuthPrompt_;
    }

    bool&
    allowStaleCacheContent()
    {
        return allowStaleCacheContent_;
    }
    const bool&
    allowStaleCacheContent() const
    {
        return allowStaleCacheContent_;
    }

    RequestMode&
    requestMode()
    {
        return requestMode_;
    }
    const RequestMode&
    requestMode() const
    {
        return requestMode_;
    }

    bool&
    forceValidateCacheContent()
    {
        return forceValidateCacheContent_;
    }
    const bool&
    forceValidateCacheContent() const
    {
        return forceValidateCacheContent_;
    }

    bool&
    preferCacheLoadOverBypass()
    {
        return preferCacheLoadOverBypass_;
    }
    const bool&
    preferCacheLoadOverBypass() const
    {
        return preferCacheLoadOverBypass_;
    }

    bool&
    forceMainDocumentChannel()
    {
        return forceMainDocumentChannel_;
    }
    const bool&
    forceMainDocumentChannel() const
    {
        return forceMainDocumentChannel_;
    }

    uint8_t&
    redirectionLimit()
    {
        return redirectionLimit_;
    }
    const uint8_t&
    redirectionLimit() const
    {
        return redirectionLimit_;
    }

    nsString&
    classicScriptHintCharset()
    {
        return classicScriptHintCharset_;
    }
    const nsString&
    classicScriptHintCharset() const
    {
        return classicScriptHintCharset_;
    }

    nsString&
    documentCharacterSet()
    {
        return documentCharacterSet_;
    }
    const nsString&
    documentCharacterSet() const
    {
        return documentCharacterSet_;
    }

    bool&
    isUserAgentHeaderModified()
    {
        return isUserAgentHeaderModified_;
    }
    const bool&
    isUserAgentHeaderModified() const
    {
        return isUserAgentHeaderModified_;
    }

    nsString&
    initiatorType()
    {
        return initiatorType_;
    }
    const nsString&
    initiatorType() const
    {
        return initiatorType_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> original_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> doc_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> referrerInfo_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> apiRedirectTo_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> topWindowURI_;
    ::mozilla::ipc::IPDLStructMember<RequestHeaderTuples> requestHeaders_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<PreferredAlternativeDataTypeParams>> preferredAlternativeTypes_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> launchServiceWorkerStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> launchServiceWorkerEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> dispatchFetchEventStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> dispatchFetchEventEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> handleFetchEventStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> handleFetchEventEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> navigationStartTimeStamp_;
    ::mozilla::ipc::IPDLStructMember<nsCString> requestMethod_;
    ::mozilla::ipc::IPDLStructMember<ClassOfService> classOfService_;
    ::mozilla::ipc::IPDLStructMember<nsCString> entityID_;
    ::mozilla::ipc::IPDLStructMember<nsCString> appCacheClientID_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CorsPreflightArgs>> preflightArgs_;
    ::mozilla::ipc::IPDLStructMember<nsCString> contentTypeHint_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCStream>> uploadStream_;
    ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
    ::mozilla::ipc::IPDLStructMember<bool> uploadStreamHasHeaders_;
    ::mozilla::ipc::IPDLStructMember<bool> allowSTS_;
    ::mozilla::ipc::IPDLStructMember<bool> resumeAt_;
    ::mozilla::ipc::IPDLStructMember<bool> allowSpdy_;
    ::mozilla::ipc::IPDLStructMember<bool> allowHttp3_;
    ::mozilla::ipc::IPDLStructMember<bool> allowAltSvc_;
    ::mozilla::ipc::IPDLStructMember<bool> beConservative_;
    ::mozilla::ipc::IPDLStructMember<bool> bypassProxy_;
    ::mozilla::ipc::IPDLStructMember<bool> blockAuthPrompt_;
    ::mozilla::ipc::IPDLStructMember<bool> allowStaleCacheContent_;
    ::mozilla::ipc::IPDLStructMember<RequestMode> requestMode_;
    ::mozilla::ipc::IPDLStructMember<bool> forceValidateCacheContent_;
    ::mozilla::ipc::IPDLStructMember<bool> preferCacheLoadOverBypass_;
    ::mozilla::ipc::IPDLStructMember<bool> forceMainDocumentChannel_;
    ::mozilla::ipc::IPDLStructMember<nsString> classicScriptHintCharset_;
    ::mozilla::ipc::IPDLStructMember<nsString> documentCharacterSet_;
    ::mozilla::ipc::IPDLStructMember<bool> isUserAgentHeaderModified_;
    ::mozilla::ipc::IPDLStructMember<nsString> initiatorType_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> startPos_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> requestContextID_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> contentWindowId_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> browserId_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> earlyHintPreloaderId_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> thirdPartyFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> tlsFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> cacheKey_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> initialRwin_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> redirectMode_;
    ::mozilla::ipc::IPDLStructMember<int16_t> priority_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> redirectionLimit_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelOpenArgs>
{
    typedef ::mozilla::net::HttpChannelOpenArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpChannelConnectArgs|
//
namespace mozilla {
namespace net {
class HttpChannelConnectArgs final
{
private:
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    HttpChannelConnectArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT HttpChannelConnectArgs(const uint32_t& _registrarId) :
        registrarId_(_registrarId)
    {
    }

    MOZ_IMPLICIT HttpChannelConnectArgs(uint32_t&& _registrarId) :
        registrarId_(std::move(_registrarId))
    {
    }

    uint32_t&
    registrarId()
    {
        return registrarId_;
    }
    const uint32_t&
    registrarId() const
    {
        return registrarId_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<uint32_t> registrarId_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelConnectArgs>
{
    typedef ::mozilla::net::HttpChannelConnectArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union HttpChannelCreationArgs|
//
namespace mozilla {
namespace net {
class HttpChannelCreationArgs final
{
public:
    enum Type {
        T__None,
        THttpChannelOpenArgs = 1,
        THttpChannelConnectArgs,
        T__Last = THttpChannelConnectArgs
    };

private:
    typedef ::mozilla::net::HttpChannelOpenArgs HttpChannelOpenArgs;
    typedef ::mozilla::net::HttpChannelConnectArgs HttpChannelConnectArgs;
    typedef HttpChannelOpenArgs HttpChannelOpenArgs__tdef;
    typedef HttpChannelConnectArgs HttpChannelConnectArgs__tdef;

    HttpChannelOpenArgs*
    ptr_HttpChannelOpenArgs()
    {
        return (&(mVHttpChannelOpenArgs));
    }
    const HttpChannelOpenArgs*
    constptr_HttpChannelOpenArgs() const
    {
        return (&(mVHttpChannelOpenArgs));
    }
    HttpChannelConnectArgs*
    ptr_HttpChannelConnectArgs()
    {
        return (&(mVHttpChannelConnectArgs));
    }
    const HttpChannelConnectArgs*
    constptr_HttpChannelConnectArgs() const
    {
        return (&(mVHttpChannelConnectArgs));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT HttpChannelCreationArgs() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelOpenArgs& aOther);

    MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelOpenArgs&& aOther);

    MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelConnectArgs& aOther);

    MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelConnectArgs&& aOther);

    MOZ_IMPLICIT HttpChannelCreationArgs(const HttpChannelCreationArgs& aOther);

    MOZ_IMPLICIT HttpChannelCreationArgs(HttpChannelCreationArgs&& aOther);

    ~HttpChannelCreationArgs();

    Type
    type() const
    {
        return mType;
    }

    HttpChannelCreationArgs&
    operator=(const HttpChannelOpenArgs& aRhs);

    HttpChannelCreationArgs&
    operator=(HttpChannelOpenArgs&& aRhs);

    HttpChannelCreationArgs&
    operator=(const HttpChannelConnectArgs& aRhs);

    HttpChannelCreationArgs&
    operator=(HttpChannelConnectArgs&& aRhs);

    HttpChannelCreationArgs&
    operator=(const HttpChannelCreationArgs& aRhs);

    HttpChannelCreationArgs&
    operator=(HttpChannelCreationArgs&& aRhs);

    HttpChannelOpenArgs&
    get_HttpChannelOpenArgs()
    {
        AssertSanity(THttpChannelOpenArgs);
        return (*(ptr_HttpChannelOpenArgs()));
    }
    const HttpChannelOpenArgs&
    get_HttpChannelOpenArgs() const
    {
        AssertSanity(THttpChannelOpenArgs);
        return (*(constptr_HttpChannelOpenArgs()));
    }
    operator HttpChannelOpenArgs&()
    {
        return get_HttpChannelOpenArgs();
    }
    operator const HttpChannelOpenArgs&() const
    {
        return get_HttpChannelOpenArgs();
    }

    HttpChannelConnectArgs&
    get_HttpChannelConnectArgs()
    {
        AssertSanity(THttpChannelConnectArgs);
        return (*(ptr_HttpChannelConnectArgs()));
    }
    const HttpChannelConnectArgs&
    get_HttpChannelConnectArgs() const
    {
        AssertSanity(THttpChannelConnectArgs);
        return (*(constptr_HttpChannelConnectArgs()));
    }
    operator HttpChannelConnectArgs&()
    {
        return get_HttpChannelConnectArgs();
    }
    operator const HttpChannelConnectArgs&() const
    {
        return get_HttpChannelConnectArgs();
    }

private:
    union {
        HttpChannelOpenArgs mVHttpChannelOpenArgs;
        HttpChannelConnectArgs mVHttpChannelConnectArgs;
    };
    Type mType;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpChannelCreationArgs>
{
    typedef ::mozilla::net::HttpChannelCreationArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ProxyInfoCloneArgs|
//
namespace mozilla {
namespace net {
class ProxyInfoCloneArgs final
{
private:
    typedef ::nsCString nsCString;
    typedef ::int32_t int32_t;
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ProxyInfoCloneArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ProxyInfoCloneArgs(
            const nsCString& _type,
            const nsCString& _host,
            const int32_t& _port,
            const nsCString& _masqueTemplate,
            const nsCString& _alpn,
            const nsCString& _username,
            const nsCString& _password,
            const uint32_t& _flags,
            const uint32_t& _timeout,
            const uint32_t& _resolveFlags,
            const nsCString& _proxyAuthorizationHeader,
            const nsCString& _connectionIsolationKey) :
        type_(_type),
        host_(_host),
        masqueTemplate_(_masqueTemplate),
        alpn_(_alpn),
        username_(_username),
        password_(_password),
        proxyAuthorizationHeader_(_proxyAuthorizationHeader),
        connectionIsolationKey_(_connectionIsolationKey),
        port_(_port),
        flags_(_flags),
        timeout_(_timeout),
        resolveFlags_(_resolveFlags)
    {
    }

    MOZ_IMPLICIT ProxyInfoCloneArgs(
            nsCString&& _type,
            nsCString&& _host,
            int32_t&& _port,
            nsCString&& _masqueTemplate,
            nsCString&& _alpn,
            nsCString&& _username,
            nsCString&& _password,
            uint32_t&& _flags,
            uint32_t&& _timeout,
            uint32_t&& _resolveFlags,
            nsCString&& _proxyAuthorizationHeader,
            nsCString&& _connectionIsolationKey) :
        type_(std::move(_type)),
        host_(std::move(_host)),
        masqueTemplate_(std::move(_masqueTemplate)),
        alpn_(std::move(_alpn)),
        username_(std::move(_username)),
        password_(std::move(_password)),
        proxyAuthorizationHeader_(std::move(_proxyAuthorizationHeader)),
        connectionIsolationKey_(std::move(_connectionIsolationKey)),
        port_(std::move(_port)),
        flags_(std::move(_flags)),
        timeout_(std::move(_timeout)),
        resolveFlags_(std::move(_resolveFlags))
    {
    }

    nsCString&
    type()
    {
        return type_;
    }
    const nsCString&
    type() const
    {
        return type_;
    }

    nsCString&
    host()
    {
        return host_;
    }
    const nsCString&
    host() const
    {
        return host_;
    }

    int32_t&
    port()
    {
        return port_;
    }
    const int32_t&
    port() const
    {
        return port_;
    }

    nsCString&
    masqueTemplate()
    {
        return masqueTemplate_;
    }
    const nsCString&
    masqueTemplate() const
    {
        return masqueTemplate_;
    }

    nsCString&
    alpn()
    {
        return alpn_;
    }
    const nsCString&
    alpn() const
    {
        return alpn_;
    }

    nsCString&
    username()
    {
        return username_;
    }
    const nsCString&
    username() const
    {
        return username_;
    }

    nsCString&
    password()
    {
        return password_;
    }
    const nsCString&
    password() const
    {
        return password_;
    }

    uint32_t&
    flags()
    {
        return flags_;
    }
    const uint32_t&
    flags() const
    {
        return flags_;
    }

    uint32_t&
    timeout()
    {
        return timeout_;
    }
    const uint32_t&
    timeout() const
    {
        return timeout_;
    }

    uint32_t&
    resolveFlags()
    {
        return resolveFlags_;
    }
    const uint32_t&
    resolveFlags() const
    {
        return resolveFlags_;
    }

    nsCString&
    proxyAuthorizationHeader()
    {
        return proxyAuthorizationHeader_;
    }
    const nsCString&
    proxyAuthorizationHeader() const
    {
        return proxyAuthorizationHeader_;
    }

    nsCString&
    connectionIsolationKey()
    {
        return connectionIsolationKey_;
    }
    const nsCString&
    connectionIsolationKey() const
    {
        return connectionIsolationKey_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<nsCString> type_;
    ::mozilla::ipc::IPDLStructMember<nsCString> host_;
    ::mozilla::ipc::IPDLStructMember<nsCString> masqueTemplate_;
    ::mozilla::ipc::IPDLStructMember<nsCString> alpn_;
    ::mozilla::ipc::IPDLStructMember<nsCString> username_;
    ::mozilla::ipc::IPDLStructMember<nsCString> password_;
    ::mozilla::ipc::IPDLStructMember<nsCString> proxyAuthorizationHeader_;
    ::mozilla::ipc::IPDLStructMember<nsCString> connectionIsolationKey_;
    ::mozilla::ipc::IPDLStructMember<int32_t> port_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> flags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> timeout_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> resolveFlags_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ProxyInfoCloneArgs>
{
    typedef ::mozilla::net::ProxyInfoCloneArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpConnectionInfoCloneArgs|
//
namespace mozilla {
namespace net {
class HttpConnectionInfoCloneArgs final
{
private:
    typedef ::nsCString nsCString;
    typedef ::int32_t int32_t;
    typedef ::mozilla::OriginAttributes OriginAttributes;
    typedef ::uint32_t uint32_t;
    typedef ::uint8_t uint8_t;
    typedef ::uint64_t uint64_t;
    typedef ::mozilla::net::ProxyInfoCloneArgs ProxyInfoCloneArgs;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    HttpConnectionInfoCloneArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT HttpConnectionInfoCloneArgs(
            const nsCString& _host,
            const int32_t& _port,
            const nsCString& _npnToken,
            const nsCString& _username,
            const OriginAttributes& _originAttributes,
            const bool& _endToEndSSL,
            const nsCString& _routedHost,
            const int32_t& _routedPort,
            const bool& _anonymous,
            const bool& _aPrivate,
            const bool& _insecureScheme,
            const bool& _noSpdy,
            const bool& _beConservative,
            const bool& _bypassProxy,
            const bool& _anonymousAllowClientCert,
            const bool& _fallbackConnection,
            const uint32_t& _tlsFlags,
            const bool& _isolated,
            const bool& _isTrrServiceChannel,
            const uint8_t& _trrMode,
            const bool& _isIPv4Disabled,
            const bool& _isIPv6Disabled,
            const nsCString& _topWindowOrigin,
            const bool& _isHttp3,
            const bool& _webTransport,
            const uint64_t& _webTransportId,
            const bool& _hasIPHintAddress,
            const nsCString& _echConfig,
            const nsTArray<ProxyInfoCloneArgs>& _proxyInfo) :
        host_(_host),
        npnToken_(_npnToken),
        username_(_username),
        originAttributes_(_originAttributes),
        endToEndSSL_(_endToEndSSL),
        routedHost_(_routedHost),
        anonymous_(_anonymous),
        aPrivate_(_aPrivate),
        insecureScheme_(_insecureScheme),
        noSpdy_(_noSpdy),
        beConservative_(_beConservative),
        bypassProxy_(_bypassProxy),
        anonymousAllowClientCert_(_anonymousAllowClientCert),
        fallbackConnection_(_fallbackConnection),
        isolated_(_isolated),
        isTrrServiceChannel_(_isTrrServiceChannel),
        isIPv4Disabled_(_isIPv4Disabled),
        isIPv6Disabled_(_isIPv6Disabled),
        topWindowOrigin_(_topWindowOrigin),
        isHttp3_(_isHttp3),
        webTransport_(_webTransport),
        hasIPHintAddress_(_hasIPHintAddress),
        echConfig_(_echConfig),
        proxyInfo_(_proxyInfo),
        webTransportId_(_webTransportId),
        port_(_port),
        routedPort_(_routedPort),
        tlsFlags_(_tlsFlags),
        trrMode_(_trrMode)
    {
    }

    MOZ_IMPLICIT HttpConnectionInfoCloneArgs(
            nsCString&& _host,
            int32_t&& _port,
            nsCString&& _npnToken,
            nsCString&& _username,
            OriginAttributes&& _originAttributes,
            bool&& _endToEndSSL,
            nsCString&& _routedHost,
            int32_t&& _routedPort,
            bool&& _anonymous,
            bool&& _aPrivate,
            bool&& _insecureScheme,
            bool&& _noSpdy,
            bool&& _beConservative,
            bool&& _bypassProxy,
            bool&& _anonymousAllowClientCert,
            bool&& _fallbackConnection,
            uint32_t&& _tlsFlags,
            bool&& _isolated,
            bool&& _isTrrServiceChannel,
            uint8_t&& _trrMode,
            bool&& _isIPv4Disabled,
            bool&& _isIPv6Disabled,
            nsCString&& _topWindowOrigin,
            bool&& _isHttp3,
            bool&& _webTransport,
            uint64_t&& _webTransportId,
            bool&& _hasIPHintAddress,
            nsCString&& _echConfig,
            nsTArray<ProxyInfoCloneArgs>&& _proxyInfo) :
        host_(std::move(_host)),
        npnToken_(std::move(_npnToken)),
        username_(std::move(_username)),
        originAttributes_(std::move(_originAttributes)),
        endToEndSSL_(std::move(_endToEndSSL)),
        routedHost_(std::move(_routedHost)),
        anonymous_(std::move(_anonymous)),
        aPrivate_(std::move(_aPrivate)),
        insecureScheme_(std::move(_insecureScheme)),
        noSpdy_(std::move(_noSpdy)),
        beConservative_(std::move(_beConservative)),
        bypassProxy_(std::move(_bypassProxy)),
        anonymousAllowClientCert_(std::move(_anonymousAllowClientCert)),
        fallbackConnection_(std::move(_fallbackConnection)),
        isolated_(std::move(_isolated)),
        isTrrServiceChannel_(std::move(_isTrrServiceChannel)),
        isIPv4Disabled_(std::move(_isIPv4Disabled)),
        isIPv6Disabled_(std::move(_isIPv6Disabled)),
        topWindowOrigin_(std::move(_topWindowOrigin)),
        isHttp3_(std::move(_isHttp3)),
        webTransport_(std::move(_webTransport)),
        hasIPHintAddress_(std::move(_hasIPHintAddress)),
        echConfig_(std::move(_echConfig)),
        proxyInfo_(std::move(_proxyInfo)),
        webTransportId_(std::move(_webTransportId)),
        port_(std::move(_port)),
        routedPort_(std::move(_routedPort)),
        tlsFlags_(std::move(_tlsFlags)),
        trrMode_(std::move(_trrMode))
    {
    }

    nsCString&
    host()
    {
        return host_;
    }
    const nsCString&
    host() const
    {
        return host_;
    }

    int32_t&
    port()
    {
        return port_;
    }
    const int32_t&
    port() const
    {
        return port_;
    }

    nsCString&
    npnToken()
    {
        return npnToken_;
    }
    const nsCString&
    npnToken() const
    {
        return npnToken_;
    }

    nsCString&
    username()
    {
        return username_;
    }
    const nsCString&
    username() const
    {
        return username_;
    }

    OriginAttributes&
    originAttributes()
    {
        return originAttributes_;
    }
    const OriginAttributes&
    originAttributes() const
    {
        return originAttributes_;
    }

    bool&
    endToEndSSL()
    {
        return endToEndSSL_;
    }
    const bool&
    endToEndSSL() const
    {
        return endToEndSSL_;
    }

    nsCString&
    routedHost()
    {
        return routedHost_;
    }
    const nsCString&
    routedHost() const
    {
        return routedHost_;
    }

    int32_t&
    routedPort()
    {
        return routedPort_;
    }
    const int32_t&
    routedPort() const
    {
        return routedPort_;
    }

    bool&
    anonymous()
    {
        return anonymous_;
    }
    const bool&
    anonymous() const
    {
        return anonymous_;
    }

    bool&
    aPrivate()
    {
        return aPrivate_;
    }
    const bool&
    aPrivate() const
    {
        return aPrivate_;
    }

    bool&
    insecureScheme()
    {
        return insecureScheme_;
    }
    const bool&
    insecureScheme() const
    {
        return insecureScheme_;
    }

    bool&
    noSpdy()
    {
        return noSpdy_;
    }
    const bool&
    noSpdy() const
    {
        return noSpdy_;
    }

    bool&
    beConservative()
    {
        return beConservative_;
    }
    const bool&
    beConservative() const
    {
        return beConservative_;
    }

    bool&
    bypassProxy()
    {
        return bypassProxy_;
    }
    const bool&
    bypassProxy() const
    {
        return bypassProxy_;
    }

    bool&
    anonymousAllowClientCert()
    {
        return anonymousAllowClientCert_;
    }
    const bool&
    anonymousAllowClientCert() const
    {
        return anonymousAllowClientCert_;
    }

    bool&
    fallbackConnection()
    {
        return fallbackConnection_;
    }
    const bool&
    fallbackConnection() const
    {
        return fallbackConnection_;
    }

    uint32_t&
    tlsFlags()
    {
        return tlsFlags_;
    }
    const uint32_t&
    tlsFlags() const
    {
        return tlsFlags_;
    }

    bool&
    isolated()
    {
        return isolated_;
    }
    const bool&
    isolated() const
    {
        return isolated_;
    }

    bool&
    isTrrServiceChannel()
    {
        return isTrrServiceChannel_;
    }
    const bool&
    isTrrServiceChannel() const
    {
        return isTrrServiceChannel_;
    }

    uint8_t&
    trrMode()
    {
        return trrMode_;
    }
    const uint8_t&
    trrMode() const
    {
        return trrMode_;
    }

    bool&
    isIPv4Disabled()
    {
        return isIPv4Disabled_;
    }
    const bool&
    isIPv4Disabled() const
    {
        return isIPv4Disabled_;
    }

    bool&
    isIPv6Disabled()
    {
        return isIPv6Disabled_;
    }
    const bool&
    isIPv6Disabled() const
    {
        return isIPv6Disabled_;
    }

    nsCString&
    topWindowOrigin()
    {
        return topWindowOrigin_;
    }
    const nsCString&
    topWindowOrigin() const
    {
        return topWindowOrigin_;
    }

    bool&
    isHttp3()
    {
        return isHttp3_;
    }
    const bool&
    isHttp3() const
    {
        return isHttp3_;
    }

    bool&
    webTransport()
    {
        return webTransport_;
    }
    const bool&
    webTransport() const
    {
        return webTransport_;
    }

    uint64_t&
    webTransportId()
    {
        return webTransportId_;
    }
    const uint64_t&
    webTransportId() const
    {
        return webTransportId_;
    }

    bool&
    hasIPHintAddress()
    {
        return hasIPHintAddress_;
    }
    const bool&
    hasIPHintAddress() const
    {
        return hasIPHintAddress_;
    }

    nsCString&
    echConfig()
    {
        return echConfig_;
    }
    const nsCString&
    echConfig() const
    {
        return echConfig_;
    }

    nsTArray<ProxyInfoCloneArgs>&
    proxyInfo()
    {
        return proxyInfo_;
    }
    const nsTArray<ProxyInfoCloneArgs>&
    proxyInfo() const
    {
        return proxyInfo_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<nsCString> host_;
    ::mozilla::ipc::IPDLStructMember<nsCString> npnToken_;
    ::mozilla::ipc::IPDLStructMember<nsCString> username_;
    ::mozilla::ipc::IPDLStructMember<OriginAttributes> originAttributes_;
    ::mozilla::ipc::IPDLStructMember<bool> endToEndSSL_;
    ::mozilla::ipc::IPDLStructMember<nsCString> routedHost_;
    ::mozilla::ipc::IPDLStructMember<bool> anonymous_;
    ::mozilla::ipc::IPDLStructMember<bool> aPrivate_;
    ::mozilla::ipc::IPDLStructMember<bool> insecureScheme_;
    ::mozilla::ipc::IPDLStructMember<bool> noSpdy_;
    ::mozilla::ipc::IPDLStructMember<bool> beConservative_;
    ::mozilla::ipc::IPDLStructMember<bool> bypassProxy_;
    ::mozilla::ipc::IPDLStructMember<bool> anonymousAllowClientCert_;
    ::mozilla::ipc::IPDLStructMember<bool> fallbackConnection_;
    ::mozilla::ipc::IPDLStructMember<bool> isolated_;
    ::mozilla::ipc::IPDLStructMember<bool> isTrrServiceChannel_;
    ::mozilla::ipc::IPDLStructMember<bool> isIPv4Disabled_;
    ::mozilla::ipc::IPDLStructMember<bool> isIPv6Disabled_;
    ::mozilla::ipc::IPDLStructMember<nsCString> topWindowOrigin_;
    ::mozilla::ipc::IPDLStructMember<bool> isHttp3_;
    ::mozilla::ipc::IPDLStructMember<bool> webTransport_;
    ::mozilla::ipc::IPDLStructMember<bool> hasIPHintAddress_;
    ::mozilla::ipc::IPDLStructMember<nsCString> echConfig_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<ProxyInfoCloneArgs>> proxyInfo_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> webTransportId_;
    ::mozilla::ipc::IPDLStructMember<int32_t> port_;
    ::mozilla::ipc::IPDLStructMember<int32_t> routedPort_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> tlsFlags_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> trrMode_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpConnectionInfoCloneArgs>
{
    typedef ::mozilla::net::HttpConnectionInfoCloneArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ConsoleReportCollected|
//
namespace mozilla {
namespace net {
class ConsoleReportCollected final
{
private:
    typedef ::uint32_t uint32_t;
    typedef ::nsCString nsCString;
    typedef ::nsString nsString;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ConsoleReportCollected() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ConsoleReportCollected(
            const uint32_t& _errorFlags,
            const nsCString& _category,
            const uint32_t& _propertiesFile,
            const nsCString& _sourceFileURI,
            const uint32_t& _lineNumber,
            const uint32_t& _columnNumber,
            const nsCString& _messageName,
            const nsTArray<nsString>& _stringParams) :
        category_(_category),
        sourceFileURI_(_sourceFileURI),
        messageName_(_messageName),
        stringParams_(_stringParams),
        errorFlags_(_errorFlags),
        propertiesFile_(_propertiesFile),
        lineNumber_(_lineNumber),
        columnNumber_(_columnNumber)
    {
    }

    MOZ_IMPLICIT ConsoleReportCollected(
            uint32_t&& _errorFlags,
            nsCString&& _category,
            uint32_t&& _propertiesFile,
            nsCString&& _sourceFileURI,
            uint32_t&& _lineNumber,
            uint32_t&& _columnNumber,
            nsCString&& _messageName,
            nsTArray<nsString>&& _stringParams) :
        category_(std::move(_category)),
        sourceFileURI_(std::move(_sourceFileURI)),
        messageName_(std::move(_messageName)),
        stringParams_(std::move(_stringParams)),
        errorFlags_(std::move(_errorFlags)),
        propertiesFile_(std::move(_propertiesFile)),
        lineNumber_(std::move(_lineNumber)),
        columnNumber_(std::move(_columnNumber))
    {
    }

    uint32_t&
    errorFlags()
    {
        return errorFlags_;
    }
    const uint32_t&
    errorFlags() const
    {
        return errorFlags_;
    }

    nsCString&
    category()
    {
        return category_;
    }
    const nsCString&
    category() const
    {
        return category_;
    }

    uint32_t&
    propertiesFile()
    {
        return propertiesFile_;
    }
    const uint32_t&
    propertiesFile() const
    {
        return propertiesFile_;
    }

    nsCString&
    sourceFileURI()
    {
        return sourceFileURI_;
    }
    const nsCString&
    sourceFileURI() const
    {
        return sourceFileURI_;
    }

    uint32_t&
    lineNumber()
    {
        return lineNumber_;
    }
    const uint32_t&
    lineNumber() const
    {
        return lineNumber_;
    }

    uint32_t&
    columnNumber()
    {
        return columnNumber_;
    }
    const uint32_t&
    columnNumber() const
    {
        return columnNumber_;
    }

    nsCString&
    messageName()
    {
        return messageName_;
    }
    const nsCString&
    messageName() const
    {
        return messageName_;
    }

    nsTArray<nsString>&
    stringParams()
    {
        return stringParams_;
    }
    const nsTArray<nsString>&
    stringParams() const
    {
        return stringParams_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<nsCString> category_;
    ::mozilla::ipc::IPDLStructMember<nsCString> sourceFileURI_;
    ::mozilla::ipc::IPDLStructMember<nsCString> messageName_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> stringParams_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> errorFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> propertiesFile_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> lineNumber_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> columnNumber_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ConsoleReportCollected>
{
    typedef ::mozilla::net::ConsoleReportCollected paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CookieStructTable|
//
namespace mozilla {
namespace net {
class CookieStructTable final
{
private:
    typedef ::mozilla::OriginAttributes OriginAttributes;
    typedef ::mozilla::net::CookieStruct CookieStruct;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    CookieStructTable() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT CookieStructTable(
            const OriginAttributes& _attrs,
            const nsTArray<CookieStruct>& _cookies) :
        attrs_(_attrs),
        cookies_(_cookies)
    {
    }

    MOZ_IMPLICIT CookieStructTable(
            OriginAttributes&& _attrs,
            nsTArray<CookieStruct>&& _cookies) :
        attrs_(std::move(_attrs)),
        cookies_(std::move(_cookies))
    {
    }

    OriginAttributes&
    attrs()
    {
        return attrs_;
    }
    const OriginAttributes&
    attrs() const
    {
        return attrs_;
    }

    nsTArray<CookieStruct>&
    cookies()
    {
        return cookies_;
    }
    const nsTArray<CookieStruct>&
    cookies() const
    {
        return cookies_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<OriginAttributes> attrs_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<CookieStruct>> cookies_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::CookieStructTable>
{
    typedef ::mozilla::net::CookieStructTable paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct DocumentCreationArgs|
//
namespace mozilla {
namespace net {
class DocumentCreationArgs final
{
private:
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    DocumentCreationArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT DocumentCreationArgs(
            const uint32_t& _loadFlags,
            const bool& _uriModified,
            const bool& _isEmbeddingBlockedError) :
        uriModified_(_uriModified),
        isEmbeddingBlockedError_(_isEmbeddingBlockedError),
        loadFlags_(_loadFlags)
    {
    }

    MOZ_IMPLICIT DocumentCreationArgs(
            uint32_t&& _loadFlags,
            bool&& _uriModified,
            bool&& _isEmbeddingBlockedError) :
        uriModified_(std::move(_uriModified)),
        isEmbeddingBlockedError_(std::move(_isEmbeddingBlockedError)),
        loadFlags_(std::move(_loadFlags))
    {
    }

    uint32_t&
    loadFlags()
    {
        return loadFlags_;
    }
    const uint32_t&
    loadFlags() const
    {
        return loadFlags_;
    }

    bool&
    uriModified()
    {
        return uriModified_;
    }
    const bool&
    uriModified() const
    {
        return uriModified_;
    }

    bool&
    isEmbeddingBlockedError()
    {
        return isEmbeddingBlockedError_;
    }
    const bool&
    isEmbeddingBlockedError() const
    {
        return isEmbeddingBlockedError_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> uriModified_;
    ::mozilla::ipc::IPDLStructMember<bool> isEmbeddingBlockedError_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::DocumentCreationArgs>
{
    typedef ::mozilla::net::DocumentCreationArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectCreationArgs|
//
namespace mozilla {
namespace net {
class ObjectCreationArgs final
{
private:
    typedef ::uint32_t uint32_t;
    typedef ::uint64_t uint64_t;
    typedef ::nsContentPolicyType nsContentPolicyType;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ObjectCreationArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ObjectCreationArgs(
            const uint32_t& _loadFlags,
            const uint64_t& _embedderInnerWindowId,
            const nsContentPolicyType& _contentPolicyType,
            const bool& _isUrgentStart) :
        contentPolicyType_(_contentPolicyType),
        isUrgentStart_(_isUrgentStart),
        embedderInnerWindowId_(_embedderInnerWindowId),
        loadFlags_(_loadFlags)
    {
    }

    MOZ_IMPLICIT ObjectCreationArgs(
            uint32_t&& _loadFlags,
            uint64_t&& _embedderInnerWindowId,
            nsContentPolicyType&& _contentPolicyType,
            bool&& _isUrgentStart) :
        contentPolicyType_(std::move(_contentPolicyType)),
        isUrgentStart_(std::move(_isUrgentStart)),
        embedderInnerWindowId_(std::move(_embedderInnerWindowId)),
        loadFlags_(std::move(_loadFlags))
    {
    }

    uint32_t&
    loadFlags()
    {
        return loadFlags_;
    }
    const uint32_t&
    loadFlags() const
    {
        return loadFlags_;
    }

    uint64_t&
    embedderInnerWindowId()
    {
        return embedderInnerWindowId_;
    }
    const uint64_t&
    embedderInnerWindowId() const
    {
        return embedderInnerWindowId_;
    }

    nsContentPolicyType&
    contentPolicyType()
    {
        return contentPolicyType_;
    }
    const nsContentPolicyType&
    contentPolicyType() const
    {
        return contentPolicyType_;
    }

    bool&
    isUrgentStart()
    {
        return isUrgentStart_;
    }
    const bool&
    isUrgentStart() const
    {
        return isUrgentStart_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
    ::mozilla::ipc::IPDLStructMember<bool> isUrgentStart_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> embedderInnerWindowId_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ObjectCreationArgs>
{
    typedef ::mozilla::net::ObjectCreationArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union DocumentChannelElementCreationArgs|
//
namespace mozilla {
namespace net {
class DocumentChannelElementCreationArgs final
{
public:
    enum Type {
        T__None,
        TDocumentCreationArgs = 1,
        TObjectCreationArgs,
        T__Last = TObjectCreationArgs
    };

private:
    typedef ::mozilla::net::DocumentCreationArgs DocumentCreationArgs;
    typedef ::mozilla::net::ObjectCreationArgs ObjectCreationArgs;
    typedef DocumentCreationArgs DocumentCreationArgs__tdef;
    typedef ObjectCreationArgs ObjectCreationArgs__tdef;

    DocumentCreationArgs*
    ptr_DocumentCreationArgs()
    {
        return (&(mVDocumentCreationArgs));
    }
    const DocumentCreationArgs*
    constptr_DocumentCreationArgs() const
    {
        return (&(mVDocumentCreationArgs));
    }
    ObjectCreationArgs*
    ptr_ObjectCreationArgs()
    {
        return (&(mVObjectCreationArgs));
    }
    const ObjectCreationArgs*
    constptr_ObjectCreationArgs() const
    {
        return (&(mVObjectCreationArgs));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT DocumentChannelElementCreationArgs() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT DocumentChannelElementCreationArgs(const DocumentCreationArgs& aOther);

    MOZ_IMPLICIT DocumentChannelElementCreationArgs(DocumentCreationArgs&& aOther);

    MOZ_IMPLICIT DocumentChannelElementCreationArgs(const ObjectCreationArgs& aOther);

    MOZ_IMPLICIT DocumentChannelElementCreationArgs(ObjectCreationArgs&& aOther);

    MOZ_IMPLICIT DocumentChannelElementCreationArgs(const DocumentChannelElementCreationArgs& aOther);

    MOZ_IMPLICIT DocumentChannelElementCreationArgs(DocumentChannelElementCreationArgs&& aOther);

    ~DocumentChannelElementCreationArgs();

    Type
    type() const
    {
        return mType;
    }

    DocumentChannelElementCreationArgs&
    operator=(const DocumentCreationArgs& aRhs);

    DocumentChannelElementCreationArgs&
    operator=(DocumentCreationArgs&& aRhs);

    DocumentChannelElementCreationArgs&
    operator=(const ObjectCreationArgs& aRhs);

    DocumentChannelElementCreationArgs&
    operator=(ObjectCreationArgs&& aRhs);

    DocumentChannelElementCreationArgs&
    operator=(const DocumentChannelElementCreationArgs& aRhs);

    DocumentChannelElementCreationArgs&
    operator=(DocumentChannelElementCreationArgs&& aRhs);

    DocumentCreationArgs&
    get_DocumentCreationArgs()
    {
        AssertSanity(TDocumentCreationArgs);
        return (*(ptr_DocumentCreationArgs()));
    }
    const DocumentCreationArgs&
    get_DocumentCreationArgs() const
    {
        AssertSanity(TDocumentCreationArgs);
        return (*(constptr_DocumentCreationArgs()));
    }
    operator DocumentCreationArgs&()
    {
        return get_DocumentCreationArgs();
    }
    operator const DocumentCreationArgs&() const
    {
        return get_DocumentCreationArgs();
    }

    ObjectCreationArgs&
    get_ObjectCreationArgs()
    {
        AssertSanity(TObjectCreationArgs);
        return (*(ptr_ObjectCreationArgs()));
    }
    const ObjectCreationArgs&
    get_ObjectCreationArgs() const
    {
        AssertSanity(TObjectCreationArgs);
        return (*(constptr_ObjectCreationArgs()));
    }
    operator ObjectCreationArgs&()
    {
        return get_ObjectCreationArgs();
    }
    operator const ObjectCreationArgs&() const
    {
        return get_ObjectCreationArgs();
    }

private:
    union {
        DocumentCreationArgs mVDocumentCreationArgs;
        ObjectCreationArgs mVObjectCreationArgs;
    };
    Type mType;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::DocumentChannelElementCreationArgs>
{
    typedef ::mozilla::net::DocumentChannelElementCreationArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct DocumentChannelCreationArgs|
//
namespace mozilla {
namespace net {
class DocumentChannelCreationArgs final
{
private:
    typedef ::nsDocShellLoadState nsDocShellLoadState;
    typedef ::mozilla::TimeStamp TimeStamp;
    typedef ::uint64_t uint64_t;
    typedef ::uint32_t uint32_t;
    typedef ::nsDOMNavigationTiming nsDOMNavigationTiming;
    typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
    typedef ::mozilla::net::DocumentChannelElementCreationArgs DocumentChannelElementCreationArgs;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    DocumentChannelCreationArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT DocumentChannelCreationArgs(
            mozilla::NotNull<nsDocShellLoadState*> _loadState,
            const TimeStamp& _asyncOpenTime,
            const uint64_t& _channelId,
            const uint32_t& _cacheKey,
            nsDOMNavigationTiming* _timing,
            const mozilla::Maybe<IPCClientInfo>& _initialClientInfo,
            const DocumentChannelElementCreationArgs& _elementCreationArgs,
            const uint64_t& _parentInitiatedNavigationEpoch) :
        loadState_(_loadState),
        asyncOpenTime_(_asyncOpenTime),
        timing_(_timing),
        initialClientInfo_(_initialClientInfo),
        elementCreationArgs_(_elementCreationArgs),
        channelId_(_channelId),
        parentInitiatedNavigationEpoch_(_parentInitiatedNavigationEpoch),
        cacheKey_(_cacheKey)
    {
    }

    MOZ_IMPLICIT DocumentChannelCreationArgs(
            mozilla::NotNull<RefPtr<nsDocShellLoadState>>&& _loadState,
            TimeStamp&& _asyncOpenTime,
            uint64_t&& _channelId,
            uint32_t&& _cacheKey,
            RefPtr<nsDOMNavigationTiming>&& _timing,
            mozilla::Maybe<IPCClientInfo>&& _initialClientInfo,
            DocumentChannelElementCreationArgs&& _elementCreationArgs,
            uint64_t&& _parentInitiatedNavigationEpoch) :
        loadState_(std::move(_loadState)),
        asyncOpenTime_(std::move(_asyncOpenTime)),
        timing_(std::move(_timing)),
        initialClientInfo_(std::move(_initialClientInfo)),
        elementCreationArgs_(std::move(_elementCreationArgs)),
        channelId_(std::move(_channelId)),
        parentInitiatedNavigationEpoch_(std::move(_parentInitiatedNavigationEpoch)),
        cacheKey_(std::move(_cacheKey))
    {
    }

    mozilla::NotNull<RefPtr<nsDocShellLoadState>>&
    loadState()
    {
        return loadState_;
    }
    mozilla::NotNull<nsDocShellLoadState*>
    loadState() const
    {
        return loadState_;
    }

    TimeStamp&
    asyncOpenTime()
    {
        return asyncOpenTime_;
    }
    const TimeStamp&
    asyncOpenTime() const
    {
        return asyncOpenTime_;
    }

    uint64_t&
    channelId()
    {
        return channelId_;
    }
    const uint64_t&
    channelId() const
    {
        return channelId_;
    }

    uint32_t&
    cacheKey()
    {
        return cacheKey_;
    }
    const uint32_t&
    cacheKey() const
    {
        return cacheKey_;
    }

    RefPtr<nsDOMNavigationTiming>&
    timing()
    {
        return timing_;
    }
    nsDOMNavigationTiming*
    timing() const
    {
        return timing_;
    }

    mozilla::Maybe<IPCClientInfo>&
    initialClientInfo()
    {
        return initialClientInfo_;
    }
    const mozilla::Maybe<IPCClientInfo>&
    initialClientInfo() const
    {
        return initialClientInfo_;
    }

    DocumentChannelElementCreationArgs&
    elementCreationArgs()
    {
        return elementCreationArgs_;
    }
    const DocumentChannelElementCreationArgs&
    elementCreationArgs() const
    {
        return elementCreationArgs_;
    }

    uint64_t&
    parentInitiatedNavigationEpoch()
    {
        return parentInitiatedNavigationEpoch_;
    }
    const uint64_t&
    parentInitiatedNavigationEpoch() const
    {
        return parentInitiatedNavigationEpoch_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<mozilla::NotNull<RefPtr<nsDocShellLoadState>>> loadState_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> asyncOpenTime_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsDOMNavigationTiming>> timing_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> initialClientInfo_;
    ::mozilla::ipc::IPDLStructMember<DocumentChannelElementCreationArgs> elementCreationArgs_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> parentInitiatedNavigationEpoch_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> cacheKey_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::DocumentChannelCreationArgs>
{
    typedef ::mozilla::net::DocumentChannelCreationArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct EarlyHintConnectArgs|
//
namespace mozilla {
namespace net {
class EarlyHintConnectArgs final
{
private:
    typedef ::mozilla::net::LinkHeader LinkHeader;
    typedef ::uint64_t uint64_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    EarlyHintConnectArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT EarlyHintConnectArgs(
            const LinkHeader& _link,
            const uint64_t& _earlyHintPreloaderId) :
        link_(_link),
        earlyHintPreloaderId_(_earlyHintPreloaderId)
    {
    }

    MOZ_IMPLICIT EarlyHintConnectArgs(
            LinkHeader&& _link,
            uint64_t&& _earlyHintPreloaderId) :
        link_(std::move(_link)),
        earlyHintPreloaderId_(std::move(_earlyHintPreloaderId))
    {
    }

    LinkHeader&
    link()
    {
        return link_;
    }
    const LinkHeader&
    link() const
    {
        return link_;
    }

    uint64_t&
    earlyHintPreloaderId()
    {
        return earlyHintPreloaderId_;
    }
    const uint64_t&
    earlyHintPreloaderId() const
    {
        return earlyHintPreloaderId_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<LinkHeader> link_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> earlyHintPreloaderId_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::EarlyHintConnectArgs>
{
    typedef ::mozilla::net::EarlyHintConnectArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct RedirectToRealChannelArgs|
//
namespace mozilla {
namespace net {
class RedirectToRealChannelArgs final
{
private:
    typedef ::uint32_t uint32_t;
    typedef ::nsIURI nsIURI;
    typedef ::mozilla::dom::ReplacementChannelConfigInit ReplacementChannelConfigInit;
    typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
    typedef ::uint64_t uint64_t;
    typedef ::nsString nsString;
    typedef ::nsIPropertyBag2 nsIPropertyBag2;
    typedef ::nsDOMNavigationTiming nsDOMNavigationTiming;
    typedef ::mozilla::dom::LoadingSessionHistoryInfo LoadingSessionHistoryInfo;
    typedef ::nsCString nsCString;
    typedef ::mozilla::net::EarlyHintConnectArgs EarlyHintConnectArgs;
    typedef ::nsIReferrerInfo nsIReferrerInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    RedirectToRealChannelArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT RedirectToRealChannelArgs(
            const uint32_t& _registrarId,
            nsIURI* _uri,
            const uint32_t& _newLoadFlags,
            const mozilla::Maybe<ReplacementChannelConfigInit>& _init,
            const LoadInfoArgs& _loadInfo,
            const uint64_t& _channelId,
            nsIURI* _originalURI,
            const uint32_t& _redirectMode,
            const uint32_t& _redirectFlags,
            const mozilla::Maybe<uint32_t>& _contentDisposition,
            const mozilla::Maybe<nsString>& _contentDispositionFilename,
            nsIPropertyBag2* _properties,
            const uint32_t& _loadStateExternalLoadFlags,
            const uint32_t& _loadStateInternalLoadFlags,
            const uint32_t& _loadStateLoadType,
            nsDOMNavigationTiming* _timing,
            const nsString& _srcdocData,
            nsIURI* _baseUri,
            const mozilla::Maybe<LoadingSessionHistoryInfo>& _loadingSessionHistoryInfo,
            const uint64_t& _loadIdentifier,
            const mozilla::Maybe<nsCString>& _originalUriString,
            const nsTArray<EarlyHintConnectArgs>& _earlyHints,
            const uint32_t& _earlyHintLinkType,
            nsIReferrerInfo* _referrerInfo) :
        uri_(_uri),
        init_(_init),
        loadInfo_(_loadInfo),
        originalURI_(_originalURI),
        contentDisposition_(_contentDisposition),
        contentDispositionFilename_(_contentDispositionFilename),
        properties_(_properties),
        timing_(_timing),
        srcdocData_(_srcdocData),
        baseUri_(_baseUri),
        loadingSessionHistoryInfo_(_loadingSessionHistoryInfo),
        originalUriString_(_originalUriString),
        earlyHints_(_earlyHints),
        referrerInfo_(_referrerInfo),
        channelId_(_channelId),
        loadIdentifier_(_loadIdentifier),
        registrarId_(_registrarId),
        newLoadFlags_(_newLoadFlags),
        redirectMode_(_redirectMode),
        redirectFlags_(_redirectFlags),
        loadStateExternalLoadFlags_(_loadStateExternalLoadFlags),
        loadStateInternalLoadFlags_(_loadStateInternalLoadFlags),
        loadStateLoadType_(_loadStateLoadType),
        earlyHintLinkType_(_earlyHintLinkType)
    {
    }

    MOZ_IMPLICIT RedirectToRealChannelArgs(
            uint32_t&& _registrarId,
            RefPtr<nsIURI>&& _uri,
            uint32_t&& _newLoadFlags,
            mozilla::Maybe<ReplacementChannelConfigInit>&& _init,
            LoadInfoArgs&& _loadInfo,
            uint64_t&& _channelId,
            RefPtr<nsIURI>&& _originalURI,
            uint32_t&& _redirectMode,
            uint32_t&& _redirectFlags,
            mozilla::Maybe<uint32_t>&& _contentDisposition,
            mozilla::Maybe<nsString>&& _contentDispositionFilename,
            RefPtr<nsIPropertyBag2>&& _properties,
            uint32_t&& _loadStateExternalLoadFlags,
            uint32_t&& _loadStateInternalLoadFlags,
            uint32_t&& _loadStateLoadType,
            RefPtr<nsDOMNavigationTiming>&& _timing,
            nsString&& _srcdocData,
            RefPtr<nsIURI>&& _baseUri,
            mozilla::Maybe<LoadingSessionHistoryInfo>&& _loadingSessionHistoryInfo,
            uint64_t&& _loadIdentifier,
            mozilla::Maybe<nsCString>&& _originalUriString,
            nsTArray<EarlyHintConnectArgs>&& _earlyHints,
            uint32_t&& _earlyHintLinkType,
            RefPtr<nsIReferrerInfo>&& _referrerInfo) :
        uri_(std::move(_uri)),
        init_(std::move(_init)),
        loadInfo_(std::move(_loadInfo)),
        originalURI_(std::move(_originalURI)),
        contentDisposition_(std::move(_contentDisposition)),
        contentDispositionFilename_(std::move(_contentDispositionFilename)),
        properties_(std::move(_properties)),
        timing_(std::move(_timing)),
        srcdocData_(std::move(_srcdocData)),
        baseUri_(std::move(_baseUri)),
        loadingSessionHistoryInfo_(std::move(_loadingSessionHistoryInfo)),
        originalUriString_(std::move(_originalUriString)),
        earlyHints_(std::move(_earlyHints)),
        referrerInfo_(std::move(_referrerInfo)),
        channelId_(std::move(_channelId)),
        loadIdentifier_(std::move(_loadIdentifier)),
        registrarId_(std::move(_registrarId)),
        newLoadFlags_(std::move(_newLoadFlags)),
        redirectMode_(std::move(_redirectMode)),
        redirectFlags_(std::move(_redirectFlags)),
        loadStateExternalLoadFlags_(std::move(_loadStateExternalLoadFlags)),
        loadStateInternalLoadFlags_(std::move(_loadStateInternalLoadFlags)),
        loadStateLoadType_(std::move(_loadStateLoadType)),
        earlyHintLinkType_(std::move(_earlyHintLinkType))
    {
    }

    uint32_t&
    registrarId()
    {
        return registrarId_;
    }
    const uint32_t&
    registrarId() const
    {
        return registrarId_;
    }

    RefPtr<nsIURI>&
    uri()
    {
        return uri_;
    }
    nsIURI*
    uri() const
    {
        return uri_;
    }

    uint32_t&
    newLoadFlags()
    {
        return newLoadFlags_;
    }
    const uint32_t&
    newLoadFlags() const
    {
        return newLoadFlags_;
    }

    mozilla::Maybe<ReplacementChannelConfigInit>&
    init()
    {
        return init_;
    }
    const mozilla::Maybe<ReplacementChannelConfigInit>&
    init() const
    {
        return init_;
    }

    LoadInfoArgs&
    loadInfo()
    {
        return loadInfo_;
    }
    const LoadInfoArgs&
    loadInfo() const
    {
        return loadInfo_;
    }

    uint64_t&
    channelId()
    {
        return channelId_;
    }
    const uint64_t&
    channelId() const
    {
        return channelId_;
    }

    RefPtr<nsIURI>&
    originalURI()
    {
        return originalURI_;
    }
    nsIURI*
    originalURI() const
    {
        return originalURI_;
    }

    uint32_t&
    redirectMode()
    {
        return redirectMode_;
    }
    const uint32_t&
    redirectMode() const
    {
        return redirectMode_;
    }

    uint32_t&
    redirectFlags()
    {
        return redirectFlags_;
    }
    const uint32_t&
    redirectFlags() const
    {
        return redirectFlags_;
    }

    mozilla::Maybe<uint32_t>&
    contentDisposition()
    {
        return contentDisposition_;
    }
    const mozilla::Maybe<uint32_t>&
    contentDisposition() const
    {
        return contentDisposition_;
    }

    mozilla::Maybe<nsString>&
    contentDispositionFilename()
    {
        return contentDispositionFilename_;
    }
    const mozilla::Maybe<nsString>&
    contentDispositionFilename() const
    {
        return contentDispositionFilename_;
    }

    RefPtr<nsIPropertyBag2>&
    properties()
    {
        return properties_;
    }
    nsIPropertyBag2*
    properties() const
    {
        return properties_;
    }

    uint32_t&
    loadStateExternalLoadFlags()
    {
        return loadStateExternalLoadFlags_;
    }
    const uint32_t&
    loadStateExternalLoadFlags() const
    {
        return loadStateExternalLoadFlags_;
    }

    uint32_t&
    loadStateInternalLoadFlags()
    {
        return loadStateInternalLoadFlags_;
    }
    const uint32_t&
    loadStateInternalLoadFlags() const
    {
        return loadStateInternalLoadFlags_;
    }

    uint32_t&
    loadStateLoadType()
    {
        return loadStateLoadType_;
    }
    const uint32_t&
    loadStateLoadType() const
    {
        return loadStateLoadType_;
    }

    RefPtr<nsDOMNavigationTiming>&
    timing()
    {
        return timing_;
    }
    nsDOMNavigationTiming*
    timing() const
    {
        return timing_;
    }

    nsString&
    srcdocData()
    {
        return srcdocData_;
    }
    const nsString&
    srcdocData() const
    {
        return srcdocData_;
    }

    RefPtr<nsIURI>&
    baseUri()
    {
        return baseUri_;
    }
    nsIURI*
    baseUri() const
    {
        return baseUri_;
    }

    mozilla::Maybe<LoadingSessionHistoryInfo>&
    loadingSessionHistoryInfo()
    {
        return loadingSessionHistoryInfo_;
    }
    const mozilla::Maybe<LoadingSessionHistoryInfo>&
    loadingSessionHistoryInfo() const
    {
        return loadingSessionHistoryInfo_;
    }

    uint64_t&
    loadIdentifier()
    {
        return loadIdentifier_;
    }
    const uint64_t&
    loadIdentifier() const
    {
        return loadIdentifier_;
    }

    mozilla::Maybe<nsCString>&
    originalUriString()
    {
        return originalUriString_;
    }
    const mozilla::Maybe<nsCString>&
    originalUriString() const
    {
        return originalUriString_;
    }

    nsTArray<EarlyHintConnectArgs>&
    earlyHints()
    {
        return earlyHints_;
    }
    const nsTArray<EarlyHintConnectArgs>&
    earlyHints() const
    {
        return earlyHints_;
    }

    uint32_t&
    earlyHintLinkType()
    {
        return earlyHintLinkType_;
    }
    const uint32_t&
    earlyHintLinkType() const
    {
        return earlyHintLinkType_;
    }

    RefPtr<nsIReferrerInfo>&
    referrerInfo()
    {
        return referrerInfo_;
    }
    nsIReferrerInfo*
    referrerInfo() const
    {
        return referrerInfo_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ReplacementChannelConfigInit>> init_;
    ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> originalURI_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint32_t>> contentDisposition_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> contentDispositionFilename_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIPropertyBag2>> properties_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsDOMNavigationTiming>> timing_;
    ::mozilla::ipc::IPDLStructMember<nsString> srcdocData_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> baseUri_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<LoadingSessionHistoryInfo>> loadingSessionHistoryInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> originalUriString_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<EarlyHintConnectArgs>> earlyHints_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> referrerInfo_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> loadIdentifier_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> registrarId_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> newLoadFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> redirectMode_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> redirectFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadStateExternalLoadFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadStateInternalLoadFlags_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadStateLoadType_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> earlyHintLinkType_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::RedirectToRealChannelArgs>
{
    typedef ::mozilla::net::RedirectToRealChannelArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct TimingStructArgs|
//
namespace mozilla {
namespace net {
class TimingStructArgs final
{
private:
    typedef ::mozilla::TimeStamp TimeStamp;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    TimingStructArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT TimingStructArgs(
            const TimeStamp& _domainLookupStart,
            const TimeStamp& _domainLookupEnd,
            const TimeStamp& _connectStart,
            const TimeStamp& _tcpConnectEnd,
            const TimeStamp& _secureConnectionStart,
            const TimeStamp& _connectEnd,
            const TimeStamp& _requestStart,
            const TimeStamp& _responseStart,
            const TimeStamp& _responseEnd,
            const TimeStamp& _transactionPending) :
        domainLookupStart_(_domainLookupStart),
        domainLookupEnd_(_domainLookupEnd),
        connectStart_(_connectStart),
        tcpConnectEnd_(_tcpConnectEnd),
        secureConnectionStart_(_secureConnectionStart),
        connectEnd_(_connectEnd),
        requestStart_(_requestStart),
        responseStart_(_responseStart),
        responseEnd_(_responseEnd),
        transactionPending_(_transactionPending)
    {
    }

    MOZ_IMPLICIT TimingStructArgs(
            TimeStamp&& _domainLookupStart,
            TimeStamp&& _domainLookupEnd,
            TimeStamp&& _connectStart,
            TimeStamp&& _tcpConnectEnd,
            TimeStamp&& _secureConnectionStart,
            TimeStamp&& _connectEnd,
            TimeStamp&& _requestStart,
            TimeStamp&& _responseStart,
            TimeStamp&& _responseEnd,
            TimeStamp&& _transactionPending) :
        domainLookupStart_(std::move(_domainLookupStart)),
        domainLookupEnd_(std::move(_domainLookupEnd)),
        connectStart_(std::move(_connectStart)),
        tcpConnectEnd_(std::move(_tcpConnectEnd)),
        secureConnectionStart_(std::move(_secureConnectionStart)),
        connectEnd_(std::move(_connectEnd)),
        requestStart_(std::move(_requestStart)),
        responseStart_(std::move(_responseStart)),
        responseEnd_(std::move(_responseEnd)),
        transactionPending_(std::move(_transactionPending))
    {
    }

    TimeStamp&
    domainLookupStart()
    {
        return domainLookupStart_;
    }
    const TimeStamp&
    domainLookupStart() const
    {
        return domainLookupStart_;
    }

    TimeStamp&
    domainLookupEnd()
    {
        return domainLookupEnd_;
    }
    const TimeStamp&
    domainLookupEnd() const
    {
        return domainLookupEnd_;
    }

    TimeStamp&
    connectStart()
    {
        return connectStart_;
    }
    const TimeStamp&
    connectStart() const
    {
        return connectStart_;
    }

    TimeStamp&
    tcpConnectEnd()
    {
        return tcpConnectEnd_;
    }
    const TimeStamp&
    tcpConnectEnd() const
    {
        return tcpConnectEnd_;
    }

    TimeStamp&
    secureConnectionStart()
    {
        return secureConnectionStart_;
    }
    const TimeStamp&
    secureConnectionStart() const
    {
        return secureConnectionStart_;
    }

    TimeStamp&
    connectEnd()
    {
        return connectEnd_;
    }
    const TimeStamp&
    connectEnd() const
    {
        return connectEnd_;
    }

    TimeStamp&
    requestStart()
    {
        return requestStart_;
    }
    const TimeStamp&
    requestStart() const
    {
        return requestStart_;
    }

    TimeStamp&
    responseStart()
    {
        return responseStart_;
    }
    const TimeStamp&
    responseStart() const
    {
        return responseStart_;
    }

    TimeStamp&
    responseEnd()
    {
        return responseEnd_;
    }
    const TimeStamp&
    responseEnd() const
    {
        return responseEnd_;
    }

    TimeStamp&
    transactionPending()
    {
        return transactionPending_;
    }
    const TimeStamp&
    transactionPending() const
    {
        return transactionPending_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> connectStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> tcpConnectEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> secureConnectionStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> connectEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> requestStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> transactionPending_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::TimingStructArgs>
{
    typedef ::mozilla::net::TimingStructArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ResourceTimingStructArgs|
//
namespace mozilla {
namespace net {
class ResourceTimingStructArgs final
{
private:
    typedef ::mozilla::TimeStamp TimeStamp;
    typedef ::uint64_t uint64_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ResourceTimingStructArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ResourceTimingStructArgs(
            const TimeStamp& _domainLookupStart,
            const TimeStamp& _domainLookupEnd,
            const TimeStamp& _connectStart,
            const TimeStamp& _tcpConnectEnd,
            const TimeStamp& _secureConnectionStart,
            const TimeStamp& _connectEnd,
            const TimeStamp& _requestStart,
            const TimeStamp& _responseStart,
            const TimeStamp& _responseEnd,
            const TimeStamp& _fetchStart,
            const TimeStamp& _redirectStart,
            const TimeStamp& _redirectEnd,
            const uint64_t& _transferSize,
            const uint64_t& _encodedBodySize,
            const uint64_t& _decodedBodySize,
            const TimeStamp& _cacheReadStart,
            const TimeStamp& _cacheReadEnd,
            const TimeStamp& _transactionPending) :
        domainLookupStart_(_domainLookupStart),
        domainLookupEnd_(_domainLookupEnd),
        connectStart_(_connectStart),
        tcpConnectEnd_(_tcpConnectEnd),
        secureConnectionStart_(_secureConnectionStart),
        connectEnd_(_connectEnd),
        requestStart_(_requestStart),
        responseStart_(_responseStart),
        responseEnd_(_responseEnd),
        fetchStart_(_fetchStart),
        redirectStart_(_redirectStart),
        redirectEnd_(_redirectEnd),
        cacheReadStart_(_cacheReadStart),
        cacheReadEnd_(_cacheReadEnd),
        transactionPending_(_transactionPending),
        transferSize_(_transferSize),
        encodedBodySize_(_encodedBodySize),
        decodedBodySize_(_decodedBodySize)
    {
    }

    MOZ_IMPLICIT ResourceTimingStructArgs(
            TimeStamp&& _domainLookupStart,
            TimeStamp&& _domainLookupEnd,
            TimeStamp&& _connectStart,
            TimeStamp&& _tcpConnectEnd,
            TimeStamp&& _secureConnectionStart,
            TimeStamp&& _connectEnd,
            TimeStamp&& _requestStart,
            TimeStamp&& _responseStart,
            TimeStamp&& _responseEnd,
            TimeStamp&& _fetchStart,
            TimeStamp&& _redirectStart,
            TimeStamp&& _redirectEnd,
            uint64_t&& _transferSize,
            uint64_t&& _encodedBodySize,
            uint64_t&& _decodedBodySize,
            TimeStamp&& _cacheReadStart,
            TimeStamp&& _cacheReadEnd,
            TimeStamp&& _transactionPending) :
        domainLookupStart_(std::move(_domainLookupStart)),
        domainLookupEnd_(std::move(_domainLookupEnd)),
        connectStart_(std::move(_connectStart)),
        tcpConnectEnd_(std::move(_tcpConnectEnd)),
        secureConnectionStart_(std::move(_secureConnectionStart)),
        connectEnd_(std::move(_connectEnd)),
        requestStart_(std::move(_requestStart)),
        responseStart_(std::move(_responseStart)),
        responseEnd_(std::move(_responseEnd)),
        fetchStart_(std::move(_fetchStart)),
        redirectStart_(std::move(_redirectStart)),
        redirectEnd_(std::move(_redirectEnd)),
        cacheReadStart_(std::move(_cacheReadStart)),
        cacheReadEnd_(std::move(_cacheReadEnd)),
        transactionPending_(std::move(_transactionPending)),
        transferSize_(std::move(_transferSize)),
        encodedBodySize_(std::move(_encodedBodySize)),
        decodedBodySize_(std::move(_decodedBodySize))
    {
    }

    TimeStamp&
    domainLookupStart()
    {
        return domainLookupStart_;
    }
    const TimeStamp&
    domainLookupStart() const
    {
        return domainLookupStart_;
    }

    TimeStamp&
    domainLookupEnd()
    {
        return domainLookupEnd_;
    }
    const TimeStamp&
    domainLookupEnd() const
    {
        return domainLookupEnd_;
    }

    TimeStamp&
    connectStart()
    {
        return connectStart_;
    }
    const TimeStamp&
    connectStart() const
    {
        return connectStart_;
    }

    TimeStamp&
    tcpConnectEnd()
    {
        return tcpConnectEnd_;
    }
    const TimeStamp&
    tcpConnectEnd() const
    {
        return tcpConnectEnd_;
    }

    TimeStamp&
    secureConnectionStart()
    {
        return secureConnectionStart_;
    }
    const TimeStamp&
    secureConnectionStart() const
    {
        return secureConnectionStart_;
    }

    TimeStamp&
    connectEnd()
    {
        return connectEnd_;
    }
    const TimeStamp&
    connectEnd() const
    {
        return connectEnd_;
    }

    TimeStamp&
    requestStart()
    {
        return requestStart_;
    }
    const TimeStamp&
    requestStart() const
    {
        return requestStart_;
    }

    TimeStamp&
    responseStart()
    {
        return responseStart_;
    }
    const TimeStamp&
    responseStart() const
    {
        return responseStart_;
    }

    TimeStamp&
    responseEnd()
    {
        return responseEnd_;
    }
    const TimeStamp&
    responseEnd() const
    {
        return responseEnd_;
    }

    TimeStamp&
    fetchStart()
    {
        return fetchStart_;
    }
    const TimeStamp&
    fetchStart() const
    {
        return fetchStart_;
    }

    TimeStamp&
    redirectStart()
    {
        return redirectStart_;
    }
    const TimeStamp&
    redirectStart() const
    {
        return redirectStart_;
    }

    TimeStamp&
    redirectEnd()
    {
        return redirectEnd_;
    }
    const TimeStamp&
    redirectEnd() const
    {
        return redirectEnd_;
    }

    uint64_t&
    transferSize()
    {
        return transferSize_;
    }
    const uint64_t&
    transferSize() const
    {
        return transferSize_;
    }

    uint64_t&
    encodedBodySize()
    {
        return encodedBodySize_;
    }
    const uint64_t&
    encodedBodySize() const
    {
        return encodedBodySize_;
    }

    uint64_t&
    decodedBodySize()
    {
        return decodedBodySize_;
    }
    const uint64_t&
    decodedBodySize() const
    {
        return decodedBodySize_;
    }

    TimeStamp&
    cacheReadStart()
    {
        return cacheReadStart_;
    }
    const TimeStamp&
    cacheReadStart() const
    {
        return cacheReadStart_;
    }

    TimeStamp&
    cacheReadEnd()
    {
        return cacheReadEnd_;
    }
    const TimeStamp&
    cacheReadEnd() const
    {
        return cacheReadEnd_;
    }

    TimeStamp&
    transactionPending()
    {
        return transactionPending_;
    }
    const TimeStamp&
    transactionPending() const
    {
        return transactionPending_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> connectStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> tcpConnectEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> secureConnectionStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> connectEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> requestStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> fetchStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> redirectStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> redirectEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> transactionPending_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> transferSize_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> encodedBodySize_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> decodedBodySize_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::ResourceTimingStructArgs>
{
    typedef ::mozilla::net::ResourceTimingStructArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpActivity|
//
namespace mozilla {
namespace net {
class HttpActivity final
{
private:
    typedef ::nsCString nsCString;
    typedef ::int32_t int32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    HttpActivity() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT HttpActivity(
            const nsCString& _host,
            const int32_t& _port,
            const bool& _endToEndSSL) :
        host_(_host),
        endToEndSSL_(_endToEndSSL),
        port_(_port)
    {
    }

    MOZ_IMPLICIT HttpActivity(
            nsCString&& _host,
            int32_t&& _port,
            bool&& _endToEndSSL) :
        host_(std::move(_host)),
        endToEndSSL_(std::move(_endToEndSSL)),
        port_(std::move(_port))
    {
    }

    nsCString&
    host()
    {
        return host_;
    }
    const nsCString&
    host() const
    {
        return host_;
    }

    int32_t&
    port()
    {
        return port_;
    }
    const int32_t&
    port() const
    {
        return port_;
    }

    bool&
    endToEndSSL()
    {
        return endToEndSSL_;
    }
    const bool&
    endToEndSSL() const
    {
        return endToEndSSL_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> host_;
    ::mozilla::ipc::IPDLStructMember<bool> endToEndSSL_;
    ::mozilla::ipc::IPDLStructMember<int32_t> port_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpActivity>
{
    typedef ::mozilla::net::HttpActivity paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpConnectionActivity|
//
namespace mozilla {
namespace net {
class HttpConnectionActivity final
{
private:
    typedef ::nsCString nsCString;
    typedef ::int32_t int32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    HttpConnectionActivity() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT HttpConnectionActivity(
            const nsCString& _connInfoKey,
            const nsCString& _host,
            const int32_t& _port,
            const bool& _ssl,
            const bool& _hasECH,
            const bool& _isHttp3) :
        connInfoKey_(_connInfoKey),
        host_(_host),
        ssl_(_ssl),
        hasECH_(_hasECH),
        isHttp3_(_isHttp3),
        port_(_port)
    {
    }

    MOZ_IMPLICIT HttpConnectionActivity(
            nsCString&& _connInfoKey,
            nsCString&& _host,
            int32_t&& _port,
            bool&& _ssl,
            bool&& _hasECH,
            bool&& _isHttp3) :
        connInfoKey_(std::move(_connInfoKey)),
        host_(std::move(_host)),
        ssl_(std::move(_ssl)),
        hasECH_(std::move(_hasECH)),
        isHttp3_(std::move(_isHttp3)),
        port_(std::move(_port))
    {
    }

    nsCString&
    connInfoKey()
    {
        return connInfoKey_;
    }
    const nsCString&
    connInfoKey() const
    {
        return connInfoKey_;
    }

    nsCString&
    host()
    {
        return host_;
    }
    const nsCString&
    host() const
    {
        return host_;
    }

    int32_t&
    port()
    {
        return port_;
    }
    const int32_t&
    port() const
    {
        return port_;
    }

    bool&
    ssl()
    {
        return ssl_;
    }
    const bool&
    ssl() const
    {
        return ssl_;
    }

    bool&
    hasECH()
    {
        return hasECH_;
    }
    const bool&
    hasECH() const
    {
        return hasECH_;
    }

    bool&
    isHttp3()
    {
        return isHttp3_;
    }
    const bool&
    isHttp3() const
    {
        return isHttp3_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> connInfoKey_;
    ::mozilla::ipc::IPDLStructMember<nsCString> host_;
    ::mozilla::ipc::IPDLStructMember<bool> ssl_;
    ::mozilla::ipc::IPDLStructMember<bool> hasECH_;
    ::mozilla::ipc::IPDLStructMember<bool> isHttp3_;
    ::mozilla::ipc::IPDLStructMember<int32_t> port_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpConnectionActivity>
{
    typedef ::mozilla::net::HttpConnectionActivity paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union HttpActivityArgs|
//
namespace mozilla {
namespace net {
class HttpActivityArgs final
{
public:
    enum Type {
        T__None,
        Tuint64_t = 1,
        THttpActivity,
        THttpConnectionActivity,
        T__Last = THttpConnectionActivity
    };

private:
    typedef ::uint64_t uint64_t;
    typedef ::mozilla::net::HttpActivity HttpActivity;
    typedef ::mozilla::net::HttpConnectionActivity HttpConnectionActivity;
    typedef uint64_t uint64_t__tdef;
    typedef HttpActivity HttpActivity__tdef;
    typedef HttpConnectionActivity HttpConnectionActivity__tdef;

    uint64_t*
    ptr_uint64_t()
    {
        return (&(mVuint64_t));
    }
    const uint64_t*
    constptr_uint64_t() const
    {
        return (&(mVuint64_t));
    }
    HttpActivity*
    ptr_HttpActivity()
    {
        return (&(mVHttpActivity));
    }
    const HttpActivity*
    constptr_HttpActivity() const
    {
        return (&(mVHttpActivity));
    }
    HttpConnectionActivity*
    ptr_HttpConnectionActivity()
    {
        return (&(mVHttpConnectionActivity));
    }
    const HttpConnectionActivity*
    constptr_HttpConnectionActivity() const
    {
        return (&(mVHttpConnectionActivity));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT HttpActivityArgs() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT HttpActivityArgs(const uint64_t& aOther);

    MOZ_IMPLICIT HttpActivityArgs(uint64_t&& aOther);

    MOZ_IMPLICIT HttpActivityArgs(const HttpActivity& aOther);

    MOZ_IMPLICIT HttpActivityArgs(HttpActivity&& aOther);

    MOZ_IMPLICIT HttpActivityArgs(const HttpConnectionActivity& aOther);

    MOZ_IMPLICIT HttpActivityArgs(HttpConnectionActivity&& aOther);

    MOZ_IMPLICIT HttpActivityArgs(const HttpActivityArgs& aOther);

    MOZ_IMPLICIT HttpActivityArgs(HttpActivityArgs&& aOther);

    ~HttpActivityArgs();

    Type
    type() const
    {
        return mType;
    }

    HttpActivityArgs&
    operator=(const uint64_t& aRhs);

    HttpActivityArgs&
    operator=(uint64_t&& aRhs);

    HttpActivityArgs&
    operator=(const HttpActivity& aRhs);

    HttpActivityArgs&
    operator=(HttpActivity&& aRhs);

    HttpActivityArgs&
    operator=(const HttpConnectionActivity& aRhs);

    HttpActivityArgs&
    operator=(HttpConnectionActivity&& aRhs);

    HttpActivityArgs&
    operator=(const HttpActivityArgs& aRhs);

    HttpActivityArgs&
    operator=(HttpActivityArgs&& aRhs);

    uint64_t&
    get_uint64_t()
    {
        AssertSanity(Tuint64_t);
        return (*(ptr_uint64_t()));
    }
    const uint64_t&
    get_uint64_t() const
    {
        AssertSanity(Tuint64_t);
        return (*(constptr_uint64_t()));
    }
    operator uint64_t&()
    {
        return get_uint64_t();
    }
    operator const uint64_t&() const
    {
        return get_uint64_t();
    }

    HttpActivity&
    get_HttpActivity()
    {
        AssertSanity(THttpActivity);
        return (*(ptr_HttpActivity()));
    }
    const HttpActivity&
    get_HttpActivity() const
    {
        AssertSanity(THttpActivity);
        return (*(constptr_HttpActivity()));
    }
    operator HttpActivity&()
    {
        return get_HttpActivity();
    }
    operator const HttpActivity&() const
    {
        return get_HttpActivity();
    }

    HttpConnectionActivity&
    get_HttpConnectionActivity()
    {
        AssertSanity(THttpConnectionActivity);
        return (*(ptr_HttpConnectionActivity()));
    }
    const HttpConnectionActivity&
    get_HttpConnectionActivity() const
    {
        AssertSanity(THttpConnectionActivity);
        return (*(constptr_HttpConnectionActivity()));
    }
    operator HttpConnectionActivity&()
    {
        return get_HttpConnectionActivity();
    }
    operator const HttpConnectionActivity&() const
    {
        return get_HttpConnectionActivity();
    }

private:
    union {
        uint64_t mVuint64_t;
        HttpActivity mVHttpActivity;
        HttpConnectionActivity mVHttpConnectionActivity;
    };
    Type mType;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpActivityArgs>
{
    typedef ::mozilla::net::HttpActivityArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct TransactionObserverResult|
//
namespace mozilla {
namespace net {
class TransactionObserverResult final
{
private:
    typedef ::nsresult nsresult;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    TransactionObserverResult() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT TransactionObserverResult(
            const bool& _versionOk,
            const bool& _authOk,
            const nsresult& _closeReason) :
        versionOk_(_versionOk),
        authOk_(_authOk),
        closeReason_(_closeReason)
    {
    }

    MOZ_IMPLICIT TransactionObserverResult(
            bool&& _versionOk,
            bool&& _authOk,
            nsresult&& _closeReason) :
        versionOk_(std::move(_versionOk)),
        authOk_(std::move(_authOk)),
        closeReason_(std::move(_closeReason))
    {
    }

    bool&
    versionOk()
    {
        return versionOk_;
    }
    const bool&
    versionOk() const
    {
        return versionOk_;
    }

    bool&
    authOk()
    {
        return authOk_;
    }
    const bool&
    authOk() const
    {
        return authOk_;
    }

    nsresult&
    closeReason()
    {
        return closeReason_;
    }
    const nsresult&
    closeReason() const
    {
        return closeReason_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> versionOk_;
    ::mozilla::ipc::IPDLStructMember<bool> authOk_;
    ::mozilla::ipc::IPDLStructMember<nsresult> closeReason_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::TransactionObserverResult>
{
    typedef ::mozilla::net::TransactionObserverResult paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SpeculativeConnectionOverriderArgs|
//
namespace mozilla {
namespace net {
class SpeculativeConnectionOverriderArgs final
{
private:
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    SpeculativeConnectionOverriderArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT SpeculativeConnectionOverriderArgs(
            const uint32_t& _parallelSpeculativeConnectLimit,
            const bool& _ignoreIdle,
            const bool& _isFromPredictor,
            const bool& _allow1918) :
        ignoreIdle_(_ignoreIdle),
        isFromPredictor_(_isFromPredictor),
        allow1918_(_allow1918),
        parallelSpeculativeConnectLimit_(_parallelSpeculativeConnectLimit)
    {
    }

    MOZ_IMPLICIT SpeculativeConnectionOverriderArgs(
            uint32_t&& _parallelSpeculativeConnectLimit,
            bool&& _ignoreIdle,
            bool&& _isFromPredictor,
            bool&& _allow1918) :
        ignoreIdle_(std::move(_ignoreIdle)),
        isFromPredictor_(std::move(_isFromPredictor)),
        allow1918_(std::move(_allow1918)),
        parallelSpeculativeConnectLimit_(std::move(_parallelSpeculativeConnectLimit))
    {
    }

    uint32_t&
    parallelSpeculativeConnectLimit()
    {
        return parallelSpeculativeConnectLimit_;
    }
    const uint32_t&
    parallelSpeculativeConnectLimit() const
    {
        return parallelSpeculativeConnectLimit_;
    }

    bool&
    ignoreIdle()
    {
        return ignoreIdle_;
    }
    const bool&
    ignoreIdle() const
    {
        return ignoreIdle_;
    }

    bool&
    isFromPredictor()
    {
        return isFromPredictor_;
    }
    const bool&
    isFromPredictor() const
    {
        return isFromPredictor_;
    }

    bool&
    allow1918()
    {
        return allow1918_;
    }
    const bool&
    allow1918() const
    {
        return allow1918_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> ignoreIdle_;
    ::mozilla::ipc::IPDLStructMember<bool> isFromPredictor_;
    ::mozilla::ipc::IPDLStructMember<bool> allow1918_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> parallelSpeculativeConnectLimit_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::SpeculativeConnectionOverriderArgs>
{
    typedef ::mozilla::net::SpeculativeConnectionOverriderArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct GIOChannelOpenArgs|
//
namespace mozilla {
namespace net {
class GIOChannelOpenArgs final
{
private:
    typedef ::mozilla::ipc::URIParams URIParams;
    typedef ::uint64_t uint64_t;
    typedef ::nsCString nsCString;
    typedef ::mozilla::ipc::IPCStream IPCStream;
    typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    GIOChannelOpenArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT GIOChannelOpenArgs(
            const URIParams& _uri,
            const uint64_t& _startPos,
            const nsCString& _entityID,
            const mozilla::Maybe<IPCStream>& _uploadStream,
            const LoadInfoArgs& _loadInfo,
            const uint32_t& _loadFlags) :
        uri_(_uri),
        entityID_(_entityID),
        uploadStream_(_uploadStream),
        loadInfo_(_loadInfo),
        startPos_(_startPos),
        loadFlags_(_loadFlags)
    {
    }

    MOZ_IMPLICIT GIOChannelOpenArgs(
            URIParams&& _uri,
            uint64_t&& _startPos,
            nsCString&& _entityID,
            mozilla::Maybe<IPCStream>&& _uploadStream,
            LoadInfoArgs&& _loadInfo,
            uint32_t&& _loadFlags) :
        uri_(std::move(_uri)),
        entityID_(std::move(_entityID)),
        uploadStream_(std::move(_uploadStream)),
        loadInfo_(std::move(_loadInfo)),
        startPos_(std::move(_startPos)),
        loadFlags_(std::move(_loadFlags))
    {
    }

    URIParams&
    uri()
    {
        return uri_;
    }
    const URIParams&
    uri() const
    {
        return uri_;
    }

    uint64_t&
    startPos()
    {
        return startPos_;
    }
    const uint64_t&
    startPos() const
    {
        return startPos_;
    }

    nsCString&
    entityID()
    {
        return entityID_;
    }
    const nsCString&
    entityID() const
    {
        return entityID_;
    }

    mozilla::Maybe<IPCStream>&
    uploadStream()
    {
        return uploadStream_;
    }
    const mozilla::Maybe<IPCStream>&
    uploadStream() const
    {
        return uploadStream_;
    }

    LoadInfoArgs&
    loadInfo()
    {
        return loadInfo_;
    }
    const LoadInfoArgs&
    loadInfo() const
    {
        return loadInfo_;
    }

    uint32_t&
    loadFlags()
    {
        return loadFlags_;
    }
    const uint32_t&
    loadFlags() const
    {
        return loadFlags_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<URIParams> uri_;
    ::mozilla::ipc::IPDLStructMember<nsCString> entityID_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCStream>> uploadStream_;
    ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> startPos_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GIOChannelOpenArgs>
{
    typedef ::mozilla::net::GIOChannelOpenArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct GIOChannelConnectArgs|
//
namespace mozilla {
namespace net {
class GIOChannelConnectArgs final
{
private:
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    GIOChannelConnectArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT GIOChannelConnectArgs(const uint32_t& _channelId) :
        channelId_(_channelId)
    {
    }

    MOZ_IMPLICIT GIOChannelConnectArgs(uint32_t&& _channelId) :
        channelId_(std::move(_channelId))
    {
    }

    uint32_t&
    channelId()
    {
        return channelId_;
    }
    const uint32_t&
    channelId() const
    {
        return channelId_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<uint32_t> channelId_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GIOChannelConnectArgs>
{
    typedef ::mozilla::net::GIOChannelConnectArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union GIOChannelCreationArgs|
//
namespace mozilla {
namespace net {
class GIOChannelCreationArgs final
{
public:
    enum Type {
        T__None,
        TGIOChannelOpenArgs = 1,
        TGIOChannelConnectArgs,
        T__Last = TGIOChannelConnectArgs
    };

private:
    typedef ::mozilla::net::GIOChannelOpenArgs GIOChannelOpenArgs;
    typedef ::mozilla::net::GIOChannelConnectArgs GIOChannelConnectArgs;
    typedef GIOChannelOpenArgs GIOChannelOpenArgs__tdef;
    typedef GIOChannelConnectArgs GIOChannelConnectArgs__tdef;

    GIOChannelOpenArgs*
    ptr_GIOChannelOpenArgs()
    {
        return (&(mVGIOChannelOpenArgs));
    }
    const GIOChannelOpenArgs*
    constptr_GIOChannelOpenArgs() const
    {
        return (&(mVGIOChannelOpenArgs));
    }
    GIOChannelConnectArgs*
    ptr_GIOChannelConnectArgs()
    {
        return (&(mVGIOChannelConnectArgs));
    }
    const GIOChannelConnectArgs*
    constptr_GIOChannelConnectArgs() const
    {
        return (&(mVGIOChannelConnectArgs));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT GIOChannelCreationArgs() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelOpenArgs& aOther);

    MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelOpenArgs&& aOther);

    MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelConnectArgs& aOther);

    MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelConnectArgs&& aOther);

    MOZ_IMPLICIT GIOChannelCreationArgs(const GIOChannelCreationArgs& aOther);

    MOZ_IMPLICIT GIOChannelCreationArgs(GIOChannelCreationArgs&& aOther);

    ~GIOChannelCreationArgs();

    Type
    type() const
    {
        return mType;
    }

    GIOChannelCreationArgs&
    operator=(const GIOChannelOpenArgs& aRhs);

    GIOChannelCreationArgs&
    operator=(GIOChannelOpenArgs&& aRhs);

    GIOChannelCreationArgs&
    operator=(const GIOChannelConnectArgs& aRhs);

    GIOChannelCreationArgs&
    operator=(GIOChannelConnectArgs&& aRhs);

    GIOChannelCreationArgs&
    operator=(const GIOChannelCreationArgs& aRhs);

    GIOChannelCreationArgs&
    operator=(GIOChannelCreationArgs&& aRhs);

    GIOChannelOpenArgs&
    get_GIOChannelOpenArgs()
    {
        AssertSanity(TGIOChannelOpenArgs);
        return (*(ptr_GIOChannelOpenArgs()));
    }
    const GIOChannelOpenArgs&
    get_GIOChannelOpenArgs() const
    {
        AssertSanity(TGIOChannelOpenArgs);
        return (*(constptr_GIOChannelOpenArgs()));
    }
    operator GIOChannelOpenArgs&()
    {
        return get_GIOChannelOpenArgs();
    }
    operator const GIOChannelOpenArgs&() const
    {
        return get_GIOChannelOpenArgs();
    }

    GIOChannelConnectArgs&
    get_GIOChannelConnectArgs()
    {
        AssertSanity(TGIOChannelConnectArgs);
        return (*(ptr_GIOChannelConnectArgs()));
    }
    const GIOChannelConnectArgs&
    get_GIOChannelConnectArgs() const
    {
        AssertSanity(TGIOChannelConnectArgs);
        return (*(constptr_GIOChannelConnectArgs()));
    }
    operator GIOChannelConnectArgs&()
    {
        return get_GIOChannelConnectArgs();
    }
    operator const GIOChannelConnectArgs&() const
    {
        return get_GIOChannelConnectArgs();
    }

private:
    union {
        GIOChannelOpenArgs mVGIOChannelOpenArgs;
        GIOChannelConnectArgs mVGIOChannelConnectArgs;
    };
    Type mType;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GIOChannelCreationArgs>
{
    typedef ::mozilla::net::GIOChannelCreationArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct FileChannelInfo|
//
namespace mozilla {
namespace net {
class FileChannelInfo final
{
private:
    typedef ::nsIURI nsIURI;
    typedef ::uint32_t uint32_t;
    typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
    typedef ::nsCString nsCString;
    typedef ::uint64_t uint64_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    FileChannelInfo() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT FileChannelInfo(
            nsIURI* _uri,
            nsIURI* _originalURI,
            const uint32_t& _loadFlags,
            const LoadInfoArgs& _loadInfo,
            const nsCString& _contentType,
            const uint64_t& _channelId) :
        uri_(_uri),
        originalURI_(_originalURI),
        loadInfo_(_loadInfo),
        contentType_(_contentType),
        channelId_(_channelId),
        loadFlags_(_loadFlags)
    {
    }

    MOZ_IMPLICIT FileChannelInfo(
            RefPtr<nsIURI>&& _uri,
            RefPtr<nsIURI>&& _originalURI,
            uint32_t&& _loadFlags,
            LoadInfoArgs&& _loadInfo,
            nsCString&& _contentType,
            uint64_t&& _channelId) :
        uri_(std::move(_uri)),
        originalURI_(std::move(_originalURI)),
        loadInfo_(std::move(_loadInfo)),
        contentType_(std::move(_contentType)),
        channelId_(std::move(_channelId)),
        loadFlags_(std::move(_loadFlags))
    {
    }

    RefPtr<nsIURI>&
    uri()
    {
        return uri_;
    }
    nsIURI*
    uri() const
    {
        return uri_;
    }

    RefPtr<nsIURI>&
    originalURI()
    {
        return originalURI_;
    }
    nsIURI*
    originalURI() const
    {
        return originalURI_;
    }

    uint32_t&
    loadFlags()
    {
        return loadFlags_;
    }
    const uint32_t&
    loadFlags() const
    {
        return loadFlags_;
    }

    LoadInfoArgs&
    loadInfo()
    {
        return loadInfo_;
    }
    const LoadInfoArgs&
    loadInfo() const
    {
        return loadInfo_;
    }

    nsCString&
    contentType()
    {
        return contentType_;
    }
    const nsCString&
    contentType() const
    {
        return contentType_;
    }

    uint64_t&
    channelId()
    {
        return channelId_;
    }
    const uint64_t&
    channelId() const
    {
        return channelId_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> originalURI_;
    ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
    ::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> channelId_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::FileChannelInfo>
{
    typedef ::mozilla::net::FileChannelInfo paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct GeckoViewContentChannelOpenArgs|
//
namespace mozilla {
namespace net {
class GeckoViewContentChannelOpenArgs final
{
private:
    typedef ::mozilla::ipc::URIParams URIParams;
    typedef ::mozilla::net::LoadInfoArgs LoadInfoArgs;
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    GeckoViewContentChannelOpenArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT GeckoViewContentChannelOpenArgs(
            const URIParams& _uri,
            const LoadInfoArgs& _loadInfo,
            const uint32_t& _loadFlags) :
        uri_(_uri),
        loadInfo_(_loadInfo),
        loadFlags_(_loadFlags)
    {
    }

    MOZ_IMPLICIT GeckoViewContentChannelOpenArgs(
            URIParams&& _uri,
            LoadInfoArgs&& _loadInfo,
            uint32_t&& _loadFlags) :
        uri_(std::move(_uri)),
        loadInfo_(std::move(_loadInfo)),
        loadFlags_(std::move(_loadFlags))
    {
    }

    URIParams&
    uri()
    {
        return uri_;
    }
    const URIParams&
    uri() const
    {
        return uri_;
    }

    LoadInfoArgs&
    loadInfo()
    {
        return loadInfo_;
    }
    const LoadInfoArgs&
    loadInfo() const
    {
        return loadInfo_;
    }

    uint32_t&
    loadFlags()
    {
        return loadFlags_;
    }
    const uint32_t&
    loadFlags() const
    {
        return loadFlags_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<URIParams> uri_;
    ::mozilla::ipc::IPDLStructMember<LoadInfoArgs> loadInfo_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GeckoViewContentChannelOpenArgs>
{
    typedef ::mozilla::net::GeckoViewContentChannelOpenArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct GeckoViewContentChannelConnectArgs|
//
namespace mozilla {
namespace net {
class GeckoViewContentChannelConnectArgs final
{
private:
    typedef ::uint32_t uint32_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    GeckoViewContentChannelConnectArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT GeckoViewContentChannelConnectArgs(const uint32_t& _channelId) :
        channelId_(_channelId)
    {
    }

    MOZ_IMPLICIT GeckoViewContentChannelConnectArgs(uint32_t&& _channelId) :
        channelId_(std::move(_channelId))
    {
    }

    uint32_t&
    channelId()
    {
        return channelId_;
    }
    const uint32_t&
    channelId() const
    {
        return channelId_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<uint32_t> channelId_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GeckoViewContentChannelConnectArgs>
{
    typedef ::mozilla::net::GeckoViewContentChannelConnectArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union GeckoViewContentChannelArgs|
//
namespace mozilla {
namespace net {
class GeckoViewContentChannelArgs final
{
public:
    enum Type {
        T__None,
        TGeckoViewContentChannelOpenArgs = 1,
        TGeckoViewContentChannelConnectArgs,
        T__Last = TGeckoViewContentChannelConnectArgs
    };

private:
    typedef ::mozilla::net::GeckoViewContentChannelOpenArgs GeckoViewContentChannelOpenArgs;
    typedef ::mozilla::net::GeckoViewContentChannelConnectArgs GeckoViewContentChannelConnectArgs;
    typedef GeckoViewContentChannelOpenArgs GeckoViewContentChannelOpenArgs__tdef;
    typedef GeckoViewContentChannelConnectArgs GeckoViewContentChannelConnectArgs__tdef;

    GeckoViewContentChannelOpenArgs*
    ptr_GeckoViewContentChannelOpenArgs()
    {
        return (&(mVGeckoViewContentChannelOpenArgs));
    }
    const GeckoViewContentChannelOpenArgs*
    constptr_GeckoViewContentChannelOpenArgs() const
    {
        return (&(mVGeckoViewContentChannelOpenArgs));
    }
    GeckoViewContentChannelConnectArgs*
    ptr_GeckoViewContentChannelConnectArgs()
    {
        return (&(mVGeckoViewContentChannelConnectArgs));
    }
    const GeckoViewContentChannelConnectArgs*
    constptr_GeckoViewContentChannelConnectArgs() const
    {
        return (&(mVGeckoViewContentChannelConnectArgs));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT GeckoViewContentChannelArgs() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT GeckoViewContentChannelArgs(const GeckoViewContentChannelOpenArgs& aOther);

    MOZ_IMPLICIT GeckoViewContentChannelArgs(GeckoViewContentChannelOpenArgs&& aOther);

    MOZ_IMPLICIT GeckoViewContentChannelArgs(const GeckoViewContentChannelConnectArgs& aOther);

    MOZ_IMPLICIT GeckoViewContentChannelArgs(GeckoViewContentChannelConnectArgs&& aOther);

    MOZ_IMPLICIT GeckoViewContentChannelArgs(const GeckoViewContentChannelArgs& aOther);

    MOZ_IMPLICIT GeckoViewContentChannelArgs(GeckoViewContentChannelArgs&& aOther);

    ~GeckoViewContentChannelArgs();

    Type
    type() const
    {
        return mType;
    }

    GeckoViewContentChannelArgs&
    operator=(const GeckoViewContentChannelOpenArgs& aRhs);

    GeckoViewContentChannelArgs&
    operator=(GeckoViewContentChannelOpenArgs&& aRhs);

    GeckoViewContentChannelArgs&
    operator=(const GeckoViewContentChannelConnectArgs& aRhs);

    GeckoViewContentChannelArgs&
    operator=(GeckoViewContentChannelConnectArgs&& aRhs);

    GeckoViewContentChannelArgs&
    operator=(const GeckoViewContentChannelArgs& aRhs);

    GeckoViewContentChannelArgs&
    operator=(GeckoViewContentChannelArgs&& aRhs);

    GeckoViewContentChannelOpenArgs&
    get_GeckoViewContentChannelOpenArgs()
    {
        AssertSanity(TGeckoViewContentChannelOpenArgs);
        return (*(ptr_GeckoViewContentChannelOpenArgs()));
    }
    const GeckoViewContentChannelOpenArgs&
    get_GeckoViewContentChannelOpenArgs() const
    {
        AssertSanity(TGeckoViewContentChannelOpenArgs);
        return (*(constptr_GeckoViewContentChannelOpenArgs()));
    }
    operator GeckoViewContentChannelOpenArgs&()
    {
        return get_GeckoViewContentChannelOpenArgs();
    }
    operator const GeckoViewContentChannelOpenArgs&() const
    {
        return get_GeckoViewContentChannelOpenArgs();
    }

    GeckoViewContentChannelConnectArgs&
    get_GeckoViewContentChannelConnectArgs()
    {
        AssertSanity(TGeckoViewContentChannelConnectArgs);
        return (*(ptr_GeckoViewContentChannelConnectArgs()));
    }
    const GeckoViewContentChannelConnectArgs&
    get_GeckoViewContentChannelConnectArgs() const
    {
        AssertSanity(TGeckoViewContentChannelConnectArgs);
        return (*(constptr_GeckoViewContentChannelConnectArgs()));
    }
    operator GeckoViewContentChannelConnectArgs&()
    {
        return get_GeckoViewContentChannelConnectArgs();
    }
    operator const GeckoViewContentChannelConnectArgs&() const
    {
        return get_GeckoViewContentChannelConnectArgs();
    }

private:
    union {
        GeckoViewContentChannelOpenArgs mVGeckoViewContentChannelOpenArgs;
        GeckoViewContentChannelConnectArgs mVGeckoViewContentChannelConnectArgs;
    };
    Type mType;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::GeckoViewContentChannelArgs>
{
    typedef ::mozilla::net::GeckoViewContentChannelArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct RemoteStreamInfo|
//
namespace mozilla {
namespace net {
class RemoteStreamInfo final
{
private:
    typedef ::nsIInputStream nsIInputStream;
    typedef ::nsCString nsCString;
    typedef ::int64_t int64_t;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    RemoteStreamInfo() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT RemoteStreamInfo(
            nsIInputStream* _inputStream,
            const nsCString& _contentType,
            const int64_t& _contentLength) :
        inputStream_(_inputStream),
        contentType_(_contentType),
        contentLength_(_contentLength)
    {
    }

    MOZ_IMPLICIT RemoteStreamInfo(
            RefPtr<nsIInputStream>&& _inputStream,
            nsCString&& _contentType,
            int64_t&& _contentLength) :
        inputStream_(std::move(_inputStream)),
        contentType_(std::move(_contentType)),
        contentLength_(std::move(_contentLength))
    {
    }

    RefPtr<nsIInputStream>&
    inputStream()
    {
        return inputStream_;
    }
    nsIInputStream*
    inputStream() const
    {
        return inputStream_;
    }

    nsCString&
    contentType()
    {
        return contentType_;
    }
    const nsCString&
    contentType() const
    {
        return contentType_;
    }

    int64_t&
    contentLength()
    {
        return contentLength_;
    }
    const int64_t&
    contentLength() const
    {
        return contentLength_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIInputStream>> inputStream_;
    ::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
    ::mozilla::ipc::IPDLStructMember<int64_t> contentLength_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::RemoteStreamInfo>
{
    typedef ::mozilla::net::RemoteStreamInfo paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

#endif // ifndef NeckoChannelParams_h
