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

#ifndef URIParams_h
#define URIParams_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/PBackgroundSharedTypes.h"


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

    MOZ_IMPLICIT SimpleURIParams(const nsCString& _spec) :
        spec_(_spec)
    {
    }

    MOZ_IMPLICIT SimpleURIParams(nsCString&& _spec) :
        spec_(std::move(_spec))
    {
    }

    nsCString&
    spec()
    {
        return spec_;
    }
    const nsCString&
    spec() const
    {
        return spec_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> spec_;
};
} // namespace ipc
} // namespace mozilla

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


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

    MOZ_IMPLICIT DefaultURIParams(const nsCString& _spec) :
        spec_(_spec)
    {
    }

    MOZ_IMPLICIT DefaultURIParams(nsCString&& _spec) :
        spec_(std::move(_spec))
    {
    }

    nsCString&
    spec()
    {
        return spec_;
    }
    const nsCString&
    spec() const
    {
        return spec_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> spec_;
};
} // namespace ipc
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT StandardURLSegment(
            const uint32_t& _position,
            const int32_t& _length) :
        position_(_position),
        length_(_length)
    {
    }

    MOZ_IMPLICIT StandardURLSegment(
            uint32_t&& _position,
            int32_t&& _length) :
        position_(std::move(_position)),
        length_(std::move(_length))
    {
    }

    uint32_t&
    position()
    {
        return position_;
    }
    const uint32_t&
    position() const
    {
        return position_;
    }

    int32_t&
    length()
    {
        return length_;
    }
    const int32_t&
    length() const
    {
        return length_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<uint32_t> position_;
    ::mozilla::ipc::IPDLStructMember<int32_t> length_;
};
} // namespace ipc
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT StandardURLParams(
            const uint32_t& _urlType,
            const int32_t& _port,
            const int32_t& _defaultPort,
            const nsCString& _spec,
            const StandardURLSegment& _scheme,
            const StandardURLSegment& _authority,
            const StandardURLSegment& _username,
            const StandardURLSegment& _password,
            const StandardURLSegment& _host,
            const StandardURLSegment& _path,
            const StandardURLSegment& _filePath,
            const StandardURLSegment& _directory,
            const StandardURLSegment& _baseName,
            const StandardURLSegment& _extension,
            const StandardURLSegment& _query,
            const StandardURLSegment& _ref,
            const bool& _supportsFileURL,
            const bool& _isSubstituting) :
        spec_(_spec),
        scheme_(_scheme),
        authority_(_authority),
        username_(_username),
        password_(_password),
        host_(_host),
        path_(_path),
        filePath_(_filePath),
        directory_(_directory),
        baseName_(_baseName),
        extension_(_extension),
        query_(_query),
        ref_(_ref),
        supportsFileURL_(_supportsFileURL),
        isSubstituting_(_isSubstituting),
        urlType_(_urlType),
        port_(_port),
        defaultPort_(_defaultPort)
    {
    }

    MOZ_IMPLICIT StandardURLParams(
            uint32_t&& _urlType,
            int32_t&& _port,
            int32_t&& _defaultPort,
            nsCString&& _spec,
            StandardURLSegment&& _scheme,
            StandardURLSegment&& _authority,
            StandardURLSegment&& _username,
            StandardURLSegment&& _password,
            StandardURLSegment&& _host,
            StandardURLSegment&& _path,
            StandardURLSegment&& _filePath,
            StandardURLSegment&& _directory,
            StandardURLSegment&& _baseName,
            StandardURLSegment&& _extension,
            StandardURLSegment&& _query,
            StandardURLSegment&& _ref,
            bool&& _supportsFileURL,
            bool&& _isSubstituting) :
        spec_(std::move(_spec)),
        scheme_(std::move(_scheme)),
        authority_(std::move(_authority)),
        username_(std::move(_username)),
        password_(std::move(_password)),
        host_(std::move(_host)),
        path_(std::move(_path)),
        filePath_(std::move(_filePath)),
        directory_(std::move(_directory)),
        baseName_(std::move(_baseName)),
        extension_(std::move(_extension)),
        query_(std::move(_query)),
        ref_(std::move(_ref)),
        supportsFileURL_(std::move(_supportsFileURL)),
        isSubstituting_(std::move(_isSubstituting)),
        urlType_(std::move(_urlType)),
        port_(std::move(_port)),
        defaultPort_(std::move(_defaultPort))
    {
    }

    uint32_t&
    urlType()
    {
        return urlType_;
    }
    const uint32_t&
    urlType() const
    {
        return urlType_;
    }

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

    int32_t&
    defaultPort()
    {
        return defaultPort_;
    }
    const int32_t&
    defaultPort() const
    {
        return defaultPort_;
    }

    nsCString&
    spec()
    {
        return spec_;
    }
    const nsCString&
    spec() const
    {
        return spec_;
    }

    StandardURLSegment&
    scheme()
    {
        return scheme_;
    }
    const StandardURLSegment&
    scheme() const
    {
        return scheme_;
    }

    StandardURLSegment&
    authority()
    {
        return authority_;
    }
    const StandardURLSegment&
    authority() const
    {
        return authority_;
    }

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

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

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

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

    StandardURLSegment&
    filePath()
    {
        return filePath_;
    }
    const StandardURLSegment&
    filePath() const
    {
        return filePath_;
    }

    StandardURLSegment&
    directory()
    {
        return directory_;
    }
    const StandardURLSegment&
    directory() const
    {
        return directory_;
    }

    StandardURLSegment&
    baseName()
    {
        return baseName_;
    }
    const StandardURLSegment&
    baseName() const
    {
        return baseName_;
    }

    StandardURLSegment&
    extension()
    {
        return extension_;
    }
    const StandardURLSegment&
    extension() const
    {
        return extension_;
    }

    StandardURLSegment&
    query()
    {
        return query_;
    }
    const StandardURLSegment&
    query() const
    {
        return query_;
    }

    StandardURLSegment&
    ref()
    {
        return ref_;
    }
    const StandardURLSegment&
    ref() const
    {
        return ref_;
    }

    bool&
    supportsFileURL()
    {
        return supportsFileURL_;
    }
    const bool&
    supportsFileURL() const
    {
        return supportsFileURL_;
    }

    bool&
    isSubstituting()
    {
        return isSubstituting_;
    }
    const bool&
    isSubstituting() const
    {
        return isSubstituting_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<nsCString> spec_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> scheme_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> authority_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> username_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> password_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> host_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> path_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> filePath_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> directory_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> baseName_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> extension_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> query_;
    ::mozilla::ipc::IPDLStructMember<StandardURLSegment> ref_;
    ::mozilla::ipc::IPDLStructMember<bool> supportsFileURL_;
    ::mozilla::ipc::IPDLStructMember<bool> isSubstituting_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> urlType_;
    ::mozilla::ipc::IPDLStructMember<int32_t> port_;
    ::mozilla::ipc::IPDLStructMember<int32_t> defaultPort_;
};
} // namespace ipc
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HostObjectURIParams|
//
namespace mozilla {
namespace ipc {
class HostObjectURIParams final
{
private:
    typedef ::mozilla::ipc::SimpleURIParams SimpleURIParams;

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

