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

#ifndef PSpeechSynthesis_h
#define PSpeechSynthesis_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"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct RemoteVoice|
//
namespace mozilla {
namespace dom {
class RemoteVoice final
{
private:
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT RemoteVoice(
            const nsString& _voiceURI,
            const nsString& _name,
            const nsString& _lang,
            const bool& _localService,
            const bool& _queued) :
        voiceURI_(_voiceURI),
        name_(_name),
        lang_(_lang),
        localService_(_localService),
        queued_(_queued)
    {
    }

    MOZ_IMPLICIT RemoteVoice(
            nsString&& _voiceURI,
            nsString&& _name,
            nsString&& _lang,
            bool&& _localService,
            bool&& _queued) :
        voiceURI_(std::move(_voiceURI)),
        name_(std::move(_name)),
        lang_(std::move(_lang)),
        localService_(std::move(_localService)),
        queued_(std::move(_queued))
    {
    }

    nsString&
    voiceURI()
    {
        return voiceURI_;
    }
    const nsString&
    voiceURI() const
    {
        return voiceURI_;
    }

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

    nsString&
    lang()
    {
        return lang_;
    }
    const nsString&
    lang() const
    {
        return lang_;
    }

    bool&
    localService()
    {
        return localService_;
    }
    const bool&
    localService() const
    {
        return localService_;
    }

    bool&
    queued()
    {
        return queued_;
    }
    const bool&
    queued() const
    {
        return queued_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> voiceURI_;
    ::mozilla::ipc::IPDLStructMember<nsString> name_;
    ::mozilla::ipc::IPDLStructMember<nsString> lang_;
    ::mozilla::ipc::IPDLStructMember<bool> localService_;
    ::mozilla::ipc::IPDLStructMember<bool> queued_;
};
} // namespace dom
} // namespace mozilla

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

namespace mozilla {
namespace dom {
class PSpeechSynthesisParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PSpeechSynthesisChild;
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PSpeechSynthesisChild and PSpeechSynthesisParent
//
namespace mozilla {
namespace dom {
namespace PSpeechSynthesis {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::PSpeechSynthesisParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PSpeechSynthesisChild>* aChild);

enum MessageType {
    PSpeechSynthesisStart = PSpeechSynthesisMsgStart << 16,
    Msg_VoiceAdded__ID,
    Msg_VoiceRemoved__ID,
    Msg_SetDefaultVoice__ID,
    Msg_IsSpeakingChanged__ID,
    Msg_NotifyVoicesChanged__ID,
    Msg_NotifyVoicesError__ID,
    Msg_InitialVoicesAndState__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    Msg_PSpeechSynthesisRequestConstructor__ID,
    Reply_PSpeechSynthesisRequestConstructor__ID,
    PSpeechSynthesisEnd
};

mozilla::UniquePtr<IPC::Message>
Msg_VoiceAdded(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_VoiceRemoved(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_SetDefaultVoice(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_IsSpeakingChanged(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_NotifyVoicesChanged(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_NotifyVoicesError(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_InitialVoicesAndState(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PSpeechSynthesisRequestConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PSpeechSynthesisRequestConstructor(IPC::Message::routeid_t routingId);



} // namespace PSpeechSynthesis
} // namespace dom
} // namespace mozilla

#endif // ifndef PSpeechSynthesis_h
