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


#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/dom/PPaymentRequest.h"
#include "mozilla/dom/PPaymentRequestParent.h"
#include "mozilla/dom/PPaymentRequestChild.h"

#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"

namespace mozilla {
namespace dom {
namespace PPaymentRequest {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::PPaymentRequestParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PPaymentRequestChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(
        mozilla::ipc::PrivateIPDLInterface(),
        aParentDestInfo, aChildDestInfo, aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_RequestPayment(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RequestPayment__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_RespondPayment(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RespondPayment__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ChangeShippingAddress(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ChangeShippingAddress__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ChangeShippingOption(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ChangeShippingOption__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ChangePayerDetail(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ChangePayerDetail__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ChangePaymentMethod(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ChangePaymentMethod__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}

} // namespace PPaymentRequest
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentMethodData|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentMethodData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).supportedMethods());
    // Sentinel = 'supportedMethods'
    (aWriter)->WriteSentinel(975111867);
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
}

auto ParamTraits<::mozilla::dom::IPCPaymentMethodData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___supportedMethods = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___supportedMethods) {
        aReader->FatalError("Error deserializing 'supportedMethods' (nsString) member of 'IPCPaymentMethodData'");
        return {};

    }
    auto& _supportedMethods = *maybe___supportedMethods;
    // Sentinel = 'supportedMethods'
    if ((!((aReader)->ReadSentinel(975111867)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'supportedMethods' (nsString) member of 'IPCPaymentMethodData'");
        return {};
    }
    auto maybe___data = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (nsString) member of 'IPCPaymentMethodData'");
        return {};

    }
    auto& _data = *maybe___data;
    // Sentinel = 'data'
    if ((!((aReader)->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsString) member of 'IPCPaymentMethodData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_supportedMethods),
            std::move(_data)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCurrencyAmount|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCurrencyAmount>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).currency());
    // Sentinel = 'currency'
    (aWriter)->WriteSentinel(257295212);
    IPC::WriteParam(aWriter, (aVar).value());
    // Sentinel = 'value'
    (aWriter)->WriteSentinel(107610654);
}

auto ParamTraits<::mozilla::dom::IPCPaymentCurrencyAmount>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___currency = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___currency) {
        aReader->FatalError("Error deserializing 'currency' (nsString) member of 'IPCPaymentCurrencyAmount'");
        return {};

    }
    auto& _currency = *maybe___currency;
    // Sentinel = 'currency'
    if ((!((aReader)->ReadSentinel(257295212)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'currency' (nsString) member of 'IPCPaymentCurrencyAmount'");
        return {};
    }
    auto maybe___value = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___value) {
        aReader->FatalError("Error deserializing 'value' (nsString) member of 'IPCPaymentCurrencyAmount'");
        return {};

    }
    auto& _value = *maybe___value;
    // Sentinel = 'value'
    if ((!((aReader)->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsString) member of 'IPCPaymentCurrencyAmount'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_currency),
            std::move(_value)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentItem|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentItem>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).label());
    // Sentinel = 'label'
    (aWriter)->WriteSentinel(100729345);
    IPC::WriteParam(aWriter, (aVar).amount());
    // Sentinel = 'amount'
    (aWriter)->WriteSentinel(148374165);
    IPC::WriteParam(aWriter, (aVar).pending());
    // Sentinel = 'pending'
    (aWriter)->WriteSentinel(195625702);
}

auto ParamTraits<::mozilla::dom::IPCPaymentItem>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___label = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___label) {
        aReader->FatalError("Error deserializing 'label' (nsString) member of 'IPCPaymentItem'");
        return {};

    }
    auto& _label = *maybe___label;
    // Sentinel = 'label'
    if ((!((aReader)->ReadSentinel(100729345)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'label' (nsString) member of 'IPCPaymentItem'");
        return {};
    }
    auto maybe___amount = IPC::ReadParam<::mozilla::dom::IPCPaymentCurrencyAmount>(aReader);
    if (!maybe___amount) {
        aReader->FatalError("Error deserializing 'amount' (IPCPaymentCurrencyAmount) member of 'IPCPaymentItem'");
        return {};

    }
    auto& _amount = *maybe___amount;
    // Sentinel = 'amount'
    if ((!((aReader)->ReadSentinel(148374165)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'amount' (IPCPaymentCurrencyAmount) member of 'IPCPaymentItem'");
        return {};
    }
    auto maybe___pending = IPC::ReadParam<bool>(aReader);
    if (!maybe___pending) {
        aReader->FatalError("Error deserializing 'pending' (bool) member of 'IPCPaymentItem'");
        return {};

    }
    auto& _pending = *maybe___pending;
    // Sentinel = 'pending'
    if ((!((aReader)->ReadSentinel(195625702)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'pending' (bool) member of 'IPCPaymentItem'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_label),
            std::move(_amount),
            std::move(_pending)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentDetailsModifier|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentDetailsModifier>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).supportedMethods());
    // Sentinel = 'supportedMethods'
    (aWriter)->WriteSentinel(975111867);
    IPC::WriteParam(aWriter, (aVar).total());
    // Sentinel = 'total'
    (aWriter)->WriteSentinel(110035493);
    IPC::WriteParam(aWriter, (aVar).additionalDisplayItems());
    // Sentinel = 'additionalDisplayItems'
    (aWriter)->WriteSentinel(1715407090);
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
    IPC::WriteParam(aWriter, (aVar).additionalDisplayItemsPassed());
    // Sentinel = 'additionalDisplayItemsPassed'
    (aWriter)->WriteSentinel(2751662930);
}

auto ParamTraits<::mozilla::dom::IPCPaymentDetailsModifier>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___supportedMethods = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___supportedMethods) {
        aReader->FatalError("Error deserializing 'supportedMethods' (nsString) member of 'IPCPaymentDetailsModifier'");
        return {};

    }
    auto& _supportedMethods = *maybe___supportedMethods;
    // Sentinel = 'supportedMethods'
    if ((!((aReader)->ReadSentinel(975111867)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'supportedMethods' (nsString) member of 'IPCPaymentDetailsModifier'");
        return {};
    }
    auto maybe___total = IPC::ReadParam<::mozilla::dom::IPCPaymentItem>(aReader);
    if (!maybe___total) {
        aReader->FatalError("Error deserializing 'total' (IPCPaymentItem) member of 'IPCPaymentDetailsModifier'");
        return {};

    }
    auto& _total = *maybe___total;
    // Sentinel = 'total'
    if ((!((aReader)->ReadSentinel(110035493)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'total' (IPCPaymentItem) member of 'IPCPaymentDetailsModifier'");
        return {};
    }
    auto maybe___additionalDisplayItems = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentItem>>(aReader);
    if (!maybe___additionalDisplayItems) {
        aReader->FatalError("Error deserializing 'additionalDisplayItems' (IPCPaymentItem[]) member of 'IPCPaymentDetailsModifier'");
        return {};

    }
    auto& _additionalDisplayItems = *maybe___additionalDisplayItems;
    // Sentinel = 'additionalDisplayItems'
    if ((!((aReader)->ReadSentinel(1715407090)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'additionalDisplayItems' (IPCPaymentItem[]) member of 'IPCPaymentDetailsModifier'");
        return {};
    }
    auto maybe___data = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (nsString) member of 'IPCPaymentDetailsModifier'");
        return {};

    }
    auto& _data = *maybe___data;
    // Sentinel = 'data'
    if ((!((aReader)->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsString) member of 'IPCPaymentDetailsModifier'");
        return {};
    }
    auto maybe___additionalDisplayItemsPassed = IPC::ReadParam<bool>(aReader);
    if (!maybe___additionalDisplayItemsPassed) {
        aReader->FatalError("Error deserializing 'additionalDisplayItemsPassed' (bool) member of 'IPCPaymentDetailsModifier'");
        return {};

    }
    auto& _additionalDisplayItemsPassed = *maybe___additionalDisplayItemsPassed;
    // Sentinel = 'additionalDisplayItemsPassed'
    if ((!((aReader)->ReadSentinel(2751662930)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'additionalDisplayItemsPassed' (bool) member of 'IPCPaymentDetailsModifier'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_supportedMethods),
            std::move(_total),
            std::move(_additionalDisplayItems),
            std::move(_data),
            std::move(_additionalDisplayItemsPassed)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentShippingOption|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentShippingOption>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).id());
    // Sentinel = 'id'
    (aWriter)->WriteSentinel(20447438);
    IPC::WriteParam(aWriter, (aVar).label());
    // Sentinel = 'label'
    (aWriter)->WriteSentinel(100729345);
    IPC::WriteParam(aWriter, (aVar).amount());
    // Sentinel = 'amount'
    (aWriter)->WriteSentinel(148374165);
    IPC::WriteParam(aWriter, (aVar).selected());
    // Sentinel = 'selected'
    (aWriter)->WriteSentinel(251265866);
}

auto ParamTraits<::mozilla::dom::IPCPaymentShippingOption>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___id = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___id) {
        aReader->FatalError("Error deserializing 'id' (nsString) member of 'IPCPaymentShippingOption'");
        return {};

    }
    auto& _id = *maybe___id;
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsString) member of 'IPCPaymentShippingOption'");
        return {};
    }
    auto maybe___label = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___label) {
        aReader->FatalError("Error deserializing 'label' (nsString) member of 'IPCPaymentShippingOption'");
        return {};

    }
    auto& _label = *maybe___label;
    // Sentinel = 'label'
    if ((!((aReader)->ReadSentinel(100729345)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'label' (nsString) member of 'IPCPaymentShippingOption'");
        return {};
    }
    auto maybe___amount = IPC::ReadParam<::mozilla::dom::IPCPaymentCurrencyAmount>(aReader);
    if (!maybe___amount) {
        aReader->FatalError("Error deserializing 'amount' (IPCPaymentCurrencyAmount) member of 'IPCPaymentShippingOption'");
        return {};

    }
    auto& _amount = *maybe___amount;
    // Sentinel = 'amount'
    if ((!((aReader)->ReadSentinel(148374165)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'amount' (IPCPaymentCurrencyAmount) member of 'IPCPaymentShippingOption'");
        return {};
    }
    auto maybe___selected = IPC::ReadParam<bool>(aReader);
    if (!maybe___selected) {
        aReader->FatalError("Error deserializing 'selected' (bool) member of 'IPCPaymentShippingOption'");
        return {};

    }
    auto& _selected = *maybe___selected;
    // Sentinel = 'selected'
    if ((!((aReader)->ReadSentinel(251265866)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'selected' (bool) member of 'IPCPaymentShippingOption'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_id),
            std::move(_label),
            std::move(_amount),
            std::move(_selected)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentDetails|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentDetails>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).id());
    // Sentinel = 'id'
    (aWriter)->WriteSentinel(20447438);
    IPC::WriteParam(aWriter, (aVar).total());
    // Sentinel = 'total'
    (aWriter)->WriteSentinel(110035493);
    IPC::WriteParam(aWriter, (aVar).displayItems());
    // Sentinel = 'displayItems'
    (aWriter)->WriteSentinel(541263097);
    IPC::WriteParam(aWriter, (aVar).shippingOptions());
    // Sentinel = 'shippingOptions'
    (aWriter)->WriteSentinel(845022799);
    IPC::WriteParam(aWriter, (aVar).modifiers());
    // Sentinel = 'modifiers'
    (aWriter)->WriteSentinel(313525187);
    IPC::WriteParam(aWriter, (aVar).error());
    // Sentinel = 'error'
    (aWriter)->WriteSentinel(107741739);
    IPC::WriteParam(aWriter, (aVar).shippingAddressErrors());
    // Sentinel = 'shippingAddressErrors'
    (aWriter)->WriteSentinel(1588463782);
    IPC::WriteParam(aWriter, (aVar).payerErrors());
    // Sentinel = 'payerErrors'
    (aWriter)->WriteSentinel(460326047);
    IPC::WriteParam(aWriter, (aVar).paymentMethodErrors());
    // Sentinel = 'paymentMethodErrors'
    (aWriter)->WriteSentinel(1316751325);
}

auto ParamTraits<::mozilla::dom::IPCPaymentDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___id = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___id) {
        aReader->FatalError("Error deserializing 'id' (nsString) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _id = *maybe___id;
    // Sentinel = 'id'
    if ((!((aReader)->ReadSentinel(20447438)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsString) member of 'IPCPaymentDetails'");
        return {};
    }
    auto maybe___total = IPC::ReadParam<::mozilla::dom::IPCPaymentItem>(aReader);
    if (!maybe___total) {
        aReader->FatalError("Error deserializing 'total' (IPCPaymentItem) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _total = *maybe___total;
    // Sentinel = 'total'
    if ((!((aReader)->ReadSentinel(110035493)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'total' (IPCPaymentItem) member of 'IPCPaymentDetails'");
        return {};
    }
    auto maybe___displayItems = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentItem>>(aReader);
    if (!maybe___displayItems) {
        aReader->FatalError("Error deserializing 'displayItems' (IPCPaymentItem[]) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _displayItems = *maybe___displayItems;
    // Sentinel = 'displayItems'
    if ((!((aReader)->ReadSentinel(541263097)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'displayItems' (IPCPaymentItem[]) member of 'IPCPaymentDetails'");
        return {};
    }
    auto maybe___shippingOptions = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentShippingOption>>(aReader);
    if (!maybe___shippingOptions) {
        aReader->FatalError("Error deserializing 'shippingOptions' (IPCPaymentShippingOption[]) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _shippingOptions = *maybe___shippingOptions;
    // Sentinel = 'shippingOptions'
    if ((!((aReader)->ReadSentinel(845022799)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'shippingOptions' (IPCPaymentShippingOption[]) member of 'IPCPaymentDetails'");
        return {};
    }
    auto maybe___modifiers = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentDetailsModifier>>(aReader);
    if (!maybe___modifiers) {
        aReader->FatalError("Error deserializing 'modifiers' (IPCPaymentDetailsModifier[]) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _modifiers = *maybe___modifiers;
    // Sentinel = 'modifiers'
    if ((!((aReader)->ReadSentinel(313525187)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'modifiers' (IPCPaymentDetailsModifier[]) member of 'IPCPaymentDetails'");
        return {};
    }
    auto maybe___error = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___error) {
        aReader->FatalError("Error deserializing 'error' (nsString) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _error = *maybe___error;
    // Sentinel = 'error'
    if ((!((aReader)->ReadSentinel(107741739)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'error' (nsString) member of 'IPCPaymentDetails'");
        return {};
    }
    auto maybe___shippingAddressErrors = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___shippingAddressErrors) {
        aReader->FatalError("Error deserializing 'shippingAddressErrors' (nsString) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _shippingAddressErrors = *maybe___shippingAddressErrors;
    // Sentinel = 'shippingAddressErrors'
    if ((!((aReader)->ReadSentinel(1588463782)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'shippingAddressErrors' (nsString) member of 'IPCPaymentDetails'");
        return {};
    }
    auto maybe___payerErrors = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___payerErrors) {
        aReader->FatalError("Error deserializing 'payerErrors' (nsString) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _payerErrors = *maybe___payerErrors;
    // Sentinel = 'payerErrors'
    if ((!((aReader)->ReadSentinel(460326047)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'payerErrors' (nsString) member of 'IPCPaymentDetails'");
        return {};
    }
    auto maybe___paymentMethodErrors = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___paymentMethodErrors) {
        aReader->FatalError("Error deserializing 'paymentMethodErrors' (nsString) member of 'IPCPaymentDetails'");
        return {};

    }
    auto& _paymentMethodErrors = *maybe___paymentMethodErrors;
    // Sentinel = 'paymentMethodErrors'
    if ((!((aReader)->ReadSentinel(1316751325)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'paymentMethodErrors' (nsString) member of 'IPCPaymentDetails'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_id),
            std::move(_total),
            std::move(_displayItems),
            std::move(_shippingOptions),
            std::move(_modifiers),
            std::move(_error),
            std::move(_shippingAddressErrors),
            std::move(_payerErrors),
            std::move(_paymentMethodErrors)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentOptions|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentOptions>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestPayerName());
    // Sentinel = 'requestPayerName'
    (aWriter)->WriteSentinel(952632972);
    IPC::WriteParam(aWriter, (aVar).requestPayerEmail());
    // Sentinel = 'requestPayerEmail'
    (aWriter)->WriteSentinel(1067910899);
    IPC::WriteParam(aWriter, (aVar).requestPayerPhone());
    // Sentinel = 'requestPayerPhone'
    (aWriter)->WriteSentinel(1073153797);
    IPC::WriteParam(aWriter, (aVar).requestShipping());
    // Sentinel = 'requestShipping'
    (aWriter)->WriteSentinel(850986572);
    IPC::WriteParam(aWriter, (aVar).requestBillingAddress());
    // Sentinel = 'requestBillingAddress'
    (aWriter)->WriteSentinel(1591281809);
    IPC::WriteParam(aWriter, (aVar).shippingType());
    // Sentinel = 'shippingType'
    (aWriter)->WriteSentinel(552076549);
}

auto ParamTraits<::mozilla::dom::IPCPaymentOptions>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestPayerName = IPC::ReadParam<bool>(aReader);
    if (!maybe___requestPayerName) {
        aReader->FatalError("Error deserializing 'requestPayerName' (bool) member of 'IPCPaymentOptions'");
        return {};

    }
    auto& _requestPayerName = *maybe___requestPayerName;
    // Sentinel = 'requestPayerName'
    if ((!((aReader)->ReadSentinel(952632972)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestPayerName' (bool) member of 'IPCPaymentOptions'");
        return {};
    }
    auto maybe___requestPayerEmail = IPC::ReadParam<bool>(aReader);
    if (!maybe___requestPayerEmail) {
        aReader->FatalError("Error deserializing 'requestPayerEmail' (bool) member of 'IPCPaymentOptions'");
        return {};

    }
    auto& _requestPayerEmail = *maybe___requestPayerEmail;
    // Sentinel = 'requestPayerEmail'
    if ((!((aReader)->ReadSentinel(1067910899)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestPayerEmail' (bool) member of 'IPCPaymentOptions'");
        return {};
    }
    auto maybe___requestPayerPhone = IPC::ReadParam<bool>(aReader);
    if (!maybe___requestPayerPhone) {
        aReader->FatalError("Error deserializing 'requestPayerPhone' (bool) member of 'IPCPaymentOptions'");
        return {};

    }
    auto& _requestPayerPhone = *maybe___requestPayerPhone;
    // Sentinel = 'requestPayerPhone'
    if ((!((aReader)->ReadSentinel(1073153797)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestPayerPhone' (bool) member of 'IPCPaymentOptions'");
        return {};
    }
    auto maybe___requestShipping = IPC::ReadParam<bool>(aReader);
    if (!maybe___requestShipping) {
        aReader->FatalError("Error deserializing 'requestShipping' (bool) member of 'IPCPaymentOptions'");
        return {};

    }
    auto& _requestShipping = *maybe___requestShipping;
    // Sentinel = 'requestShipping'
    if ((!((aReader)->ReadSentinel(850986572)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestShipping' (bool) member of 'IPCPaymentOptions'");
        return {};
    }
    auto maybe___requestBillingAddress = IPC::ReadParam<bool>(aReader);
    if (!maybe___requestBillingAddress) {
        aReader->FatalError("Error deserializing 'requestBillingAddress' (bool) member of 'IPCPaymentOptions'");
        return {};

    }
    auto& _requestBillingAddress = *maybe___requestBillingAddress;
    // Sentinel = 'requestBillingAddress'
    if ((!((aReader)->ReadSentinel(1591281809)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestBillingAddress' (bool) member of 'IPCPaymentOptions'");
        return {};
    }
    auto maybe___shippingType = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___shippingType) {
        aReader->FatalError("Error deserializing 'shippingType' (nsString) member of 'IPCPaymentOptions'");
        return {};

    }
    auto& _shippingType = *maybe___shippingType;
    // Sentinel = 'shippingType'
    if ((!((aReader)->ReadSentinel(552076549)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'shippingType' (nsString) member of 'IPCPaymentOptions'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestPayerName),
            std::move(_requestPayerEmail),
            std::move(_requestPayerPhone),
            std::move(_requestShipping),
            std::move(_requestBillingAddress),
            std::move(_shippingType)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCreateActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCreateActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).topLevelPrincipal());
    // Sentinel = 'topLevelPrincipal'
    (aWriter)->WriteSentinel(1049167598);
    IPC::WriteParam(aWriter, (aVar).methodData());
    // Sentinel = 'methodData'
    (aWriter)->WriteSentinel(375063548);
    IPC::WriteParam(aWriter, (aVar).details());
    // Sentinel = 'details'
    (aWriter)->WriteSentinel(191824615);
    IPC::WriteParam(aWriter, (aVar).options());
    // Sentinel = 'options'
    (aWriter)->WriteSentinel(204735245);
    IPC::WriteParam(aWriter, (aVar).shippingOption());
    // Sentinel = 'shippingOption'
    (aWriter)->WriteSentinel(739182044);
    (aWriter)->WriteBytes((&((aVar).topOuterWindowId())), 8);
    // Sentinel = 'topOuterWindowId'
    (aWriter)->WriteSentinel(949356168);
}

auto ParamTraits<::mozilla::dom::IPCPaymentCreateActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCreateActionRequest'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCreateActionRequest'");
        return {};
    }
    auto maybe___topLevelPrincipal = IPC::ReadParam<RefPtr<::nsIPrincipal>>(aReader);
    if (!maybe___topLevelPrincipal) {
        aReader->FatalError("Error deserializing 'topLevelPrincipal' (nsIPrincipal) member of 'IPCPaymentCreateActionRequest'");
        return {};

    }
    auto& _topLevelPrincipal = *maybe___topLevelPrincipal;
    // Sentinel = 'topLevelPrincipal'
    if ((!((aReader)->ReadSentinel(1049167598)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'topLevelPrincipal' (nsIPrincipal) member of 'IPCPaymentCreateActionRequest'");
        return {};
    }
    auto maybe___methodData = IPC::ReadParam<nsTArray<::mozilla::dom::IPCPaymentMethodData>>(aReader);
    if (!maybe___methodData) {
        aReader->FatalError("Error deserializing 'methodData' (IPCPaymentMethodData[]) member of 'IPCPaymentCreateActionRequest'");
        return {};

    }
    auto& _methodData = *maybe___methodData;
    // Sentinel = 'methodData'
    if ((!((aReader)->ReadSentinel(375063548)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'methodData' (IPCPaymentMethodData[]) member of 'IPCPaymentCreateActionRequest'");
        return {};
    }
    auto maybe___details = IPC::ReadParam<::mozilla::dom::IPCPaymentDetails>(aReader);
    if (!maybe___details) {
        aReader->FatalError("Error deserializing 'details' (IPCPaymentDetails) member of 'IPCPaymentCreateActionRequest'");
        return {};

    }
    auto& _details = *maybe___details;
    // Sentinel = 'details'
    if ((!((aReader)->ReadSentinel(191824615)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'details' (IPCPaymentDetails) member of 'IPCPaymentCreateActionRequest'");
        return {};
    }
    auto maybe___options = IPC::ReadParam<::mozilla::dom::IPCPaymentOptions>(aReader);
    if (!maybe___options) {
        aReader->FatalError("Error deserializing 'options' (IPCPaymentOptions) member of 'IPCPaymentCreateActionRequest'");
        return {};

    }
    auto& _options = *maybe___options;
    // Sentinel = 'options'
    if ((!((aReader)->ReadSentinel(204735245)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'options' (IPCPaymentOptions) member of 'IPCPaymentCreateActionRequest'");
        return {};
    }
    auto maybe___shippingOption = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___shippingOption) {
        aReader->FatalError("Error deserializing 'shippingOption' (nsString) member of 'IPCPaymentCreateActionRequest'");
        return {};

    }
    auto& _shippingOption = *maybe___shippingOption;
    // Sentinel = 'shippingOption'
    if ((!((aReader)->ReadSentinel(739182044)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'shippingOption' (nsString) member of 'IPCPaymentCreateActionRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint64_t{0},
            std::move(_requestId),
            std::move(_topLevelPrincipal),
            std::move(_methodData),
            std::move(_details),
            std::move(_options),
            std::move(_shippingOption)};
    if ((!((aReader)->ReadBytesInto((&((result__)->topOuterWindowId())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'topOuterWindowId'
    if ((!((aReader)->ReadSentinel(949356168)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCanMakeActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCanMakeActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
}

auto ParamTraits<::mozilla::dom::IPCPaymentCanMakeActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCanMakeActionRequest'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCanMakeActionRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentShowActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentShowActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).isUpdating());
    // Sentinel = 'isUpdating'
    (aWriter)->WriteSentinel(376570905);
}

auto ParamTraits<::mozilla::dom::IPCPaymentShowActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentShowActionRequest'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentShowActionRequest'");
        return {};
    }
    auto maybe___isUpdating = IPC::ReadParam<bool>(aReader);
    if (!maybe___isUpdating) {
        aReader->FatalError("Error deserializing 'isUpdating' (bool) member of 'IPCPaymentShowActionRequest'");
        return {};

    }
    auto& _isUpdating = *maybe___isUpdating;
    // Sentinel = 'isUpdating'
    if ((!((aReader)->ReadSentinel(376570905)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isUpdating' (bool) member of 'IPCPaymentShowActionRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId),
            std::move(_isUpdating)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentAbortActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentAbortActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
}

auto ParamTraits<::mozilla::dom::IPCPaymentAbortActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentAbortActionRequest'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentAbortActionRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCompleteActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCompleteActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).completeStatus());
    // Sentinel = 'completeStatus'
    (aWriter)->WriteSentinel(732038622);
}

auto ParamTraits<::mozilla::dom::IPCPaymentCompleteActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCompleteActionRequest'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCompleteActionRequest'");
        return {};
    }
    auto maybe___completeStatus = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___completeStatus) {
        aReader->FatalError("Error deserializing 'completeStatus' (nsString) member of 'IPCPaymentCompleteActionRequest'");
        return {};

    }
    auto& _completeStatus = *maybe___completeStatus;
    // Sentinel = 'completeStatus'
    if ((!((aReader)->ReadSentinel(732038622)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'completeStatus' (nsString) member of 'IPCPaymentCompleteActionRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId),
            std::move(_completeStatus)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentUpdateActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentUpdateActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).details());
    // Sentinel = 'details'
    (aWriter)->WriteSentinel(191824615);
    IPC::WriteParam(aWriter, (aVar).shippingOption());
    // Sentinel = 'shippingOption'
    (aWriter)->WriteSentinel(739182044);
}

auto ParamTraits<::mozilla::dom::IPCPaymentUpdateActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentUpdateActionRequest'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentUpdateActionRequest'");
        return {};
    }
    auto maybe___details = IPC::ReadParam<::mozilla::dom::IPCPaymentDetails>(aReader);
    if (!maybe___details) {
        aReader->FatalError("Error deserializing 'details' (IPCPaymentDetails) member of 'IPCPaymentUpdateActionRequest'");
        return {};

    }
    auto& _details = *maybe___details;
    // Sentinel = 'details'
    if ((!((aReader)->ReadSentinel(191824615)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'details' (IPCPaymentDetails) member of 'IPCPaymentUpdateActionRequest'");
        return {};
    }
    auto maybe___shippingOption = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___shippingOption) {
        aReader->FatalError("Error deserializing 'shippingOption' (nsString) member of 'IPCPaymentUpdateActionRequest'");
        return {};

    }
    auto& _shippingOption = *maybe___shippingOption;
    // Sentinel = 'shippingOption'
    if ((!((aReader)->ReadSentinel(739182044)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'shippingOption' (nsString) member of 'IPCPaymentUpdateActionRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId),
            std::move(_details),
            std::move(_shippingOption)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCloseActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCloseActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
}

auto ParamTraits<::mozilla::dom::IPCPaymentCloseActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCloseActionRequest'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCloseActionRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentRetryActionRequest|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentRetryActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).error());
    // Sentinel = 'error'
    (aWriter)->WriteSentinel(107741739);
    IPC::WriteParam(aWriter, (aVar).payerErrors());
    // Sentinel = 'payerErrors'
    (aWriter)->WriteSentinel(460326047);
    IPC::WriteParam(aWriter, (aVar).paymentMethodErrors());
    // Sentinel = 'paymentMethodErrors'
    (aWriter)->WriteSentinel(1316751325);
    IPC::WriteParam(aWriter, (aVar).shippingAddressErrors());
    // Sentinel = 'shippingAddressErrors'
    (aWriter)->WriteSentinel(1588463782);
}

auto ParamTraits<::mozilla::dom::IPCPaymentRetryActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};
    }
    auto maybe___error = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___error) {
        aReader->FatalError("Error deserializing 'error' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};

    }
    auto& _error = *maybe___error;
    // Sentinel = 'error'
    if ((!((aReader)->ReadSentinel(107741739)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'error' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};
    }
    auto maybe___payerErrors = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___payerErrors) {
        aReader->FatalError("Error deserializing 'payerErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};

    }
    auto& _payerErrors = *maybe___payerErrors;
    // Sentinel = 'payerErrors'
    if ((!((aReader)->ReadSentinel(460326047)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'payerErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};
    }
    auto maybe___paymentMethodErrors = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___paymentMethodErrors) {
        aReader->FatalError("Error deserializing 'paymentMethodErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};

    }
    auto& _paymentMethodErrors = *maybe___paymentMethodErrors;
    // Sentinel = 'paymentMethodErrors'
    if ((!((aReader)->ReadSentinel(1316751325)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'paymentMethodErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};
    }
    auto maybe___shippingAddressErrors = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___shippingAddressErrors) {
        aReader->FatalError("Error deserializing 'shippingAddressErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};

    }
    auto& _shippingAddressErrors = *maybe___shippingAddressErrors;
    // Sentinel = 'shippingAddressErrors'
    if ((!((aReader)->ReadSentinel(1588463782)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'shippingAddressErrors' (nsString) member of 'IPCPaymentRetryActionRequest'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId),
            std::move(_error),
            std::move(_payerErrors),
            std::move(_paymentMethodErrors),
            std::move(_shippingAddressErrors)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCPaymentActionRequest|
//
namespace mozilla {
namespace dom {
auto IPCPaymentActionRequest::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TIPCPaymentCreateActionRequest:
        {
            (ptr_IPCPaymentCreateActionRequest())->~IPCPaymentCreateActionRequest__tdef();
            break;
        }
    case TIPCPaymentCanMakeActionRequest:
        {
            (ptr_IPCPaymentCanMakeActionRequest())->~IPCPaymentCanMakeActionRequest__tdef();
            break;
        }
    case TIPCPaymentShowActionRequest:
        {
            (ptr_IPCPaymentShowActionRequest())->~IPCPaymentShowActionRequest__tdef();
            break;
        }
    case TIPCPaymentAbortActionRequest:
        {
            (ptr_IPCPaymentAbortActionRequest())->~IPCPaymentAbortActionRequest__tdef();
            break;
        }
    case TIPCPaymentCompleteActionRequest:
        {
            (ptr_IPCPaymentCompleteActionRequest())->~IPCPaymentCompleteActionRequest__tdef();
            break;
        }
    case TIPCPaymentUpdateActionRequest:
        {
            (ptr_IPCPaymentUpdateActionRequest())->~IPCPaymentUpdateActionRequest__tdef();
            break;
        }
    case TIPCPaymentCloseActionRequest:
        {
            (ptr_IPCPaymentCloseActionRequest())->~IPCPaymentCloseActionRequest__tdef();
            break;
        }
    case TIPCPaymentRetryActionRequest:
        {
            (ptr_IPCPaymentRetryActionRequest())->~IPCPaymentRetryActionRequest__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentCreateActionRequest& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(aOther);
    mType = TIPCPaymentCreateActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentCreateActionRequest&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(std::move(aOther));
    mType = TIPCPaymentCreateActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentCanMakeActionRequest& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(aOther);
    mType = TIPCPaymentCanMakeActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentCanMakeActionRequest&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(std::move(aOther));
    mType = TIPCPaymentCanMakeActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentShowActionRequest& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(aOther);
    mType = TIPCPaymentShowActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentShowActionRequest&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(std::move(aOther));
    mType = TIPCPaymentShowActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentAbortActionRequest& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(aOther);
    mType = TIPCPaymentAbortActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentAbortActionRequest&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(std::move(aOther));
    mType = TIPCPaymentAbortActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentCompleteActionRequest& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(aOther);
    mType = TIPCPaymentCompleteActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentCompleteActionRequest&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(std::move(aOther));
    mType = TIPCPaymentCompleteActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentUpdateActionRequest& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(aOther);
    mType = TIPCPaymentUpdateActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentUpdateActionRequest&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(std::move(aOther));
    mType = TIPCPaymentUpdateActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentCloseActionRequest& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(aOther);
    mType = TIPCPaymentCloseActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentCloseActionRequest&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(std::move(aOther));
    mType = TIPCPaymentCloseActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentRetryActionRequest& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(aOther);
    mType = TIPCPaymentRetryActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentRetryActionRequest&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(std::move(aOther));
    mType = TIPCPaymentRetryActionRequest;
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(const IPCPaymentActionRequest& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TIPCPaymentCreateActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest((aOther).get_IPCPaymentCreateActionRequest());
            break;
        }
    case TIPCPaymentCanMakeActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest((aOther).get_IPCPaymentCanMakeActionRequest());
            break;
        }
    case TIPCPaymentShowActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest((aOther).get_IPCPaymentShowActionRequest());
            break;
        }
    case TIPCPaymentAbortActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest((aOther).get_IPCPaymentAbortActionRequest());
            break;
        }
    case TIPCPaymentCompleteActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest((aOther).get_IPCPaymentCompleteActionRequest());
            break;
        }
    case TIPCPaymentUpdateActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest((aOther).get_IPCPaymentUpdateActionRequest());
            break;
        }
    case TIPCPaymentCloseActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest((aOther).get_IPCPaymentCloseActionRequest());
            break;
        }
    case TIPCPaymentRetryActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest((aOther).get_IPCPaymentRetryActionRequest());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCPaymentActionRequest::IPCPaymentActionRequest(IPCPaymentActionRequest&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TIPCPaymentCreateActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(std::move((aOther).get_IPCPaymentCreateActionRequest()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentCanMakeActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(std::move((aOther).get_IPCPaymentCanMakeActionRequest()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentShowActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(std::move((aOther).get_IPCPaymentShowActionRequest()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentAbortActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(std::move((aOther).get_IPCPaymentAbortActionRequest()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentCompleteActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(std::move((aOther).get_IPCPaymentCompleteActionRequest()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentUpdateActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(std::move((aOther).get_IPCPaymentUpdateActionRequest()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentCloseActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(std::move((aOther).get_IPCPaymentCloseActionRequest()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentRetryActionRequest:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(std::move((aOther).get_IPCPaymentRetryActionRequest()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

IPCPaymentActionRequest::~IPCPaymentActionRequest()
{
    MaybeDestroy();
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentCreateActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(aRhs);
    mType = TIPCPaymentCreateActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentCreateActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(std::move(aRhs));
    mType = TIPCPaymentCreateActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentCanMakeActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(aRhs);
    mType = TIPCPaymentCanMakeActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentCanMakeActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(std::move(aRhs));
    mType = TIPCPaymentCanMakeActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentShowActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(aRhs);
    mType = TIPCPaymentShowActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentShowActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(std::move(aRhs));
    mType = TIPCPaymentShowActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentAbortActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(aRhs);
    mType = TIPCPaymentAbortActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentAbortActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(std::move(aRhs));
    mType = TIPCPaymentAbortActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentCompleteActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(aRhs);
    mType = TIPCPaymentCompleteActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentCompleteActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(std::move(aRhs));
    mType = TIPCPaymentCompleteActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentUpdateActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(aRhs);
    mType = TIPCPaymentUpdateActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentUpdateActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(std::move(aRhs));
    mType = TIPCPaymentUpdateActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentCloseActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(aRhs);
    mType = TIPCPaymentCloseActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentCloseActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(std::move(aRhs));
    mType = TIPCPaymentCloseActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentRetryActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(aRhs);
    mType = TIPCPaymentRetryActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentRetryActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(std::move(aRhs));
    mType = TIPCPaymentRetryActionRequest;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(const IPCPaymentActionRequest& aRhs) -> IPCPaymentActionRequest&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCPaymentCreateActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest((aRhs).get_IPCPaymentCreateActionRequest());
            break;
        }
    case TIPCPaymentCanMakeActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest((aRhs).get_IPCPaymentCanMakeActionRequest());
            break;
        }
    case TIPCPaymentShowActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest((aRhs).get_IPCPaymentShowActionRequest());
            break;
        }
    case TIPCPaymentAbortActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest((aRhs).get_IPCPaymentAbortActionRequest());
            break;
        }
    case TIPCPaymentCompleteActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest((aRhs).get_IPCPaymentCompleteActionRequest());
            break;
        }
    case TIPCPaymentUpdateActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest((aRhs).get_IPCPaymentUpdateActionRequest());
            break;
        }
    case TIPCPaymentCloseActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest((aRhs).get_IPCPaymentCloseActionRequest());
            break;
        }
    case TIPCPaymentRetryActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest((aRhs).get_IPCPaymentRetryActionRequest());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCPaymentActionRequest::operator=(IPCPaymentActionRequest&& aRhs) -> IPCPaymentActionRequest&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCPaymentCreateActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCreateActionRequest()) IPCPaymentCreateActionRequest(std::move((aRhs).get_IPCPaymentCreateActionRequest()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentCanMakeActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionRequest()) IPCPaymentCanMakeActionRequest(std::move((aRhs).get_IPCPaymentCanMakeActionRequest()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentShowActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionRequest()) IPCPaymentShowActionRequest(std::move((aRhs).get_IPCPaymentShowActionRequest()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentAbortActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionRequest()) IPCPaymentAbortActionRequest(std::move((aRhs).get_IPCPaymentAbortActionRequest()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentCompleteActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionRequest()) IPCPaymentCompleteActionRequest(std::move((aRhs).get_IPCPaymentCompleteActionRequest()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentUpdateActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentUpdateActionRequest()) IPCPaymentUpdateActionRequest(std::move((aRhs).get_IPCPaymentUpdateActionRequest()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentCloseActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCloseActionRequest()) IPCPaymentCloseActionRequest(std::move((aRhs).get_IPCPaymentCloseActionRequest()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentRetryActionRequest:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentRetryActionRequest()) IPCPaymentRetryActionRequest(std::move((aRhs).get_IPCPaymentRetryActionRequest()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentActionRequest>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::IPCPaymentActionRequest union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'IPCPaymentActionRequest'
    (aWriter)->WriteSentinel(1725761794);

    switch (type) {
    case union__::TIPCPaymentCreateActionRequest:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCreateActionRequest());
            // Sentinel = 'TIPCPaymentCreateActionRequest'
            (aWriter)->WriteSentinel(2905344938);
            return;
        }
    case union__::TIPCPaymentCanMakeActionRequest:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCanMakeActionRequest());
            // Sentinel = 'TIPCPaymentCanMakeActionRequest'
            (aWriter)->WriteSentinel(3058306022);
            return;
        }
    case union__::TIPCPaymentShowActionRequest:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentShowActionRequest());
            // Sentinel = 'TIPCPaymentShowActionRequest'
            (aWriter)->WriteSentinel(2550139639);
            return;
        }
    case union__::TIPCPaymentAbortActionRequest:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentAbortActionRequest());
            // Sentinel = 'TIPCPaymentAbortActionRequest'
            (aWriter)->WriteSentinel(2719157070);
            return;
        }
    case union__::TIPCPaymentCompleteActionRequest:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCompleteActionRequest());
            // Sentinel = 'TIPCPaymentCompleteActionRequest'
            (aWriter)->WriteSentinel(3341159567);
            return;
        }
    case union__::TIPCPaymentUpdateActionRequest:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentUpdateActionRequest());
            // Sentinel = 'TIPCPaymentUpdateActionRequest'
            (aWriter)->WriteSentinel(2924284857);
            return;
        }
    case union__::TIPCPaymentCloseActionRequest:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCloseActionRequest());
            // Sentinel = 'TIPCPaymentCloseActionRequest'
            (aWriter)->WriteSentinel(2719877964);
            return;
        }
    case union__::TIPCPaymentRetryActionRequest:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentRetryActionRequest());
            // Sentinel = 'TIPCPaymentRetryActionRequest'
            (aWriter)->WriteSentinel(2752383852);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union IPCPaymentActionRequest");
            return;
        }
    }
}

auto ParamTraits<::mozilla::dom::IPCPaymentActionRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    typedef ::mozilla::dom::IPCPaymentActionRequest union__;
    auto maybe__type = IPC::ReadParam<int>(aReader);
    if (!maybe__type) {
        aReader->FatalError("Error deserializing type of union IPCPaymentActionRequest");
        return {};

    }
    auto& type = *maybe__type;
    // Sentinel = 'IPCPaymentActionRequest'
    if ((!((aReader)->ReadSentinel(1725761794)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union IPCPaymentActionRequest");
        return {};
    }

    switch (type) {
    case union__::TIPCPaymentCreateActionRequest:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCreateActionRequest>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentCreateActionRequest of union IPCPaymentActionRequest");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentCreateActionRequest'
            if ((!((aReader)->ReadSentinel(2905344938)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCreateActionRequest of union IPCPaymentActionRequest");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentCanMakeActionRequest:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCanMakeActionRequest>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentCanMakeActionRequest of union IPCPaymentActionRequest");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentCanMakeActionRequest'
            if ((!((aReader)->ReadSentinel(3058306022)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCanMakeActionRequest of union IPCPaymentActionRequest");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentShowActionRequest:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentShowActionRequest>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentShowActionRequest of union IPCPaymentActionRequest");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentShowActionRequest'
            if ((!((aReader)->ReadSentinel(2550139639)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentShowActionRequest of union IPCPaymentActionRequest");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentAbortActionRequest:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentAbortActionRequest>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentAbortActionRequest of union IPCPaymentActionRequest");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentAbortActionRequest'
            if ((!((aReader)->ReadSentinel(2719157070)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentAbortActionRequest of union IPCPaymentActionRequest");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentCompleteActionRequest:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCompleteActionRequest>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentCompleteActionRequest of union IPCPaymentActionRequest");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentCompleteActionRequest'
            if ((!((aReader)->ReadSentinel(3341159567)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCompleteActionRequest of union IPCPaymentActionRequest");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentUpdateActionRequest:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentUpdateActionRequest>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentUpdateActionRequest of union IPCPaymentActionRequest");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentUpdateActionRequest'
            if ((!((aReader)->ReadSentinel(2924284857)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentUpdateActionRequest of union IPCPaymentActionRequest");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentCloseActionRequest:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCloseActionRequest>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentCloseActionRequest of union IPCPaymentActionRequest");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentCloseActionRequest'
            if ((!((aReader)->ReadSentinel(2719877964)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCloseActionRequest of union IPCPaymentActionRequest");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentRetryActionRequest:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentRetryActionRequest>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentRetryActionRequest of union IPCPaymentActionRequest");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentRetryActionRequest'
            if ((!((aReader)->ReadSentinel(2752383852)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentRetryActionRequest of union IPCPaymentActionRequest");
                return {};
            }
            return std::move(tmp);
        }
    default:
        {
            aReader->FatalError("unknown variant of union IPCPaymentActionRequest");
            return {};
        }
    }
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCanMakeActionResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCanMakeActionResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).result());
    // Sentinel = 'result'
    (aWriter)->WriteSentinel(153223840);
}

auto ParamTraits<::mozilla::dom::IPCPaymentCanMakeActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCanMakeActionResponse'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCanMakeActionResponse'");
        return {};
    }
    auto maybe___result = IPC::ReadParam<bool>(aReader);
    if (!maybe___result) {
        aReader->FatalError("Error deserializing 'result' (bool) member of 'IPCPaymentCanMakeActionResponse'");
        return {};

    }
    auto& _result = *maybe___result;
    // Sentinel = 'result'
    if ((!((aReader)->ReadSentinel(153223840)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'result' (bool) member of 'IPCPaymentCanMakeActionResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId),
            std::move(_result)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentAddress|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentAddress>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).country());
    // Sentinel = 'country'
    (aWriter)->WriteSentinel(202375957);
    IPC::WriteParam(aWriter, (aVar).addressLine());
    // Sentinel = 'addressLine'
    (aWriter)->WriteSentinel(445777007);
    IPC::WriteParam(aWriter, (aVar).region());
    // Sentinel = 'region'
    (aWriter)->WriteSentinel(147718789);
    IPC::WriteParam(aWriter, (aVar).regionCode());
    // Sentinel = 'regionCode'
    (aWriter)->WriteSentinel(375915520);
    IPC::WriteParam(aWriter, (aVar).city());
    // Sentinel = 'city'
    (aWriter)->WriteSentinel(69992890);
    IPC::WriteParam(aWriter, (aVar).dependentLocality());
    // Sentinel = 'dependentLocality'
    (aWriter)->WriteSentinel(1040451321);
    IPC::WriteParam(aWriter, (aVar).postalCode());
    // Sentinel = 'postalCode'
    (aWriter)->WriteSentinel(385680399);
    IPC::WriteParam(aWriter, (aVar).sortingCode());
    // Sentinel = 'sortingCode'
    (aWriter)->WriteSentinel(468714626);
    IPC::WriteParam(aWriter, (aVar).organization());
    // Sentinel = 'organization'
    (aWriter)->WriteSentinel(553387286);
    IPC::WriteParam(aWriter, (aVar).recipient());
    // Sentinel = 'recipient'
    (aWriter)->WriteSentinel(313590724);
    IPC::WriteParam(aWriter, (aVar).phone());
    // Sentinel = 'phone'
    (aWriter)->WriteSentinel(107151899);
}

auto ParamTraits<::mozilla::dom::IPCPaymentAddress>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___country = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___country) {
        aReader->FatalError("Error deserializing 'country' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _country = *maybe___country;
    // Sentinel = 'country'
    if ((!((aReader)->ReadSentinel(202375957)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'country' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___addressLine = IPC::ReadParam<nsTArray<::nsString>>(aReader);
    if (!maybe___addressLine) {
        aReader->FatalError("Error deserializing 'addressLine' (nsString[]) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _addressLine = *maybe___addressLine;
    // Sentinel = 'addressLine'
    if ((!((aReader)->ReadSentinel(445777007)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'addressLine' (nsString[]) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___region = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___region) {
        aReader->FatalError("Error deserializing 'region' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _region = *maybe___region;
    // Sentinel = 'region'
    if ((!((aReader)->ReadSentinel(147718789)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'region' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___regionCode = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___regionCode) {
        aReader->FatalError("Error deserializing 'regionCode' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _regionCode = *maybe___regionCode;
    // Sentinel = 'regionCode'
    if ((!((aReader)->ReadSentinel(375915520)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'regionCode' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___city = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___city) {
        aReader->FatalError("Error deserializing 'city' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _city = *maybe___city;
    // Sentinel = 'city'
    if ((!((aReader)->ReadSentinel(69992890)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'city' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___dependentLocality = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___dependentLocality) {
        aReader->FatalError("Error deserializing 'dependentLocality' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _dependentLocality = *maybe___dependentLocality;
    // Sentinel = 'dependentLocality'
    if ((!((aReader)->ReadSentinel(1040451321)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'dependentLocality' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___postalCode = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___postalCode) {
        aReader->FatalError("Error deserializing 'postalCode' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _postalCode = *maybe___postalCode;
    // Sentinel = 'postalCode'
    if ((!((aReader)->ReadSentinel(385680399)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'postalCode' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___sortingCode = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___sortingCode) {
        aReader->FatalError("Error deserializing 'sortingCode' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _sortingCode = *maybe___sortingCode;
    // Sentinel = 'sortingCode'
    if ((!((aReader)->ReadSentinel(468714626)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sortingCode' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___organization = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___organization) {
        aReader->FatalError("Error deserializing 'organization' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _organization = *maybe___organization;
    // Sentinel = 'organization'
    if ((!((aReader)->ReadSentinel(553387286)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'organization' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___recipient = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___recipient) {
        aReader->FatalError("Error deserializing 'recipient' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _recipient = *maybe___recipient;
    // Sentinel = 'recipient'
    if ((!((aReader)->ReadSentinel(313590724)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'recipient' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    auto maybe___phone = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___phone) {
        aReader->FatalError("Error deserializing 'phone' (nsString) member of 'IPCPaymentAddress'");
        return {};

    }
    auto& _phone = *maybe___phone;
    // Sentinel = 'phone'
    if ((!((aReader)->ReadSentinel(107151899)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'phone' (nsString) member of 'IPCPaymentAddress'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_country),
            std::move(_addressLine),
            std::move(_region),
            std::move(_regionCode),
            std::move(_city),
            std::move(_dependentLocality),
            std::move(_postalCode),
            std::move(_sortingCode),
            std::move(_organization),
            std::move(_recipient),
            std::move(_phone)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCGeneralResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCGeneralResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
}

auto ParamTraits<::mozilla::dom::IPCGeneralResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___data = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (nsString) member of 'IPCGeneralResponse'");
        return {};

    }
    auto& _data = *maybe___data;
    // Sentinel = 'data'
    if ((!((aReader)->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsString) member of 'IPCGeneralResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_data)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCBasicCardResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCBasicCardResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).cardholderName());
    // Sentinel = 'cardholderName'
    (aWriter)->WriteSentinel(709756314);
    IPC::WriteParam(aWriter, (aVar).cardNumber());
    // Sentinel = 'cardNumber'
    (aWriter)->WriteSentinel(365954052);
    IPC::WriteParam(aWriter, (aVar).expiryMonth());
    // Sentinel = 'expiryMonth'
    (aWriter)->WriteSentinel(471139496);
    IPC::WriteParam(aWriter, (aVar).expiryYear());
    // Sentinel = 'expiryYear'
    (aWriter)->WriteSentinel(392365107);
    IPC::WriteParam(aWriter, (aVar).cardSecurityCode());
    // Sentinel = 'cardSecurityCode'
    (aWriter)->WriteSentinel(914294382);
    IPC::WriteParam(aWriter, (aVar).billingAddress());
    // Sentinel = 'billingAddress'
    (aWriter)->WriteSentinel(705037736);
}

auto ParamTraits<::mozilla::dom::IPCBasicCardResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___cardholderName = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___cardholderName) {
        aReader->FatalError("Error deserializing 'cardholderName' (nsString) member of 'IPCBasicCardResponse'");
        return {};

    }
    auto& _cardholderName = *maybe___cardholderName;
    // Sentinel = 'cardholderName'
    if ((!((aReader)->ReadSentinel(709756314)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cardholderName' (nsString) member of 'IPCBasicCardResponse'");
        return {};
    }
    auto maybe___cardNumber = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___cardNumber) {
        aReader->FatalError("Error deserializing 'cardNumber' (nsString) member of 'IPCBasicCardResponse'");
        return {};

    }
    auto& _cardNumber = *maybe___cardNumber;
    // Sentinel = 'cardNumber'
    if ((!((aReader)->ReadSentinel(365954052)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cardNumber' (nsString) member of 'IPCBasicCardResponse'");
        return {};
    }
    auto maybe___expiryMonth = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___expiryMonth) {
        aReader->FatalError("Error deserializing 'expiryMonth' (nsString) member of 'IPCBasicCardResponse'");
        return {};

    }
    auto& _expiryMonth = *maybe___expiryMonth;
    // Sentinel = 'expiryMonth'
    if ((!((aReader)->ReadSentinel(471139496)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'expiryMonth' (nsString) member of 'IPCBasicCardResponse'");
        return {};
    }
    auto maybe___expiryYear = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___expiryYear) {
        aReader->FatalError("Error deserializing 'expiryYear' (nsString) member of 'IPCBasicCardResponse'");
        return {};

    }
    auto& _expiryYear = *maybe___expiryYear;
    // Sentinel = 'expiryYear'
    if ((!((aReader)->ReadSentinel(392365107)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'expiryYear' (nsString) member of 'IPCBasicCardResponse'");
        return {};
    }
    auto maybe___cardSecurityCode = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___cardSecurityCode) {
        aReader->FatalError("Error deserializing 'cardSecurityCode' (nsString) member of 'IPCBasicCardResponse'");
        return {};

    }
    auto& _cardSecurityCode = *maybe___cardSecurityCode;
    // Sentinel = 'cardSecurityCode'
    if ((!((aReader)->ReadSentinel(914294382)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cardSecurityCode' (nsString) member of 'IPCBasicCardResponse'");
        return {};
    }
    auto maybe___billingAddress = IPC::ReadParam<::mozilla::dom::IPCPaymentAddress>(aReader);
    if (!maybe___billingAddress) {
        aReader->FatalError("Error deserializing 'billingAddress' (IPCPaymentAddress) member of 'IPCBasicCardResponse'");
        return {};

    }
    auto& _billingAddress = *maybe___billingAddress;
    // Sentinel = 'billingAddress'
    if ((!((aReader)->ReadSentinel(705037736)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'billingAddress' (IPCPaymentAddress) member of 'IPCBasicCardResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_cardholderName),
            std::move(_cardNumber),
            std::move(_expiryMonth),
            std::move(_expiryYear),
            std::move(_cardSecurityCode),
            std::move(_billingAddress)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCPaymentResponseData|
//
namespace mozilla {
namespace dom {
auto IPCPaymentResponseData::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TIPCGeneralResponse:
        {
            (ptr_IPCGeneralResponse())->~IPCGeneralResponse__tdef();
            break;
        }
    case TIPCBasicCardResponse:
        {
            (ptr_IPCBasicCardResponse())->~IPCBasicCardResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(const IPCGeneralResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(aOther);
    mType = TIPCGeneralResponse;
}

MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(IPCGeneralResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(std::move(aOther));
    mType = TIPCGeneralResponse;
}

MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(const IPCBasicCardResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(aOther);
    mType = TIPCBasicCardResponse;
}

MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(IPCBasicCardResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(std::move(aOther));
    mType = TIPCBasicCardResponse;
}

MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(const IPCPaymentResponseData& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TIPCGeneralResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse((aOther).get_IPCGeneralResponse());
            break;
        }
    case TIPCBasicCardResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse((aOther).get_IPCBasicCardResponse());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCPaymentResponseData::IPCPaymentResponseData(IPCPaymentResponseData&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TIPCGeneralResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(std::move((aOther).get_IPCGeneralResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCBasicCardResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(std::move((aOther).get_IPCBasicCardResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

IPCPaymentResponseData::~IPCPaymentResponseData()
{
    MaybeDestroy();
}

auto IPCPaymentResponseData::operator=(const IPCGeneralResponse& aRhs) -> IPCPaymentResponseData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(aRhs);
    mType = TIPCGeneralResponse;
    return (*(this));
}

auto IPCPaymentResponseData::operator=(IPCGeneralResponse&& aRhs) -> IPCPaymentResponseData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(std::move(aRhs));
    mType = TIPCGeneralResponse;
    return (*(this));
}

auto IPCPaymentResponseData::operator=(const IPCBasicCardResponse& aRhs) -> IPCPaymentResponseData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(aRhs);
    mType = TIPCBasicCardResponse;
    return (*(this));
}

auto IPCPaymentResponseData::operator=(IPCBasicCardResponse&& aRhs) -> IPCPaymentResponseData&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(std::move(aRhs));
    mType = TIPCBasicCardResponse;
    return (*(this));
}

auto IPCPaymentResponseData::operator=(const IPCPaymentResponseData& aRhs) -> IPCPaymentResponseData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCGeneralResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse((aRhs).get_IPCGeneralResponse());
            break;
        }
    case TIPCBasicCardResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse((aRhs).get_IPCBasicCardResponse());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCPaymentResponseData::operator=(IPCPaymentResponseData&& aRhs) -> IPCPaymentResponseData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCGeneralResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCGeneralResponse()) IPCGeneralResponse(std::move((aRhs).get_IPCGeneralResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCBasicCardResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCBasicCardResponse()) IPCBasicCardResponse(std::move((aRhs).get_IPCBasicCardResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentResponseData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::IPCPaymentResponseData union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'IPCPaymentResponseData'
    (aWriter)->WriteSentinel(1590954116);

    switch (type) {
    case union__::TIPCGeneralResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCGeneralResponse());
            // Sentinel = 'TIPCGeneralResponse'
            (aWriter)->WriteSentinel(1140066110);
            return;
        }
    case union__::TIPCBasicCardResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCBasicCardResponse());
            // Sentinel = 'TIPCBasicCardResponse'
            (aWriter)->WriteSentinel(1360267228);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union IPCPaymentResponseData");
            return;
        }
    }
}

auto ParamTraits<::mozilla::dom::IPCPaymentResponseData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    typedef ::mozilla::dom::IPCPaymentResponseData union__;
    auto maybe__type = IPC::ReadParam<int>(aReader);
    if (!maybe__type) {
        aReader->FatalError("Error deserializing type of union IPCPaymentResponseData");
        return {};

    }
    auto& type = *maybe__type;
    // Sentinel = 'IPCPaymentResponseData'
    if ((!((aReader)->ReadSentinel(1590954116)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union IPCPaymentResponseData");
        return {};
    }

    switch (type) {
    case union__::TIPCGeneralResponse:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCGeneralResponse>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCGeneralResponse of union IPCPaymentResponseData");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCGeneralResponse'
            if ((!((aReader)->ReadSentinel(1140066110)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCGeneralResponse of union IPCPaymentResponseData");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCBasicCardResponse:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCBasicCardResponse>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCBasicCardResponse of union IPCPaymentResponseData");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCBasicCardResponse'
            if ((!((aReader)->ReadSentinel(1360267228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCBasicCardResponse of union IPCPaymentResponseData");
                return {};
            }
            return std::move(tmp);
        }
    default:
        {
            aReader->FatalError("unknown variant of union IPCPaymentResponseData");
            return {};
        }
    }
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentShowActionResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentShowActionResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).methodName());
    // Sentinel = 'methodName'
    (aWriter)->WriteSentinel(377029635);
    IPC::WriteParam(aWriter, (aVar).data());
    // Sentinel = 'data'
    (aWriter)->WriteSentinel(67109275);
    IPC::WriteParam(aWriter, (aVar).payerName());
    // Sentinel = 'payerName'
    (aWriter)->WriteSentinel(310510499);
    IPC::WriteParam(aWriter, (aVar).payerEmail());
    // Sentinel = 'payerEmail'
    (aWriter)->WriteSentinel(376964106);
    IPC::WriteParam(aWriter, (aVar).payerPhone());
    // Sentinel = 'payerPhone'
    (aWriter)->WriteSentinel(382207004);
    (aWriter)->WriteBytes((&((aVar).status())), 4);
    // Sentinel = 'status'
    (aWriter)->WriteSentinel(154731173);
}

auto ParamTraits<::mozilla::dom::IPCPaymentShowActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};
    }
    auto maybe___methodName = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___methodName) {
        aReader->FatalError("Error deserializing 'methodName' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};

    }
    auto& _methodName = *maybe___methodName;
    // Sentinel = 'methodName'
    if ((!((aReader)->ReadSentinel(377029635)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'methodName' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};
    }
    auto maybe___data = IPC::ReadParam<::mozilla::dom::IPCPaymentResponseData>(aReader);
    if (!maybe___data) {
        aReader->FatalError("Error deserializing 'data' (IPCPaymentResponseData) member of 'IPCPaymentShowActionResponse'");
        return {};

    }
    auto& _data = *maybe___data;
    // Sentinel = 'data'
    if ((!((aReader)->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (IPCPaymentResponseData) member of 'IPCPaymentShowActionResponse'");
        return {};
    }
    auto maybe___payerName = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___payerName) {
        aReader->FatalError("Error deserializing 'payerName' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};

    }
    auto& _payerName = *maybe___payerName;
    // Sentinel = 'payerName'
    if ((!((aReader)->ReadSentinel(310510499)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'payerName' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};
    }
    auto maybe___payerEmail = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___payerEmail) {
        aReader->FatalError("Error deserializing 'payerEmail' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};

    }
    auto& _payerEmail = *maybe___payerEmail;
    // Sentinel = 'payerEmail'
    if ((!((aReader)->ReadSentinel(376964106)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'payerEmail' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};
    }
    auto maybe___payerPhone = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___payerPhone) {
        aReader->FatalError("Error deserializing 'payerPhone' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};

    }
    auto& _payerPhone = *maybe___payerPhone;
    // Sentinel = 'payerPhone'
    if ((!((aReader)->ReadSentinel(382207004)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'payerPhone' (nsString) member of 'IPCPaymentShowActionResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId),
            ::uint32_t{0},
            std::move(_methodName),
            std::move(_data),
            std::move(_payerName),
            std::move(_payerEmail),
            std::move(_payerPhone)};
    if ((!((aReader)->ReadBytesInto((&((result__)->status())), 4)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'status'
    if ((!((aReader)->ReadSentinel(154731173)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentAbortActionResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentAbortActionResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).isSucceeded());
    // Sentinel = 'isSucceeded'
    (aWriter)->WriteSentinel(445449314);
}

auto ParamTraits<::mozilla::dom::IPCPaymentAbortActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentAbortActionResponse'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentAbortActionResponse'");
        return {};
    }
    auto maybe___isSucceeded = IPC::ReadParam<bool>(aReader);
    if (!maybe___isSucceeded) {
        aReader->FatalError("Error deserializing 'isSucceeded' (bool) member of 'IPCPaymentAbortActionResponse'");
        return {};

    }
    auto& _isSucceeded = *maybe___isSucceeded;
    // Sentinel = 'isSucceeded'
    if ((!((aReader)->ReadSentinel(445449314)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isSucceeded' (bool) member of 'IPCPaymentAbortActionResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId),
            std::move(_isSucceeded)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPaymentCompleteActionResponse|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentCompleteActionResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).requestId());
    // Sentinel = 'requestId'
    (aWriter)->WriteSentinel(320799671);
    IPC::WriteParam(aWriter, (aVar).isCompleted());
    // Sentinel = 'isCompleted'
    (aWriter)->WriteSentinel(448005242);
}

auto ParamTraits<::mozilla::dom::IPCPaymentCompleteActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___requestId = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___requestId) {
        aReader->FatalError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCompleteActionResponse'");
        return {};

    }
    auto& _requestId = *maybe___requestId;
    // Sentinel = 'requestId'
    if ((!((aReader)->ReadSentinel(320799671)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestId' (nsString) member of 'IPCPaymentCompleteActionResponse'");
        return {};
    }
    auto maybe___isCompleted = IPC::ReadParam<bool>(aReader);
    if (!maybe___isCompleted) {
        aReader->FatalError("Error deserializing 'isCompleted' (bool) member of 'IPCPaymentCompleteActionResponse'");
        return {};

    }
    auto& _isCompleted = *maybe___isCompleted;
    // Sentinel = 'isCompleted'
    if ((!((aReader)->ReadSentinel(448005242)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isCompleted' (bool) member of 'IPCPaymentCompleteActionResponse'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_requestId),
            std::move(_isCompleted)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCPaymentActionResponse|
//
namespace mozilla {
namespace dom {
auto IPCPaymentActionResponse::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TIPCPaymentCanMakeActionResponse:
        {
            (ptr_IPCPaymentCanMakeActionResponse())->~IPCPaymentCanMakeActionResponse__tdef();
            break;
        }
    case TIPCPaymentShowActionResponse:
        {
            (ptr_IPCPaymentShowActionResponse())->~IPCPaymentShowActionResponse__tdef();
            break;
        }
    case TIPCPaymentAbortActionResponse:
        {
            (ptr_IPCPaymentAbortActionResponse())->~IPCPaymentAbortActionResponse__tdef();
            break;
        }
    case TIPCPaymentCompleteActionResponse:
        {
            (ptr_IPCPaymentCompleteActionResponse())->~IPCPaymentCompleteActionResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentCanMakeActionResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(aOther);
    mType = TIPCPaymentCanMakeActionResponse;
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentCanMakeActionResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(std::move(aOther));
    mType = TIPCPaymentCanMakeActionResponse;
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentShowActionResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(aOther);
    mType = TIPCPaymentShowActionResponse;
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentShowActionResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(std::move(aOther));
    mType = TIPCPaymentShowActionResponse;
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentAbortActionResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(aOther);
    mType = TIPCPaymentAbortActionResponse;
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentAbortActionResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(std::move(aOther));
    mType = TIPCPaymentAbortActionResponse;
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentCompleteActionResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(aOther);
    mType = TIPCPaymentCompleteActionResponse;
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentCompleteActionResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(std::move(aOther));
    mType = TIPCPaymentCompleteActionResponse;
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(const IPCPaymentActionResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TIPCPaymentCanMakeActionResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse((aOther).get_IPCPaymentCanMakeActionResponse());
            break;
        }
    case TIPCPaymentShowActionResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse((aOther).get_IPCPaymentShowActionResponse());
            break;
        }
    case TIPCPaymentAbortActionResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse((aOther).get_IPCPaymentAbortActionResponse());
            break;
        }
    case TIPCPaymentCompleteActionResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse((aOther).get_IPCPaymentCompleteActionResponse());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCPaymentActionResponse::IPCPaymentActionResponse(IPCPaymentActionResponse&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TIPCPaymentCanMakeActionResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(std::move((aOther).get_IPCPaymentCanMakeActionResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentShowActionResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(std::move((aOther).get_IPCPaymentShowActionResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentAbortActionResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(std::move((aOther).get_IPCPaymentAbortActionResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCPaymentCompleteActionResponse:
        {
            new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(std::move((aOther).get_IPCPaymentCompleteActionResponse()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

IPCPaymentActionResponse::~IPCPaymentActionResponse()
{
    MaybeDestroy();
}

auto IPCPaymentActionResponse::operator=(const IPCPaymentCanMakeActionResponse& aRhs) -> IPCPaymentActionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(aRhs);
    mType = TIPCPaymentCanMakeActionResponse;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(IPCPaymentCanMakeActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(std::move(aRhs));
    mType = TIPCPaymentCanMakeActionResponse;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(const IPCPaymentShowActionResponse& aRhs) -> IPCPaymentActionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(aRhs);
    mType = TIPCPaymentShowActionResponse;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(IPCPaymentShowActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(std::move(aRhs));
    mType = TIPCPaymentShowActionResponse;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(const IPCPaymentAbortActionResponse& aRhs) -> IPCPaymentActionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(aRhs);
    mType = TIPCPaymentAbortActionResponse;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(IPCPaymentAbortActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(std::move(aRhs));
    mType = TIPCPaymentAbortActionResponse;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(const IPCPaymentCompleteActionResponse& aRhs) -> IPCPaymentActionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(aRhs);
    mType = TIPCPaymentCompleteActionResponse;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(IPCPaymentCompleteActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(std::move(aRhs));
    mType = TIPCPaymentCompleteActionResponse;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(const IPCPaymentActionResponse& aRhs) -> IPCPaymentActionResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCPaymentCanMakeActionResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse((aRhs).get_IPCPaymentCanMakeActionResponse());
            break;
        }
    case TIPCPaymentShowActionResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse((aRhs).get_IPCPaymentShowActionResponse());
            break;
        }
    case TIPCPaymentAbortActionResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse((aRhs).get_IPCPaymentAbortActionResponse());
            break;
        }
    case TIPCPaymentCompleteActionResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse((aRhs).get_IPCPaymentCompleteActionResponse());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCPaymentActionResponse::operator=(IPCPaymentActionResponse&& aRhs) -> IPCPaymentActionResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCPaymentCanMakeActionResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCanMakeActionResponse()) IPCPaymentCanMakeActionResponse(std::move((aRhs).get_IPCPaymentCanMakeActionResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentShowActionResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentShowActionResponse()) IPCPaymentShowActionResponse(std::move((aRhs).get_IPCPaymentShowActionResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentAbortActionResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentAbortActionResponse()) IPCPaymentAbortActionResponse(std::move((aRhs).get_IPCPaymentAbortActionResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCPaymentCompleteActionResponse:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCPaymentCompleteActionResponse()) IPCPaymentCompleteActionResponse(std::move((aRhs).get_IPCPaymentCompleteActionResponse()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPaymentActionResponse>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::IPCPaymentActionResponse union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'IPCPaymentActionResponse'
    (aWriter)->WriteSentinel(1884162408);

    switch (type) {
    case union__::TIPCPaymentCanMakeActionResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCanMakeActionResponse());
            // Sentinel = 'TIPCPaymentCanMakeActionResponse'
            (aWriter)->WriteSentinel(3265203276);
            return;
        }
    case union__::TIPCPaymentShowActionResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentShowActionResponse());
            // Sentinel = 'TIPCPaymentShowActionResponse'
            (aWriter)->WriteSentinel(2741373789);
            return;
        }
    case union__::TIPCPaymentAbortActionResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentAbortActionResponse());
            // Sentinel = 'TIPCPaymentAbortActionResponse'
            (aWriter)->WriteSentinel(2916092852);
            return;
        }
    case union__::TIPCPaymentCompleteActionResponse:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCPaymentCompleteActionResponse());
            // Sentinel = 'TIPCPaymentCompleteActionResponse'
            (aWriter)->WriteSentinel(3559132405);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union IPCPaymentActionResponse");
            return;
        }
    }
}

auto ParamTraits<::mozilla::dom::IPCPaymentActionResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    typedef ::mozilla::dom::IPCPaymentActionResponse union__;
    auto maybe__type = IPC::ReadParam<int>(aReader);
    if (!maybe__type) {
        aReader->FatalError("Error deserializing type of union IPCPaymentActionResponse");
        return {};

    }
    auto& type = *maybe__type;
    // Sentinel = 'IPCPaymentActionResponse'
    if ((!((aReader)->ReadSentinel(1884162408)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union IPCPaymentActionResponse");
        return {};
    }

    switch (type) {
    case union__::TIPCPaymentCanMakeActionResponse:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCanMakeActionResponse>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentCanMakeActionResponse of union IPCPaymentActionResponse");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentCanMakeActionResponse'
            if ((!((aReader)->ReadSentinel(3265203276)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCanMakeActionResponse of union IPCPaymentActionResponse");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentShowActionResponse:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentShowActionResponse>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentShowActionResponse of union IPCPaymentActionResponse");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentShowActionResponse'
            if ((!((aReader)->ReadSentinel(2741373789)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentShowActionResponse of union IPCPaymentActionResponse");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentAbortActionResponse:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentAbortActionResponse>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentAbortActionResponse of union IPCPaymentActionResponse");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentAbortActionResponse'
            if ((!((aReader)->ReadSentinel(2916092852)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentAbortActionResponse of union IPCPaymentActionResponse");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCPaymentCompleteActionResponse:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCPaymentCompleteActionResponse>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCPaymentCompleteActionResponse of union IPCPaymentActionResponse");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCPaymentCompleteActionResponse'
            if ((!((aReader)->ReadSentinel(3559132405)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCPaymentCompleteActionResponse of union IPCPaymentActionResponse");
                return {};
            }
            return std::move(tmp);
        }
    default:
        {
            aReader->FatalError("unknown variant of union IPCPaymentActionResponse");
            return {};
        }
    }
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCGeneralChangeDetails|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCGeneralChangeDetails>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).details());
    // Sentinel = 'details'
    (aWriter)->WriteSentinel(191824615);
}

auto ParamTraits<::mozilla::dom::IPCGeneralChangeDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___details = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___details) {
        aReader->FatalError("Error deserializing 'details' (nsString) member of 'IPCGeneralChangeDetails'");
        return {};

    }
    auto& _details = *maybe___details;
    // Sentinel = 'details'
    if ((!((aReader)->ReadSentinel(191824615)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'details' (nsString) member of 'IPCGeneralChangeDetails'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_details)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCBasicCardChangeDetails|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCBasicCardChangeDetails>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).billingAddress());
    // Sentinel = 'billingAddress'
    (aWriter)->WriteSentinel(705037736);
}

auto ParamTraits<::mozilla::dom::IPCBasicCardChangeDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___billingAddress = IPC::ReadParam<::mozilla::dom::IPCPaymentAddress>(aReader);
    if (!maybe___billingAddress) {
        aReader->FatalError("Error deserializing 'billingAddress' (IPCPaymentAddress) member of 'IPCBasicCardChangeDetails'");
        return {};

    }
    auto& _billingAddress = *maybe___billingAddress;
    // Sentinel = 'billingAddress'
    if ((!((aReader)->ReadSentinel(705037736)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'billingAddress' (IPCPaymentAddress) member of 'IPCBasicCardChangeDetails'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_billingAddress)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCMethodChangeDetails|
//
namespace mozilla {
namespace dom {
auto IPCMethodChangeDetails::MaybeDestroy() -> void
{
    if ((mType) == (T__None)) {
        return;
    }
    switch (mType) {
    case TIPCGeneralChangeDetails:
        {
            (ptr_IPCGeneralChangeDetails())->~IPCGeneralChangeDetails__tdef();
            break;
        }
    case TIPCBasicCardChangeDetails:
        {
            (ptr_IPCBasicCardChangeDetails())->~IPCBasicCardChangeDetails__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
}

MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(const IPCGeneralChangeDetails& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(aOther);
    mType = TIPCGeneralChangeDetails;
}

MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(IPCGeneralChangeDetails&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(std::move(aOther));
    mType = TIPCGeneralChangeDetails;
}

MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(const IPCBasicCardChangeDetails& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(aOther);
    mType = TIPCBasicCardChangeDetails;
}

MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(IPCBasicCardChangeDetails&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(std::move(aOther));
    mType = TIPCBasicCardChangeDetails;
}

MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(const IPCMethodChangeDetails& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TIPCGeneralChangeDetails:
        {
            new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails((aOther).get_IPCGeneralChangeDetails());
            break;
        }
    case TIPCBasicCardChangeDetails:
        {
            new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails((aOther).get_IPCBasicCardChangeDetails());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCMethodChangeDetails::IPCMethodChangeDetails(IPCMethodChangeDetails&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TIPCGeneralChangeDetails:
        {
            new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(std::move((aOther).get_IPCGeneralChangeDetails()));
            (aOther).MaybeDestroy();
            break;
        }
    case TIPCBasicCardChangeDetails:
        {
            new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(std::move((aOther).get_IPCBasicCardChangeDetails()));
            (aOther).MaybeDestroy();
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

IPCMethodChangeDetails::~IPCMethodChangeDetails()
{
    MaybeDestroy();
}

auto IPCMethodChangeDetails::operator=(const IPCGeneralChangeDetails& aRhs) -> IPCMethodChangeDetails&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(aRhs);
    mType = TIPCGeneralChangeDetails;
    return (*(this));
}

auto IPCMethodChangeDetails::operator=(IPCGeneralChangeDetails&& aRhs) -> IPCMethodChangeDetails&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(std::move(aRhs));
    mType = TIPCGeneralChangeDetails;
    return (*(this));
}

auto IPCMethodChangeDetails::operator=(const IPCBasicCardChangeDetails& aRhs) -> IPCMethodChangeDetails&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(aRhs);
    mType = TIPCBasicCardChangeDetails;
    return (*(this));
}

auto IPCMethodChangeDetails::operator=(IPCBasicCardChangeDetails&& aRhs) -> IPCMethodChangeDetails&
{
    MaybeDestroy();
    new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(std::move(aRhs));
    mType = TIPCBasicCardChangeDetails;
    return (*(this));
}

auto IPCMethodChangeDetails::operator=(const IPCMethodChangeDetails& aRhs) -> IPCMethodChangeDetails&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCGeneralChangeDetails:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails((aRhs).get_IPCGeneralChangeDetails());
            break;
        }
    case TIPCBasicCardChangeDetails:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails((aRhs).get_IPCBasicCardChangeDetails());
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCMethodChangeDetails::operator=(IPCMethodChangeDetails&& aRhs) -> IPCMethodChangeDetails&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCGeneralChangeDetails:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCGeneralChangeDetails()) IPCGeneralChangeDetails(std::move((aRhs).get_IPCGeneralChangeDetails()));
            (aRhs).MaybeDestroy();
            break;
        }
    case TIPCBasicCardChangeDetails:
        {
            MaybeDestroy();
            new (mozilla::KnownNotNull, ptr_IPCBasicCardChangeDetails()) IPCBasicCardChangeDetails(std::move((aRhs).get_IPCBasicCardChangeDetails()));
            (aRhs).MaybeDestroy();
            break;
        }
    case T__None:
        {
            MaybeDestroy();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCMethodChangeDetails>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    typedef ::mozilla::dom::IPCMethodChangeDetails union__;
    int type = (aVar).type();
    IPC::WriteParam(aWriter, type);
    // Sentinel = 'IPCMethodChangeDetails'
    (aWriter)->WriteSentinel(1530071114);

    switch (type) {
    case union__::TIPCGeneralChangeDetails:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCGeneralChangeDetails());
            // Sentinel = 'TIPCGeneralChangeDetails'
            (aWriter)->WriteSentinel(1797654779);
            return;
        }
    case union__::TIPCBasicCardChangeDetails:
        {
            IPC::WriteParam(aWriter, (aVar).get_IPCBasicCardChangeDetails());
            // Sentinel = 'TIPCBasicCardChangeDetails'
            (aWriter)->WriteSentinel(2069629337);
            return;
        }
    default:
        {
            aWriter->FatalError("unknown variant of union IPCMethodChangeDetails");
            return;
        }
    }
}

auto ParamTraits<::mozilla::dom::IPCMethodChangeDetails>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    typedef ::mozilla::dom::IPCMethodChangeDetails union__;
    auto maybe__type = IPC::ReadParam<int>(aReader);
    if (!maybe__type) {
        aReader->FatalError("Error deserializing type of union IPCMethodChangeDetails");
        return {};

    }
    auto& type = *maybe__type;
    // Sentinel = 'IPCMethodChangeDetails'
    if ((!((aReader)->ReadSentinel(1530071114)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union IPCMethodChangeDetails");
        return {};
    }

    switch (type) {
    case union__::TIPCGeneralChangeDetails:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCGeneralChangeDetails>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCGeneralChangeDetails of union IPCMethodChangeDetails");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCGeneralChangeDetails'
            if ((!((aReader)->ReadSentinel(1797654779)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCGeneralChangeDetails of union IPCMethodChangeDetails");
                return {};
            }
            return std::move(tmp);
        }
    case union__::TIPCBasicCardChangeDetails:
        {
            auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCBasicCardChangeDetails>(aReader);
            if (!maybe__tmp) {
                aReader->FatalError("Error deserializing variant TIPCBasicCardChangeDetails of union IPCMethodChangeDetails");
                return {};

            }
            auto& tmp = *maybe__tmp;
            // Sentinel = 'TIPCBasicCardChangeDetails'
            if ((!((aReader)->ReadSentinel(2069629337)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCBasicCardChangeDetails of union IPCMethodChangeDetails");
                return {};
            }
            return std::move(tmp);
        }
    default:
        {
            aReader->FatalError("unknown variant of union IPCMethodChangeDetails");
            return {};
        }
    }
}

} // namespace IPC