    MOZ_IMPLICIT HostObjectURIParams(
            const SimpleURIParams& _simpleParams,
            const bool& _revoked) :
        simpleParams_(_simpleParams),
        revoked_(_revoked)
    {
    }

    MOZ_IMPLICIT HostObjectURIParams(
            SimpleURIParams&& _simpleParams,
            bool&& _revoked) :
        simpleParams_(std::move(_simpleParams)),
        revoked_(std::move(_revoked))
    {
    }

    SimpleURIParams&
    simpleParams()
    {
        return simpleParams_;
    }
    const SimpleURIParams&
    simpleParams() const
    {
        return simpleParams_;
    }

    bool&
    revoked()
    {
        return revoked_;
    }
    const bool&
    revoked() const
    {
        return revoked_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<SimpleURIParams> simpleParams_;
    ::mozilla::ipc::IPDLStructMember<bool> revoked_;
};
} // namespace ipc
} // namespace mozilla

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

namespace mozilla {
namespace ipc {
class JARURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class IconURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class JSURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class SimpleNestedURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class NestedAboutURIParams;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class SubstitutingJARURIParams;
} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union URIParams|
//
namespace mozilla {
namespace ipc {
class URIParams final
{
public:
    enum Type {
        T__None,
        TSimpleURIParams = 1,
        TStandardURLParams,
        TJARURIParams,
        TIconURIParams,
        TJSURIParams,
        TSimpleNestedURIParams,
        THostObjectURIParams,
        TDefaultURIParams,
        TNestedAboutURIParams,
        TSubstitutingJARURIParams,
        T__Last = TSubstitutingJARURIParams
    };

private:
    typedef ::mozilla::ipc::SimpleURIParams SimpleURIParams;
    typedef ::mozilla::ipc::StandardURLParams StandardURLParams;
    typedef ::mozilla::ipc::JARURIParams JARURIParams;
    typedef ::mozilla::ipc::IconURIParams IconURIParams;
    typedef ::mozilla::ipc::JSURIParams JSURIParams;
    typedef ::mozilla::ipc::SimpleNestedURIParams SimpleNestedURIParams;
    typedef ::mozilla::ipc::HostObjectURIParams HostObjectURIParams;
    typedef ::mozilla::ipc::DefaultURIParams DefaultURIParams;
    typedef ::mozilla::ipc::NestedAboutURIParams NestedAboutURIParams;
    typedef ::mozilla::ipc::SubstitutingJARURIParams SubstitutingJARURIParams;
    typedef SimpleURIParams SimpleURIParams__tdef;
    typedef StandardURLParams StandardURLParams__tdef;
    typedef JARURIParams* JARURIParams__tdef;
    typedef IconURIParams* IconURIParams__tdef;
    typedef JSURIParams* JSURIParams__tdef;
    typedef SimpleNestedURIParams* SimpleNestedURIParams__tdef;
    typedef HostObjectURIParams HostObjectURIParams__tdef;
    typedef DefaultURIParams DefaultURIParams__tdef;
    typedef NestedAboutURIParams* NestedAboutURIParams__tdef;
    typedef SubstitutingJARURIParams* SubstitutingJARURIParams__tdef;

