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

#ifndef PerformanceTimingTypes_h
#define PerformanceTimingTypes_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/PerformanceTimingIPCUtils.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "nsDOMNavigationTiming.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCServerTiming|
//
namespace mozilla {
namespace dom {
class IPCServerTiming 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
    IPCServerTiming() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCServerTiming(
            const nsCString& _name,
            const double& _duration,
            const nsCString& _description) :
        name_(_name),
        description_(_description),
        duration_(_duration)
    {
    }

    MOZ_IMPLICIT IPCServerTiming(
            nsCString&& _name,
            double&& _duration,
            nsCString&& _description) :
        name_(std::move(_name)),
        description_(std::move(_description)),
        duration_(std::move(_duration))
    {
    }

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

    double&
    duration()
    {
        return duration_;
    }
    const double&
    duration() const
    {
        return duration_;
    }

    nsCString&
    description()
    {
        return description_;
    }
    const nsCString&
    description() const
    {
        return description_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> name_;
    ::mozilla::ipc::IPDLStructMember<nsCString> description_;
    ::mozilla::ipc::IPDLStructMember<double> duration_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCServerTiming>
{
    typedef ::mozilla::dom::IPCServerTiming 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 IPCPerformanceTimingData|
//
namespace mozilla {
namespace dom {
class IPCPerformanceTimingData final
{
private:
    typedef ::mozilla::dom::IPCServerTiming IPCServerTiming;
    typedef ::nsString nsString;
    typedef ::mozilla::TimeStamp TimeStamp;
    typedef ::DOMHighResTimeStamp DOMHighResTimeStamp;
    typedef ::uint64_t uint64_t;
    typedef ::uint16_t uint16_t;
    typedef ::uint8_t uint8_t;
    typedef ::nsITimedChannel::BodyInfoAccess BodyInfoAccess;

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

    MOZ_IMPLICIT IPCPerformanceTimingData(
            const nsTArray<IPCServerTiming>& _serverTiming,
            const nsString& _nextHopProtocol,
            const TimeStamp& _asyncOpen,
            const TimeStamp& _redirectStart,
            const TimeStamp& _redirectEnd,
            const TimeStamp& _domainLookupStart,
            const TimeStamp& _domainLookupEnd,
            const TimeStamp& _connectStart,
            const TimeStamp& _secureConnectionStart,
            const TimeStamp& _connectEnd,
            const TimeStamp& _requestStart,
            const TimeStamp& _responseStart,
            const TimeStamp& _cacheReadStart,
            const TimeStamp& _responseEnd,
            const TimeStamp& _cacheReadEnd,
            const TimeStamp& _workerStart,
            const TimeStamp& _workerRequestStart,
            const TimeStamp& _workerResponseEnd,
            const DOMHighResTimeStamp& _zeroTime,
            const DOMHighResTimeStamp& _fetchStart,
            const uint64_t& _encodedBodySize,
            const uint64_t& _transferSize,
            const uint64_t& _decodedBodySize,
            const uint16_t& _responseStatus,
            const uint8_t& _redirectCount,
            const bool& _renderBlocking,
            const nsString& _contentType,
            const bool& _allRedirectsSameOrigin,
            const bool& _allRedirectsPassTAO,
            const bool& _secureConnection,
            const BodyInfoAccess& _bodyInfoAccessAllowed,
            const bool& _timingAllowed,
            const bool& _initialized) :
        serverTiming_(_serverTiming),
        nextHopProtocol_(_nextHopProtocol),
        asyncOpen_(_asyncOpen),
        redirectStart_(_redirectStart),
        redirectEnd_(_redirectEnd),
        domainLookupStart_(_domainLookupStart),
        domainLookupEnd_(_domainLookupEnd),
        connectStart_(_connectStart),
        secureConnectionStart_(_secureConnectionStart),
        connectEnd_(_connectEnd),
        requestStart_(_requestStart),
        responseStart_(_responseStart),
        cacheReadStart_(_cacheReadStart),
        responseEnd_(_responseEnd),
        cacheReadEnd_(_cacheReadEnd),
        workerStart_(_workerStart),
        workerRequestStart_(_workerRequestStart),
        workerResponseEnd_(_workerResponseEnd),
        zeroTime_(_zeroTime),
        fetchStart_(_fetchStart),
        renderBlocking_(_renderBlocking),
        contentType_(_contentType),
        allRedirectsSameOrigin_(_allRedirectsSameOrigin),
        allRedirectsPassTAO_(_allRedirectsPassTAO),
        secureConnection_(_secureConnection),
        bodyInfoAccessAllowed_(_bodyInfoAccessAllowed),
        timingAllowed_(_timingAllowed),
        initialized_(_initialized),
        encodedBodySize_(_encodedBodySize),
        transferSize_(_transferSize),
        decodedBodySize_(_decodedBodySize),
        responseStatus_(_responseStatus),
        redirectCount_(_redirectCount)
    {
    }

    MOZ_IMPLICIT IPCPerformanceTimingData(
            nsTArray<IPCServerTiming>&& _serverTiming,
            nsString&& _nextHopProtocol,
            TimeStamp&& _asyncOpen,
            TimeStamp&& _redirectStart,
            TimeStamp&& _redirectEnd,
            TimeStamp&& _domainLookupStart,
            TimeStamp&& _domainLookupEnd,
            TimeStamp&& _connectStart,
            TimeStamp&& _secureConnectionStart,
            TimeStamp&& _connectEnd,
            TimeStamp&& _requestStart,
            TimeStamp&& _responseStart,
            TimeStamp&& _cacheReadStart,
            TimeStamp&& _responseEnd,
            TimeStamp&& _cacheReadEnd,
            TimeStamp&& _workerStart,
            TimeStamp&& _workerRequestStart,
            TimeStamp&& _workerResponseEnd,
            DOMHighResTimeStamp&& _zeroTime,
            DOMHighResTimeStamp&& _fetchStart,
            uint64_t&& _encodedBodySize,
            uint64_t&& _transferSize,
            uint64_t&& _decodedBodySize,
            uint16_t&& _responseStatus,
            uint8_t&& _redirectCount,
            bool&& _renderBlocking,
            nsString&& _contentType,
            bool&& _allRedirectsSameOrigin,
            bool&& _allRedirectsPassTAO,
            bool&& _secureConnection,
            BodyInfoAccess&& _bodyInfoAccessAllowed,
            bool&& _timingAllowed,
            bool&& _initialized) :
        serverTiming_(std::move(_serverTiming)),
        nextHopProtocol_(std::move(_nextHopProtocol)),
        asyncOpen_(std::move(_asyncOpen)),
        redirectStart_(std::move(_redirectStart)),
        redirectEnd_(std::move(_redirectEnd)),
        domainLookupStart_(std::move(_domainLookupStart)),
        domainLookupEnd_(std::move(_domainLookupEnd)),
        connectStart_(std::move(_connectStart)),
        secureConnectionStart_(std::move(_secureConnectionStart)),
        connectEnd_(std::move(_connectEnd)),
        requestStart_(std::move(_requestStart)),
        responseStart_(std::move(_responseStart)),
        cacheReadStart_(std::move(_cacheReadStart)),
        responseEnd_(std::move(_responseEnd)),
        cacheReadEnd_(std::move(_cacheReadEnd)),
        workerStart_(std::move(_workerStart)),
        workerRequestStart_(std::move(_workerRequestStart)),
        workerResponseEnd_(std::move(_workerResponseEnd)),
        zeroTime_(std::move(_zeroTime)),
        fetchStart_(std::move(_fetchStart)),
        renderBlocking_(std::move(_renderBlocking)),
        contentType_(std::move(_contentType)),
        allRedirectsSameOrigin_(std::move(_allRedirectsSameOrigin)),
        allRedirectsPassTAO_(std::move(_allRedirectsPassTAO)),
        secureConnection_(std::move(_secureConnection)),
        bodyInfoAccessAllowed_(std::move(_bodyInfoAccessAllowed)),
        timingAllowed_(std::move(_timingAllowed)),
        initialized_(std::move(_initialized)),
        encodedBodySize_(std::move(_encodedBodySize)),
        transferSize_(std::move(_transferSize)),
        decodedBodySize_(std::move(_decodedBodySize)),
        responseStatus_(std::move(_responseStatus)),
        redirectCount_(std::move(_redirectCount))
    {
    }

    nsTArray<IPCServerTiming>&
    serverTiming()
    {
        return serverTiming_;
    }
    const nsTArray<IPCServerTiming>&
    serverTiming() const
    {
        return serverTiming_;
    }

    nsString&
    nextHopProtocol()
    {
        return nextHopProtocol_;
    }
    const nsString&
    nextHopProtocol() const
    {
        return nextHopProtocol_;
    }

    TimeStamp&
    asyncOpen()
    {
        return asyncOpen_;
    }
    const TimeStamp&
    asyncOpen() const
    {
        return asyncOpen_;
    }

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

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

    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&
    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&
    cacheReadStart()
    {
        return cacheReadStart_;
    }
    const TimeStamp&
    cacheReadStart() const
    {
        return cacheReadStart_;
    }

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

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

    TimeStamp&
    workerStart()
    {
        return workerStart_;
    }
    const TimeStamp&
    workerStart() const
    {
        return workerStart_;
    }

    TimeStamp&
    workerRequestStart()
    {
        return workerRequestStart_;
    }
    const TimeStamp&
    workerRequestStart() const
    {
        return workerRequestStart_;
    }

    TimeStamp&
    workerResponseEnd()
    {
        return workerResponseEnd_;
    }
    const TimeStamp&
    workerResponseEnd() const
    {
        return workerResponseEnd_;
    }

    DOMHighResTimeStamp&
    zeroTime()
    {
        return zeroTime_;
    }
    const DOMHighResTimeStamp&
    zeroTime() const
    {
        return zeroTime_;
    }

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

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

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

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

    uint16_t&
    responseStatus()
    {
        return responseStatus_;
    }
    const uint16_t&
    responseStatus() const
    {
        return responseStatus_;
    }

    uint8_t&
    redirectCount()
    {
        return redirectCount_;
    }
    const uint8_t&
    redirectCount() const
    {
        return redirectCount_;
    }

    bool&
    renderBlocking()
    {
        return renderBlocking_;
    }
    const bool&
    renderBlocking() const
    {
        return renderBlocking_;
    }

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

    bool&
    allRedirectsSameOrigin()
    {
        return allRedirectsSameOrigin_;
    }
    const bool&
    allRedirectsSameOrigin() const
    {
        return allRedirectsSameOrigin_;
    }

    bool&
    allRedirectsPassTAO()
    {
        return allRedirectsPassTAO_;
    }
    const bool&
    allRedirectsPassTAO() const
    {
        return allRedirectsPassTAO_;
    }

    bool&
    secureConnection()
    {
        return secureConnection_;
    }
    const bool&
    secureConnection() const
    {
        return secureConnection_;
    }

    BodyInfoAccess&
    bodyInfoAccessAllowed()
    {
        return bodyInfoAccessAllowed_;
    }
    const BodyInfoAccess&
    bodyInfoAccessAllowed() const
    {
        return bodyInfoAccessAllowed_;
    }

    bool&
    timingAllowed()
    {
        return timingAllowed_;
    }
    const bool&
    timingAllowed() const
    {
        return timingAllowed_;
    }

    bool&
    initialized()
    {
        return initialized_;
    }
    const bool&
    initialized() const
    {
        return initialized_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<IPCServerTiming>> serverTiming_;
    ::mozilla::ipc::IPDLStructMember<nsString> nextHopProtocol_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> asyncOpen_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> redirectStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> redirectEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> connectStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> secureConnectionStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> connectEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> requestStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadEnd_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> workerStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> workerRequestStart_;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> workerResponseEnd_;
    ::mozilla::ipc::IPDLStructMember<DOMHighResTimeStamp> zeroTime_;
    ::mozilla::ipc::IPDLStructMember<DOMHighResTimeStamp> fetchStart_;
    ::mozilla::ipc::IPDLStructMember<bool> renderBlocking_;
    ::mozilla::ipc::IPDLStructMember<nsString> contentType_;
    ::mozilla::ipc::IPDLStructMember<bool> allRedirectsSameOrigin_;
    ::mozilla::ipc::IPDLStructMember<bool> allRedirectsPassTAO_;
    ::mozilla::ipc::IPDLStructMember<bool> secureConnection_;
    ::mozilla::ipc::IPDLStructMember<BodyInfoAccess> bodyInfoAccessAllowed_;
    ::mozilla::ipc::IPDLStructMember<bool> timingAllowed_;
    ::mozilla::ipc::IPDLStructMember<bool> initialized_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> encodedBodySize_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> transferSize_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> decodedBodySize_;
    ::mozilla::ipc::IPDLStructMember<uint16_t> responseStatus_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> redirectCount_;
};
} // namespace dom
} // namespace mozilla

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

#endif // ifndef PerformanceTimingTypes_h
