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

#ifndef PBackgroundLSSharedTypes_h
#define PBackgroundLSSharedTypes_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/dom/LSValue.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "mozilla/ipc/ProtocolTypes.h"


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

    MOZ_IMPLICIT LSRequestCommonParams(
            const PrincipalInfo& _principalInfo,
            const PrincipalInfo& _storagePrincipalInfo,
            const nsCString& _originKey) :
        principalInfo_(_principalInfo),
        storagePrincipalInfo_(_storagePrincipalInfo),
        originKey_(_originKey)
    {
    }

    MOZ_IMPLICIT LSRequestCommonParams(
            PrincipalInfo&& _principalInfo,
            PrincipalInfo&& _storagePrincipalInfo,
            nsCString&& _originKey) :
        principalInfo_(std::move(_principalInfo)),
        storagePrincipalInfo_(std::move(_storagePrincipalInfo)),
        originKey_(std::move(_originKey))
    {
    }

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

    PrincipalInfo&
    storagePrincipalInfo()
    {
        return storagePrincipalInfo_;
    }
    const PrincipalInfo&
    storagePrincipalInfo() const
    {
        return storagePrincipalInfo_;
    }

    nsCString&
    originKey()
    {
        return originKey_;
    }
    const nsCString&
    originKey() const
    {
        return originKey_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> storagePrincipalInfo_;
    ::mozilla::ipc::IPDLStructMember<nsCString> originKey_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestCommonParams>
{
    typedef ::mozilla::dom::LSRequestCommonParams 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 LSRequestPreloadDatastoreParams|
//
namespace mozilla {
namespace dom {
class LSRequestPreloadDatastoreParams final
{
private:
    typedef ::mozilla::dom::LSRequestCommonParams LSRequestCommonParams;

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

    MOZ_IMPLICIT LSRequestPreloadDatastoreParams(const LSRequestCommonParams& _commonParams) :
        commonParams_(_commonParams)
    {
    }

    MOZ_IMPLICIT LSRequestPreloadDatastoreParams(LSRequestCommonParams&& _commonParams) :
        commonParams_(std::move(_commonParams))
    {
    }

    LSRequestCommonParams&
    commonParams()
    {
        return commonParams_;
    }
    const LSRequestCommonParams&
    commonParams() const
    {
        return commonParams_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<LSRequestCommonParams> commonParams_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestPreloadDatastoreParams>
{
    typedef ::mozilla::dom::LSRequestPreloadDatastoreParams 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 LSRequestPrepareDatastoreParams|
//
namespace mozilla {
namespace dom {
class LSRequestPrepareDatastoreParams final
{
private:
    typedef ::mozilla::dom::LSRequestCommonParams LSRequestCommonParams;
    typedef ::nsID nsID;
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;

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

    MOZ_IMPLICIT LSRequestPrepareDatastoreParams(
            const LSRequestCommonParams& _commonParams,
            const mozilla::Maybe<nsID>& _clientId,
            const mozilla::Maybe<PrincipalInfo>& _clientPrincipalInfo) :
        commonParams_(_commonParams),
        clientId_(_clientId),
        clientPrincipalInfo_(_clientPrincipalInfo)
    {
    }

    MOZ_IMPLICIT LSRequestPrepareDatastoreParams(
            LSRequestCommonParams&& _commonParams,
            mozilla::Maybe<nsID>&& _clientId,
            mozilla::Maybe<PrincipalInfo>&& _clientPrincipalInfo) :
        commonParams_(std::move(_commonParams)),
        clientId_(std::move(_clientId)),
        clientPrincipalInfo_(std::move(_clientPrincipalInfo))
    {
    }

    LSRequestCommonParams&
    commonParams()
    {
        return commonParams_;
    }
    const LSRequestCommonParams&
    commonParams() const
    {
        return commonParams_;
    }

    mozilla::Maybe<nsID>&
    clientId()
    {
        return clientId_;
    }
    const mozilla::Maybe<nsID>&
    clientId() const
    {
        return clientId_;
    }

    mozilla::Maybe<PrincipalInfo>&
    clientPrincipalInfo()
    {
        return clientPrincipalInfo_;
    }
    const mozilla::Maybe<PrincipalInfo>&
    clientPrincipalInfo() const
    {
        return clientPrincipalInfo_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<LSRequestCommonParams> commonParams_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsID>> clientId_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> clientPrincipalInfo_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestPrepareDatastoreParams>
{
    typedef ::mozilla::dom::LSRequestPrepareDatastoreParams 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 LSRequestPrepareObserverParams|
//
namespace mozilla {
namespace dom {
class LSRequestPrepareObserverParams final
{
private:
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef ::nsID nsID;

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

    MOZ_IMPLICIT LSRequestPrepareObserverParams(
            const PrincipalInfo& _principalInfo,
            const PrincipalInfo& _storagePrincipalInfo,
            const mozilla::Maybe<nsID>& _clientId,
            const mozilla::Maybe<PrincipalInfo>& _clientPrincipalInfo) :
        principalInfo_(_principalInfo),
        storagePrincipalInfo_(_storagePrincipalInfo),
        clientId_(_clientId),
        clientPrincipalInfo_(_clientPrincipalInfo)
    {
    }

    MOZ_IMPLICIT LSRequestPrepareObserverParams(
            PrincipalInfo&& _principalInfo,
            PrincipalInfo&& _storagePrincipalInfo,
            mozilla::Maybe<nsID>&& _clientId,
            mozilla::Maybe<PrincipalInfo>&& _clientPrincipalInfo) :
        principalInfo_(std::move(_principalInfo)),
        storagePrincipalInfo_(std::move(_storagePrincipalInfo)),
        clientId_(std::move(_clientId)),
        clientPrincipalInfo_(std::move(_clientPrincipalInfo))
    {
    }

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

    PrincipalInfo&
    storagePrincipalInfo()
    {
        return storagePrincipalInfo_;
    }
    const PrincipalInfo&
    storagePrincipalInfo() const
    {
        return storagePrincipalInfo_;
    }

    mozilla::Maybe<nsID>&
    clientId()
    {
        return clientId_;
    }
    const mozilla::Maybe<nsID>&
    clientId() const
    {
        return clientId_;
    }

    mozilla::Maybe<PrincipalInfo>&
    clientPrincipalInfo()
    {
        return clientPrincipalInfo_;
    }
    const mozilla::Maybe<PrincipalInfo>&
    clientPrincipalInfo() const
    {
        return clientPrincipalInfo_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> storagePrincipalInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsID>> clientId_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> clientPrincipalInfo_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union LSRequestParams|
//
namespace mozilla {
namespace dom {
class LSRequestParams final
{
public:
    enum Type {
        T__None,
        TLSRequestPreloadDatastoreParams = 1,
        TLSRequestPrepareDatastoreParams,
        TLSRequestPrepareObserverParams,
        T__Last = TLSRequestPrepareObserverParams
    };

private:
    typedef ::mozilla::dom::LSRequestPreloadDatastoreParams LSRequestPreloadDatastoreParams;
    typedef ::mozilla::dom::LSRequestPrepareDatastoreParams LSRequestPrepareDatastoreParams;
    typedef ::mozilla::dom::LSRequestPrepareObserverParams LSRequestPrepareObserverParams;
    typedef LSRequestPreloadDatastoreParams LSRequestPreloadDatastoreParams__tdef;
    typedef LSRequestPrepareDatastoreParams LSRequestPrepareDatastoreParams__tdef;
    typedef LSRequestPrepareObserverParams LSRequestPrepareObserverParams__tdef;

    LSRequestPreloadDatastoreParams*
    ptr_LSRequestPreloadDatastoreParams()
    {
        return (&(mVLSRequestPreloadDatastoreParams));
    }
    const LSRequestPreloadDatastoreParams*
    constptr_LSRequestPreloadDatastoreParams() const
    {
        return (&(mVLSRequestPreloadDatastoreParams));
    }
    LSRequestPrepareDatastoreParams*
    ptr_LSRequestPrepareDatastoreParams()
    {
        return (&(mVLSRequestPrepareDatastoreParams));
    }
    const LSRequestPrepareDatastoreParams*
    constptr_LSRequestPrepareDatastoreParams() const
    {
        return (&(mVLSRequestPrepareDatastoreParams));
    }
    LSRequestPrepareObserverParams*
    ptr_LSRequestPrepareObserverParams()
    {
        return (&(mVLSRequestPrepareObserverParams));
    }
    const LSRequestPrepareObserverParams*
    constptr_LSRequestPrepareObserverParams() const
    {
        return (&(mVLSRequestPrepareObserverParams));
    }

    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 LSRequestParams() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT LSRequestParams(const LSRequestPreloadDatastoreParams& aOther);

    MOZ_IMPLICIT LSRequestParams(LSRequestPreloadDatastoreParams&& aOther);

    MOZ_IMPLICIT LSRequestParams(const LSRequestPrepareDatastoreParams& aOther);

    MOZ_IMPLICIT LSRequestParams(LSRequestPrepareDatastoreParams&& aOther);

    MOZ_IMPLICIT LSRequestParams(const LSRequestPrepareObserverParams& aOther);

    MOZ_IMPLICIT LSRequestParams(LSRequestPrepareObserverParams&& aOther);

    MOZ_IMPLICIT LSRequestParams(const LSRequestParams& aOther);

    MOZ_IMPLICIT LSRequestParams(LSRequestParams&& aOther);

    ~LSRequestParams();

    Type
    type() const
    {
        return mType;
    }

    LSRequestParams&
    operator=(const LSRequestPreloadDatastoreParams& aRhs);

    LSRequestParams&
    operator=(LSRequestPreloadDatastoreParams&& aRhs);

    LSRequestParams&
    operator=(const LSRequestPrepareDatastoreParams& aRhs);

    LSRequestParams&
    operator=(LSRequestPrepareDatastoreParams&& aRhs);

    LSRequestParams&
    operator=(const LSRequestPrepareObserverParams& aRhs);

    LSRequestParams&
    operator=(LSRequestPrepareObserverParams&& aRhs);

    LSRequestParams&
    operator=(const LSRequestParams& aRhs);

    LSRequestParams&
    operator=(LSRequestParams&& aRhs);

    LSRequestPreloadDatastoreParams&
    get_LSRequestPreloadDatastoreParams()
    {
        AssertSanity(TLSRequestPreloadDatastoreParams);
        return (*(ptr_LSRequestPreloadDatastoreParams()));
    }
    const LSRequestPreloadDatastoreParams&
    get_LSRequestPreloadDatastoreParams() const
    {
        AssertSanity(TLSRequestPreloadDatastoreParams);
        return (*(constptr_LSRequestPreloadDatastoreParams()));
    }
    operator LSRequestPreloadDatastoreParams&()
    {
        return get_LSRequestPreloadDatastoreParams();
    }
    operator const LSRequestPreloadDatastoreParams&() const
    {
        return get_LSRequestPreloadDatastoreParams();
    }

    LSRequestPrepareDatastoreParams&
    get_LSRequestPrepareDatastoreParams()
    {
        AssertSanity(TLSRequestPrepareDatastoreParams);
        return (*(ptr_LSRequestPrepareDatastoreParams()));
    }
    const LSRequestPrepareDatastoreParams&
    get_LSRequestPrepareDatastoreParams() const
    {
        AssertSanity(TLSRequestPrepareDatastoreParams);
        return (*(constptr_LSRequestPrepareDatastoreParams()));
    }
    operator LSRequestPrepareDatastoreParams&()
    {
        return get_LSRequestPrepareDatastoreParams();
    }
    operator const LSRequestPrepareDatastoreParams&() const
    {
        return get_LSRequestPrepareDatastoreParams();
    }

    LSRequestPrepareObserverParams&
    get_LSRequestPrepareObserverParams()
    {
        AssertSanity(TLSRequestPrepareObserverParams);
        return (*(ptr_LSRequestPrepareObserverParams()));
    }
    const LSRequestPrepareObserverParams&
    get_LSRequestPrepareObserverParams() const
    {
        AssertSanity(TLSRequestPrepareObserverParams);
        return (*(constptr_LSRequestPrepareObserverParams()));
    }
    operator LSRequestPrepareObserverParams&()
    {
        return get_LSRequestPrepareObserverParams();
    }
    operator const LSRequestPrepareObserverParams&() const
    {
        return get_LSRequestPrepareObserverParams();
    }

private:
    union {
        LSRequestPreloadDatastoreParams mVLSRequestPreloadDatastoreParams;
        LSRequestPrepareDatastoreParams mVLSRequestPrepareDatastoreParams;
        LSRequestPrepareObserverParams mVLSRequestPrepareObserverParams;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestParams>
{
    typedef ::mozilla::dom::LSRequestParams 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 LSSimpleRequestPreloadedParams|
//
namespace mozilla {
namespace dom {
class LSSimpleRequestPreloadedParams final
{
private:
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;

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

    MOZ_IMPLICIT LSSimpleRequestPreloadedParams(
            const PrincipalInfo& _principalInfo,
            const PrincipalInfo& _storagePrincipalInfo) :
        principalInfo_(_principalInfo),
        storagePrincipalInfo_(_storagePrincipalInfo)
    {
    }

    MOZ_IMPLICIT LSSimpleRequestPreloadedParams(
            PrincipalInfo&& _principalInfo,
            PrincipalInfo&& _storagePrincipalInfo) :
        principalInfo_(std::move(_principalInfo)),
        storagePrincipalInfo_(std::move(_storagePrincipalInfo))
    {
    }

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

    PrincipalInfo&
    storagePrincipalInfo()
    {
        return storagePrincipalInfo_;
    }
    const PrincipalInfo&
    storagePrincipalInfo() const
    {
        return storagePrincipalInfo_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> storagePrincipalInfo_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSSimpleRequestPreloadedParams>
{
    typedef ::mozilla::dom::LSSimpleRequestPreloadedParams 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 LSSimpleRequestGetStateParams|
//
namespace mozilla {
namespace dom {
class LSSimpleRequestGetStateParams final
{
private:
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;

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

    MOZ_IMPLICIT LSSimpleRequestGetStateParams(
            const PrincipalInfo& _principalInfo,
            const PrincipalInfo& _storagePrincipalInfo) :
        principalInfo_(_principalInfo),
        storagePrincipalInfo_(_storagePrincipalInfo)
    {
    }

    MOZ_IMPLICIT LSSimpleRequestGetStateParams(
            PrincipalInfo&& _principalInfo,
            PrincipalInfo&& _storagePrincipalInfo) :
        principalInfo_(std::move(_principalInfo)),
        storagePrincipalInfo_(std::move(_storagePrincipalInfo))
    {
    }

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

    PrincipalInfo&
    storagePrincipalInfo()
    {
        return storagePrincipalInfo_;
    }
    const PrincipalInfo&
    storagePrincipalInfo() const
    {
        return storagePrincipalInfo_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> storagePrincipalInfo_;
};
} // namespace dom
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union LSSimpleRequestParams|
//
namespace mozilla {
namespace dom {
class LSSimpleRequestParams final
{
public:
    enum Type {
        T__None,
        TLSSimpleRequestPreloadedParams = 1,
        TLSSimpleRequestGetStateParams,
        T__Last = TLSSimpleRequestGetStateParams
    };

private:
    typedef ::mozilla::dom::LSSimpleRequestPreloadedParams LSSimpleRequestPreloadedParams;
    typedef ::mozilla::dom::LSSimpleRequestGetStateParams LSSimpleRequestGetStateParams;
    typedef LSSimpleRequestPreloadedParams LSSimpleRequestPreloadedParams__tdef;
    typedef LSSimpleRequestGetStateParams LSSimpleRequestGetStateParams__tdef;

    LSSimpleRequestPreloadedParams*
    ptr_LSSimpleRequestPreloadedParams()
    {
        return (&(mVLSSimpleRequestPreloadedParams));
    }
    const LSSimpleRequestPreloadedParams*
    constptr_LSSimpleRequestPreloadedParams() const
    {
        return (&(mVLSSimpleRequestPreloadedParams));
    }
    LSSimpleRequestGetStateParams*
    ptr_LSSimpleRequestGetStateParams()
    {
        return (&(mVLSSimpleRequestGetStateParams));
    }
    const LSSimpleRequestGetStateParams*
    constptr_LSSimpleRequestGetStateParams() const
    {
        return (&(mVLSSimpleRequestGetStateParams));
    }

    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 LSSimpleRequestParams() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT LSSimpleRequestParams(const LSSimpleRequestPreloadedParams& aOther);

    MOZ_IMPLICIT LSSimpleRequestParams(LSSimpleRequestPreloadedParams&& aOther);

    MOZ_IMPLICIT LSSimpleRequestParams(const LSSimpleRequestGetStateParams& aOther);

    MOZ_IMPLICIT LSSimpleRequestParams(LSSimpleRequestGetStateParams&& aOther);

    MOZ_IMPLICIT LSSimpleRequestParams(const LSSimpleRequestParams& aOther);

    MOZ_IMPLICIT LSSimpleRequestParams(LSSimpleRequestParams&& aOther);

    ~LSSimpleRequestParams();

    Type
    type() const
    {
        return mType;
    }

    LSSimpleRequestParams&
    operator=(const LSSimpleRequestPreloadedParams& aRhs);

    LSSimpleRequestParams&
    operator=(LSSimpleRequestPreloadedParams&& aRhs);

    LSSimpleRequestParams&
    operator=(const LSSimpleRequestGetStateParams& aRhs);

    LSSimpleRequestParams&
    operator=(LSSimpleRequestGetStateParams&& aRhs);

    LSSimpleRequestParams&
    operator=(const LSSimpleRequestParams& aRhs);

    LSSimpleRequestParams&
    operator=(LSSimpleRequestParams&& aRhs);

    LSSimpleRequestPreloadedParams&
    get_LSSimpleRequestPreloadedParams()
    {
        AssertSanity(TLSSimpleRequestPreloadedParams);
        return (*(ptr_LSSimpleRequestPreloadedParams()));
    }
    const LSSimpleRequestPreloadedParams&
    get_LSSimpleRequestPreloadedParams() const
    {
        AssertSanity(TLSSimpleRequestPreloadedParams);
        return (*(constptr_LSSimpleRequestPreloadedParams()));
    }
    operator LSSimpleRequestPreloadedParams&()
    {
        return get_LSSimpleRequestPreloadedParams();
    }
    operator const LSSimpleRequestPreloadedParams&() const
    {
        return get_LSSimpleRequestPreloadedParams();
    }

    LSSimpleRequestGetStateParams&
    get_LSSimpleRequestGetStateParams()
    {
        AssertSanity(TLSSimpleRequestGetStateParams);
        return (*(ptr_LSSimpleRequestGetStateParams()));
    }
    const LSSimpleRequestGetStateParams&
    get_LSSimpleRequestGetStateParams() const
    {
        AssertSanity(TLSSimpleRequestGetStateParams);
        return (*(constptr_LSSimpleRequestGetStateParams()));
    }
    operator LSSimpleRequestGetStateParams&()
    {
        return get_LSSimpleRequestGetStateParams();
    }
    operator const LSSimpleRequestGetStateParams&() const
    {
        return get_LSSimpleRequestGetStateParams();
    }

private:
    union {
        LSSimpleRequestPreloadedParams mVLSSimpleRequestPreloadedParams;
        LSSimpleRequestGetStateParams mVLSSimpleRequestGetStateParams;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSSimpleRequestParams>
{
    typedef ::mozilla::dom::LSSimpleRequestParams 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 LSItemInfo|
//
namespace mozilla {
namespace dom {
class LSItemInfo final
{
private:
    typedef ::nsString nsString;
    typedef ::mozilla::dom::LSValue LSValue;

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

    MOZ_IMPLICIT LSItemInfo(
            const nsString& _key,
            const LSValue& _value) :
        key_(_key),
        value_(_value)
    {
    }

    MOZ_IMPLICIT LSItemInfo(
            nsString&& _key,
            LSValue&& _value) :
        key_(std::move(_key)),
        value_(std::move(_value))
    {
    }

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

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

private:
    ::mozilla::ipc::IPDLStructMember<nsString> key_;
    ::mozilla::ipc::IPDLStructMember<LSValue> value_;
};
} // namespace dom
} // namespace mozilla

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

#endif // ifndef PBackgroundLSSharedTypes_h