    SimpleURIParams*
    ptr_SimpleURIParams()
    {
        return (&(mVSimpleURIParams));
    }
    const SimpleURIParams*
    constptr_SimpleURIParams() const
    {
        return (&(mVSimpleURIParams));
    }
    StandardURLParams*
    ptr_StandardURLParams()
    {
        return (&(mVStandardURLParams));
    }
    const StandardURLParams*
    constptr_StandardURLParams() const
    {
        return (&(mVStandardURLParams));
    }
    JARURIParams*&
    ptr_JARURIParams()
    {
        return mVJARURIParams;
    }
    const JARURIParams*
    constptr_JARURIParams() const
    {
        return mVJARURIParams;
    }
    IconURIParams*&
    ptr_IconURIParams()
    {
        return mVIconURIParams;
    }
    const IconURIParams*
    constptr_IconURIParams() const
    {
        return mVIconURIParams;
    }
    JSURIParams*&
    ptr_JSURIParams()
    {
        return mVJSURIParams;
    }
    const JSURIParams*
    constptr_JSURIParams() const
    {
        return mVJSURIParams;
    }
    SimpleNestedURIParams*&
    ptr_SimpleNestedURIParams()
    {
        return mVSimpleNestedURIParams;
    }
    const SimpleNestedURIParams*
    constptr_SimpleNestedURIParams() const
    {
        return mVSimpleNestedURIParams;
    }
    HostObjectURIParams*
    ptr_HostObjectURIParams()
    {
        return (&(mVHostObjectURIParams));
    }
    const HostObjectURIParams*
    constptr_HostObjectURIParams() const
    {
        return (&(mVHostObjectURIParams));
    }
    DefaultURIParams*
    ptr_DefaultURIParams()
    {
        return (&(mVDefaultURIParams));
    }
    const DefaultURIParams*
    constptr_DefaultURIParams() const
    {
        return (&(mVDefaultURIParams));
    }
    NestedAboutURIParams*&
    ptr_NestedAboutURIParams()
    {
        return mVNestedAboutURIParams;
    }
    const NestedAboutURIParams*
    constptr_NestedAboutURIParams() const
    {
        return mVNestedAboutURIParams;
    }
    SubstitutingJARURIParams*&
    ptr_SubstitutingJARURIParams()
    {
        return mVSubstitutingJARURIParams;
    }
    const SubstitutingJARURIParams*
    constptr_SubstitutingJARURIParams() const
    {
        return mVSubstitutingJARURIParams;
    }

