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

#ifndef PPrintingTypes_h
#define PPrintingTypes_h

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

// Headers for typedefs
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/SideVariant.h"


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

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

    MOZ_IMPLICIT CStringKeyValue(
            const nsCString& _key,
            const nsCString& _value) :
        key_(_key),
        value_(_value)
    {
    }

    MOZ_IMPLICIT CStringKeyValue(
            nsCString&& _key,
            nsCString&& _value) :
        key_(std::move(_key)),
        value_(std::move(_value))
    {
    }

    nsCString&
    key()
    {
        return key_;
    }
    const nsCString&
    key() const
    {
        return key_;
    }

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

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> key_;
    ::mozilla::ipc::IPDLStructMember<nsCString> value_;
};
} // namespace embedding
} // namespace mozilla

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

namespace mozilla {
namespace layout {
class PRemotePrintJobParent;
} // namespace layout
} // namespace mozilla

namespace mozilla {
namespace layout {
class PRemotePrintJobChild;
} // namespace layout
} // namespace mozilla


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct PrintData|
//
namespace mozilla {
namespace embedding {
class PrintData final
{
private:
    typedef ::mozilla::layout::PRemotePrintJobParent PRemotePrintJobParent;
    typedef ::mozilla::layout::PRemotePrintJobChild PRemotePrintJobChild;
    typedef ::int32_t int32_t;
    typedef ::nsString nsString;
    typedef ::uint8_t uint8_t;
    typedef ::mozilla::embedding::CStringKeyValue CStringKeyValue;
    typedef ::uint16_t uint16_t;

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

    MOZ_IMPLICIT PrintData(
            ::mozilla::ipc::SideVariant<PRemotePrintJobParent*, PRemotePrintJobChild*> _remotePrintJob,
            const double& _edgeTop,
            const double& _edgeLeft,
            const double& _edgeBottom,
            const double& _edgeRight,
            const double& _marginTop,
            const double& _marginLeft,
            const double& _marginBottom,
            const double& _marginRight,
            const double& _unwriteableMarginTop,
            const double& _unwriteableMarginLeft,
            const double& _unwriteableMarginBottom,
            const double& _unwriteableMarginRight,
            const double& _scaling,
            const bool& _printBGColors,
            const bool& _printBGImages,
            const bool& _honorPageRuleMargins,
            const bool& _usePageRuleSizeAsPaperSize,
            const bool& _ignoreUnwriteableMargins,
            const bool& _showMarginGuides,
            const bool& _printSelectionOnly,
            const nsTArray<int32_t>& _pageRanges,
            const nsString& _title,
            const nsString& _docURL,
            const nsString& _headerStrLeft,
            const nsString& _headerStrCenter,
            const nsString& _headerStrRight,
            const nsString& _footerStrLeft,
            const nsString& _footerStrCenter,
            const nsString& _footerStrRight,
            const bool& _printSilent,
            const bool& _shrinkToFit,
            const nsString& _paperId,
            const double& _paperWidth,
            const double& _paperHeight,
            const short& _paperSizeUnit,
            const bool& _printReversed,
            const bool& _printInColor,
            const int32_t& _orientation,
            const int32_t& _numCopies,
            const int32_t& _numPagesPerSheet,
            const short& _outputDestination,
            const short& _outputFormat,
            const int32_t& _printPageDelay,
            const int32_t& _resolution,
            const int32_t& _duplex,
            const bool& _isInitializedFromPrinter,
            const bool& _isInitializedFromPrefs,
            const nsString& _driverName,
            const nsString& _deviceName,
            const nsTArray<uint8_t>& _devModeData,
            const nsTArray<CStringKeyValue>& _GTKPrintSettings,
            const nsString& _disposition,
            const uint16_t& _destination) :
        remotePrintJob_(_remotePrintJob),
        printBGColors_(_printBGColors),
        printBGImages_(_printBGImages),
        honorPageRuleMargins_(_honorPageRuleMargins),
        usePageRuleSizeAsPaperSize_(_usePageRuleSizeAsPaperSize),
        ignoreUnwriteableMargins_(_ignoreUnwriteableMargins),
        showMarginGuides_(_showMarginGuides),
        printSelectionOnly_(_printSelectionOnly),
        pageRanges_(_pageRanges),
        title_(_title),
        docURL_(_docURL),
        headerStrLeft_(_headerStrLeft),
        headerStrCenter_(_headerStrCenter),
        headerStrRight_(_headerStrRight),
        footerStrLeft_(_footerStrLeft),
        footerStrCenter_(_footerStrCenter),
        footerStrRight_(_footerStrRight),
        printSilent_(_printSilent),
        shrinkToFit_(_shrinkToFit),
        paperId_(_paperId),
        paperSizeUnit_(_paperSizeUnit),
        printReversed_(_printReversed),
        printInColor_(_printInColor),
        outputDestination_(_outputDestination),
        outputFormat_(_outputFormat),
        isInitializedFromPrinter_(_isInitializedFromPrinter),
        isInitializedFromPrefs_(_isInitializedFromPrefs),
        driverName_(_driverName),
        deviceName_(_deviceName),
        devModeData_(_devModeData),
        GTKPrintSettings_(_GTKPrintSettings),
        disposition_(_disposition),
        edgeTop_(_edgeTop),
        edgeLeft_(_edgeLeft),
        edgeBottom_(_edgeBottom),
        edgeRight_(_edgeRight),
        marginTop_(_marginTop),
        marginLeft_(_marginLeft),
        marginBottom_(_marginBottom),
        marginRight_(_marginRight),
        unwriteableMarginTop_(_unwriteableMarginTop),
        unwriteableMarginLeft_(_unwriteableMarginLeft),
        unwriteableMarginBottom_(_unwriteableMarginBottom),
        unwriteableMarginRight_(_unwriteableMarginRight),
        scaling_(_scaling),
        paperWidth_(_paperWidth),
        paperHeight_(_paperHeight),
        orientation_(_orientation),
        numCopies_(_numCopies),
        numPagesPerSheet_(_numPagesPerSheet),
        printPageDelay_(_printPageDelay),
        resolution_(_resolution),
        duplex_(_duplex),
        destination_(_destination)
    {
    }

