/*
 * Copyright (C) 2010 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef WebPageMessages_h
#define WebPageMessages_h

#include "Arguments.h"
#include "MessageEncoder.h"
#include "SandboxExtension.h"
#include "SharedMemory.h"
#include "StringReference.h"
#include <WebCore/DictationAlternative.h>
#include <WebCore/Editor.h>
#include <WebCore/KeyboardEvent.h>
#include <WebCore/TextCheckerClient.h>
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>

namespace IPC {
    class DataReference;
}

namespace WTF {
    class String;
}

namespace WebCore {
    class Color;
    class IntPoint;
    class DragData;
    class ResourceRequest;
    class FloatRect;
    class FloatPoint;
    class IntRect;
    class IntSize;
}

namespace WebKit {
    class WebContextUserMessageEncoder;
    struct PrintInfo;
    struct WebPreferencesStore;
    class WebMouseEvent;
    class WebContextMenuItemData;
    struct InteractionInformationAtPosition;
    struct EditorState;
    class SessionState;
    class WebWheelEvent;
    class WebKeyboardEvent;
    class WebTouchEvent;
    struct AttributedString;
}

namespace Messages {
namespace WebPage {

static inline IPC::StringReference messageReceiverName()
{
    return IPC::StringReference("WebPage");
}

class SetInitialFocus {
public:
    typedef std::tuple<bool, bool, WebKit::WebKeyboardEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetInitialFocus"); }
    static const bool isSync = false;

    SetInitialFocus(bool forward, bool isKeyboardEventValid, const WebKit::WebKeyboardEvent& event)
        : m_arguments(forward, isKeyboardEventValid, event)
    {
    }

    const std::tuple<bool, bool, const WebKit::WebKeyboardEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool, bool, const WebKit::WebKeyboardEvent&> m_arguments;
};

class SetViewState {
public:
    typedef std::tuple<unsigned, bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetViewState"); }
    static const bool isSync = false;

    SetViewState(const unsigned& viewState, bool wantsDidUpdateViewState)
        : m_arguments(viewState, wantsDidUpdateViewState)
    {
    }

    const std::tuple<const unsigned&, bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const unsigned&, bool> m_arguments;
};

class SetLayerHostingMode {
public:
    typedef std::tuple<unsigned> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetLayerHostingMode"); }
    static const bool isSync = false;

    explicit SetLayerHostingMode(const unsigned& layerHostingMode)
        : m_arguments(layerHostingMode)
    {
    }

    const std::tuple<const unsigned&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const unsigned&> m_arguments;
};

class SetSessionID {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetSessionID"); }
    static const bool isSync = false;

    explicit SetSessionID(uint64_t sessionID)
        : m_arguments(sessionID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class SetDrawsBackground {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetDrawsBackground"); }
    static const bool isSync = false;

    explicit SetDrawsBackground(bool drawsBackground)
        : m_arguments(drawsBackground)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetDrawsTransparentBackground {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetDrawsTransparentBackground"); }
    static const bool isSync = false;

    explicit SetDrawsTransparentBackground(bool drawsTransparentBackground)
        : m_arguments(drawsTransparentBackground)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetUnderlayColor {
public:
    typedef std::tuple<WebCore::Color> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetUnderlayColor"); }
    static const bool isSync = false;

    explicit SetUnderlayColor(const WebCore::Color& color)
        : m_arguments(color)
    {
    }

    const std::tuple<const WebCore::Color&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::Color&> m_arguments;
};

class ViewWillStartLiveResize {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ViewWillStartLiveResize"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class ViewWillEndLiveResize {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ViewWillEndLiveResize"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class KeyEvent {
public:
    typedef std::tuple<WebKit::WebKeyboardEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("KeyEvent"); }
    static const bool isSync = false;

    explicit KeyEvent(const WebKit::WebKeyboardEvent& event)
        : m_arguments(event)
    {
    }

    const std::tuple<const WebKit::WebKeyboardEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebKeyboardEvent&> m_arguments;
};

class KeyEventSyncForTesting {
public:
    typedef std::tuple<WebKit::WebKeyboardEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("KeyEventSyncForTesting"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<bool&> Reply;
    explicit KeyEventSyncForTesting(const WebKit::WebKeyboardEvent& event)
        : m_arguments(event)
    {
    }

    const std::tuple<const WebKit::WebKeyboardEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebKeyboardEvent&> m_arguments;
};

class MouseEvent {
public:
    typedef std::tuple<WebKit::WebMouseEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("MouseEvent"); }
    static const bool isSync = false;

    explicit MouseEvent(const WebKit::WebMouseEvent& event)
        : m_arguments(event)
    {
    }

    const std::tuple<const WebKit::WebMouseEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebMouseEvent&> m_arguments;
};

class MouseEventSyncForTesting {
public:
    typedef std::tuple<WebKit::WebMouseEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("MouseEventSyncForTesting"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<bool&> Reply;
    explicit MouseEventSyncForTesting(const WebKit::WebMouseEvent& event)
        : m_arguments(event)
    {
    }

    const std::tuple<const WebKit::WebMouseEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebMouseEvent&> m_arguments;
};

class WheelEventSyncForTesting {
public:
    typedef std::tuple<WebKit::WebWheelEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("WheelEventSyncForTesting"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<bool&> Reply;
    explicit WheelEventSyncForTesting(const WebKit::WebWheelEvent& event)
        : m_arguments(event)
    {
    }

    const std::tuple<const WebKit::WebWheelEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebWheelEvent&> m_arguments;
};

#if PLATFORM(IOS)
class HandleTap {
public:
    typedef std::tuple<WebCore::IntPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("HandleTap"); }
    static const bool isSync = false;

    explicit HandleTap(const WebCore::IntPoint& point)
        : m_arguments(point)
    {
    }

    const std::tuple<const WebCore::IntPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&> m_arguments;
};
#endif

#if PLATFORM(IOS)
class TapHighlightAtPosition {
public:
    typedef std::tuple<uint64_t, WebCore::FloatPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("TapHighlightAtPosition"); }
    static const bool isSync = false;

    TapHighlightAtPosition(uint64_t requestID, const WebCore::FloatPoint& point)
        : m_arguments(requestID, point)
    {
    }

    const std::tuple<uint64_t, const WebCore::FloatPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const WebCore::FloatPoint&> m_arguments;
};
#endif

#if PLATFORM(IOS)
class BlurAssistedNode {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("BlurAssistedNode"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(IOS)
class SelectWithGesture {
public:
    typedef std::tuple<WebCore::IntPoint, uint32_t, uint32_t, uint32_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SelectWithGesture"); }
    static const bool isSync = false;

    SelectWithGesture(const WebCore::IntPoint& point, uint32_t granularity, uint32_t gestureType, uint32_t gestureState, uint64_t callbackID)
        : m_arguments(point, granularity, gestureType, gestureState, callbackID)
    {
    }

    const std::tuple<const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class UpdateSelectionWithTouches {
public:
    typedef std::tuple<WebCore::IntPoint, uint32_t, bool, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("UpdateSelectionWithTouches"); }
    static const bool isSync = false;

    UpdateSelectionWithTouches(const WebCore::IntPoint& point, uint32_t touches, bool baseIsStart, uint64_t callbackID)
        : m_arguments(point, touches, baseIsStart, callbackID)
    {
    }

    const std::tuple<const WebCore::IntPoint&, uint32_t, bool, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&, uint32_t, bool, uint64_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class SelectWithTwoTouches {
public:
    typedef std::tuple<WebCore::IntPoint, WebCore::IntPoint, uint32_t, uint32_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SelectWithTwoTouches"); }
    static const bool isSync = false;

    SelectWithTwoTouches(const WebCore::IntPoint& from, const WebCore::IntPoint& to, uint32_t gestureType, uint32_t gestureState, uint64_t callbackID)
        : m_arguments(from, to, gestureType, gestureState, callbackID)
    {
    }

    const std::tuple<const WebCore::IntPoint&, const WebCore::IntPoint&, uint32_t, uint32_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&, const WebCore::IntPoint&, uint32_t, uint32_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class ExtendSelection {
public:
    typedef std::tuple<uint32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ExtendSelection"); }
    static const bool isSync = false;

    explicit ExtendSelection(uint32_t granularity)
        : m_arguments(granularity)
    {
    }

    const std::tuple<uint32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint32_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class RequestAutocorrectionData {
public:
    typedef std::tuple<String, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("RequestAutocorrectionData"); }
    static const bool isSync = false;

    RequestAutocorrectionData(const String& textForAutocorrection, uint64_t callbackID)
        : m_arguments(textForAutocorrection, callbackID)
    {
    }

    const std::tuple<const String&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint64_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class ApplyAutocorrection {
public:
    typedef std::tuple<String, String, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ApplyAutocorrection"); }
    static const bool isSync = false;

    ApplyAutocorrection(const String& correction, const String& originalText, uint64_t callbackID)
        : m_arguments(correction, originalText, callbackID)
    {
    }

    const std::tuple<const String&, const String&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const String&, uint64_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class RequestAutocorrectionContext {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("RequestAutocorrectionContext"); }
    static const bool isSync = false;

    explicit RequestAutocorrectionContext(uint64_t callbackID)
        : m_arguments(callbackID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class GetAutocorrectionContext {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetAutocorrectionContext"); }
    static const bool isSync = true;

    typedef IPC::Arguments6<String&, String&, String&, String&, uint64_t&, uint64_t&> Reply;
    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(IOS)
class InsertText {
public:
    typedef std::tuple<String, uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("InsertText"); }
    static const bool isSync = false;

    InsertText(const String& text, uint64_t replacementRangeStart, uint64_t replacementRangeEnd)
        : m_arguments(text, replacementRangeStart, replacementRangeEnd)
    {
    }

    const std::tuple<const String&, uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint64_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class SetComposition {
public:
    typedef std::tuple<String, Vector<WebCore::CompositionUnderline>, uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetComposition"); }
    static const bool isSync = false;

    SetComposition(const String& text, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t selectionStart, uint64_t selectionEnd)
        : m_arguments(text, underlines, selectionStart, selectionEnd)
    {
    }

    const std::tuple<const String&, const Vector<WebCore::CompositionUnderline>&, uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const Vector<WebCore::CompositionUnderline>&, uint64_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(IOS)
class ConfirmComposition {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ConfirmComposition"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(IOS)
class GetPositionInformation {
public:
    typedef std::tuple<WebCore::IntPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetPositionInformation"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<WebKit::InteractionInformationAtPosition&> Reply;
    explicit GetPositionInformation(const WebCore::IntPoint& point)
        : m_arguments(point)
    {
    }

    const std::tuple<const WebCore::IntPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&> m_arguments;
};
#endif

#if PLATFORM(IOS)
class RequestPositionInformation {
public:
    typedef std::tuple<WebCore::IntPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("RequestPositionInformation"); }
    static const bool isSync = false;

    explicit RequestPositionInformation(const WebCore::IntPoint& point)
        : m_arguments(point)
    {
    }

    const std::tuple<const WebCore::IntPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&> m_arguments;
};
#endif

#if ENABLE(TOUCH_EVENTS)
class TouchEvent {
public:
    typedef std::tuple<WebKit::WebTouchEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("TouchEvent"); }
    static const bool isSync = false;

    explicit TouchEvent(const WebKit::WebTouchEvent& event)
        : m_arguments(event)
    {
    }

    const std::tuple<const WebKit::WebTouchEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebTouchEvent&> m_arguments;
};
#endif

#if ENABLE(TOUCH_EVENTS)
class TouchEventSyncForTesting {
public:
    typedef std::tuple<WebKit::WebTouchEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("TouchEventSyncForTesting"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<bool&> Reply;
    explicit TouchEventSyncForTesting(const WebKit::WebTouchEvent& event)
        : m_arguments(event)
    {
    }

    const std::tuple<const WebKit::WebTouchEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebTouchEvent&> m_arguments;
};
#endif

#if ENABLE(INPUT_TYPE_COLOR)
class DidEndColorPicker {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidEndColorPicker"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if ENABLE(INPUT_TYPE_COLOR)
class DidChooseColor {
public:
    typedef std::tuple<WebCore::Color> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidChooseColor"); }
    static const bool isSync = false;

    explicit DidChooseColor(const WebCore::Color& color)
        : m_arguments(color)
    {
    }

    const std::tuple<const WebCore::Color&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::Color&> m_arguments;
};
#endif

#if ENABLE(CONTEXT_MENUS)
class ContextMenuHidden {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ContextMenuHidden"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

class ScrollBy {
public:
    typedef std::tuple<uint32_t, uint32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ScrollBy"); }
    static const bool isSync = false;

    ScrollBy(uint32_t scrollDirection, uint32_t scrollGranularity)
        : m_arguments(scrollDirection, scrollGranularity)
    {
    }

    const std::tuple<uint32_t, uint32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint32_t, uint32_t> m_arguments;
};

class CenterSelectionInVisibleArea {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("CenterSelectionInVisibleArea"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class GoBack {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GoBack"); }
    static const bool isSync = false;

    explicit GoBack(uint64_t backForwardItemID)
        : m_arguments(backForwardItemID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class GoForward {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GoForward"); }
    static const bool isSync = false;

    explicit GoForward(uint64_t backForwardItemID)
        : m_arguments(backForwardItemID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class GoToBackForwardItem {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GoToBackForwardItem"); }
    static const bool isSync = false;

    explicit GoToBackForwardItem(uint64_t backForwardItemID)
        : m_arguments(backForwardItemID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class TryRestoreScrollPosition {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("TryRestoreScrollPosition"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class LoadURLInFrame {
public:
    typedef std::tuple<String, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("LoadURLInFrame"); }
    static const bool isSync = false;

    LoadURLInFrame(const String& url, uint64_t frameID)
        : m_arguments(url, frameID)
    {
    }

    const std::tuple<const String&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint64_t> m_arguments;
};

class LoadRequest {
public:
    typedef std::tuple<WebCore::ResourceRequest, WebKit::SandboxExtension::Handle> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("LoadRequest"); }
    static const bool isSync = false;

    LoadRequest(const WebCore::ResourceRequest& request, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle, const WebKit::WebContextUserMessageEncoder& userData)
        : m_arguments(request, sandboxExtensionHandle, userData)
    {
    }

    const std::tuple<const WebCore::ResourceRequest&, const WebKit::SandboxExtension::Handle&, const WebKit::WebContextUserMessageEncoder&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::ResourceRequest&, const WebKit::SandboxExtension::Handle&, const WebKit::WebContextUserMessageEncoder&> m_arguments;
};

class LoadData {
public:
    typedef std::tuple<IPC::DataReference, String, String, String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("LoadData"); }
    static const bool isSync = false;

    LoadData(const IPC::DataReference& data, const String& MIMEType, const String& encoding, const String& baseURL, const WebKit::WebContextUserMessageEncoder& userData)
        : m_arguments(data, MIMEType, encoding, baseURL, userData)
    {
    }

    const std::tuple<const IPC::DataReference&, const String&, const String&, const String&, const WebKit::WebContextUserMessageEncoder&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const IPC::DataReference&, const String&, const String&, const String&, const WebKit::WebContextUserMessageEncoder&> m_arguments;
};

class LoadHTMLString {
public:
    typedef std::tuple<String, String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("LoadHTMLString"); }
    static const bool isSync = false;

    LoadHTMLString(const String& htmlString, const String& baseURL, const WebKit::WebContextUserMessageEncoder& userData)
        : m_arguments(htmlString, baseURL, userData)
    {
    }

    const std::tuple<const String&, const String&, const WebKit::WebContextUserMessageEncoder&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const String&, const WebKit::WebContextUserMessageEncoder&> m_arguments;
};

class LoadAlternateHTMLString {
public:
    typedef std::tuple<String, String, String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("LoadAlternateHTMLString"); }
    static const bool isSync = false;

    LoadAlternateHTMLString(const String& htmlString, const String& baseURL, const String& unreachableURL, const WebKit::WebContextUserMessageEncoder& userData)
        : m_arguments(htmlString, baseURL, unreachableURL, userData)
    {
    }

    const std::tuple<const String&, const String&, const String&, const WebKit::WebContextUserMessageEncoder&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const String&, const String&, const WebKit::WebContextUserMessageEncoder&> m_arguments;
};

class LoadPlainTextString {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("LoadPlainTextString"); }
    static const bool isSync = false;

    LoadPlainTextString(const String& string, const WebKit::WebContextUserMessageEncoder& userData)
        : m_arguments(string, userData)
    {
    }

    const std::tuple<const String&, const WebKit::WebContextUserMessageEncoder&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const WebKit::WebContextUserMessageEncoder&> m_arguments;
};

class LoadWebArchiveData {
public:
    typedef std::tuple<IPC::DataReference> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("LoadWebArchiveData"); }
    static const bool isSync = false;

    LoadWebArchiveData(const IPC::DataReference& webArchiveData, const WebKit::WebContextUserMessageEncoder& userData)
        : m_arguments(webArchiveData, userData)
    {
    }

    const std::tuple<const IPC::DataReference&, const WebKit::WebContextUserMessageEncoder&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const IPC::DataReference&, const WebKit::WebContextUserMessageEncoder&> m_arguments;
};

class Reload {
public:
    typedef std::tuple<bool, WebKit::SandboxExtension::Handle> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("Reload"); }
    static const bool isSync = false;

    Reload(bool reloadFromOrigin, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle)
        : m_arguments(reloadFromOrigin, sandboxExtensionHandle)
    {
    }

    const std::tuple<bool, const WebKit::SandboxExtension::Handle&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool, const WebKit::SandboxExtension::Handle&> m_arguments;
};

class StopLoading {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("StopLoading"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class StopLoadingFrame {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("StopLoadingFrame"); }
    static const bool isSync = false;

    explicit StopLoadingFrame(uint64_t frameID)
        : m_arguments(frameID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class RestoreSession {
public:
    typedef std::tuple<WebKit::SessionState> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("RestoreSession"); }
    static const bool isSync = false;

    explicit RestoreSession(const WebKit::SessionState& state)
        : m_arguments(state)
    {
    }

    const std::tuple<const WebKit::SessionState&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::SessionState&> m_arguments;
};

class RestoreSessionAndNavigateToCurrentItem {
public:
    typedef std::tuple<WebKit::SessionState> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("RestoreSessionAndNavigateToCurrentItem"); }
    static const bool isSync = false;

    explicit RestoreSessionAndNavigateToCurrentItem(const WebKit::SessionState& state)
        : m_arguments(state)
    {
    }

    const std::tuple<const WebKit::SessionState&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::SessionState&> m_arguments;
};

class DidRemoveBackForwardItem {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidRemoveBackForwardItem"); }
    static const bool isSync = false;

    explicit DidRemoveBackForwardItem(uint64_t backForwardItemID)
        : m_arguments(backForwardItemID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class DidReceivePolicyDecision {
public:
    typedef std::tuple<uint64_t, uint64_t, uint32_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidReceivePolicyDecision"); }
    static const bool isSync = false;

    DidReceivePolicyDecision(uint64_t frameID, uint64_t listenerID, uint32_t policyAction, uint64_t downloadID)
        : m_arguments(frameID, listenerID, policyAction, downloadID)
    {
    }

    const std::tuple<uint64_t, uint64_t, uint32_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, uint64_t, uint32_t, uint64_t> m_arguments;
};

class ClearSelection {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ClearSelection"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class GetContentsAsString {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetContentsAsString"); }
    static const bool isSync = false;

    explicit GetContentsAsString(uint64_t callbackID)
        : m_arguments(callbackID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

#if ENABLE(MHTML)
class GetContentsAsMHTMLData {
public:
    typedef std::tuple<uint64_t, bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetContentsAsMHTMLData"); }
    static const bool isSync = false;

    GetContentsAsMHTMLData(uint64_t callbackID, bool useBinaryEncoding)
        : m_arguments(callbackID, useBinaryEncoding)
    {
    }

    const std::tuple<uint64_t, bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, bool> m_arguments;
};
#endif

class GetMainResourceDataOfFrame {
public:
    typedef std::tuple<uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetMainResourceDataOfFrame"); }
    static const bool isSync = false;

    GetMainResourceDataOfFrame(uint64_t frameID, uint64_t callbackID)
        : m_arguments(frameID, callbackID)
    {
    }

    const std::tuple<uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, uint64_t> m_arguments;
};

class GetResourceDataFromFrame {
public:
    typedef std::tuple<uint64_t, String, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetResourceDataFromFrame"); }
    static const bool isSync = false;

    GetResourceDataFromFrame(uint64_t frameID, const String& resourceURL, uint64_t callbackID)
        : m_arguments(frameID, resourceURL, callbackID)
    {
    }

    const std::tuple<uint64_t, const String&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const String&, uint64_t> m_arguments;
};

class GetRenderTreeExternalRepresentation {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetRenderTreeExternalRepresentation"); }
    static const bool isSync = false;

    explicit GetRenderTreeExternalRepresentation(uint64_t callbackID)
        : m_arguments(callbackID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class GetSelectionOrContentsAsString {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetSelectionOrContentsAsString"); }
    static const bool isSync = false;

    explicit GetSelectionOrContentsAsString(uint64_t callbackID)
        : m_arguments(callbackID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class GetSelectionAsWebArchiveData {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetSelectionAsWebArchiveData"); }
    static const bool isSync = false;

    explicit GetSelectionAsWebArchiveData(uint64_t callbackID)
        : m_arguments(callbackID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class GetSourceForFrame {
public:
    typedef std::tuple<uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetSourceForFrame"); }
    static const bool isSync = false;

    GetSourceForFrame(uint64_t frameID, uint64_t callbackID)
        : m_arguments(frameID, callbackID)
    {
    }

    const std::tuple<uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, uint64_t> m_arguments;
};

class GetWebArchiveOfFrame {
public:
    typedef std::tuple<uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetWebArchiveOfFrame"); }
    static const bool isSync = false;

    GetWebArchiveOfFrame(uint64_t frameID, uint64_t callbackID)
        : m_arguments(frameID, callbackID)
    {
    }

    const std::tuple<uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, uint64_t> m_arguments;
};

class RunJavaScriptInMainFrame {
public:
    typedef std::tuple<String, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("RunJavaScriptInMainFrame"); }
    static const bool isSync = false;

    RunJavaScriptInMainFrame(const String& script, uint64_t callbackID)
        : m_arguments(script, callbackID)
    {
    }

    const std::tuple<const String&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint64_t> m_arguments;
};

class ForceRepaint {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ForceRepaint"); }
    static const bool isSync = false;

    explicit ForceRepaint(uint64_t callbackID)
        : m_arguments(callbackID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

#if PLATFORM(MAC)
class PerformDictionaryLookupAtLocation {
public:
    typedef std::tuple<WebCore::FloatPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("PerformDictionaryLookupAtLocation"); }
    static const bool isSync = false;

    explicit PerformDictionaryLookupAtLocation(const WebCore::FloatPoint& point)
        : m_arguments(point)
    {
    }

    const std::tuple<const WebCore::FloatPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::FloatPoint&> m_arguments;
};
#endif

class PreferencesDidChange {
public:
    typedef std::tuple<WebKit::WebPreferencesStore> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("PreferencesDidChange"); }
    static const bool isSync = false;

    explicit PreferencesDidChange(const WebKit::WebPreferencesStore& store)
        : m_arguments(store)
    {
    }

    const std::tuple<const WebKit::WebPreferencesStore&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebPreferencesStore&> m_arguments;
};

class SetUserAgent {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetUserAgent"); }
    static const bool isSync = false;

    explicit SetUserAgent(const String& userAgent)
        : m_arguments(userAgent)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};

class SetCustomTextEncodingName {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetCustomTextEncodingName"); }
    static const bool isSync = false;

    explicit SetCustomTextEncodingName(const String& encodingName)
        : m_arguments(encodingName)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};

class SuspendActiveDOMObjectsAndAnimations {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SuspendActiveDOMObjectsAndAnimations"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class ResumeActiveDOMObjectsAndAnimations {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ResumeActiveDOMObjectsAndAnimations"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class Close {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("Close"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class TryClose {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("TryClose"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class ValidateCommand {
public:
    typedef std::tuple<String, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ValidateCommand"); }
    static const bool isSync = false;

    ValidateCommand(const String& name, uint64_t callbackID)
        : m_arguments(name, callbackID)
    {
    }

    const std::tuple<const String&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint64_t> m_arguments;
};

class ExecuteEditCommand {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ExecuteEditCommand"); }
    static const bool isSync = false;

    explicit ExecuteEditCommand(const String& name)
        : m_arguments(name)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};

class DidRemoveEditCommand {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidRemoveEditCommand"); }
    static const bool isSync = false;

    explicit DidRemoveEditCommand(uint64_t commandID)
        : m_arguments(commandID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class ReapplyEditCommand {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ReapplyEditCommand"); }
    static const bool isSync = false;

    explicit ReapplyEditCommand(uint64_t commandID)
        : m_arguments(commandID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class UnapplyEditCommand {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("UnapplyEditCommand"); }
    static const bool isSync = false;

    explicit UnapplyEditCommand(uint64_t commandID)
        : m_arguments(commandID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class SetPageAndTextZoomFactors {
public:
    typedef std::tuple<double, double> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetPageAndTextZoomFactors"); }
    static const bool isSync = false;

    SetPageAndTextZoomFactors(double pageZoomFactor, double textZoomFactor)
        : m_arguments(pageZoomFactor, textZoomFactor)
    {
    }

    const std::tuple<double, double> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<double, double> m_arguments;
};

class SetPageZoomFactor {
public:
    typedef std::tuple<double> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetPageZoomFactor"); }
    static const bool isSync = false;

    explicit SetPageZoomFactor(double zoomFactor)
        : m_arguments(zoomFactor)
    {
    }

    const std::tuple<double> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<double> m_arguments;
};

class SetTextZoomFactor {
public:
    typedef std::tuple<double> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetTextZoomFactor"); }
    static const bool isSync = false;

    explicit SetTextZoomFactor(double zoomFactor)
        : m_arguments(zoomFactor)
    {
    }

    const std::tuple<double> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<double> m_arguments;
};

class WindowScreenDidChange {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("WindowScreenDidChange"); }
    static const bool isSync = false;

    explicit WindowScreenDidChange(uint64_t displayID)
        : m_arguments(displayID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

class ScalePage {
public:
    typedef std::tuple<double, WebCore::IntPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ScalePage"); }
    static const bool isSync = false;

    ScalePage(double scale, const WebCore::IntPoint& origin)
        : m_arguments(scale, origin)
    {
    }

    const std::tuple<double, const WebCore::IntPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<double, const WebCore::IntPoint&> m_arguments;
};

class SetUseFixedLayout {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetUseFixedLayout"); }
    static const bool isSync = false;

    explicit SetUseFixedLayout(bool fixed)
        : m_arguments(fixed)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetFixedLayoutSize {
public:
    typedef std::tuple<WebCore::IntSize> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetFixedLayoutSize"); }
    static const bool isSync = false;

    explicit SetFixedLayoutSize(const WebCore::IntSize& size)
        : m_arguments(size)
    {
    }

    const std::tuple<const WebCore::IntSize&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntSize&> m_arguments;
};

class ListenForLayoutMilestones {
public:
    typedef std::tuple<uint32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ListenForLayoutMilestones"); }
    static const bool isSync = false;

    explicit ListenForLayoutMilestones(uint32_t milestones)
        : m_arguments(milestones)
    {
    }

    const std::tuple<uint32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint32_t> m_arguments;
};

class SetSuppressScrollbarAnimations {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetSuppressScrollbarAnimations"); }
    static const bool isSync = false;

    explicit SetSuppressScrollbarAnimations(bool suppressAnimations)
        : m_arguments(suppressAnimations)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetBackgroundExtendsBeyondPage {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetBackgroundExtendsBeyondPage"); }
    static const bool isSync = false;

    explicit SetBackgroundExtendsBeyondPage(bool backgroundExtendsBeyondPage)
        : m_arguments(backgroundExtendsBeyondPage)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetPaginationMode {
public:
    typedef std::tuple<uint32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetPaginationMode"); }
    static const bool isSync = false;

    explicit SetPaginationMode(uint32_t mode)
        : m_arguments(mode)
    {
    }

    const std::tuple<uint32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint32_t> m_arguments;
};

class SetPaginationBehavesLikeColumns {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetPaginationBehavesLikeColumns"); }
    static const bool isSync = false;

    explicit SetPaginationBehavesLikeColumns(bool behavesLikeColumns)
        : m_arguments(behavesLikeColumns)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetPageLength {
public:
    typedef std::tuple<double> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetPageLength"); }
    static const bool isSync = false;

    explicit SetPageLength(double pageLength)
        : m_arguments(pageLength)
    {
    }

    const std::tuple<double> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<double> m_arguments;
};

class SetGapBetweenPages {
public:
    typedef std::tuple<double> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetGapBetweenPages"); }
    static const bool isSync = false;

    explicit SetGapBetweenPages(double gap)
        : m_arguments(gap)
    {
    }

    const std::tuple<double> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<double> m_arguments;
};

class PostInjectedBundleMessage {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("PostInjectedBundleMessage"); }
    static const bool isSync = false;

    PostInjectedBundleMessage(const String& messageName, const WebKit::WebContextUserMessageEncoder& messageBody)
        : m_arguments(messageName, messageBody)
    {
    }

    const std::tuple<const String&, const WebKit::WebContextUserMessageEncoder&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const WebKit::WebContextUserMessageEncoder&> m_arguments;
};

class FindString {
public:
    typedef std::tuple<String, uint32_t, unsigned> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("FindString"); }
    static const bool isSync = false;

    FindString(const String& string, uint32_t findOptions, const unsigned& maxMatchCount)
        : m_arguments(string, findOptions, maxMatchCount)
    {
    }

    const std::tuple<const String&, uint32_t, const unsigned&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint32_t, const unsigned&> m_arguments;
};

class FindStringMatches {
public:
    typedef std::tuple<String, uint32_t, unsigned> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("FindStringMatches"); }
    static const bool isSync = false;

    FindStringMatches(const String& string, uint32_t findOptions, const unsigned& maxMatchCount)
        : m_arguments(string, findOptions, maxMatchCount)
    {
    }

    const std::tuple<const String&, uint32_t, const unsigned&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint32_t, const unsigned&> m_arguments;
};

class GetImageForFindMatch {
public:
    typedef std::tuple<uint32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetImageForFindMatch"); }
    static const bool isSync = false;

    explicit GetImageForFindMatch(uint32_t matchIndex)
        : m_arguments(matchIndex)
    {
    }

    const std::tuple<uint32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint32_t> m_arguments;
};

class SelectFindMatch {
public:
    typedef std::tuple<uint32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SelectFindMatch"); }
    static const bool isSync = false;

    explicit SelectFindMatch(uint32_t matchIndex)
        : m_arguments(matchIndex)
    {
    }

    const std::tuple<uint32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint32_t> m_arguments;
};

class HideFindUI {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("HideFindUI"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class CountStringMatches {
public:
    typedef std::tuple<String, uint32_t, unsigned> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("CountStringMatches"); }
    static const bool isSync = false;

    CountStringMatches(const String& string, uint32_t findOptions, const unsigned& maxMatchCount)
        : m_arguments(string, findOptions, maxMatchCount)
    {
    }

    const std::tuple<const String&, uint32_t, const unsigned&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint32_t, const unsigned&> m_arguments;
};

#if PLATFORM(GTK) && ENABLE(DRAG_SUPPORT)
class PerformDragControllerAction {
public:
    typedef std::tuple<uint64_t, WebCore::DragData> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("PerformDragControllerAction"); }
    static const bool isSync = false;

    PerformDragControllerAction(uint64_t action, const WebCore::DragData& dragData)
        : m_arguments(action, dragData)
    {
    }

    const std::tuple<uint64_t, const WebCore::DragData&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const WebCore::DragData&> m_arguments;
};
#endif

#if !PLATFORM(GTK) && ENABLE(DRAG_SUPPORT)
class PerformDragControllerAction {
public:
    typedef std::tuple<uint64_t, WebCore::IntPoint, WebCore::IntPoint, uint64_t, String, uint32_t, WebKit::SandboxExtension::Handle, WebKit::SandboxExtension::HandleArray> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("PerformDragControllerAction"); }
    static const bool isSync = false;

    PerformDragControllerAction(uint64_t action, const WebCore::IntPoint& clientPosition, const WebCore::IntPoint& globalPosition, uint64_t draggingSourceOperationMask, const String& dragStorageName, uint32_t flags, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle, const WebKit::SandboxExtension::HandleArray& sandboxExtensionsForUpload)
        : m_arguments(action, clientPosition, globalPosition, draggingSourceOperationMask, dragStorageName, flags, sandboxExtensionHandle, sandboxExtensionsForUpload)
    {
    }

    const std::tuple<uint64_t, const WebCore::IntPoint&, const WebCore::IntPoint&, uint64_t, const String&, uint32_t, const WebKit::SandboxExtension::Handle&, const WebKit::SandboxExtension::HandleArray&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const WebCore::IntPoint&, const WebCore::IntPoint&, uint64_t, const String&, uint32_t, const WebKit::SandboxExtension::Handle&, const WebKit::SandboxExtension::HandleArray&> m_arguments;
};
#endif

#if ENABLE(DRAG_SUPPORT)
class DragEnded {
public:
    typedef std::tuple<WebCore::IntPoint, WebCore::IntPoint, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DragEnded"); }
    static const bool isSync = false;

    DragEnded(const WebCore::IntPoint& clientPosition, const WebCore::IntPoint& globalPosition, uint64_t operation)
        : m_arguments(clientPosition, globalPosition, operation)
    {
    }

    const std::tuple<const WebCore::IntPoint&, const WebCore::IntPoint&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&, const WebCore::IntPoint&, uint64_t> m_arguments;
};
#endif

class DidChangeSelectedIndexForActivePopupMenu {
public:
    typedef std::tuple<int32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidChangeSelectedIndexForActivePopupMenu"); }
    static const bool isSync = false;

    explicit DidChangeSelectedIndexForActivePopupMenu(int32_t newIndex)
        : m_arguments(newIndex)
    {
    }

    const std::tuple<int32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<int32_t> m_arguments;
};

class SetTextForActivePopupMenu {
public:
    typedef std::tuple<int32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetTextForActivePopupMenu"); }
    static const bool isSync = false;

    explicit SetTextForActivePopupMenu(int32_t index)
        : m_arguments(index)
    {
    }

    const std::tuple<int32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<int32_t> m_arguments;
};

#if PLATFORM(GTK)
class FailedToShowPopupMenu {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("FailedToShowPopupMenu"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if ENABLE(CONTEXT_MENUS)
class DidSelectItemFromActiveContextMenu {
public:
    typedef std::tuple<WebKit::WebContextMenuItemData> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidSelectItemFromActiveContextMenu"); }
    static const bool isSync = false;

    explicit DidSelectItemFromActiveContextMenu(const WebKit::WebContextMenuItemData& menuItem)
        : m_arguments(menuItem)
    {
    }

    const std::tuple<const WebKit::WebContextMenuItemData&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebContextMenuItemData&> m_arguments;
};
#endif

class DidChooseFilesForOpenPanel {
public:
    typedef std::tuple<Vector<String>> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidChooseFilesForOpenPanel"); }
    static const bool isSync = false;

    explicit DidChooseFilesForOpenPanel(const Vector<String>& fileURLs)
        : m_arguments(fileURLs)
    {
    }

    const std::tuple<const Vector<String>&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const Vector<String>&> m_arguments;
};

class DidCancelForOpenPanel {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidCancelForOpenPanel"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

#if ENABLE(WEB_PROCESS_SANDBOX)
class ExtendSandboxForFileFromOpenPanel {
public:
    typedef std::tuple<WebKit::SandboxExtension::Handle> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ExtendSandboxForFileFromOpenPanel"); }
    static const bool isSync = false;

    explicit ExtendSandboxForFileFromOpenPanel(const WebKit::SandboxExtension::Handle& sandboxExtensionHandle)
        : m_arguments(sandboxExtensionHandle)
    {
    }

    const std::tuple<const WebKit::SandboxExtension::Handle&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::SandboxExtension::Handle&> m_arguments;
};
#endif

class AdvanceToNextMisspelling {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("AdvanceToNextMisspelling"); }
    static const bool isSync = false;

    explicit AdvanceToNextMisspelling(bool startBeforeSelection)
        : m_arguments(startBeforeSelection)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class ChangeSpellingToWord {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ChangeSpellingToWord"); }
    static const bool isSync = false;

    explicit ChangeSpellingToWord(const String& word)
        : m_arguments(word)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};

class DidFinishCheckingText {
public:
    typedef std::tuple<uint64_t, Vector<WebCore::TextCheckingResult>> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidFinishCheckingText"); }
    static const bool isSync = false;

    DidFinishCheckingText(uint64_t requestID, const Vector<WebCore::TextCheckingResult>& result)
        : m_arguments(requestID, result)
    {
    }

    const std::tuple<uint64_t, const Vector<WebCore::TextCheckingResult>&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const Vector<WebCore::TextCheckingResult>&> m_arguments;
};

class DidCancelCheckingText {
public:
    typedef std::tuple<uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidCancelCheckingText"); }
    static const bool isSync = false;

    explicit DidCancelCheckingText(uint64_t requestID)
        : m_arguments(requestID)
    {
    }

    const std::tuple<uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t> m_arguments;
};

#if USE(APPKIT)
class UppercaseWord {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("UppercaseWord"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if USE(APPKIT)
class LowercaseWord {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("LowercaseWord"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if USE(APPKIT)
class CapitalizeWord {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("CapitalizeWord"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(MAC)
class SetSmartInsertDeleteEnabled {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetSmartInsertDeleteEnabled"); }
    static const bool isSync = false;

    explicit SetSmartInsertDeleteEnabled(bool isSmartInsertDeleteEnabled)
        : m_arguments(isSmartInsertDeleteEnabled)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};
#endif

#if ENABLE(GEOLOCATION)
class DidReceiveGeolocationPermissionDecision {
public:
    typedef std::tuple<uint64_t, bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidReceiveGeolocationPermissionDecision"); }
    static const bool isSync = false;

    DidReceiveGeolocationPermissionDecision(uint64_t geolocationID, bool allowed)
        : m_arguments(geolocationID, allowed)
    {
    }

    const std::tuple<uint64_t, bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, bool> m_arguments;
};
#endif

class DidReceiveNotificationPermissionDecision {
public:
    typedef std::tuple<uint64_t, bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidReceiveNotificationPermissionDecision"); }
    static const bool isSync = false;

    DidReceiveNotificationPermissionDecision(uint64_t notificationID, bool allowed)
        : m_arguments(notificationID, allowed)
    {
    }

    const std::tuple<uint64_t, bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, bool> m_arguments;
};

class SetWindowResizerSize {
public:
    typedef std::tuple<WebCore::IntSize> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetWindowResizerSize"); }
    static const bool isSync = false;

    explicit SetWindowResizerSize(const WebCore::IntSize& intersectsView)
        : m_arguments(intersectsView)
    {
    }

    const std::tuple<const WebCore::IntSize&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntSize&> m_arguments;
};

class BeginPrinting {
public:
    typedef std::tuple<uint64_t, WebKit::PrintInfo> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("BeginPrinting"); }
    static const bool isSync = false;

    BeginPrinting(uint64_t frameID, const WebKit::PrintInfo& printInfo)
        : m_arguments(frameID, printInfo)
    {
    }

    const std::tuple<uint64_t, const WebKit::PrintInfo&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const WebKit::PrintInfo&> m_arguments;
};

class EndPrinting {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("EndPrinting"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class ComputePagesForPrinting {
public:
    typedef std::tuple<uint64_t, WebKit::PrintInfo, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ComputePagesForPrinting"); }
    static const bool isSync = false;

    ComputePagesForPrinting(uint64_t frameID, const WebKit::PrintInfo& printInfo, uint64_t callbackID)
        : m_arguments(frameID, printInfo, callbackID)
    {
    }

    const std::tuple<uint64_t, const WebKit::PrintInfo&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const WebKit::PrintInfo&, uint64_t> m_arguments;
};

#if PLATFORM(MAC)
class DrawRectToImage {
public:
    typedef std::tuple<uint64_t, WebKit::PrintInfo, WebCore::IntRect, WebCore::IntSize, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DrawRectToImage"); }
    static const bool isSync = false;

    DrawRectToImage(uint64_t frameID, const WebKit::PrintInfo& printInfo, const WebCore::IntRect& rect, const WebCore::IntSize& imageSize, uint64_t callbackID)
        : m_arguments(frameID, printInfo, rect, imageSize, callbackID)
    {
    }

    const std::tuple<uint64_t, const WebKit::PrintInfo&, const WebCore::IntRect&, const WebCore::IntSize&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const WebKit::PrintInfo&, const WebCore::IntRect&, const WebCore::IntSize&, uint64_t> m_arguments;
};
#endif

#if PLATFORM(MAC)
class DrawPagesToPDF {
public:
    typedef std::tuple<uint64_t, WebKit::PrintInfo, uint32_t, uint32_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DrawPagesToPDF"); }
    static const bool isSync = false;

    DrawPagesToPDF(uint64_t frameID, const WebKit::PrintInfo& printInfo, uint32_t first, uint32_t count, uint64_t callbackID)
        : m_arguments(frameID, printInfo, first, count, callbackID)
    {
    }

    const std::tuple<uint64_t, const WebKit::PrintInfo&, uint32_t, uint32_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const WebKit::PrintInfo&, uint32_t, uint32_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(GTK)
class DrawPagesForPrinting {
public:
    typedef std::tuple<uint64_t, WebKit::PrintInfo, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DrawPagesForPrinting"); }
    static const bool isSync = false;

    DrawPagesForPrinting(uint64_t frameID, const WebKit::PrintInfo& printInfo, uint64_t callbackID)
        : m_arguments(frameID, printInfo, callbackID)
    {
    }

    const std::tuple<uint64_t, const WebKit::PrintInfo&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const WebKit::PrintInfo&, uint64_t> m_arguments;
};
#endif

class SetMediaVolume {
public:
    typedef std::tuple<float> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetMediaVolume"); }
    static const bool isSync = false;

    explicit SetMediaVolume(float volume)
        : m_arguments(volume)
    {
    }

    const std::tuple<float> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<float> m_arguments;
};

class SetMayStartMediaWhenInWindow {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetMayStartMediaWhenInWindow"); }
    static const bool isSync = false;

    explicit SetMayStartMediaWhenInWindow(bool mayStartMedia)
        : m_arguments(mayStartMedia)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetMemoryCacheMessagesEnabled {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetMemoryCacheMessagesEnabled"); }
    static const bool isSync = false;

    explicit SetMemoryCacheMessagesEnabled(bool memoryCacheMessagesEnabled)
        : m_arguments(memoryCacheMessagesEnabled)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class Dummy {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("Dummy"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<bool&> Reply;
    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

class SetCanRunBeforeUnloadConfirmPanel {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetCanRunBeforeUnloadConfirmPanel"); }
    static const bool isSync = false;

    explicit SetCanRunBeforeUnloadConfirmPanel(bool canRunBeforeUnloadConfirmPanel)
        : m_arguments(canRunBeforeUnloadConfirmPanel)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetCanRunModal {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetCanRunModal"); }
    static const bool isSync = false;

    explicit SetCanRunModal(bool canRunModal)
        : m_arguments(canRunModal)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

#if PLATFORM(EFL)
class SetThemePath {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetThemePath"); }
    static const bool isSync = false;

    explicit SetThemePath(const String& themePath)
        : m_arguments(themePath)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};
#endif

#if USE(TILED_BACKING_STORE)
class CommitPageTransitionViewport {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("CommitPageTransitionViewport"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(GTK)
class SetComposition {
public:
    typedef std::tuple<String, Vector<WebCore::CompositionUnderline>, uint64_t, uint64_t, uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetComposition"); }
    static const bool isSync = false;

    SetComposition(const String& text, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t selectionStart, uint64_t selectionEnd, uint64_t replacementRangeStart, uint64_t replacementRangeEnd)
        : m_arguments(text, underlines, selectionStart, selectionEnd, replacementRangeStart, replacementRangeEnd)
    {
    }

    const std::tuple<const String&, const Vector<WebCore::CompositionUnderline>&, uint64_t, uint64_t, uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const Vector<WebCore::CompositionUnderline>&, uint64_t, uint64_t, uint64_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(GTK)
class ConfirmComposition {
public:
    typedef std::tuple<String, int64_t, int64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ConfirmComposition"); }
    static const bool isSync = false;

    ConfirmComposition(const String& text, int64_t selectionStart, int64_t selectionLength)
        : m_arguments(text, selectionStart, selectionLength)
    {
    }

    const std::tuple<const String&, int64_t, int64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, int64_t, int64_t> m_arguments;
};
#endif

#if PLATFORM(GTK)
class CancelComposition {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("CancelComposition"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(MAC)
class SendComplexTextInputToPlugin {
public:
    typedef std::tuple<uint64_t, String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SendComplexTextInputToPlugin"); }
    static const bool isSync = false;

    SendComplexTextInputToPlugin(uint64_t pluginComplexTextInputIdentifier, const String& textInput)
        : m_arguments(pluginComplexTextInputIdentifier, textInput)
    {
    }

    const std::tuple<uint64_t, const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, const String&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class WindowAndViewFramesChanged {
public:
    typedef std::tuple<WebCore::FloatRect, WebCore::FloatRect, WebCore::FloatRect, WebCore::FloatPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("WindowAndViewFramesChanged"); }
    static const bool isSync = false;

    WindowAndViewFramesChanged(const WebCore::FloatRect& windowFrameInScreenCoordinates, const WebCore::FloatRect& windowFrameInUnflippedScreenCoordinates, const WebCore::FloatRect& viewFrameInWindowCoordinates, const WebCore::FloatPoint& accessibilityViewCoordinates)
        : m_arguments(windowFrameInScreenCoordinates, windowFrameInUnflippedScreenCoordinates, viewFrameInWindowCoordinates, accessibilityViewCoordinates)
    {
    }

    const std::tuple<const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::FloatPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::FloatPoint&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class SetMainFrameIsScrollable {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetMainFrameIsScrollable"); }
    static const bool isSync = false;

    explicit SetMainFrameIsScrollable(bool isScrollable)
        : m_arguments(isScrollable)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};
#endif

#if PLATFORM(MAC)
class RegisterUIProcessAccessibilityTokens {
public:
    typedef std::tuple<IPC::DataReference, IPC::DataReference> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("RegisterUIProcessAccessibilityTokens"); }
    static const bool isSync = false;

    RegisterUIProcessAccessibilityTokens(const IPC::DataReference& elemenToken, const IPC::DataReference& windowToken)
        : m_arguments(elemenToken, windowToken)
    {
    }

    const std::tuple<const IPC::DataReference&, const IPC::DataReference&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const IPC::DataReference&, const IPC::DataReference&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class GetStringSelectionForPasteboard {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetStringSelectionForPasteboard"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<String&> Reply;
    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(MAC)
class GetDataSelectionForPasteboard {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetDataSelectionForPasteboard"); }
    static const bool isSync = true;

    typedef IPC::Arguments2<WebKit::SharedMemory::Handle&, uint64_t&> Reply;
    explicit GetDataSelectionForPasteboard(const String& pasteboardType)
        : m_arguments(pasteboardType)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class ReadSelectionFromPasteboard {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ReadSelectionFromPasteboard"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<bool&> Reply;
    explicit ReadSelectionFromPasteboard(const String& pasteboardName)
        : m_arguments(pasteboardName)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class CancelComposition {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("CancelComposition"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<WebKit::EditorState&> Reply;
    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(MAC)
class GetMarkedRange {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetMarkedRange"); }
    static const bool isSync = true;

    typedef IPC::Arguments2<uint64_t&, uint64_t&> Reply;
    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(MAC)
class GetSelectedRange {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetSelectedRange"); }
    static const bool isSync = true;

    typedef IPC::Arguments2<uint64_t&, uint64_t&> Reply;
    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if PLATFORM(MAC)
class GetAttributedSubstringFromRange {
public:
    typedef std::tuple<uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("GetAttributedSubstringFromRange"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<WebKit::AttributedString&> Reply;
    GetAttributedSubstringFromRange(uint64_t location, uint64_t length)
        : m_arguments(location, length)
    {
    }

    const std::tuple<uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(MAC)
class CharacterIndexForPoint {
public:
    typedef std::tuple<WebCore::IntPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("CharacterIndexForPoint"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<uint64_t&> Reply;
    explicit CharacterIndexForPoint(const WebCore::IntPoint& point)
        : m_arguments(point)
    {
    }

    const std::tuple<const WebCore::IntPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class FirstRectForCharacterRange {
public:
    typedef std::tuple<uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("FirstRectForCharacterRange"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<WebCore::IntRect&> Reply;
    FirstRectForCharacterRange(uint64_t location, uint64_t length)
        : m_arguments(location, length)
    {
    }

    const std::tuple<uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint64_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(MAC)
class ExecuteKeypressCommands {
public:
    typedef std::tuple<Vector<WebCore::KeypressCommand>> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ExecuteKeypressCommands"); }
    static const bool isSync = true;

    typedef IPC::Arguments2<bool&, WebKit::EditorState&> Reply;
    explicit ExecuteKeypressCommands(const Vector<WebCore::KeypressCommand>& savedCommands)
        : m_arguments(savedCommands)
    {
    }

    const std::tuple<const Vector<WebCore::KeypressCommand>&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const Vector<WebCore::KeypressCommand>&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class ShouldDelayWindowOrderingEvent {
public:
    typedef std::tuple<WebKit::WebMouseEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ShouldDelayWindowOrderingEvent"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<bool&> Reply;
    explicit ShouldDelayWindowOrderingEvent(const WebKit::WebMouseEvent& event)
        : m_arguments(event)
    {
    }

    const std::tuple<const WebKit::WebMouseEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebKit::WebMouseEvent&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class AcceptsFirstMouse {
public:
    typedef std::tuple<int, WebKit::WebMouseEvent> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("AcceptsFirstMouse"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<bool&> Reply;
    AcceptsFirstMouse(const int& eventNumber, const WebKit::WebMouseEvent& event)
        : m_arguments(eventNumber, event)
    {
    }

    const std::tuple<const int&, const WebKit::WebMouseEvent&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const int&, const WebKit::WebMouseEvent&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class InsertDictatedText {
public:
    typedef std::tuple<String, uint64_t, uint64_t, Vector<WebCore::DictationAlternative>> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("InsertDictatedText"); }
    static const bool isSync = true;

    typedef IPC::Arguments2<bool&, WebKit::EditorState&> Reply;
    InsertDictatedText(const String& text, uint64_t replacementRangeStart, uint64_t replacementRangeEnd, const Vector<WebCore::DictationAlternative>& dictationAlternatives)
        : m_arguments(text, replacementRangeStart, replacementRangeEnd, dictationAlternatives)
    {
    }

    const std::tuple<const String&, uint64_t, uint64_t, const Vector<WebCore::DictationAlternative>&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint64_t, uint64_t, const Vector<WebCore::DictationAlternative>&> m_arguments;
};
#endif

#if PLATFORM(MAC) && !PLATFORM(IOS)
class InsertText {
public:
    typedef std::tuple<String, uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("InsertText"); }
    static const bool isSync = true;

    typedef IPC::Arguments2<bool&, WebKit::EditorState&> Reply;
    InsertText(const String& text, uint64_t replacementRangeStart, uint64_t replacementRangeEnd)
        : m_arguments(text, replacementRangeStart, replacementRangeEnd)
    {
    }

    const std::tuple<const String&, uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, uint64_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(MAC) && !PLATFORM(IOS)
class SetComposition {
public:
    typedef std::tuple<String, Vector<WebCore::CompositionUnderline>, uint64_t, uint64_t, uint64_t, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetComposition"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<WebKit::EditorState&> Reply;
    SetComposition(const String& text, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t selectionStart, uint64_t selectionEnd, uint64_t replacementRangeStart, uint64_t replacementRangeEnd)
        : m_arguments(text, underlines, selectionStart, selectionEnd, replacementRangeStart, replacementRangeEnd)
    {
    }

    const std::tuple<const String&, const Vector<WebCore::CompositionUnderline>&, uint64_t, uint64_t, uint64_t, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const Vector<WebCore::CompositionUnderline>&, uint64_t, uint64_t, uint64_t, uint64_t> m_arguments;
};
#endif

#if PLATFORM(MAC) && !PLATFORM(IOS)
class ConfirmComposition {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ConfirmComposition"); }
    static const bool isSync = true;

    typedef IPC::Arguments1<WebKit::EditorState&> Reply;
    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

class SetMinimumLayoutSize {
public:
    typedef std::tuple<WebCore::IntSize> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetMinimumLayoutSize"); }
    static const bool isSync = false;

    explicit SetMinimumLayoutSize(const WebCore::IntSize& minimumLayoutSize)
        : m_arguments(minimumLayoutSize)
    {
    }

    const std::tuple<const WebCore::IntSize&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntSize&> m_arguments;
};

class SetAutoSizingShouldExpandToViewHeight {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetAutoSizingShouldExpandToViewHeight"); }
    static const bool isSync = false;

    explicit SetAutoSizingShouldExpandToViewHeight(bool shouldExpand)
        : m_arguments(shouldExpand)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

#if PLATFORM(EFL)
class ConfirmComposition {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("ConfirmComposition"); }
    static const bool isSync = false;

    explicit ConfirmComposition(const String& compositionString)
        : m_arguments(compositionString)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};
#endif

#if PLATFORM(EFL)
class SetComposition {
public:
    typedef std::tuple<String, Vector<WebCore::CompositionUnderline>, uint64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetComposition"); }
    static const bool isSync = false;

    SetComposition(const String& compositionString, const Vector<WebCore::CompositionUnderline>& underlines, uint64_t cursorPosition)
        : m_arguments(compositionString, underlines, cursorPosition)
    {
    }

    const std::tuple<const String&, const Vector<WebCore::CompositionUnderline>&, uint64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&, const Vector<WebCore::CompositionUnderline>&, uint64_t> m_arguments;
};
#endif

#if PLATFORM(EFL)
class CancelComposition {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("CancelComposition"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};
#endif

#if USE(COORDINATED_GRAPHICS)
class FindZoomableAreaForPoint {
public:
    typedef std::tuple<WebCore::IntPoint, WebCore::IntSize> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("FindZoomableAreaForPoint"); }
    static const bool isSync = false;

    FindZoomableAreaForPoint(const WebCore::IntPoint& point, const WebCore::IntSize& area)
        : m_arguments(point, area)
    {
    }

    const std::tuple<const WebCore::IntPoint&, const WebCore::IntSize&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::IntPoint&, const WebCore::IntSize&> m_arguments;
};
#endif

#if PLATFORM(MAC)
class HandleAlternativeTextUIResult {
public:
    typedef std::tuple<String> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("HandleAlternativeTextUIResult"); }
    static const bool isSync = false;

    explicit HandleAlternativeTextUIResult(const String& result)
        : m_arguments(result)
    {
    }

    const std::tuple<const String&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const String&> m_arguments;
};
#endif

class SetVisibilityStatePrerender {
public:
    typedef std::tuple<> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetVisibilityStatePrerender"); }
    static const bool isSync = false;

    const std::tuple<> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<> m_arguments;
};

#if PLATFORM(IOS)
class DidFinishScrolling {
public:
    typedef std::tuple<WebCore::FloatPoint> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidFinishScrolling"); }
    static const bool isSync = false;

    explicit DidFinishScrolling(const WebCore::FloatPoint& contentOffset)
        : m_arguments(contentOffset)
    {
    }

    const std::tuple<const WebCore::FloatPoint&> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<const WebCore::FloatPoint&> m_arguments;
};
#endif

#if PLATFORM(IOS)
class DidFinishZooming {
public:
    typedef std::tuple<float> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("DidFinishZooming"); }
    static const bool isSync = false;

    explicit DidFinishZooming(float scale)
        : m_arguments(scale)
    {
    }

    const std::tuple<float> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<float> m_arguments;
};
#endif

#if PLATFORM(GTK) && USE(TEXTURE_MAPPER_GL)
class SetAcceleratedCompositingWindowId {
public:
    typedef std::tuple<int64_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetAcceleratedCompositingWindowId"); }
    static const bool isSync = false;

    explicit SetAcceleratedCompositingWindowId(int64_t id)
        : m_arguments(id)
    {
    }

    const std::tuple<int64_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<int64_t> m_arguments;
};
#endif

class SetMainFrameInViewSourceMode {
public:
    typedef std::tuple<bool> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetMainFrameInViewSourceMode"); }
    static const bool isSync = false;

    explicit SetMainFrameInViewSourceMode(bool inViewSourceMode)
        : m_arguments(inViewSourceMode)
    {
    }

    const std::tuple<bool> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<bool> m_arguments;
};

class SetScrollPinningBehavior {
public:
    typedef std::tuple<uint32_t> DecodeType;

    static IPC::StringReference receiverName() { return messageReceiverName(); }
    static IPC::StringReference name() { return IPC::StringReference("SetScrollPinningBehavior"); }
    static const bool isSync = false;

    explicit SetScrollPinningBehavior(uint32_t pinning)
        : m_arguments(pinning)
    {
    }

    const std::tuple<uint32_t> arguments() const
    {
        return m_arguments;
    }

private:
    std::tuple<uint32_t> m_arguments;
};

} // namespace WebPage
} // namespace Messages

#endif // WebPageMessages_h