    void
    MaybeDestroy();

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

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

    MOZ_IMPLICIT URIParams(const SimpleURIParams& aOther);

    MOZ_IMPLICIT URIParams(SimpleURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const StandardURLParams& aOther);

    MOZ_IMPLICIT URIParams(StandardURLParams&& aOther);

    MOZ_IMPLICIT URIParams(const JARURIParams& aOther);

    MOZ_IMPLICIT URIParams(JARURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const IconURIParams& aOther);

    MOZ_IMPLICIT URIParams(IconURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const JSURIParams& aOther);

    MOZ_IMPLICIT URIParams(JSURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const SimpleNestedURIParams& aOther);

    MOZ_IMPLICIT URIParams(SimpleNestedURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const HostObjectURIParams& aOther);

    MOZ_IMPLICIT URIParams(HostObjectURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const DefaultURIParams& aOther);

    MOZ_IMPLICIT URIParams(DefaultURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const NestedAboutURIParams& aOther);

    MOZ_IMPLICIT URIParams(NestedAboutURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const SubstitutingJARURIParams& aOther);

    MOZ_IMPLICIT URIParams(SubstitutingJARURIParams&& aOther);

    MOZ_IMPLICIT URIParams(const URIParams& aOther);

    MOZ_IMPLICIT URIParams(URIParams&& aOther);

    ~URIParams();

    Type
    type() const
    {
        return mType;
    }

    URIParams&
    operator=(const SimpleURIParams& aRhs);

    URIParams&
    operator=(SimpleURIParams&& aRhs);

    URIParams&
    operator=(const StandardURLParams& aRhs);

    URIParams&
    operator=(StandardURLParams&& aRhs);

    URIParams&
    operator=(const JARURIParams& aRhs);

    URIParams&
    operator=(JARURIParams&& aRhs);

    URIParams&
    operator=(const IconURIParams& aRhs);

    URIParams&
    operator=(IconURIParams&& aRhs);

    URIParams&
    operator=(const JSURIParams& aRhs);

    URIParams&
    operator=(JSURIParams&& aRhs);

    URIParams&
    operator=(const SimpleNestedURIParams& aRhs);

    URIParams&
    operator=(SimpleNestedURIParams&& aRhs);

    URIParams&
    operator=(const HostObjectURIParams& aRhs);

    URIParams&
    operator=(HostObjectURIParams&& aRhs);

    URIParams&
    operator=(const DefaultURIParams& aRhs);

    URIParams&
    operator=(DefaultURIParams&& aRhs);