    MOZ_IMPLICIT PrintData(
            ::mozilla::ipc::SideVariant<PRemotePrintJobParent*, PRemotePrintJobChild*> _remotePrintJob,
            double&& _edgeTop,
            double&& _edgeLeft,
            double&& _edgeBottom,
            double&& _edgeRight,
            double&& _marginTop,
            double&& _marginLeft,
            double&& _marginBottom,
            double&& _marginRight,
            double&& _unwriteableMarginTop,
            double&& _unwriteableMarginLeft,
            double&& _unwriteableMarginBottom,
            double&& _unwriteableMarginRight,
            double&& _scaling,
            bool&& _printBGColors,
            bool&& _printBGImages,
            bool&& _honorPageRuleMargins,
            bool&& _usePageRuleSizeAsPaperSize,
            bool&& _ignoreUnwriteableMargins,
            bool&& _showMarginGuides,
            bool&& _printSelectionOnly,
            nsTArray<int32_t>&& _pageRanges,
            nsString&& _title,
            nsString&& _docURL,
            nsString&& _headerStrLeft,
            nsString&& _headerStrCenter,
            nsString&& _headerStrRight,
            nsString&& _footerStrLeft,
            nsString&& _footerStrCenter,
            nsString&& _footerStrRight,
            bool&& _printSilent,
            bool&& _shrinkToFit,
            nsString&& _paperId,
            double&& _paperWidth,
            double&& _paperHeight,
            short&& _paperSizeUnit,
            bool&& _printReversed,
            bool&& _printInColor,
            int32_t&& _orientation,
            int32_t&& _numCopies,
            int32_t&& _numPagesPerSheet,
            short&& _outputDestination,
            short&& _outputFormat,
            int32_t&& _printPageDelay,
            int32_t&& _resolution,
            int32_t&& _duplex,
            bool&& _isInitializedFromPrinter,
            bool&& _isInitializedFromPrefs,
            nsString&& _driverName,
            nsString&& _deviceName,
            nsTArray<uint8_t>&& _devModeData,
            nsTArray<CStringKeyValue>&& _GTKPrintSettings,
            nsString&& _disposition,
            uint16_t&& _destination) :
        remotePrintJob_(_remotePrintJob),
        printBGColors_(std::move(_printBGColors)),
        printBGImages_(std::move(_printBGImages)),
        honorPageRuleMargins_(std::move(_honorPageRuleMargins)),
        usePageRuleSizeAsPaperSize_(std::move(_usePageRuleSizeAsPaperSize)),
        ignoreUnwriteableMargins_(std::move(_ignoreUnwriteableMargins)),
        showMarginGuides_(std::move(_showMarginGuides)),
        printSelectionOnly_(std::move(_printSelectionOnly)),
        pageRanges_(std::move(_pageRanges)),
        title_(std::move(_title)),
        docURL_(std::move(_docURL)),
        headerStrLeft_(std::move(_headerStrLeft)),
        headerStrCenter_(std::move(_headerStrCenter)),
        headerStrRight_(std::move(_headerStrRight)),
        footerStrLeft_(std::move(_footerStrLeft)),
        footerStrCenter_(std::move(_footerStrCenter)),
        footerStrRight_(std::move(_footerStrRight)),
        printSilent_(std::move(_printSilent)),
        shrinkToFit_(std::move(_shrinkToFit)),
        paperId_(std::move(_paperId)),
        paperSizeUnit_(std::move(_paperSizeUnit)),
        printReversed_(std::move(_printReversed)),
        printInColor_(std::move(_printInColor)),
        outputDestination_(std::move(_outputDestination)),
        outputFormat_(std::move(_outputFormat)),
        isInitializedFromPrinter_(std::move(_isInitializedFromPrinter)),
        isInitializedFromPrefs_(std::move(_isInitializedFromPrefs)),
        driverName_(std::move(_driverName)),
        deviceName_(std::move(_deviceName)),
        devModeData_(std::move(_devModeData)),
        GTKPrintSettings_(std::move(_GTKPrintSettings)),
        disposition_(std::move(_disposition)),
        edgeTop_(std::move(_edgeTop)),
        edgeLeft_(std::move(_edgeLeft)),
        edgeBottom_(std::move(_edgeBottom)),
        edgeRight_(std::move(_edgeRight)),
        marginTop_(std::move(_marginTop)),
        marginLeft_(std::move(_marginLeft)),
        marginBottom_(std::move(_marginBottom)),
        marginRight_(std::move(_marginRight)),
        unwriteableMarginTop_(std::move(_unwriteableMarginTop)),
        unwriteableMarginLeft_(std::move(_unwriteableMarginLeft)),
        unwriteableMarginBottom_(std::move(_unwriteableMarginBottom)),
        unwriteableMarginRight_(std::move(_unwriteableMarginRight)),
        scaling_(std::move(_scaling)),
        paperWidth_(std::move(_paperWidth)),
        paperHeight_(std::move(_paperHeight)),
        orientation_(std::move(_orientation)),
        numCopies_(std::move(_numCopies)),
        numPagesPerSheet_(std::move(_numPagesPerSheet)),
        printPageDelay_(std::move(_printPageDelay)),
        resolution_(std::move(_resolution)),
        duplex_(std::move(_duplex)),
        destination_(std::move(_destination))
    {
    }

    ::mozilla::ipc::SideVariant<PRemotePrintJobParent*, PRemotePrintJobChild*>&
    remotePrintJob()
    {
        return remotePrintJob_;
    }
    ::mozilla::ipc::SideVariant<PRemotePrintJobParent*, PRemotePrintJobChild*>
    remotePrintJob() const
    {
        return remotePrintJob_;
    }

    double&
    edgeTop()
    {
        return edgeTop_;
    }
    const double&
    edgeTop() const
    {
        return edgeTop_;
    }

    double&
    edgeLeft()
    {
        return edgeLeft_;
    }
    const double&
    edgeLeft() const
    {
        return edgeLeft_;
    }

    double&
    edgeBottom()
    {
        return edgeBottom_;
    }
    const double&
    edgeBottom() const
    {
        return edgeBottom_;
    }

    double&
    edgeRight()
    {
        return edgeRight_;
    }
    const double&
    edgeRight() const
    {
        return edgeRight_;
    }

    double&
    marginTop()
    {
        return marginTop_;
    }
    const double&
    marginTop() const
    {
        return marginTop_;
    }

    double&
    marginLeft()
    {
        return marginLeft_;
    }
    const double&
    marginLeft() const
    {
        return marginLeft_;
    }

    double&
    marginBottom()
    {
        return marginBottom_;
    }
    const double&
    marginBottom() const
    {
        return marginBottom_;
    }