    URIParams&
    operator=(const NestedAboutURIParams& aRhs);

    URIParams&
    operator=(NestedAboutURIParams&& aRhs);

    URIParams&
    operator=(const SubstitutingJARURIParams& aRhs);

    URIParams&
    operator=(SubstitutingJARURIParams&& aRhs);

    URIParams&
    operator=(const URIParams& aRhs);

    URIParams&
    operator=(URIParams&& aRhs);

    SimpleURIParams&
    get_SimpleURIParams()
    {
        AssertSanity(TSimpleURIParams);
        return (*(ptr_SimpleURIParams()));
    }
    const SimpleURIParams&
    get_SimpleURIParams() const
    {
        AssertSanity(TSimpleURIParams);
        return (*(constptr_SimpleURIParams()));
    }
    operator SimpleURIParams&()
    {
        return get_SimpleURIParams();
    }
    operator const SimpleURIParams&() const
    {
        return get_SimpleURIParams();
    }

    StandardURLParams&
    get_StandardURLParams()
    {
        AssertSanity(TStandardURLParams);
        return (*(ptr_StandardURLParams()));
    }
    const StandardURLParams&
    get_StandardURLParams() const
    {
        AssertSanity(TStandardURLParams);
        return (*(constptr_StandardURLParams()));
    }
    operator StandardURLParams&()
    {
        return get_StandardURLParams();
    }
    operator const StandardURLParams&() const
    {
        return get_StandardURLParams();
    }

    JARURIParams&
    get_JARURIParams()
    {
        AssertSanity(TJARURIParams);
        return (*(ptr_JARURIParams()));
    }
    const JARURIParams&
    get_JARURIParams() const
    {
        AssertSanity(TJARURIParams);
        return (*(constptr_JARURIParams()));
    }
    operator JARURIParams&()
    {
        return get_JARURIParams();
    }
    operator const JARURIParams&() const
    {
        return get_JARURIParams();
    }

    IconURIParams&
    get_IconURIParams()
    {
        AssertSanity(TIconURIParams);
        return (*(ptr_IconURIParams()));
    }
    const IconURIParams&
    get_IconURIParams() const
    {
        AssertSanity(TIconURIParams);
        return (*(constptr_IconURIParams()));
    }
    operator IconURIParams&()
    {
        return get_IconURIParams();
    }
    operator const IconURIParams&() const
    {
        return get_IconURIParams();
    }

    JSURIParams&
    get_JSURIParams()
    {
        AssertSanity(TJSURIParams);
        return (*(ptr_JSURIParams()));
    }
    const JSURIParams&
    get_JSURIParams() const
    {
        AssertSanity(TJSURIParams);
        return (*(constptr_JSURIParams()));
    }
    operator JSURIParams&()
    {
        return get_JSURIParams();
    }
    operator const JSURIParams&() const
    {
        return get_JSURIParams();
    }

    SimpleNestedURIParams&
    get_SimpleNestedURIParams()
    {
        AssertSanity(TSimpleNestedURIParams);
        return (*(ptr_SimpleNestedURIParams()));
    }
    const SimpleNestedURIParams&
    get_SimpleNestedURIParams() const
    {
        AssertSanity(TSimpleNestedURIParams);
        return (*(constptr_SimpleNestedURIParams()));
    }
    operator SimpleNestedURIParams&()
    {
        return get_SimpleNestedURIParams();
    }
    operator const SimpleNestedURIParams&() const
    {
        return get_SimpleNestedURIParams();
    }

    HostObjectURIParams&
    get_HostObjectURIParams()
    {
        AssertSanity(THostObjectURIParams);
        return (*(ptr_HostObjectURIParams()));
    }
    const HostObjectURIParams&
    get_HostObjectURIParams() const
    {
        AssertSanity(THostObjectURIParams);
        return (*(constptr_HostObjectURIParams()));
    }
    operator HostObjectURIParams&()
    {
        return get_HostObjectURIParams();
    }
    operator const HostObjectURIParams&() const
    {
        return get_HostObjectURIParams();
    }