    double&
    marginRight()
    {
        return marginRight_;
    }
    const double&
    marginRight() const
    {
        return marginRight_;
    }

    double&
    unwriteableMarginTop()
    {
        return unwriteableMarginTop_;
    }
    const double&
    unwriteableMarginTop() const
    {
        return unwriteableMarginTop_;
    }

    double&
    unwriteableMarginLeft()
    {
        return unwriteableMarginLeft_;
    }
    const double&
    unwriteableMarginLeft() const
    {
        return unwriteableMarginLeft_;
    }

    double&
    unwriteableMarginBottom()
    {
        return unwriteableMarginBottom_;
    }
    const double&
    unwriteableMarginBottom() const
    {
        return unwriteableMarginBottom_;
    }

    double&
    unwriteableMarginRight()
    {
        return unwriteableMarginRight_;
    }
    const double&
    unwriteableMarginRight() const
    {
        return unwriteableMarginRight_;
    }

    double&
    scaling()
    {
        return scaling_;
    }
    const double&
    scaling() const
    {
        return scaling_;
    }

    bool&
    printBGColors()
    {
        return printBGColors_;
    }
    const bool&
    printBGColors() const
    {
        return printBGColors_;
    }

    bool&
    printBGImages()
    {
        return printBGImages_;
    }
    const bool&
    printBGImages() const
    {
        return printBGImages_;
    }

    bool&
    honorPageRuleMargins()
    {
        return honorPageRuleMargins_;
    }
    const bool&
    honorPageRuleMargins() const
    {
        return honorPageRuleMargins_;
    }

    bool&
    usePageRuleSizeAsPaperSize()
    {
        return usePageRuleSizeAsPaperSize_;
    }
    const bool&
    usePageRuleSizeAsPaperSize() const
    {
        return usePageRuleSizeAsPaperSize_;
    }

    bool&
    ignoreUnwriteableMargins()
    {
        return ignoreUnwriteableMargins_;
    }
    const bool&
    ignoreUnwriteableMargins() const
    {
        return ignoreUnwriteableMargins_;
    }

    bool&
    showMarginGuides()
    {
        return showMarginGuides_;
    }
    const bool&
    showMarginGuides() const
    {
        return showMarginGuides_;
    }

    bool&
    printSelectionOnly()
    {
        return printSelectionOnly_;
    }
    const bool&
    printSelectionOnly() const
    {
        return printSelectionOnly_;
    }

    nsTArray<int32_t>&
    pageRanges()
    {
        return pageRanges_;
    }
    const nsTArray<int32_t>&
    pageRanges() const
    {
        return pageRanges_;
    }

    nsString&
    title()
    {
        return title_;
    }
    const nsString&
    title() const
    {
        return title_;
    }

    nsString&
    docURL()
    {
        return docURL_;
    }
    const nsString&
    docURL() const
    {
        return docURL_;
    }

    nsString&
    headerStrLeft()
    {
        return headerStrLeft_;
    }
    const nsString&
    headerStrLeft() const
    {
        return headerStrLeft_;
    }

    nsString&
    headerStrCenter()
    {
        return headerStrCenter_;
    }
    const nsString&
    headerStrCenter() const
    {
        return headerStrCenter_;
    }

    nsString&
    headerStrRight()
    {
        return headerStrRight_;
    }
    const nsString&
    headerStrRight() const
    {
        return headerStrRight_;
    }

    nsString&
    footerStrLeft()
    {
        return footerStrLeft_;
    }
    const nsString&
    footerStrLeft() const
    {
        return footerStrLeft_;
    }

    nsString&
    footerStrCenter()
    {
        return footerStrCenter_;
    }
    const nsString&
    footerStrCenter() const
    {
        return footerStrCenter_;
    }

    nsString&
    footerStrRight()
    {
        return footerStrRight_;
    }
    const nsString&
    footerStrRight() const
    {
        return footerStrRight_;
    }

    bool&
    printSilent()
    {
        return printSilent_;
    }
    const bool&
    printSilent() const
    {
        return printSilent_;
    }

    bool&
    shrinkToFit()
    {
        return shrinkToFit_;
    }
    const bool&
    shrinkToFit() const
    {
        return shrinkToFit_;
    }

    nsString&
    paperId()
    {
        return paperId_;
    }
    const nsString&
    paperId() const
    {
        return paperId_;
    }

    double&
    paperWidth()
    {
        return paperWidth_;
    }
    const double&
    paperWidth() const
    {
        return paperWidth_;
    }

    double&
    paperHeight()
    {
        return paperHeight_;
    }
    const double&
    paperHeight() const
    {
        return paperHeight_;
    }

    short&
    paperSizeUnit()
    {
        return paperSizeUnit_;
    }
    const short&
    paperSizeUnit() const
    {
        return paperSizeUnit_;
    }

    bool&
    printReversed()
    {
        return printReversed_;
    }
    const bool&
    printReversed() const
    {
        return printReversed_;
    }

    bool&
    printInColor()
    {
        return printInColor_;
    }
    const bool&
    printInColor() const
    {
        return printInColor_;
    }

    int32_t&
    orientation()
    {
        return orientation_;
    }
    const int32_t&
    orientation() const
    {
        return orientation_;
    }

    int32_t&
    numCopies()
    {
        return numCopies_;
    }
    const int32_t&
    numCopies() const
    {
        return numCopies_;
    }

    int32_t&
    numPagesPerSheet()
    {
        return numPagesPerSheet_;
    }
    const int32_t&
    numPagesPerSheet() const
    {
        return numPagesPerSheet_;
    }

    short&
    outputDestination()
    {
        return outputDestination_;
    }
    const short&
    outputDestination() const
    {
        return outputDestination_;
    }

    short&
    outputFormat()
    {
        return outputFormat_;
    }
    const short&
    outputFormat() const
    {
        return outputFormat_;
    }

    int32_t&
    printPageDelay()
    {
        return printPageDelay_;
    }
    const int32_t&
    printPageDelay() const
    {
        return printPageDelay_;
    }

    int32_t&
    resolution()
    {
        return resolution_;
    }
    const int32_t&
    resolution() const
    {
        return resolution_;
    }

    int32_t&
    duplex()
    {
        return duplex_;
    }
    const int32_t&
    duplex() const
    {
        return duplex_;
    }

    bool&
    isInitializedFromPrinter()
    {
        return isInitializedFromPrinter_;
    }
    const bool&
    isInitializedFromPrinter() const
    {
        return isInitializedFromPrinter_;
    }

    bool&
    isInitializedFromPrefs()
    {
        return isInitializedFromPrefs_;
    }
    const bool&
    isInitializedFromPrefs() const
    {
        return isInitializedFromPrefs_;
    }

    nsString&
    driverName()
    {
        return driverName_;
    }
    const nsString&
    driverName() const
    {
        return driverName_;
    }

    nsString&
    deviceName()
    {
        return deviceName_;
    }
    const nsString&
    deviceName() const
    {
        return deviceName_;
    }

    nsTArray<uint8_t>&
    devModeData()
    {
        return devModeData_;
    }
    const nsTArray<uint8_t>&
    devModeData() const
    {
        return devModeData_;
    }

    nsTArray<CStringKeyValue>&
    GTKPrintSettings()
    {
        return GTKPrintSettings_;
    }
    const nsTArray<CStringKeyValue>&
    GTKPrintSettings() const
    {
        return GTKPrintSettings_;
    }

    nsString&
    disposition()
    {
        return disposition_;
    }
    const nsString&
    disposition() const
    {
        return disposition_;
    }