    DefaultURIParams&
    get_DefaultURIParams()
    {
        AssertSanity(TDefaultURIParams);
        return (*(ptr_DefaultURIParams()));
    }
    const DefaultURIParams&
    get_DefaultURIParams() const
    {
        AssertSanity(TDefaultURIParams);
        return (*(constptr_DefaultURIParams()));
    }
    operator DefaultURIParams&()
    {
        return get_DefaultURIParams();
    }
    operator const DefaultURIParams&() const
    {
        return get_DefaultURIParams();
    }

    NestedAboutURIParams&
    get_NestedAboutURIParams()
    {
        AssertSanity(TNestedAboutURIParams);
        return (*(ptr_NestedAboutURIParams()));
    }
    const NestedAboutURIParams&
    get_NestedAboutURIParams() const
    {
        AssertSanity(TNestedAboutURIParams);
        return (*(constptr_NestedAboutURIParams()));
    }
    operator NestedAboutURIParams&()
    {
        return get_NestedAboutURIParams();
    }
    operator const NestedAboutURIParams&() const
    {
        return get_NestedAboutURIParams();
    }

    SubstitutingJARURIParams&
    get_SubstitutingJARURIParams()
    {
        AssertSanity(TSubstitutingJARURIParams);
        return (*(ptr_SubstitutingJARURIParams()));
    }
    const SubstitutingJARURIParams&
    get_SubstitutingJARURIParams() const
    {
        AssertSanity(TSubstitutingJARURIParams);
        return (*(constptr_SubstitutingJARURIParams()));
    }
    operator SubstitutingJARURIParams&()
    {
        return get_SubstitutingJARURIParams();
    }
    operator const SubstitutingJARURIParams&() const
    {
        return get_SubstitutingJARURIParams();
    }

private:
    union {
        SimpleURIParams mVSimpleURIParams;
        StandardURLParams mVStandardURLParams;
        JARURIParams* mVJARURIParams;
        IconURIParams* mVIconURIParams;
        JSURIParams* mVJSURIParams;
        SimpleNestedURIParams* mVSimpleNestedURIParams;
        HostObjectURIParams mVHostObjectURIParams;
        DefaultURIParams mVDefaultURIParams;
        NestedAboutURIParams* mVNestedAboutURIParams;
        SubstitutingJARURIParams* mVSubstitutingJARURIParams;
    };
    Type mType;
};
} // namespace ipc
} // namespace mozilla

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


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

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

    MOZ_IMPLICIT JARURIParams(
            const URIParams& _jarFile,
            const URIParams& _jarEntry,
            const nsCString& _charset) :
        jarFile_(_jarFile),
        jarEntry_(_jarEntry),
        charset_(_charset)
    {
    }

    MOZ_IMPLICIT JARURIParams(
            URIParams&& _jarFile,
            URIParams&& _jarEntry,
            nsCString&& _charset) :
        jarFile_(std::move(_jarFile)),
        jarEntry_(std::move(_jarEntry)),
        charset_(std::move(_charset))
    {
    }

    URIParams&
    jarFile()
    {
        return jarFile_;
    }
    const URIParams&
    jarFile() const
    {
        return jarFile_;
    }

    URIParams&
    jarEntry()
    {
        return jarEntry_;
    }
    const URIParams&
    jarEntry() const
    {
        return jarEntry_;
    }