    uint16_t&
    destination()
    {
        return destination_;
    }
    const uint16_t&
    destination() const
    {
        return destination_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<::mozilla::ipc::SideVariant<PRemotePrintJobParent*, PRemotePrintJobChild*>> remotePrintJob_;
    ::mozilla::ipc::IPDLStructMember<bool> printBGColors_;
    ::mozilla::ipc::IPDLStructMember<bool> printBGImages_;
    ::mozilla::ipc::IPDLStructMember<bool> honorPageRuleMargins_;
    ::mozilla::ipc::IPDLStructMember<bool> usePageRuleSizeAsPaperSize_;
    ::mozilla::ipc::IPDLStructMember<bool> ignoreUnwriteableMargins_;
    ::mozilla::ipc::IPDLStructMember<bool> showMarginGuides_;
    ::mozilla::ipc::IPDLStructMember<bool> printSelectionOnly_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<int32_t>> pageRanges_;
    ::mozilla::ipc::IPDLStructMember<nsString> title_;
    ::mozilla::ipc::IPDLStructMember<nsString> docURL_;
    ::mozilla::ipc::IPDLStructMember<nsString> headerStrLeft_;
    ::mozilla::ipc::IPDLStructMember<nsString> headerStrCenter_;
    ::mozilla::ipc::IPDLStructMember<nsString> headerStrRight_;
    ::mozilla::ipc::IPDLStructMember<nsString> footerStrLeft_;
    ::mozilla::ipc::IPDLStructMember<nsString> footerStrCenter_;
    ::mozilla::ipc::IPDLStructMember<nsString> footerStrRight_;
    ::mozilla::ipc::IPDLStructMember<bool> printSilent_;
    ::mozilla::ipc::IPDLStructMember<bool> shrinkToFit_;
    ::mozilla::ipc::IPDLStructMember<nsString> paperId_;
    ::mozilla::ipc::IPDLStructMember<short> paperSizeUnit_;
    ::mozilla::ipc::IPDLStructMember<bool> printReversed_;
    ::mozilla::ipc::IPDLStructMember<bool> printInColor_;
    ::mozilla::ipc::IPDLStructMember<short> outputDestination_;
    ::mozilla::ipc::IPDLStructMember<short> outputFormat_;
    ::mozilla::ipc::IPDLStructMember<bool> isInitializedFromPrinter_;
    ::mozilla::ipc::IPDLStructMember<bool> isInitializedFromPrefs_;
    ::mozilla::ipc::IPDLStructMember<nsString> driverName_;
    ::mozilla::ipc::IPDLStructMember<nsString> deviceName_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> devModeData_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<CStringKeyValue>> GTKPrintSettings_;
    ::mozilla::ipc::IPDLStructMember<nsString> disposition_;
    ::mozilla::ipc::IPDLStructMember<double> edgeTop_;
    ::mozilla::ipc::IPDLStructMember<double> edgeLeft_;
    ::mozilla::ipc::IPDLStructMember<double> edgeBottom_;
    ::mozilla::ipc::IPDLStructMember<double> edgeRight_;
    ::mozilla::ipc::IPDLStructMember<double> marginTop_;
    ::mozilla::ipc::IPDLStructMember<double> marginLeft_;
    ::mozilla::ipc::IPDLStructMember<double> marginBottom_;
    ::mozilla::ipc::IPDLStructMember<double> marginRight_;
    ::mozilla::ipc::IPDLStructMember<double> unwriteableMarginTop_;
    ::mozilla::ipc::IPDLStructMember<double> unwriteableMarginLeft_;
    ::mozilla::ipc::IPDLStructMember<double> unwriteableMarginBottom_;
    ::mozilla::ipc::IPDLStructMember<double> unwriteableMarginRight_;
    ::mozilla::ipc::IPDLStructMember<double> scaling_;
    ::mozilla::ipc::IPDLStructMember<double> paperWidth_;
    ::mozilla::ipc::IPDLStructMember<double> paperHeight_;
    ::mozilla::ipc::IPDLStructMember<int32_t> orientation_;
    ::mozilla::ipc::IPDLStructMember<int32_t> numCopies_;
    ::mozilla::ipc::IPDLStructMember<int32_t> numPagesPerSheet_;
    ::mozilla::ipc::IPDLStructMember<int32_t> printPageDelay_;
    ::mozilla::ipc::IPDLStructMember<int32_t> resolution_;
    ::mozilla::ipc::IPDLStructMember<int32_t> duplex_;
    ::mozilla::ipc::IPDLStructMember<uint16_t> destination_;
};
} // namespace embedding
} // namespace mozilla

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

#endif // ifndef PPrintingTypes_h