    nsCString&
    charset()
    {
        return charset_;
    }
    const nsCString&
    charset() const
    {
        return charset_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<URIParams> jarFile_;
    ::mozilla::ipc::IPDLStructMember<URIParams> jarEntry_;
    ::mozilla::ipc::IPDLStructMember<nsCString> charset_;
};
} // namespace ipc
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IconURIParams|
//
namespace mozilla {
namespace ipc {
class IconURIParams final
{
private:
    typedef ::mozilla::ipc::URIParams URIParams;
    typedef ::uint32_t uint32_t;
    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
    IconURIParams() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IconURIParams(
            const mozilla::Maybe<URIParams>& _uri,
            const uint32_t& _size,
            const nsCString& _contentType,
            const nsCString& _fileName,
            const nsCString& _stockIcon,
            const uint32_t& _iconScale,
            const mozilla::Maybe<bool>& _iconDark) :
        uri_(_uri),
        contentType_(_contentType),
        fileName_(_fileName),
        stockIcon_(_stockIcon),
        iconDark_(_iconDark),
        size_(_size),
        iconScale_(_iconScale)
    {
    }

    MOZ_IMPLICIT IconURIParams(
            mozilla::Maybe<URIParams>&& _uri,
            uint32_t&& _size,
            nsCString&& _contentType,
            nsCString&& _fileName,
            nsCString&& _stockIcon,
            uint32_t&& _iconScale,
            mozilla::Maybe<bool>&& _iconDark) :
        uri_(std::move(_uri)),
        contentType_(std::move(_contentType)),
        fileName_(std::move(_fileName)),
        stockIcon_(std::move(_stockIcon)),
        iconDark_(std::move(_iconDark)),
        size_(std::move(_size)),
        iconScale_(std::move(_iconScale))
    {
    }

    mozilla::Maybe<URIParams>&
    uri()
    {
        return uri_;
    }
    const mozilla::Maybe<URIParams>&
    uri() const
    {
        return uri_;
    }

    uint32_t&
    size()
    {
        return size_;
    }
    const uint32_t&
    size() const
    {
        return size_;
    }

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

    nsCString&
    fileName()
    {
        return fileName_;
    }
    const nsCString&
    fileName() const
    {
        return fileName_;
    }

    nsCString&
    stockIcon()
    {
        return stockIcon_;
    }
    const nsCString&
    stockIcon() const
    {
        return stockIcon_;
    }

    uint32_t&
    iconScale()
    {
        return iconScale_;
    }
    const uint32_t&
    iconScale() const
    {
        return iconScale_;
    }

    mozilla::Maybe<bool>&
    iconDark()
    {
        return iconDark_;
    }
    const mozilla::Maybe<bool>&
    iconDark() const
    {
        return iconDark_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> uri_;
    ::mozilla::ipc::IPDLStructMember<nsCString> contentType_;
    ::mozilla::ipc::IPDLStructMember<nsCString> fileName_;
    ::mozilla::ipc::IPDLStructMember<nsCString> stockIcon_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> iconDark_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> size_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> iconScale_;
};
} // namespace ipc
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct JSURIParams|
//
namespace mozilla {
namespace ipc {
class JSURIParams final
{
private:
    typedef ::mozilla::ipc::SimpleURIParams SimpleURIParams;
    typedef ::mozilla::ipc::URIParams URIParams;

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

    MOZ_IMPLICIT JSURIParams(
            const SimpleURIParams& _simpleParams,
            const mozilla::Maybe<URIParams>& _baseURI) :
        simpleParams_(_simpleParams),
        baseURI_(_baseURI)
    {
    }

    MOZ_IMPLICIT JSURIParams(
            SimpleURIParams&& _simpleParams,
            mozilla::Maybe<URIParams>&& _baseURI) :
        simpleParams_(std::move(_simpleParams)),
        baseURI_(std::move(_baseURI))
    {
    }

    SimpleURIParams&
    simpleParams()
    {
        return simpleParams_;
    }
    const SimpleURIParams&
    simpleParams() const
    {
        return simpleParams_;
    }

    mozilla::Maybe<URIParams>&
    baseURI()
    {
        return baseURI_;
    }
    const mozilla::Maybe<URIParams>&
    baseURI() const
    {
        return baseURI_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<SimpleURIParams> simpleParams_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> baseURI_;
};
} // namespace ipc
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SimpleNestedURIParams|
//
namespace mozilla {
namespace ipc {
class SimpleNestedURIParams final
{
private:
    typedef ::mozilla::ipc::SimpleURIParams SimpleURIParams;
    typedef ::mozilla::ipc::URIParams URIParams;

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

    MOZ_IMPLICIT SimpleNestedURIParams(
            const SimpleURIParams& _simpleParams,
            const URIParams& _innerURI) :
        simpleParams_(_simpleParams),
        innerURI_(_innerURI)
    {
    }

    MOZ_IMPLICIT SimpleNestedURIParams(
            SimpleURIParams&& _simpleParams,
            URIParams&& _innerURI) :
        simpleParams_(std::move(_simpleParams)),
        innerURI_(std::move(_innerURI))
    {
    }

    SimpleURIParams&
    simpleParams()
    {
        return simpleParams_;
    }
    const SimpleURIParams&
    simpleParams() const
    {
        return simpleParams_;
    }

    URIParams&
    innerURI()
    {
        return innerURI_;
    }
    const URIParams&
    innerURI() const
    {
        return innerURI_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<SimpleURIParams> simpleParams_;
    ::mozilla::ipc::IPDLStructMember<URIParams> innerURI_;
};
} // namespace ipc
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct NestedAboutURIParams|
//
namespace mozilla {
namespace ipc {
class NestedAboutURIParams final
{
private:
    typedef ::mozilla::ipc::SimpleNestedURIParams SimpleNestedURIParams;
    typedef ::mozilla::ipc::URIParams URIParams;

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

    MOZ_IMPLICIT NestedAboutURIParams(
            const SimpleNestedURIParams& _nestedParams,
            const mozilla::Maybe<URIParams>& _baseURI) :
        nestedParams_(_nestedParams),
        baseURI_(_baseURI)
    {
    }

    MOZ_IMPLICIT NestedAboutURIParams(
            SimpleNestedURIParams&& _nestedParams,
            mozilla::Maybe<URIParams>&& _baseURI) :
        nestedParams_(std::move(_nestedParams)),
        baseURI_(std::move(_baseURI))
    {
    }

    SimpleNestedURIParams&
    nestedParams()
    {
        return nestedParams_;
    }
    const SimpleNestedURIParams&
    nestedParams() const
    {
        return nestedParams_;
    }

    mozilla::Maybe<URIParams>&
    baseURI()
    {
        return baseURI_;
    }
    const mozilla::Maybe<URIParams>&
    baseURI() const
    {
        return baseURI_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<SimpleNestedURIParams> nestedParams_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<URIParams>> baseURI_;
};
} // namespace ipc
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SubstitutingJARURIParams|
//
namespace mozilla {
namespace ipc {
class SubstitutingJARURIParams final
{
private:
    typedef ::mozilla::ipc::URIParams URIParams;
    typedef ::mozilla::ipc::JARURIParams JARURIParams;

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

    MOZ_IMPLICIT SubstitutingJARURIParams(
            const URIParams& _source,
            const JARURIParams& _resolved) :
        source_(_source),
        resolved_(_resolved)
    {
    }

    MOZ_IMPLICIT SubstitutingJARURIParams(
            URIParams&& _source,
            JARURIParams&& _resolved) :
        source_(std::move(_source)),
        resolved_(std::move(_resolved))
    {
    }

    URIParams&
    source()
    {
        return source_;
    }
    const URIParams&
    source() const
    {
        return source_;
    }

    JARURIParams&
    resolved()
    {
        return resolved_;
    }
    const JARURIParams&
    resolved() const
    {
        return resolved_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<URIParams> source_;
    ::mozilla::ipc::IPDLStructMember<JARURIParams> resolved_;
};
} // namespace ipc
} // namespace mozilla

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

#endif // ifndef URIParams_h
