#pragma once

#include <LibCore/SharedVersion.h>
#include <LibGfx/Rect.h>
#include <LibHTTP/Cookie/Cookie.h>
#include <LibIPC/File.h>
#include <LibIPC/TransportHandle.h>
#include <LibURL/URL.h>
#include <LibWeb/Clipboard/SystemClipboard.h>
#include <LibWeb/CSS/PreferredColorScheme.h>
#include <LibWeb/CSS/PreferredContrast.h>
#include <LibWeb/CSS/PreferredMotion.h>
#include <LibWeb/CSS/Selector.h>
#include <LibWeb/CSS/StyleSheetIdentifier.h>
#include <LibWeb/HTML/ColorPickerUpdateState.h>
#include <LibWeb/HTML/BroadcastChannelMessage.h>
#include <LibWeb/HTML/SelectedFile.h>
#include <LibWeb/HTML/VisibilityState.h>
#include <LibWeb/Page/InputEvent.h>
#include <LibWeb/Page/ViewportIsFullscreen.h>
#include <LibWeb/WebDriver/ExecuteScript.h>
#include <LibWebView/Attribute.h>
#include <LibWebView/DOMNodeProperties.h>
#include <LibWebView/PageInfo.h>
#include <LibWebView/Settings.h>
#include <AK/Error.h>
#include <AK/MemoryStream.h>
#include <AK/OwnPtr.h>
#include <AK/Platform.h>
#include <AK/Result.h>
#include <AK/Utf8View.h>
#include <LibIPC/Attachment.h>
#include <LibIPC/Connection.h>
#include <LibIPC/Decoder.h>
#include <LibIPC/Encoder.h>
#include <LibIPC/File.h>
#include <LibIPC/Message.h>
#include <LibIPC/Stub.h>

#if defined(AK_COMPILER_CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#endif

namespace Messages::WebContentServer {

enum class MessageID : i32 {
    InitTransport = 1,
    InitTransportResponse = 2,
    CloseServer = 3,
    GetWindowHandle = 4,
    GetWindowHandleResponse = 5,
    SetWindowHandle = 6,
    ConnectToWebdriver = 7,
    ConnectToWebUi = 8,
    ConnectToRequestServer = 9,
    ConnectToImageDecoder = 10,
    ConnectToCompositor = 11,
    UpdateSystemTheme = 12,
    UpdateScreenRects = 13,
    LoadUrl = 14,
    LoadHtml = 15,
    Reload = 16,
    TraverseTheHistoryByDelta = 17,
    SetViewport = 18,
    KeyEvent = 19,
    MouseEvent = 20,
    DragEvent = 21,
    PinchEvent = 22,
    DebugRequest = 23,
    GetSource = 24,
    InspectDomTree = 25,
    InspectDomNode = 26,
    ClearInspectedDomNode = 27,
    HighlightDomNode = 28,
    InspectAccessibilityTree = 29,
    GetHoveredNodeId = 30,
    JsConsoleInput = 31,
    RunJavascript = 32,
    ListStyleSheets = 33,
    RequestStyleSheetSource = 34,
    SetListenForDomMutations = 35,
    DidConnectDevtoolsClient = 36,
    DidDisconnectDevtoolsClient = 37,
    GetDomNodeInnerHtml = 38,
    GetDomNodeOuterHtml = 39,
    SetDomNodeOuterHtml = 40,
    SetDomNodeText = 41,
    SetDomNodeTag = 42,
    AddDomNodeAttributes = 43,
    ReplaceDomNodeAttribute = 44,
    CreateChildElement = 45,
    CreateChildTextNode = 46,
    InsertDomNodeBefore = 47,
    CloneDomNode = 48,
    RemoveDomNode = 49,
    TakeDocumentScreenshot = 50,
    TakeDomNodeScreenshot = 51,
    RequestInternalPageInfo = 52,
    GetSelectedText = 53,
    GetSelectedTextResponse = 54,
    CutSelectedText = 55,
    CutSelectedTextResponse = 56,
    SelectAll = 57,
    Paste = 58,
    FindInPage = 59,
    FindInPageNextMatch = 60,
    FindInPagePreviousMatch = 61,
    SetContentFilters = 62,
    SetAutoplayAllowedOnAllWebsites = 63,
    SetAutoplayAllowlist = 64,
    SetProxyMappings = 65,
    SetPreferredColorScheme = 66,
    SetPreferredContrast = 67,
    SetPreferredMotion = 68,
    SetPreferredLanguages = 69,
    SetBrowsingBehavior = 70,
    SetEnableGlobalPrivacyControl = 71,
    SetHasFocus = 72,
    SetIsScriptingEnabled = 73,
    SetZoomLevel = 74,
    SetMaximumFramesPerSecond = 75,
    SetWindowPosition = 76,
    SetWindowSize = 77,
    DidUpdateWindowRect = 78,
    ResetZoom = 79,
    HandleFileReturn = 80,
    SetSystemVisibilityState = 81,
    AlertClosed = 82,
    ConfirmClosed = 83,
    PromptClosed = 84,
    ColorPickerUpdate = 85,
    FilePickerClosed = 86,
    SelectDropdownClosed = 87,
    RetrievedClipboardEntries = 88,
    ToggleMediaPlayState = 89,
    ToggleMediaMuteState = 90,
    ToggleMediaLoopState = 91,
    ToggleMediaFullscreenState = 92,
    ToggleMediaControlsState = 93,
    TogglePageMuteState = 94,
    SetUserStyle = 95,
    SystemTimeZoneChanged = 96,
    SetDocumentCookieVersionBuffer = 97,
    SetDocumentCookieVersionIndex = 98,
    CookiesChanged = 99,
    BroadcastChannelMessage = 100,
    RequestClose = 101,
    ExitFullscreen = 102,
};

class InitTransportResponse final : public IPC::Message {
public:
    InitTransportResponse(int peer_pid)
        : m_peer_pid(move(peer_pid))
    {
    }

    InitTransportResponse(InitTransportResponse const&) = default;
    InitTransportResponse(InitTransportResponse&&) = default;
    InitTransportResponse& operator=(InitTransportResponse const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, int>)
    InitTransportResponse(WrappedReturnType&& value)
        : m_peer_pid(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::InitTransportResponse; }
    static i32 static_message_id() { return (int)MessageID::InitTransportResponse; }
    virtual StringView message_name() const override { return "WebContentServer::InitTransportResponse"sv; }

    static ErrorOr<NonnullOwnPtr<InitTransportResponse>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto peer_pid = TRY((decoder.decode<int>()));
        return make<InitTransportResponse>(move(peer_pid));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(int peer_pid)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::InitTransportResponse));
        TRY(stream.encode(peer_pid));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_peer_pid);
    }

    int peer_pid() const { return m_peer_pid; }

private:
    int m_peer_pid;
};

class InitTransport final : public IPC::Message {
public:
    typedef class InitTransportResponse ResponseType;

    InitTransport(int peer_pid)
        : m_peer_pid(move(peer_pid))
    {
    }

    InitTransport(InitTransport const&) = default;
    InitTransport(InitTransport&&) = default;
    InitTransport& operator=(InitTransport const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, int>)
    InitTransport(WrappedReturnType&& value)
        : m_peer_pid(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::InitTransport; }
    static i32 static_message_id() { return (int)MessageID::InitTransport; }
    virtual StringView message_name() const override { return "WebContentServer::InitTransport"sv; }

    static ErrorOr<NonnullOwnPtr<InitTransport>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto peer_pid = TRY((decoder.decode<int>()));
        return make<InitTransport>(move(peer_pid));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(int peer_pid)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::InitTransport));
        TRY(stream.encode(peer_pid));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_peer_pid);
    }

    int peer_pid() const { return m_peer_pid; }

private:
    int m_peer_pid;
};

class CloseServer final : public IPC::Message {
public:
    CloseServer() = default;

    CloseServer(CloseServer const&) = default;
    CloseServer(CloseServer&&) = default;
    CloseServer& operator=(CloseServer const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::CloseServer; }
    static i32 static_message_id() { return (int)MessageID::CloseServer; }
    virtual StringView message_name() const override { return "WebContentServer::CloseServer"sv; }

    static ErrorOr<NonnullOwnPtr<CloseServer>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        return make<CloseServer>();
    }

    static ErrorOr<IPC::MessageBuffer> static_encode()
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::CloseServer));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode();
    }

private:
};

class GetWindowHandleResponse final : public IPC::Message {
public:
    GetWindowHandleResponse(String handle)
        : m_handle(move(handle))
    {
    }

    GetWindowHandleResponse(GetWindowHandleResponse const&) = default;
    GetWindowHandleResponse(GetWindowHandleResponse&&) = default;
    GetWindowHandleResponse& operator=(GetWindowHandleResponse const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, String>)
    GetWindowHandleResponse(WrappedReturnType&& value)
        : m_handle(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::GetWindowHandleResponse; }
    static i32 static_message_id() { return (int)MessageID::GetWindowHandleResponse; }
    virtual StringView message_name() const override { return "WebContentServer::GetWindowHandleResponse"sv; }

    static ErrorOr<NonnullOwnPtr<GetWindowHandleResponse>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto handle = TRY((decoder.decode<String>()));
        return make<GetWindowHandleResponse>(move(handle));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(StringView handle)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetWindowHandleResponse));
        TRY(stream.encode(handle));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_handle);
    }

    String const& handle() const { return m_handle; }
    String take_handle() { return move(m_handle); }

private:
    String m_handle;
};

class GetWindowHandle final : public IPC::Message {
public:
    typedef class GetWindowHandleResponse ResponseType;

    GetWindowHandle(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    GetWindowHandle(GetWindowHandle const&) = default;
    GetWindowHandle(GetWindowHandle&&) = default;
    GetWindowHandle& operator=(GetWindowHandle const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    GetWindowHandle(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::GetWindowHandle; }
    static i32 static_message_id() { return (int)MessageID::GetWindowHandle; }
    virtual StringView message_name() const override { return "WebContentServer::GetWindowHandle"sv; }

    static ErrorOr<NonnullOwnPtr<GetWindowHandle>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<GetWindowHandle>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetWindowHandle));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class SetWindowHandle final : public IPC::Message {
public:
    SetWindowHandle(u64 page_id, String handle)
        : m_page_id(move(page_id))
        , m_handle(move(handle))
    {
    }

    SetWindowHandle(SetWindowHandle const&) = default;
    SetWindowHandle(SetWindowHandle&&) = default;
    SetWindowHandle& operator=(SetWindowHandle const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetWindowHandle; }
    static i32 static_message_id() { return (int)MessageID::SetWindowHandle; }
    virtual StringView message_name() const override { return "WebContentServer::SetWindowHandle"sv; }

    static ErrorOr<NonnullOwnPtr<SetWindowHandle>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto handle = TRY((decoder.decode<String>()));
        return make<SetWindowHandle>(move(page_id), move(handle));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView handle)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetWindowHandle));
        TRY(stream.encode(page_id));
        TRY(stream.encode(handle));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_handle);
    }

    u64 page_id() const { return m_page_id; }

    String const& handle() const { return m_handle; }
    String take_handle() { return move(m_handle); }

private:
    u64 m_page_id;
    String m_handle;
};

class ConnectToWebdriver final : public IPC::Message {
public:
    ConnectToWebdriver(u64 page_id, ByteString webdriver_endpoint)
        : m_page_id(move(page_id))
        , m_webdriver_endpoint(move(webdriver_endpoint))
    {
    }

    ConnectToWebdriver(ConnectToWebdriver const&) = default;
    ConnectToWebdriver(ConnectToWebdriver&&) = default;
    ConnectToWebdriver& operator=(ConnectToWebdriver const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ConnectToWebdriver; }
    static i32 static_message_id() { return (int)MessageID::ConnectToWebdriver; }
    virtual StringView message_name() const override { return "WebContentServer::ConnectToWebdriver"sv; }

    static ErrorOr<NonnullOwnPtr<ConnectToWebdriver>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto webdriver_endpoint = TRY((decoder.decode<ByteString>()));
        return make<ConnectToWebdriver>(move(page_id), move(webdriver_endpoint));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView webdriver_endpoint)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ConnectToWebdriver));
        TRY(stream.encode(page_id));
        TRY(stream.encode(webdriver_endpoint));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_webdriver_endpoint);
    }

    u64 page_id() const { return m_page_id; }

    ByteString const& webdriver_endpoint() const { return m_webdriver_endpoint; }
    ByteString take_webdriver_endpoint() { return move(m_webdriver_endpoint); }

private:
    u64 m_page_id;
    ByteString m_webdriver_endpoint;
};

class ConnectToWebUi final : public IPC::Message {
public:
    ConnectToWebUi(u64 page_id, IPC::TransportHandle handle)
        : m_page_id(move(page_id))
        , m_handle(move(handle))
    {
    }

    ConnectToWebUi(ConnectToWebUi const&) = default;
    ConnectToWebUi(ConnectToWebUi&&) = default;
    ConnectToWebUi& operator=(ConnectToWebUi const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ConnectToWebUi; }
    static i32 static_message_id() { return (int)MessageID::ConnectToWebUi; }
    virtual StringView message_name() const override { return "WebContentServer::ConnectToWebUi"sv; }

    static ErrorOr<NonnullOwnPtr<ConnectToWebUi>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto handle = TRY((decoder.decode<IPC::TransportHandle>()));
        return make<ConnectToWebUi>(move(page_id), move(handle));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, IPC::TransportHandle const& handle)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ConnectToWebUi));
        TRY(stream.encode(page_id));
        TRY(stream.encode(handle));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_handle);
    }

    u64 page_id() const { return m_page_id; }

    IPC::TransportHandle const& handle() const { return m_handle; }
    IPC::TransportHandle take_handle() { return move(m_handle); }

private:
    u64 m_page_id;
    IPC::TransportHandle m_handle;
};

class ConnectToRequestServer final : public IPC::Message {
public:
    ConnectToRequestServer(IPC::TransportHandle handle)
        : m_handle(move(handle))
    {
    }

    ConnectToRequestServer(ConnectToRequestServer const&) = default;
    ConnectToRequestServer(ConnectToRequestServer&&) = default;
    ConnectToRequestServer& operator=(ConnectToRequestServer const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, IPC::TransportHandle>)
    ConnectToRequestServer(WrappedReturnType&& value)
        : m_handle(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ConnectToRequestServer; }
    static i32 static_message_id() { return (int)MessageID::ConnectToRequestServer; }
    virtual StringView message_name() const override { return "WebContentServer::ConnectToRequestServer"sv; }

    static ErrorOr<NonnullOwnPtr<ConnectToRequestServer>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto handle = TRY((decoder.decode<IPC::TransportHandle>()));
        return make<ConnectToRequestServer>(move(handle));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(IPC::TransportHandle const& handle)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ConnectToRequestServer));
        TRY(stream.encode(handle));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_handle);
    }

    IPC::TransportHandle const& handle() const { return m_handle; }
    IPC::TransportHandle take_handle() { return move(m_handle); }

private:
    IPC::TransportHandle m_handle;
};

class ConnectToImageDecoder final : public IPC::Message {
public:
    ConnectToImageDecoder(IPC::TransportHandle handle)
        : m_handle(move(handle))
    {
    }

    ConnectToImageDecoder(ConnectToImageDecoder const&) = default;
    ConnectToImageDecoder(ConnectToImageDecoder&&) = default;
    ConnectToImageDecoder& operator=(ConnectToImageDecoder const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, IPC::TransportHandle>)
    ConnectToImageDecoder(WrappedReturnType&& value)
        : m_handle(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ConnectToImageDecoder; }
    static i32 static_message_id() { return (int)MessageID::ConnectToImageDecoder; }
    virtual StringView message_name() const override { return "WebContentServer::ConnectToImageDecoder"sv; }

    static ErrorOr<NonnullOwnPtr<ConnectToImageDecoder>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto handle = TRY((decoder.decode<IPC::TransportHandle>()));
        return make<ConnectToImageDecoder>(move(handle));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(IPC::TransportHandle const& handle)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ConnectToImageDecoder));
        TRY(stream.encode(handle));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_handle);
    }

    IPC::TransportHandle const& handle() const { return m_handle; }
    IPC::TransportHandle take_handle() { return move(m_handle); }

private:
    IPC::TransportHandle m_handle;
};

class ConnectToCompositor final : public IPC::Message {
public:
    ConnectToCompositor(IPC::TransportHandle handle)
        : m_handle(move(handle))
    {
    }

    ConnectToCompositor(ConnectToCompositor const&) = default;
    ConnectToCompositor(ConnectToCompositor&&) = default;
    ConnectToCompositor& operator=(ConnectToCompositor const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, IPC::TransportHandle>)
    ConnectToCompositor(WrappedReturnType&& value)
        : m_handle(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ConnectToCompositor; }
    static i32 static_message_id() { return (int)MessageID::ConnectToCompositor; }
    virtual StringView message_name() const override { return "WebContentServer::ConnectToCompositor"sv; }

    static ErrorOr<NonnullOwnPtr<ConnectToCompositor>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto handle = TRY((decoder.decode<IPC::TransportHandle>()));
        return make<ConnectToCompositor>(move(handle));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(IPC::TransportHandle const& handle)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ConnectToCompositor));
        TRY(stream.encode(handle));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_handle);
    }

    IPC::TransportHandle const& handle() const { return m_handle; }
    IPC::TransportHandle take_handle() { return move(m_handle); }

private:
    IPC::TransportHandle m_handle;
};

class UpdateSystemTheme final : public IPC::Message {
public:
    UpdateSystemTheme(u64 page_id, Core::AnonymousBuffer theme_buffer)
        : m_page_id(move(page_id))
        , m_theme_buffer(move(theme_buffer))
    {
    }

    UpdateSystemTheme(UpdateSystemTheme const&) = default;
    UpdateSystemTheme(UpdateSystemTheme&&) = default;
    UpdateSystemTheme& operator=(UpdateSystemTheme const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::UpdateSystemTheme; }
    static i32 static_message_id() { return (int)MessageID::UpdateSystemTheme; }
    virtual StringView message_name() const override { return "WebContentServer::UpdateSystemTheme"sv; }

    static ErrorOr<NonnullOwnPtr<UpdateSystemTheme>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto theme_buffer = TRY((decoder.decode<Core::AnonymousBuffer>()));
        return make<UpdateSystemTheme>(move(page_id), move(theme_buffer));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Core::AnonymousBuffer const& theme_buffer)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::UpdateSystemTheme));
        TRY(stream.encode(page_id));
        TRY(stream.encode(theme_buffer));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_theme_buffer);
    }

    u64 page_id() const { return m_page_id; }

    Core::AnonymousBuffer const& theme_buffer() const { return m_theme_buffer; }
    Core::AnonymousBuffer take_theme_buffer() { return move(m_theme_buffer); }

private:
    u64 m_page_id;
    Core::AnonymousBuffer m_theme_buffer;
};

class UpdateScreenRects final : public IPC::Message {
public:
    UpdateScreenRects(u64 page_id, Vector<Web::DevicePixelRect> rects, u32 main_screen_index)
        : m_page_id(move(page_id))
        , m_rects(move(rects))
        , m_main_screen_index(move(main_screen_index))
    {
    }

    UpdateScreenRects(UpdateScreenRects const&) = default;
    UpdateScreenRects(UpdateScreenRects&&) = default;
    UpdateScreenRects& operator=(UpdateScreenRects const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::UpdateScreenRects; }
    static i32 static_message_id() { return (int)MessageID::UpdateScreenRects; }
    virtual StringView message_name() const override { return "WebContentServer::UpdateScreenRects"sv; }

    static ErrorOr<NonnullOwnPtr<UpdateScreenRects>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto rects = TRY((decoder.decode<Vector<Web::DevicePixelRect>>()));
        auto main_screen_index = TRY((decoder.decode<u32>()));
        return make<UpdateScreenRects>(move(page_id), move(rects), move(main_screen_index));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, ReadonlySpan<Web::DevicePixelRect> rects, u32 main_screen_index)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::UpdateScreenRects));
        TRY(stream.encode(page_id));
        TRY(stream.encode(rects));
        TRY(stream.encode(main_screen_index));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_rects, m_main_screen_index);
    }

    u64 page_id() const { return m_page_id; }

    Vector<Web::DevicePixelRect> const& rects() const { return m_rects; }
    Vector<Web::DevicePixelRect> take_rects() { return move(m_rects); }

    u32 main_screen_index() const { return m_main_screen_index; }

private:
    u64 m_page_id;
    Vector<Web::DevicePixelRect> m_rects;
    u32 m_main_screen_index;
};

class LoadUrl final : public IPC::Message {
public:
    LoadUrl(u64 page_id, URL::URL url)
        : m_page_id(move(page_id))
        , m_url(move(url))
    {
    }

    LoadUrl(LoadUrl const&) = default;
    LoadUrl(LoadUrl&&) = default;
    LoadUrl& operator=(LoadUrl const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::LoadUrl; }
    static i32 static_message_id() { return (int)MessageID::LoadUrl; }
    virtual StringView message_name() const override { return "WebContentServer::LoadUrl"sv; }

    static ErrorOr<NonnullOwnPtr<LoadUrl>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto url = TRY((decoder.decode<URL::URL>()));
        return make<LoadUrl>(move(page_id), move(url));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, URL::URL const& url)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::LoadUrl));
        TRY(stream.encode(page_id));
        TRY(stream.encode(url));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_url);
    }

    u64 page_id() const { return m_page_id; }

    URL::URL const& url() const { return m_url; }
    URL::URL take_url() { return move(m_url); }

private:
    u64 m_page_id;
    URL::URL m_url;
};

class LoadHtml final : public IPC::Message {
public:
    LoadHtml(u64 page_id, ByteString html)
        : m_page_id(move(page_id))
        , m_html(move(html))
    {
    }

    LoadHtml(LoadHtml const&) = default;
    LoadHtml(LoadHtml&&) = default;
    LoadHtml& operator=(LoadHtml const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::LoadHtml; }
    static i32 static_message_id() { return (int)MessageID::LoadHtml; }
    virtual StringView message_name() const override { return "WebContentServer::LoadHtml"sv; }

    static ErrorOr<NonnullOwnPtr<LoadHtml>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto html = TRY((decoder.decode<ByteString>()));
        return make<LoadHtml>(move(page_id), move(html));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView html)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::LoadHtml));
        TRY(stream.encode(page_id));
        TRY(stream.encode(html));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_html);
    }

    u64 page_id() const { return m_page_id; }

    ByteString const& html() const { return m_html; }
    ByteString take_html() { return move(m_html); }

private:
    u64 m_page_id;
    ByteString m_html;
};

class Reload final : public IPC::Message {
public:
    Reload(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    Reload(Reload const&) = default;
    Reload(Reload&&) = default;
    Reload& operator=(Reload const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    Reload(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::Reload; }
    static i32 static_message_id() { return (int)MessageID::Reload; }
    virtual StringView message_name() const override { return "WebContentServer::Reload"sv; }

    static ErrorOr<NonnullOwnPtr<Reload>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<Reload>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::Reload));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class TraverseTheHistoryByDelta final : public IPC::Message {
public:
    TraverseTheHistoryByDelta(u64 page_id, i32 delta)
        : m_page_id(move(page_id))
        , m_delta(move(delta))
    {
    }

    TraverseTheHistoryByDelta(TraverseTheHistoryByDelta const&) = default;
    TraverseTheHistoryByDelta(TraverseTheHistoryByDelta&&) = default;
    TraverseTheHistoryByDelta& operator=(TraverseTheHistoryByDelta const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::TraverseTheHistoryByDelta; }
    static i32 static_message_id() { return (int)MessageID::TraverseTheHistoryByDelta; }
    virtual StringView message_name() const override { return "WebContentServer::TraverseTheHistoryByDelta"sv; }

    static ErrorOr<NonnullOwnPtr<TraverseTheHistoryByDelta>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto delta = TRY((decoder.decode<i32>()));
        return make<TraverseTheHistoryByDelta>(move(page_id), move(delta));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, i32 delta)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::TraverseTheHistoryByDelta));
        TRY(stream.encode(page_id));
        TRY(stream.encode(delta));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_delta);
    }

    u64 page_id() const { return m_page_id; }

    i32 delta() const { return m_delta; }

private:
    u64 m_page_id;
    i32 m_delta;
};

class SetViewport final : public IPC::Message {
public:
    SetViewport(u64 page_id, Web::DevicePixelSize size, double device_pixel_ratio, Web::ViewportIsFullscreen is_fullscreen)
        : m_page_id(move(page_id))
        , m_size(move(size))
        , m_device_pixel_ratio(move(device_pixel_ratio))
        , m_is_fullscreen(move(is_fullscreen))
    {
    }

    SetViewport(SetViewport const&) = default;
    SetViewport(SetViewport&&) = default;
    SetViewport& operator=(SetViewport const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetViewport; }
    static i32 static_message_id() { return (int)MessageID::SetViewport; }
    virtual StringView message_name() const override { return "WebContentServer::SetViewport"sv; }

    static ErrorOr<NonnullOwnPtr<SetViewport>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto size = TRY((decoder.decode<Web::DevicePixelSize>()));
        auto device_pixel_ratio = TRY((decoder.decode<double>()));
        auto is_fullscreen = TRY((decoder.decode<Web::ViewportIsFullscreen>()));
        return make<SetViewport>(move(page_id), move(size), move(device_pixel_ratio), move(is_fullscreen));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::DevicePixelSize size, double device_pixel_ratio, Web::ViewportIsFullscreen const& is_fullscreen)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetViewport));
        TRY(stream.encode(page_id));
        TRY(stream.encode(size));
        TRY(stream.encode(device_pixel_ratio));
        TRY(stream.encode(is_fullscreen));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_size, m_device_pixel_ratio, m_is_fullscreen);
    }

    u64 page_id() const { return m_page_id; }

    Web::DevicePixelSize size() const { return m_size; }

    double device_pixel_ratio() const { return m_device_pixel_ratio; }

    Web::ViewportIsFullscreen const& is_fullscreen() const { return m_is_fullscreen; }
    Web::ViewportIsFullscreen take_is_fullscreen() { return move(m_is_fullscreen); }

private:
    u64 m_page_id;
    Web::DevicePixelSize m_size;
    double m_device_pixel_ratio;
    Web::ViewportIsFullscreen m_is_fullscreen;
};

class KeyEvent final : public IPC::Message {
public:
    KeyEvent(u64 page_id, Web::KeyEvent event)
        : m_page_id(move(page_id))
        , m_event(move(event))
    {
    }

    KeyEvent(KeyEvent const&) = default;
    KeyEvent(KeyEvent&&) = default;
    KeyEvent& operator=(KeyEvent const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::KeyEvent; }
    static i32 static_message_id() { return (int)MessageID::KeyEvent; }
    virtual StringView message_name() const override { return "WebContentServer::KeyEvent"sv; }

    static ErrorOr<NonnullOwnPtr<KeyEvent>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto event = TRY((decoder.decode<Web::KeyEvent>()));
        return make<KeyEvent>(move(page_id), move(event));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::KeyEvent const& event)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::KeyEvent));
        TRY(stream.encode(page_id));
        TRY(stream.encode(event));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_event);
    }

    u64 page_id() const { return m_page_id; }

    Web::KeyEvent const& event() const { return m_event; }
    Web::KeyEvent take_event() { return move(m_event); }

private:
    u64 m_page_id;
    Web::KeyEvent m_event;
};

class MouseEvent final : public IPC::Message {
public:
    MouseEvent(u64 page_id, Web::MouseEvent event)
        : m_page_id(move(page_id))
        , m_event(move(event))
    {
    }

    MouseEvent(MouseEvent const&) = default;
    MouseEvent(MouseEvent&&) = default;
    MouseEvent& operator=(MouseEvent const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::MouseEvent; }
    static i32 static_message_id() { return (int)MessageID::MouseEvent; }
    virtual StringView message_name() const override { return "WebContentServer::MouseEvent"sv; }

    static ErrorOr<NonnullOwnPtr<MouseEvent>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto event = TRY((decoder.decode<Web::MouseEvent>()));
        return make<MouseEvent>(move(page_id), move(event));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::MouseEvent const& event)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::MouseEvent));
        TRY(stream.encode(page_id));
        TRY(stream.encode(event));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_event);
    }

    u64 page_id() const { return m_page_id; }

    Web::MouseEvent const& event() const { return m_event; }
    Web::MouseEvent take_event() { return move(m_event); }

private:
    u64 m_page_id;
    Web::MouseEvent m_event;
};

class DragEvent final : public IPC::Message {
public:
    DragEvent(u64 page_id, Web::DragEvent event)
        : m_page_id(move(page_id))
        , m_event(move(event))
    {
    }

    DragEvent(DragEvent const&) = default;
    DragEvent(DragEvent&&) = default;
    DragEvent& operator=(DragEvent const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::DragEvent; }
    static i32 static_message_id() { return (int)MessageID::DragEvent; }
    virtual StringView message_name() const override { return "WebContentServer::DragEvent"sv; }

    static ErrorOr<NonnullOwnPtr<DragEvent>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto event = TRY((decoder.decode<Web::DragEvent>()));
        return make<DragEvent>(move(page_id), move(event));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::DragEvent const& event)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DragEvent));
        TRY(stream.encode(page_id));
        TRY(stream.encode(event));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_event);
    }

    u64 page_id() const { return m_page_id; }

    Web::DragEvent const& event() const { return m_event; }
    Web::DragEvent take_event() { return move(m_event); }

private:
    u64 m_page_id;
    Web::DragEvent m_event;
};

class PinchEvent final : public IPC::Message {
public:
    PinchEvent(u64 page_id, Web::PinchEvent event)
        : m_page_id(move(page_id))
        , m_event(move(event))
    {
    }

    PinchEvent(PinchEvent const&) = default;
    PinchEvent(PinchEvent&&) = default;
    PinchEvent& operator=(PinchEvent const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::PinchEvent; }
    static i32 static_message_id() { return (int)MessageID::PinchEvent; }
    virtual StringView message_name() const override { return "WebContentServer::PinchEvent"sv; }

    static ErrorOr<NonnullOwnPtr<PinchEvent>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto event = TRY((decoder.decode<Web::PinchEvent>()));
        return make<PinchEvent>(move(page_id), move(event));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::PinchEvent const& event)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::PinchEvent));
        TRY(stream.encode(page_id));
        TRY(stream.encode(event));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_event);
    }

    u64 page_id() const { return m_page_id; }

    Web::PinchEvent const& event() const { return m_event; }
    Web::PinchEvent take_event() { return move(m_event); }

private:
    u64 m_page_id;
    Web::PinchEvent m_event;
};

class DebugRequest final : public IPC::Message {
public:
    DebugRequest(u64 page_id, ByteString request, ByteString argument)
        : m_page_id(move(page_id))
        , m_request(move(request))
        , m_argument(move(argument))
    {
    }

    DebugRequest(DebugRequest const&) = default;
    DebugRequest(DebugRequest&&) = default;
    DebugRequest& operator=(DebugRequest const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::DebugRequest; }
    static i32 static_message_id() { return (int)MessageID::DebugRequest; }
    virtual StringView message_name() const override { return "WebContentServer::DebugRequest"sv; }

    static ErrorOr<NonnullOwnPtr<DebugRequest>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto request = TRY((decoder.decode<ByteString>()));
        auto argument = TRY((decoder.decode<ByteString>()));
        return make<DebugRequest>(move(page_id), move(request), move(argument));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView request, StringView argument)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DebugRequest));
        TRY(stream.encode(page_id));
        TRY(stream.encode(request));
        TRY(stream.encode(argument));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_request, m_argument);
    }

    u64 page_id() const { return m_page_id; }

    ByteString const& request() const { return m_request; }
    ByteString take_request() { return move(m_request); }

    ByteString const& argument() const { return m_argument; }
    ByteString take_argument() { return move(m_argument); }

private:
    u64 m_page_id;
    ByteString m_request;
    ByteString m_argument;
};

class GetSource final : public IPC::Message {
public:
    GetSource(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    GetSource(GetSource const&) = default;
    GetSource(GetSource&&) = default;
    GetSource& operator=(GetSource const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    GetSource(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::GetSource; }
    static i32 static_message_id() { return (int)MessageID::GetSource; }
    virtual StringView message_name() const override { return "WebContentServer::GetSource"sv; }

    static ErrorOr<NonnullOwnPtr<GetSource>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<GetSource>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetSource));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class InspectDomTree final : public IPC::Message {
public:
    InspectDomTree(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    InspectDomTree(InspectDomTree const&) = default;
    InspectDomTree(InspectDomTree&&) = default;
    InspectDomTree& operator=(InspectDomTree const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    InspectDomTree(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::InspectDomTree; }
    static i32 static_message_id() { return (int)MessageID::InspectDomTree; }
    virtual StringView message_name() const override { return "WebContentServer::InspectDomTree"sv; }

    static ErrorOr<NonnullOwnPtr<InspectDomTree>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<InspectDomTree>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::InspectDomTree));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class InspectDomNode final : public IPC::Message {
public:
    InspectDomNode(u64 page_id, WebView::DOMNodeProperties::Type property_type, Web::UniqueNodeID node_id, Optional<Web::CSS::PseudoElement> pseudo_element)
        : m_page_id(move(page_id))
        , m_property_type(move(property_type))
        , m_node_id(move(node_id))
        , m_pseudo_element(move(pseudo_element))
    {
    }

    InspectDomNode(InspectDomNode const&) = default;
    InspectDomNode(InspectDomNode&&) = default;
    InspectDomNode& operator=(InspectDomNode const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::InspectDomNode; }
    static i32 static_message_id() { return (int)MessageID::InspectDomNode; }
    virtual StringView message_name() const override { return "WebContentServer::InspectDomNode"sv; }

    static ErrorOr<NonnullOwnPtr<InspectDomNode>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto property_type = TRY((decoder.decode<WebView::DOMNodeProperties::Type>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto pseudo_element = TRY((decoder.decode<Optional<Web::CSS::PseudoElement>>()));
        return make<InspectDomNode>(move(page_id), move(property_type), move(node_id), move(pseudo_element));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, WebView::DOMNodeProperties::Type const& property_type, Web::UniqueNodeID const& node_id, Optional<Web::CSS::PseudoElement> const& pseudo_element)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::InspectDomNode));
        TRY(stream.encode(page_id));
        TRY(stream.encode(property_type));
        TRY(stream.encode(node_id));
        TRY(stream.encode(pseudo_element));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_property_type, m_node_id, m_pseudo_element);
    }

    u64 page_id() const { return m_page_id; }

    WebView::DOMNodeProperties::Type const& property_type() const { return m_property_type; }
    WebView::DOMNodeProperties::Type take_property_type() { return move(m_property_type); }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

    Optional<Web::CSS::PseudoElement> const& pseudo_element() const { return m_pseudo_element; }
    Optional<Web::CSS::PseudoElement> take_pseudo_element() { return move(m_pseudo_element); }

private:
    u64 m_page_id;
    WebView::DOMNodeProperties::Type m_property_type;
    Web::UniqueNodeID m_node_id;
    Optional<Web::CSS::PseudoElement> m_pseudo_element;
};

class ClearInspectedDomNode final : public IPC::Message {
public:
    ClearInspectedDomNode(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ClearInspectedDomNode(ClearInspectedDomNode const&) = default;
    ClearInspectedDomNode(ClearInspectedDomNode&&) = default;
    ClearInspectedDomNode& operator=(ClearInspectedDomNode const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ClearInspectedDomNode(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ClearInspectedDomNode; }
    static i32 static_message_id() { return (int)MessageID::ClearInspectedDomNode; }
    virtual StringView message_name() const override { return "WebContentServer::ClearInspectedDomNode"sv; }

    static ErrorOr<NonnullOwnPtr<ClearInspectedDomNode>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ClearInspectedDomNode>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ClearInspectedDomNode));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class HighlightDomNode final : public IPC::Message {
public:
    HighlightDomNode(u64 page_id, Web::UniqueNodeID node_id, Optional<Web::CSS::PseudoElement> pseudo_element)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_pseudo_element(move(pseudo_element))
    {
    }

    HighlightDomNode(HighlightDomNode const&) = default;
    HighlightDomNode(HighlightDomNode&&) = default;
    HighlightDomNode& operator=(HighlightDomNode const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::HighlightDomNode; }
    static i32 static_message_id() { return (int)MessageID::HighlightDomNode; }
    virtual StringView message_name() const override { return "WebContentServer::HighlightDomNode"sv; }

    static ErrorOr<NonnullOwnPtr<HighlightDomNode>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto pseudo_element = TRY((decoder.decode<Optional<Web::CSS::PseudoElement>>()));
        return make<HighlightDomNode>(move(page_id), move(node_id), move(pseudo_element));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id, Optional<Web::CSS::PseudoElement> const& pseudo_element)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::HighlightDomNode));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        TRY(stream.encode(pseudo_element));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id, m_pseudo_element);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

    Optional<Web::CSS::PseudoElement> const& pseudo_element() const { return m_pseudo_element; }
    Optional<Web::CSS::PseudoElement> take_pseudo_element() { return move(m_pseudo_element); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
    Optional<Web::CSS::PseudoElement> m_pseudo_element;
};

class InspectAccessibilityTree final : public IPC::Message {
public:
    InspectAccessibilityTree(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    InspectAccessibilityTree(InspectAccessibilityTree const&) = default;
    InspectAccessibilityTree(InspectAccessibilityTree&&) = default;
    InspectAccessibilityTree& operator=(InspectAccessibilityTree const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    InspectAccessibilityTree(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::InspectAccessibilityTree; }
    static i32 static_message_id() { return (int)MessageID::InspectAccessibilityTree; }
    virtual StringView message_name() const override { return "WebContentServer::InspectAccessibilityTree"sv; }

    static ErrorOr<NonnullOwnPtr<InspectAccessibilityTree>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<InspectAccessibilityTree>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::InspectAccessibilityTree));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class GetHoveredNodeId final : public IPC::Message {
public:
    GetHoveredNodeId(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    GetHoveredNodeId(GetHoveredNodeId const&) = default;
    GetHoveredNodeId(GetHoveredNodeId&&) = default;
    GetHoveredNodeId& operator=(GetHoveredNodeId const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    GetHoveredNodeId(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::GetHoveredNodeId; }
    static i32 static_message_id() { return (int)MessageID::GetHoveredNodeId; }
    virtual StringView message_name() const override { return "WebContentServer::GetHoveredNodeId"sv; }

    static ErrorOr<NonnullOwnPtr<GetHoveredNodeId>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<GetHoveredNodeId>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetHoveredNodeId));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class JsConsoleInput final : public IPC::Message {
public:
    JsConsoleInput(u64 page_id, String js_source)
        : m_page_id(move(page_id))
        , m_js_source(move(js_source))
    {
    }

    JsConsoleInput(JsConsoleInput const&) = default;
    JsConsoleInput(JsConsoleInput&&) = default;
    JsConsoleInput& operator=(JsConsoleInput const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::JsConsoleInput; }
    static i32 static_message_id() { return (int)MessageID::JsConsoleInput; }
    virtual StringView message_name() const override { return "WebContentServer::JsConsoleInput"sv; }

    static ErrorOr<NonnullOwnPtr<JsConsoleInput>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto js_source = TRY((decoder.decode<String>()));
        return make<JsConsoleInput>(move(page_id), move(js_source));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView js_source)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::JsConsoleInput));
        TRY(stream.encode(page_id));
        TRY(stream.encode(js_source));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_js_source);
    }

    u64 page_id() const { return m_page_id; }

    String const& js_source() const { return m_js_source; }
    String take_js_source() { return move(m_js_source); }

private:
    u64 m_page_id;
    String m_js_source;
};

class RunJavascript final : public IPC::Message {
public:
    RunJavascript(u64 page_id, String js_source)
        : m_page_id(move(page_id))
        , m_js_source(move(js_source))
    {
    }

    RunJavascript(RunJavascript const&) = default;
    RunJavascript(RunJavascript&&) = default;
    RunJavascript& operator=(RunJavascript const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::RunJavascript; }
    static i32 static_message_id() { return (int)MessageID::RunJavascript; }
    virtual StringView message_name() const override { return "WebContentServer::RunJavascript"sv; }

    static ErrorOr<NonnullOwnPtr<RunJavascript>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto js_source = TRY((decoder.decode<String>()));
        return make<RunJavascript>(move(page_id), move(js_source));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView js_source)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::RunJavascript));
        TRY(stream.encode(page_id));
        TRY(stream.encode(js_source));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_js_source);
    }

    u64 page_id() const { return m_page_id; }

    String const& js_source() const { return m_js_source; }
    String take_js_source() { return move(m_js_source); }

private:
    u64 m_page_id;
    String m_js_source;
};

class ListStyleSheets final : public IPC::Message {
public:
    ListStyleSheets(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ListStyleSheets(ListStyleSheets const&) = default;
    ListStyleSheets(ListStyleSheets&&) = default;
    ListStyleSheets& operator=(ListStyleSheets const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ListStyleSheets(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ListStyleSheets; }
    static i32 static_message_id() { return (int)MessageID::ListStyleSheets; }
    virtual StringView message_name() const override { return "WebContentServer::ListStyleSheets"sv; }

    static ErrorOr<NonnullOwnPtr<ListStyleSheets>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ListStyleSheets>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ListStyleSheets));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class RequestStyleSheetSource final : public IPC::Message {
public:
    RequestStyleSheetSource(u64 page_id, Web::CSS::StyleSheetIdentifier identifier)
        : m_page_id(move(page_id))
        , m_identifier(move(identifier))
    {
    }

    RequestStyleSheetSource(RequestStyleSheetSource const&) = default;
    RequestStyleSheetSource(RequestStyleSheetSource&&) = default;
    RequestStyleSheetSource& operator=(RequestStyleSheetSource const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::RequestStyleSheetSource; }
    static i32 static_message_id() { return (int)MessageID::RequestStyleSheetSource; }
    virtual StringView message_name() const override { return "WebContentServer::RequestStyleSheetSource"sv; }

    static ErrorOr<NonnullOwnPtr<RequestStyleSheetSource>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto identifier = TRY((decoder.decode<Web::CSS::StyleSheetIdentifier>()));
        return make<RequestStyleSheetSource>(move(page_id), move(identifier));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::CSS::StyleSheetIdentifier const& identifier)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::RequestStyleSheetSource));
        TRY(stream.encode(page_id));
        TRY(stream.encode(identifier));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_identifier);
    }

    u64 page_id() const { return m_page_id; }

    Web::CSS::StyleSheetIdentifier const& identifier() const { return m_identifier; }
    Web::CSS::StyleSheetIdentifier take_identifier() { return move(m_identifier); }

private:
    u64 m_page_id;
    Web::CSS::StyleSheetIdentifier m_identifier;
};

class SetListenForDomMutations final : public IPC::Message {
public:
    SetListenForDomMutations(u64 page_id, bool listen_for_dom_mutations)
        : m_page_id(move(page_id))
        , m_listen_for_dom_mutations(move(listen_for_dom_mutations))
    {
    }

    SetListenForDomMutations(SetListenForDomMutations const&) = default;
    SetListenForDomMutations(SetListenForDomMutations&&) = default;
    SetListenForDomMutations& operator=(SetListenForDomMutations const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetListenForDomMutations; }
    static i32 static_message_id() { return (int)MessageID::SetListenForDomMutations; }
    virtual StringView message_name() const override { return "WebContentServer::SetListenForDomMutations"sv; }

    static ErrorOr<NonnullOwnPtr<SetListenForDomMutations>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto listen_for_dom_mutations = TRY((decoder.decode<bool>()));
        return make<SetListenForDomMutations>(move(page_id), move(listen_for_dom_mutations));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, bool listen_for_dom_mutations)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetListenForDomMutations));
        TRY(stream.encode(page_id));
        TRY(stream.encode(listen_for_dom_mutations));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_listen_for_dom_mutations);
    }

    u64 page_id() const { return m_page_id; }

    bool listen_for_dom_mutations() const { return m_listen_for_dom_mutations; }

private:
    u64 m_page_id;
    bool m_listen_for_dom_mutations;
};

class DidConnectDevtoolsClient final : public IPC::Message {
public:
    DidConnectDevtoolsClient(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    DidConnectDevtoolsClient(DidConnectDevtoolsClient const&) = default;
    DidConnectDevtoolsClient(DidConnectDevtoolsClient&&) = default;
    DidConnectDevtoolsClient& operator=(DidConnectDevtoolsClient const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    DidConnectDevtoolsClient(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::DidConnectDevtoolsClient; }
    static i32 static_message_id() { return (int)MessageID::DidConnectDevtoolsClient; }
    virtual StringView message_name() const override { return "WebContentServer::DidConnectDevtoolsClient"sv; }

    static ErrorOr<NonnullOwnPtr<DidConnectDevtoolsClient>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidConnectDevtoolsClient>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidConnectDevtoolsClient));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class DidDisconnectDevtoolsClient final : public IPC::Message {
public:
    DidDisconnectDevtoolsClient(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    DidDisconnectDevtoolsClient(DidDisconnectDevtoolsClient const&) = default;
    DidDisconnectDevtoolsClient(DidDisconnectDevtoolsClient&&) = default;
    DidDisconnectDevtoolsClient& operator=(DidDisconnectDevtoolsClient const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    DidDisconnectDevtoolsClient(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::DidDisconnectDevtoolsClient; }
    static i32 static_message_id() { return (int)MessageID::DidDisconnectDevtoolsClient; }
    virtual StringView message_name() const override { return "WebContentServer::DidDisconnectDevtoolsClient"sv; }

    static ErrorOr<NonnullOwnPtr<DidDisconnectDevtoolsClient>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidDisconnectDevtoolsClient>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidDisconnectDevtoolsClient));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class GetDomNodeInnerHtml final : public IPC::Message {
public:
    GetDomNodeInnerHtml(u64 page_id, Web::UniqueNodeID node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
    {
    }

    GetDomNodeInnerHtml(GetDomNodeInnerHtml const&) = default;
    GetDomNodeInnerHtml(GetDomNodeInnerHtml&&) = default;
    GetDomNodeInnerHtml& operator=(GetDomNodeInnerHtml const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::GetDomNodeInnerHtml; }
    static i32 static_message_id() { return (int)MessageID::GetDomNodeInnerHtml; }
    virtual StringView message_name() const override { return "WebContentServer::GetDomNodeInnerHtml"sv; }

    static ErrorOr<NonnullOwnPtr<GetDomNodeInnerHtml>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        return make<GetDomNodeInnerHtml>(move(page_id), move(node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetDomNodeInnerHtml));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
};

class GetDomNodeOuterHtml final : public IPC::Message {
public:
    GetDomNodeOuterHtml(u64 page_id, Web::UniqueNodeID node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
    {
    }

    GetDomNodeOuterHtml(GetDomNodeOuterHtml const&) = default;
    GetDomNodeOuterHtml(GetDomNodeOuterHtml&&) = default;
    GetDomNodeOuterHtml& operator=(GetDomNodeOuterHtml const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::GetDomNodeOuterHtml; }
    static i32 static_message_id() { return (int)MessageID::GetDomNodeOuterHtml; }
    virtual StringView message_name() const override { return "WebContentServer::GetDomNodeOuterHtml"sv; }

    static ErrorOr<NonnullOwnPtr<GetDomNodeOuterHtml>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        return make<GetDomNodeOuterHtml>(move(page_id), move(node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetDomNodeOuterHtml));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
};

class SetDomNodeOuterHtml final : public IPC::Message {
public:
    SetDomNodeOuterHtml(u64 page_id, Web::UniqueNodeID node_id, String html)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_html(move(html))
    {
    }

    SetDomNodeOuterHtml(SetDomNodeOuterHtml const&) = default;
    SetDomNodeOuterHtml(SetDomNodeOuterHtml&&) = default;
    SetDomNodeOuterHtml& operator=(SetDomNodeOuterHtml const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetDomNodeOuterHtml; }
    static i32 static_message_id() { return (int)MessageID::SetDomNodeOuterHtml; }
    virtual StringView message_name() const override { return "WebContentServer::SetDomNodeOuterHtml"sv; }

    static ErrorOr<NonnullOwnPtr<SetDomNodeOuterHtml>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto html = TRY((decoder.decode<String>()));
        return make<SetDomNodeOuterHtml>(move(page_id), move(node_id), move(html));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id, StringView html)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetDomNodeOuterHtml));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        TRY(stream.encode(html));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id, m_html);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

    String const& html() const { return m_html; }
    String take_html() { return move(m_html); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
    String m_html;
};

class SetDomNodeText final : public IPC::Message {
public:
    SetDomNodeText(u64 page_id, Web::UniqueNodeID node_id, String text)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_text(move(text))
    {
    }

    SetDomNodeText(SetDomNodeText const&) = default;
    SetDomNodeText(SetDomNodeText&&) = default;
    SetDomNodeText& operator=(SetDomNodeText const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetDomNodeText; }
    static i32 static_message_id() { return (int)MessageID::SetDomNodeText; }
    virtual StringView message_name() const override { return "WebContentServer::SetDomNodeText"sv; }

    static ErrorOr<NonnullOwnPtr<SetDomNodeText>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto text = TRY((decoder.decode<String>()));
        return make<SetDomNodeText>(move(page_id), move(node_id), move(text));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id, StringView text)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetDomNodeText));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        TRY(stream.encode(text));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id, m_text);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

    String const& text() const { return m_text; }
    String take_text() { return move(m_text); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
    String m_text;
};

class SetDomNodeTag final : public IPC::Message {
public:
    SetDomNodeTag(u64 page_id, Web::UniqueNodeID node_id, String name)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_name(move(name))
    {
    }

    SetDomNodeTag(SetDomNodeTag const&) = default;
    SetDomNodeTag(SetDomNodeTag&&) = default;
    SetDomNodeTag& operator=(SetDomNodeTag const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetDomNodeTag; }
    static i32 static_message_id() { return (int)MessageID::SetDomNodeTag; }
    virtual StringView message_name() const override { return "WebContentServer::SetDomNodeTag"sv; }

    static ErrorOr<NonnullOwnPtr<SetDomNodeTag>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto name = TRY((decoder.decode<String>()));
        return make<SetDomNodeTag>(move(page_id), move(node_id), move(name));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id, StringView name)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetDomNodeTag));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        TRY(stream.encode(name));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id, m_name);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

    String const& name() const { return m_name; }
    String take_name() { return move(m_name); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
    String m_name;
};

class AddDomNodeAttributes final : public IPC::Message {
public:
    AddDomNodeAttributes(u64 page_id, Web::UniqueNodeID node_id, Vector<WebView::Attribute> attributes)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_attributes(move(attributes))
    {
    }

    AddDomNodeAttributes(AddDomNodeAttributes const&) = default;
    AddDomNodeAttributes(AddDomNodeAttributes&&) = default;
    AddDomNodeAttributes& operator=(AddDomNodeAttributes const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::AddDomNodeAttributes; }
    static i32 static_message_id() { return (int)MessageID::AddDomNodeAttributes; }
    virtual StringView message_name() const override { return "WebContentServer::AddDomNodeAttributes"sv; }

    static ErrorOr<NonnullOwnPtr<AddDomNodeAttributes>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto attributes = TRY((decoder.decode<Vector<WebView::Attribute>>()));
        return make<AddDomNodeAttributes>(move(page_id), move(node_id), move(attributes));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id, ReadonlySpan<WebView::Attribute> attributes)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::AddDomNodeAttributes));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        TRY(stream.encode(attributes));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id, m_attributes);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

    Vector<WebView::Attribute> const& attributes() const { return m_attributes; }
    Vector<WebView::Attribute> take_attributes() { return move(m_attributes); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
    Vector<WebView::Attribute> m_attributes;
};

class ReplaceDomNodeAttribute final : public IPC::Message {
public:
    ReplaceDomNodeAttribute(u64 page_id, Web::UniqueNodeID node_id, String name, Vector<WebView::Attribute> replacement_attributes)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_name(move(name))
        , m_replacement_attributes(move(replacement_attributes))
    {
    }

    ReplaceDomNodeAttribute(ReplaceDomNodeAttribute const&) = default;
    ReplaceDomNodeAttribute(ReplaceDomNodeAttribute&&) = default;
    ReplaceDomNodeAttribute& operator=(ReplaceDomNodeAttribute const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ReplaceDomNodeAttribute; }
    static i32 static_message_id() { return (int)MessageID::ReplaceDomNodeAttribute; }
    virtual StringView message_name() const override { return "WebContentServer::ReplaceDomNodeAttribute"sv; }

    static ErrorOr<NonnullOwnPtr<ReplaceDomNodeAttribute>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto name = TRY((decoder.decode<String>()));
        auto replacement_attributes = TRY((decoder.decode<Vector<WebView::Attribute>>()));
        return make<ReplaceDomNodeAttribute>(move(page_id), move(node_id), move(name), move(replacement_attributes));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id, StringView name, ReadonlySpan<WebView::Attribute> replacement_attributes)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ReplaceDomNodeAttribute));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        TRY(stream.encode(name));
        TRY(stream.encode(replacement_attributes));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id, m_name, m_replacement_attributes);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

    String const& name() const { return m_name; }
    String take_name() { return move(m_name); }

    Vector<WebView::Attribute> const& replacement_attributes() const { return m_replacement_attributes; }
    Vector<WebView::Attribute> take_replacement_attributes() { return move(m_replacement_attributes); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
    String m_name;
    Vector<WebView::Attribute> m_replacement_attributes;
};

class CreateChildElement final : public IPC::Message {
public:
    CreateChildElement(u64 page_id, Web::UniqueNodeID node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
    {
    }

    CreateChildElement(CreateChildElement const&) = default;
    CreateChildElement(CreateChildElement&&) = default;
    CreateChildElement& operator=(CreateChildElement const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::CreateChildElement; }
    static i32 static_message_id() { return (int)MessageID::CreateChildElement; }
    virtual StringView message_name() const override { return "WebContentServer::CreateChildElement"sv; }

    static ErrorOr<NonnullOwnPtr<CreateChildElement>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        return make<CreateChildElement>(move(page_id), move(node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::CreateChildElement));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
};

class CreateChildTextNode final : public IPC::Message {
public:
    CreateChildTextNode(u64 page_id, Web::UniqueNodeID node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
    {
    }

    CreateChildTextNode(CreateChildTextNode const&) = default;
    CreateChildTextNode(CreateChildTextNode&&) = default;
    CreateChildTextNode& operator=(CreateChildTextNode const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::CreateChildTextNode; }
    static i32 static_message_id() { return (int)MessageID::CreateChildTextNode; }
    virtual StringView message_name() const override { return "WebContentServer::CreateChildTextNode"sv; }

    static ErrorOr<NonnullOwnPtr<CreateChildTextNode>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        return make<CreateChildTextNode>(move(page_id), move(node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::CreateChildTextNode));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
};

class InsertDomNodeBefore final : public IPC::Message {
public:
    InsertDomNodeBefore(u64 page_id, Web::UniqueNodeID node_id, Web::UniqueNodeID parent_node_id, Optional<Web::UniqueNodeID> sibling_node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_parent_node_id(move(parent_node_id))
        , m_sibling_node_id(move(sibling_node_id))
    {
    }

    InsertDomNodeBefore(InsertDomNodeBefore const&) = default;
    InsertDomNodeBefore(InsertDomNodeBefore&&) = default;
    InsertDomNodeBefore& operator=(InsertDomNodeBefore const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::InsertDomNodeBefore; }
    static i32 static_message_id() { return (int)MessageID::InsertDomNodeBefore; }
    virtual StringView message_name() const override { return "WebContentServer::InsertDomNodeBefore"sv; }

    static ErrorOr<NonnullOwnPtr<InsertDomNodeBefore>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto parent_node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        auto sibling_node_id = TRY((decoder.decode<Optional<Web::UniqueNodeID>>()));
        return make<InsertDomNodeBefore>(move(page_id), move(node_id), move(parent_node_id), move(sibling_node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id, Web::UniqueNodeID const& parent_node_id, Optional<Web::UniqueNodeID> const& sibling_node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::InsertDomNodeBefore));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        TRY(stream.encode(parent_node_id));
        TRY(stream.encode(sibling_node_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id, m_parent_node_id, m_sibling_node_id);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

    Web::UniqueNodeID const& parent_node_id() const { return m_parent_node_id; }
    Web::UniqueNodeID take_parent_node_id() { return move(m_parent_node_id); }

    Optional<Web::UniqueNodeID> const& sibling_node_id() const { return m_sibling_node_id; }
    Optional<Web::UniqueNodeID> take_sibling_node_id() { return move(m_sibling_node_id); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
    Web::UniqueNodeID m_parent_node_id;
    Optional<Web::UniqueNodeID> m_sibling_node_id;
};

class CloneDomNode final : public IPC::Message {
public:
    CloneDomNode(u64 page_id, Web::UniqueNodeID node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
    {
    }

    CloneDomNode(CloneDomNode const&) = default;
    CloneDomNode(CloneDomNode&&) = default;
    CloneDomNode& operator=(CloneDomNode const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::CloneDomNode; }
    static i32 static_message_id() { return (int)MessageID::CloneDomNode; }
    virtual StringView message_name() const override { return "WebContentServer::CloneDomNode"sv; }

    static ErrorOr<NonnullOwnPtr<CloneDomNode>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        return make<CloneDomNode>(move(page_id), move(node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::CloneDomNode));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
};

class RemoveDomNode final : public IPC::Message {
public:
    RemoveDomNode(u64 page_id, Web::UniqueNodeID node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
    {
    }

    RemoveDomNode(RemoveDomNode const&) = default;
    RemoveDomNode(RemoveDomNode&&) = default;
    RemoveDomNode& operator=(RemoveDomNode const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::RemoveDomNode; }
    static i32 static_message_id() { return (int)MessageID::RemoveDomNode; }
    virtual StringView message_name() const override { return "WebContentServer::RemoveDomNode"sv; }

    static ErrorOr<NonnullOwnPtr<RemoveDomNode>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        return make<RemoveDomNode>(move(page_id), move(node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::RemoveDomNode));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
};

class TakeDocumentScreenshot final : public IPC::Message {
public:
    TakeDocumentScreenshot(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    TakeDocumentScreenshot(TakeDocumentScreenshot const&) = default;
    TakeDocumentScreenshot(TakeDocumentScreenshot&&) = default;
    TakeDocumentScreenshot& operator=(TakeDocumentScreenshot const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    TakeDocumentScreenshot(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::TakeDocumentScreenshot; }
    static i32 static_message_id() { return (int)MessageID::TakeDocumentScreenshot; }
    virtual StringView message_name() const override { return "WebContentServer::TakeDocumentScreenshot"sv; }

    static ErrorOr<NonnullOwnPtr<TakeDocumentScreenshot>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<TakeDocumentScreenshot>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::TakeDocumentScreenshot));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class TakeDomNodeScreenshot final : public IPC::Message {
public:
    TakeDomNodeScreenshot(u64 page_id, Web::UniqueNodeID node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
    {
    }

    TakeDomNodeScreenshot(TakeDomNodeScreenshot const&) = default;
    TakeDomNodeScreenshot(TakeDomNodeScreenshot&&) = default;
    TakeDomNodeScreenshot& operator=(TakeDomNodeScreenshot const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::TakeDomNodeScreenshot; }
    static i32 static_message_id() { return (int)MessageID::TakeDomNodeScreenshot; }
    virtual StringView message_name() const override { return "WebContentServer::TakeDomNodeScreenshot"sv; }

    static ErrorOr<NonnullOwnPtr<TakeDomNodeScreenshot>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto node_id = TRY((decoder.decode<Web::UniqueNodeID>()));
        return make<TakeDomNodeScreenshot>(move(page_id), move(node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::TakeDomNodeScreenshot));
        TRY(stream.encode(page_id));
        TRY(stream.encode(node_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_node_id);
    }

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& node_id() const { return m_node_id; }
    Web::UniqueNodeID take_node_id() { return move(m_node_id); }

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
};

class RequestInternalPageInfo final : public IPC::Message {
public:
    RequestInternalPageInfo(u64 page_id, WebView::PageInfoType type)
        : m_page_id(move(page_id))
        , m_type(move(type))
    {
    }

    RequestInternalPageInfo(RequestInternalPageInfo const&) = default;
    RequestInternalPageInfo(RequestInternalPageInfo&&) = default;
    RequestInternalPageInfo& operator=(RequestInternalPageInfo const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::RequestInternalPageInfo; }
    static i32 static_message_id() { return (int)MessageID::RequestInternalPageInfo; }
    virtual StringView message_name() const override { return "WebContentServer::RequestInternalPageInfo"sv; }

    static ErrorOr<NonnullOwnPtr<RequestInternalPageInfo>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto type = TRY((decoder.decode<WebView::PageInfoType>()));
        return make<RequestInternalPageInfo>(move(page_id), move(type));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, WebView::PageInfoType type)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::RequestInternalPageInfo));
        TRY(stream.encode(page_id));
        TRY(stream.encode(type));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_type);
    }

    u64 page_id() const { return m_page_id; }

    WebView::PageInfoType type() const { return m_type; }

private:
    u64 m_page_id;
    WebView::PageInfoType m_type;
};

class GetSelectedTextResponse final : public IPC::Message {
public:
    GetSelectedTextResponse(ByteString selection)
        : m_selection(move(selection))
    {
    }

    GetSelectedTextResponse(GetSelectedTextResponse const&) = default;
    GetSelectedTextResponse(GetSelectedTextResponse&&) = default;
    GetSelectedTextResponse& operator=(GetSelectedTextResponse const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, ByteString>)
    GetSelectedTextResponse(WrappedReturnType&& value)
        : m_selection(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::GetSelectedTextResponse; }
    static i32 static_message_id() { return (int)MessageID::GetSelectedTextResponse; }
    virtual StringView message_name() const override { return "WebContentServer::GetSelectedTextResponse"sv; }

    static ErrorOr<NonnullOwnPtr<GetSelectedTextResponse>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto selection = TRY((decoder.decode<ByteString>()));
        return make<GetSelectedTextResponse>(move(selection));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(StringView selection)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetSelectedTextResponse));
        TRY(stream.encode(selection));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_selection);
    }

    ByteString const& selection() const { return m_selection; }
    ByteString take_selection() { return move(m_selection); }

private:
    ByteString m_selection;
};

class GetSelectedText final : public IPC::Message {
public:
    typedef class GetSelectedTextResponse ResponseType;

    GetSelectedText(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    GetSelectedText(GetSelectedText const&) = default;
    GetSelectedText(GetSelectedText&&) = default;
    GetSelectedText& operator=(GetSelectedText const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    GetSelectedText(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::GetSelectedText; }
    static i32 static_message_id() { return (int)MessageID::GetSelectedText; }
    virtual StringView message_name() const override { return "WebContentServer::GetSelectedText"sv; }

    static ErrorOr<NonnullOwnPtr<GetSelectedText>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<GetSelectedText>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetSelectedText));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class CutSelectedTextResponse final : public IPC::Message {
public:
    CutSelectedTextResponse(ByteString selection)
        : m_selection(move(selection))
    {
    }

    CutSelectedTextResponse(CutSelectedTextResponse const&) = default;
    CutSelectedTextResponse(CutSelectedTextResponse&&) = default;
    CutSelectedTextResponse& operator=(CutSelectedTextResponse const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, ByteString>)
    CutSelectedTextResponse(WrappedReturnType&& value)
        : m_selection(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::CutSelectedTextResponse; }
    static i32 static_message_id() { return (int)MessageID::CutSelectedTextResponse; }
    virtual StringView message_name() const override { return "WebContentServer::CutSelectedTextResponse"sv; }

    static ErrorOr<NonnullOwnPtr<CutSelectedTextResponse>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto selection = TRY((decoder.decode<ByteString>()));
        return make<CutSelectedTextResponse>(move(selection));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(StringView selection)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::CutSelectedTextResponse));
        TRY(stream.encode(selection));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_selection);
    }

    ByteString const& selection() const { return m_selection; }
    ByteString take_selection() { return move(m_selection); }

private:
    ByteString m_selection;
};

class CutSelectedText final : public IPC::Message {
public:
    typedef class CutSelectedTextResponse ResponseType;

    CutSelectedText(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    CutSelectedText(CutSelectedText const&) = default;
    CutSelectedText(CutSelectedText&&) = default;
    CutSelectedText& operator=(CutSelectedText const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    CutSelectedText(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::CutSelectedText; }
    static i32 static_message_id() { return (int)MessageID::CutSelectedText; }
    virtual StringView message_name() const override { return "WebContentServer::CutSelectedText"sv; }

    static ErrorOr<NonnullOwnPtr<CutSelectedText>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<CutSelectedText>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::CutSelectedText));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class SelectAll final : public IPC::Message {
public:
    SelectAll(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    SelectAll(SelectAll const&) = default;
    SelectAll(SelectAll&&) = default;
    SelectAll& operator=(SelectAll const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    SelectAll(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SelectAll; }
    static i32 static_message_id() { return (int)MessageID::SelectAll; }
    virtual StringView message_name() const override { return "WebContentServer::SelectAll"sv; }

    static ErrorOr<NonnullOwnPtr<SelectAll>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<SelectAll>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SelectAll));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class Paste final : public IPC::Message {
public:
    Paste(u64 page_id, Utf16String text)
        : m_page_id(move(page_id))
        , m_text(move(text))
    {
    }

    Paste(Paste const&) = default;
    Paste(Paste&&) = default;
    Paste& operator=(Paste const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::Paste; }
    static i32 static_message_id() { return (int)MessageID::Paste; }
    virtual StringView message_name() const override { return "WebContentServer::Paste"sv; }

    static ErrorOr<NonnullOwnPtr<Paste>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto text = TRY((decoder.decode<Utf16String>()));
        return make<Paste>(move(page_id), move(text));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Utf16View const& text)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::Paste));
        TRY(stream.encode(page_id));
        TRY(stream.encode(text));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_text);
    }

    u64 page_id() const { return m_page_id; }

    Utf16String const& text() const { return m_text; }
    Utf16String take_text() { return move(m_text); }

private:
    u64 m_page_id;
    Utf16String m_text;
};

class FindInPage final : public IPC::Message {
public:
    FindInPage(u64 page_id, String query, AK::CaseSensitivity case_sensitivity)
        : m_page_id(move(page_id))
        , m_query(move(query))
        , m_case_sensitivity(move(case_sensitivity))
    {
    }

    FindInPage(FindInPage const&) = default;
    FindInPage(FindInPage&&) = default;
    FindInPage& operator=(FindInPage const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::FindInPage; }
    static i32 static_message_id() { return (int)MessageID::FindInPage; }
    virtual StringView message_name() const override { return "WebContentServer::FindInPage"sv; }

    static ErrorOr<NonnullOwnPtr<FindInPage>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto query = TRY((decoder.decode<String>()));
        auto case_sensitivity = TRY((decoder.decode<AK::CaseSensitivity>()));
        return make<FindInPage>(move(page_id), move(query), move(case_sensitivity));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView query, AK::CaseSensitivity case_sensitivity)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::FindInPage));
        TRY(stream.encode(page_id));
        TRY(stream.encode(query));
        TRY(stream.encode(case_sensitivity));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_query, m_case_sensitivity);
    }

    u64 page_id() const { return m_page_id; }

    String const& query() const { return m_query; }
    String take_query() { return move(m_query); }

    AK::CaseSensitivity case_sensitivity() const { return m_case_sensitivity; }

private:
    u64 m_page_id;
    String m_query;
    AK::CaseSensitivity m_case_sensitivity;
};

class FindInPageNextMatch final : public IPC::Message {
public:
    FindInPageNextMatch(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    FindInPageNextMatch(FindInPageNextMatch const&) = default;
    FindInPageNextMatch(FindInPageNextMatch&&) = default;
    FindInPageNextMatch& operator=(FindInPageNextMatch const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    FindInPageNextMatch(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::FindInPageNextMatch; }
    static i32 static_message_id() { return (int)MessageID::FindInPageNextMatch; }
    virtual StringView message_name() const override { return "WebContentServer::FindInPageNextMatch"sv; }

    static ErrorOr<NonnullOwnPtr<FindInPageNextMatch>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<FindInPageNextMatch>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::FindInPageNextMatch));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class FindInPagePreviousMatch final : public IPC::Message {
public:
    FindInPagePreviousMatch(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    FindInPagePreviousMatch(FindInPagePreviousMatch const&) = default;
    FindInPagePreviousMatch(FindInPagePreviousMatch&&) = default;
    FindInPagePreviousMatch& operator=(FindInPagePreviousMatch const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    FindInPagePreviousMatch(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::FindInPagePreviousMatch; }
    static i32 static_message_id() { return (int)MessageID::FindInPagePreviousMatch; }
    virtual StringView message_name() const override { return "WebContentServer::FindInPagePreviousMatch"sv; }

    static ErrorOr<NonnullOwnPtr<FindInPagePreviousMatch>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<FindInPagePreviousMatch>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::FindInPagePreviousMatch));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class SetContentFilters final : public IPC::Message {
public:
    SetContentFilters(u64 page_id, Vector<String> filters)
        : m_page_id(move(page_id))
        , m_filters(move(filters))
    {
    }

    SetContentFilters(SetContentFilters const&) = default;
    SetContentFilters(SetContentFilters&&) = default;
    SetContentFilters& operator=(SetContentFilters const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetContentFilters; }
    static i32 static_message_id() { return (int)MessageID::SetContentFilters; }
    virtual StringView message_name() const override { return "WebContentServer::SetContentFilters"sv; }

    static ErrorOr<NonnullOwnPtr<SetContentFilters>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto filters = TRY((decoder.decode<Vector<String>>()));
        return make<SetContentFilters>(move(page_id), move(filters));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, ReadonlySpan<String> filters)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetContentFilters));
        TRY(stream.encode(page_id));
        TRY(stream.encode(filters));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_filters);
    }

    u64 page_id() const { return m_page_id; }

    Vector<String> const& filters() const { return m_filters; }
    Vector<String> take_filters() { return move(m_filters); }

private:
    u64 m_page_id;
    Vector<String> m_filters;
};

class SetAutoplayAllowedOnAllWebsites final : public IPC::Message {
public:
    SetAutoplayAllowedOnAllWebsites(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    SetAutoplayAllowedOnAllWebsites(SetAutoplayAllowedOnAllWebsites const&) = default;
    SetAutoplayAllowedOnAllWebsites(SetAutoplayAllowedOnAllWebsites&&) = default;
    SetAutoplayAllowedOnAllWebsites& operator=(SetAutoplayAllowedOnAllWebsites const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    SetAutoplayAllowedOnAllWebsites(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetAutoplayAllowedOnAllWebsites; }
    static i32 static_message_id() { return (int)MessageID::SetAutoplayAllowedOnAllWebsites; }
    virtual StringView message_name() const override { return "WebContentServer::SetAutoplayAllowedOnAllWebsites"sv; }

    static ErrorOr<NonnullOwnPtr<SetAutoplayAllowedOnAllWebsites>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<SetAutoplayAllowedOnAllWebsites>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetAutoplayAllowedOnAllWebsites));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class SetAutoplayAllowlist final : public IPC::Message {
public:
    SetAutoplayAllowlist(u64 page_id, Vector<String> allowlist)
        : m_page_id(move(page_id))
        , m_allowlist(move(allowlist))
    {
    }

    SetAutoplayAllowlist(SetAutoplayAllowlist const&) = default;
    SetAutoplayAllowlist(SetAutoplayAllowlist&&) = default;
    SetAutoplayAllowlist& operator=(SetAutoplayAllowlist const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetAutoplayAllowlist; }
    static i32 static_message_id() { return (int)MessageID::SetAutoplayAllowlist; }
    virtual StringView message_name() const override { return "WebContentServer::SetAutoplayAllowlist"sv; }

    static ErrorOr<NonnullOwnPtr<SetAutoplayAllowlist>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto allowlist = TRY((decoder.decode<Vector<String>>()));
        return make<SetAutoplayAllowlist>(move(page_id), move(allowlist));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, ReadonlySpan<String> allowlist)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetAutoplayAllowlist));
        TRY(stream.encode(page_id));
        TRY(stream.encode(allowlist));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_allowlist);
    }

    u64 page_id() const { return m_page_id; }

    Vector<String> const& allowlist() const { return m_allowlist; }
    Vector<String> take_allowlist() { return move(m_allowlist); }

private:
    u64 m_page_id;
    Vector<String> m_allowlist;
};

class SetProxyMappings final : public IPC::Message {
public:
    SetProxyMappings(u64 page_id, Vector<ByteString> proxies, HashMap<ByteString, size_t> mappings)
        : m_page_id(move(page_id))
        , m_proxies(move(proxies))
        , m_mappings(move(mappings))
    {
    }

    SetProxyMappings(SetProxyMappings const&) = default;
    SetProxyMappings(SetProxyMappings&&) = default;
    SetProxyMappings& operator=(SetProxyMappings const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetProxyMappings; }
    static i32 static_message_id() { return (int)MessageID::SetProxyMappings; }
    virtual StringView message_name() const override { return "WebContentServer::SetProxyMappings"sv; }

    static ErrorOr<NonnullOwnPtr<SetProxyMappings>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto proxies = TRY((decoder.decode<Vector<ByteString>>()));
        auto mappings = TRY((decoder.decode<HashMap<ByteString, size_t>>()));
        return make<SetProxyMappings>(move(page_id), move(proxies), move(mappings));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, ReadonlySpan<ByteString> proxies, HashMap<ByteString, size_t> const& mappings)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetProxyMappings));
        TRY(stream.encode(page_id));
        TRY(stream.encode(proxies));
        TRY(stream.encode(mappings));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_proxies, m_mappings);
    }

    u64 page_id() const { return m_page_id; }

    Vector<ByteString> const& proxies() const { return m_proxies; }
    Vector<ByteString> take_proxies() { return move(m_proxies); }

    HashMap<ByteString, size_t> const& mappings() const { return m_mappings; }
    HashMap<ByteString, size_t> take_mappings() { return move(m_mappings); }

private:
    u64 m_page_id;
    Vector<ByteString> m_proxies;
    HashMap<ByteString, size_t> m_mappings;
};

class SetPreferredColorScheme final : public IPC::Message {
public:
    SetPreferredColorScheme(u64 page_id, Web::CSS::PreferredColorScheme color_scheme)
        : m_page_id(move(page_id))
        , m_color_scheme(move(color_scheme))
    {
    }

    SetPreferredColorScheme(SetPreferredColorScheme const&) = default;
    SetPreferredColorScheme(SetPreferredColorScheme&&) = default;
    SetPreferredColorScheme& operator=(SetPreferredColorScheme const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetPreferredColorScheme; }
    static i32 static_message_id() { return (int)MessageID::SetPreferredColorScheme; }
    virtual StringView message_name() const override { return "WebContentServer::SetPreferredColorScheme"sv; }

    static ErrorOr<NonnullOwnPtr<SetPreferredColorScheme>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto color_scheme = TRY((decoder.decode<Web::CSS::PreferredColorScheme>()));
        return make<SetPreferredColorScheme>(move(page_id), move(color_scheme));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::CSS::PreferredColorScheme const& color_scheme)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetPreferredColorScheme));
        TRY(stream.encode(page_id));
        TRY(stream.encode(color_scheme));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_color_scheme);
    }

    u64 page_id() const { return m_page_id; }

    Web::CSS::PreferredColorScheme const& color_scheme() const { return m_color_scheme; }
    Web::CSS::PreferredColorScheme take_color_scheme() { return move(m_color_scheme); }

private:
    u64 m_page_id;
    Web::CSS::PreferredColorScheme m_color_scheme;
};

class SetPreferredContrast final : public IPC::Message {
public:
    SetPreferredContrast(u64 page_id, Web::CSS::PreferredContrast contrast)
        : m_page_id(move(page_id))
        , m_contrast(move(contrast))
    {
    }

    SetPreferredContrast(SetPreferredContrast const&) = default;
    SetPreferredContrast(SetPreferredContrast&&) = default;
    SetPreferredContrast& operator=(SetPreferredContrast const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetPreferredContrast; }
    static i32 static_message_id() { return (int)MessageID::SetPreferredContrast; }
    virtual StringView message_name() const override { return "WebContentServer::SetPreferredContrast"sv; }

    static ErrorOr<NonnullOwnPtr<SetPreferredContrast>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto contrast = TRY((decoder.decode<Web::CSS::PreferredContrast>()));
        return make<SetPreferredContrast>(move(page_id), move(contrast));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::CSS::PreferredContrast const& contrast)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetPreferredContrast));
        TRY(stream.encode(page_id));
        TRY(stream.encode(contrast));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_contrast);
    }

    u64 page_id() const { return m_page_id; }

    Web::CSS::PreferredContrast const& contrast() const { return m_contrast; }
    Web::CSS::PreferredContrast take_contrast() { return move(m_contrast); }

private:
    u64 m_page_id;
    Web::CSS::PreferredContrast m_contrast;
};

class SetPreferredMotion final : public IPC::Message {
public:
    SetPreferredMotion(u64 page_id, Web::CSS::PreferredMotion motion)
        : m_page_id(move(page_id))
        , m_motion(move(motion))
    {
    }

    SetPreferredMotion(SetPreferredMotion const&) = default;
    SetPreferredMotion(SetPreferredMotion&&) = default;
    SetPreferredMotion& operator=(SetPreferredMotion const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetPreferredMotion; }
    static i32 static_message_id() { return (int)MessageID::SetPreferredMotion; }
    virtual StringView message_name() const override { return "WebContentServer::SetPreferredMotion"sv; }

    static ErrorOr<NonnullOwnPtr<SetPreferredMotion>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto motion = TRY((decoder.decode<Web::CSS::PreferredMotion>()));
        return make<SetPreferredMotion>(move(page_id), move(motion));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::CSS::PreferredMotion const& motion)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetPreferredMotion));
        TRY(stream.encode(page_id));
        TRY(stream.encode(motion));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_motion);
    }

    u64 page_id() const { return m_page_id; }

    Web::CSS::PreferredMotion const& motion() const { return m_motion; }
    Web::CSS::PreferredMotion take_motion() { return move(m_motion); }

private:
    u64 m_page_id;
    Web::CSS::PreferredMotion m_motion;
};

class SetPreferredLanguages final : public IPC::Message {
public:
    SetPreferredLanguages(u64 page_id, Vector<String> preferred_languages)
        : m_page_id(move(page_id))
        , m_preferred_languages(move(preferred_languages))
    {
    }

    SetPreferredLanguages(SetPreferredLanguages const&) = default;
    SetPreferredLanguages(SetPreferredLanguages&&) = default;
    SetPreferredLanguages& operator=(SetPreferredLanguages const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetPreferredLanguages; }
    static i32 static_message_id() { return (int)MessageID::SetPreferredLanguages; }
    virtual StringView message_name() const override { return "WebContentServer::SetPreferredLanguages"sv; }

    static ErrorOr<NonnullOwnPtr<SetPreferredLanguages>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto preferred_languages = TRY((decoder.decode<Vector<String>>()));
        return make<SetPreferredLanguages>(move(page_id), move(preferred_languages));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, ReadonlySpan<String> preferred_languages)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetPreferredLanguages));
        TRY(stream.encode(page_id));
        TRY(stream.encode(preferred_languages));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_preferred_languages);
    }

    u64 page_id() const { return m_page_id; }

    Vector<String> const& preferred_languages() const { return m_preferred_languages; }
    Vector<String> take_preferred_languages() { return move(m_preferred_languages); }

private:
    u64 m_page_id;
    Vector<String> m_preferred_languages;
};

class SetBrowsingBehavior final : public IPC::Message {
public:
    SetBrowsingBehavior(u64 page_id, WebView::BrowsingBehavior browsing_behavior)
        : m_page_id(move(page_id))
        , m_browsing_behavior(move(browsing_behavior))
    {
    }

    SetBrowsingBehavior(SetBrowsingBehavior const&) = default;
    SetBrowsingBehavior(SetBrowsingBehavior&&) = default;
    SetBrowsingBehavior& operator=(SetBrowsingBehavior const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetBrowsingBehavior; }
    static i32 static_message_id() { return (int)MessageID::SetBrowsingBehavior; }
    virtual StringView message_name() const override { return "WebContentServer::SetBrowsingBehavior"sv; }

    static ErrorOr<NonnullOwnPtr<SetBrowsingBehavior>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto browsing_behavior = TRY((decoder.decode<WebView::BrowsingBehavior>()));
        return make<SetBrowsingBehavior>(move(page_id), move(browsing_behavior));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, WebView::BrowsingBehavior const& browsing_behavior)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetBrowsingBehavior));
        TRY(stream.encode(page_id));
        TRY(stream.encode(browsing_behavior));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_browsing_behavior);
    }

    u64 page_id() const { return m_page_id; }

    WebView::BrowsingBehavior const& browsing_behavior() const { return m_browsing_behavior; }
    WebView::BrowsingBehavior take_browsing_behavior() { return move(m_browsing_behavior); }

private:
    u64 m_page_id;
    WebView::BrowsingBehavior m_browsing_behavior;
};

class SetEnableGlobalPrivacyControl final : public IPC::Message {
public:
    SetEnableGlobalPrivacyControl(u64 page_id, bool enable)
        : m_page_id(move(page_id))
        , m_enable(move(enable))
    {
    }

    SetEnableGlobalPrivacyControl(SetEnableGlobalPrivacyControl const&) = default;
    SetEnableGlobalPrivacyControl(SetEnableGlobalPrivacyControl&&) = default;
    SetEnableGlobalPrivacyControl& operator=(SetEnableGlobalPrivacyControl const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetEnableGlobalPrivacyControl; }
    static i32 static_message_id() { return (int)MessageID::SetEnableGlobalPrivacyControl; }
    virtual StringView message_name() const override { return "WebContentServer::SetEnableGlobalPrivacyControl"sv; }

    static ErrorOr<NonnullOwnPtr<SetEnableGlobalPrivacyControl>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto enable = TRY((decoder.decode<bool>()));
        return make<SetEnableGlobalPrivacyControl>(move(page_id), move(enable));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, bool enable)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetEnableGlobalPrivacyControl));
        TRY(stream.encode(page_id));
        TRY(stream.encode(enable));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_enable);
    }

    u64 page_id() const { return m_page_id; }

    bool enable() const { return m_enable; }

private:
    u64 m_page_id;
    bool m_enable;
};

class SetHasFocus final : public IPC::Message {
public:
    SetHasFocus(u64 page_id, bool has_focus)
        : m_page_id(move(page_id))
        , m_has_focus(move(has_focus))
    {
    }

    SetHasFocus(SetHasFocus const&) = default;
    SetHasFocus(SetHasFocus&&) = default;
    SetHasFocus& operator=(SetHasFocus const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetHasFocus; }
    static i32 static_message_id() { return (int)MessageID::SetHasFocus; }
    virtual StringView message_name() const override { return "WebContentServer::SetHasFocus"sv; }

    static ErrorOr<NonnullOwnPtr<SetHasFocus>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto has_focus = TRY((decoder.decode<bool>()));
        return make<SetHasFocus>(move(page_id), move(has_focus));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, bool has_focus)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetHasFocus));
        TRY(stream.encode(page_id));
        TRY(stream.encode(has_focus));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_has_focus);
    }

    u64 page_id() const { return m_page_id; }

    bool has_focus() const { return m_has_focus; }

private:
    u64 m_page_id;
    bool m_has_focus;
};

class SetIsScriptingEnabled final : public IPC::Message {
public:
    SetIsScriptingEnabled(u64 page_id, bool is_scripting_enabled)
        : m_page_id(move(page_id))
        , m_is_scripting_enabled(move(is_scripting_enabled))
    {
    }

    SetIsScriptingEnabled(SetIsScriptingEnabled const&) = default;
    SetIsScriptingEnabled(SetIsScriptingEnabled&&) = default;
    SetIsScriptingEnabled& operator=(SetIsScriptingEnabled const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetIsScriptingEnabled; }
    static i32 static_message_id() { return (int)MessageID::SetIsScriptingEnabled; }
    virtual StringView message_name() const override { return "WebContentServer::SetIsScriptingEnabled"sv; }

    static ErrorOr<NonnullOwnPtr<SetIsScriptingEnabled>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto is_scripting_enabled = TRY((decoder.decode<bool>()));
        return make<SetIsScriptingEnabled>(move(page_id), move(is_scripting_enabled));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, bool is_scripting_enabled)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetIsScriptingEnabled));
        TRY(stream.encode(page_id));
        TRY(stream.encode(is_scripting_enabled));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_is_scripting_enabled);
    }

    u64 page_id() const { return m_page_id; }

    bool is_scripting_enabled() const { return m_is_scripting_enabled; }

private:
    u64 m_page_id;
    bool m_is_scripting_enabled;
};

class SetZoomLevel final : public IPC::Message {
public:
    SetZoomLevel(u64 page_id, double zoom_level)
        : m_page_id(move(page_id))
        , m_zoom_level(move(zoom_level))
    {
    }

    SetZoomLevel(SetZoomLevel const&) = default;
    SetZoomLevel(SetZoomLevel&&) = default;
    SetZoomLevel& operator=(SetZoomLevel const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetZoomLevel; }
    static i32 static_message_id() { return (int)MessageID::SetZoomLevel; }
    virtual StringView message_name() const override { return "WebContentServer::SetZoomLevel"sv; }

    static ErrorOr<NonnullOwnPtr<SetZoomLevel>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto zoom_level = TRY((decoder.decode<double>()));
        return make<SetZoomLevel>(move(page_id), move(zoom_level));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, double zoom_level)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetZoomLevel));
        TRY(stream.encode(page_id));
        TRY(stream.encode(zoom_level));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_zoom_level);
    }

    u64 page_id() const { return m_page_id; }

    double zoom_level() const { return m_zoom_level; }

private:
    u64 m_page_id;
    double m_zoom_level;
};

class SetMaximumFramesPerSecond final : public IPC::Message {
public:
    SetMaximumFramesPerSecond(u64 page_id, double maximum_frames_per_second)
        : m_page_id(move(page_id))
        , m_maximum_frames_per_second(move(maximum_frames_per_second))
    {
    }

    SetMaximumFramesPerSecond(SetMaximumFramesPerSecond const&) = default;
    SetMaximumFramesPerSecond(SetMaximumFramesPerSecond&&) = default;
    SetMaximumFramesPerSecond& operator=(SetMaximumFramesPerSecond const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetMaximumFramesPerSecond; }
    static i32 static_message_id() { return (int)MessageID::SetMaximumFramesPerSecond; }
    virtual StringView message_name() const override { return "WebContentServer::SetMaximumFramesPerSecond"sv; }

    static ErrorOr<NonnullOwnPtr<SetMaximumFramesPerSecond>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto maximum_frames_per_second = TRY((decoder.decode<double>()));
        return make<SetMaximumFramesPerSecond>(move(page_id), move(maximum_frames_per_second));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, double maximum_frames_per_second)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetMaximumFramesPerSecond));
        TRY(stream.encode(page_id));
        TRY(stream.encode(maximum_frames_per_second));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_maximum_frames_per_second);
    }

    u64 page_id() const { return m_page_id; }

    double maximum_frames_per_second() const { return m_maximum_frames_per_second; }

private:
    u64 m_page_id;
    double m_maximum_frames_per_second;
};

class SetWindowPosition final : public IPC::Message {
public:
    SetWindowPosition(u64 page_id, Web::DevicePixelPoint position)
        : m_page_id(move(page_id))
        , m_position(move(position))
    {
    }

    SetWindowPosition(SetWindowPosition const&) = default;
    SetWindowPosition(SetWindowPosition&&) = default;
    SetWindowPosition& operator=(SetWindowPosition const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetWindowPosition; }
    static i32 static_message_id() { return (int)MessageID::SetWindowPosition; }
    virtual StringView message_name() const override { return "WebContentServer::SetWindowPosition"sv; }

    static ErrorOr<NonnullOwnPtr<SetWindowPosition>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto position = TRY((decoder.decode<Web::DevicePixelPoint>()));
        return make<SetWindowPosition>(move(page_id), move(position));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::DevicePixelPoint position)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetWindowPosition));
        TRY(stream.encode(page_id));
        TRY(stream.encode(position));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_position);
    }

    u64 page_id() const { return m_page_id; }

    Web::DevicePixelPoint position() const { return m_position; }

private:
    u64 m_page_id;
    Web::DevicePixelPoint m_position;
};

class SetWindowSize final : public IPC::Message {
public:
    SetWindowSize(u64 page_id, Web::DevicePixelSize size)
        : m_page_id(move(page_id))
        , m_size(move(size))
    {
    }

    SetWindowSize(SetWindowSize const&) = default;
    SetWindowSize(SetWindowSize&&) = default;
    SetWindowSize& operator=(SetWindowSize const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetWindowSize; }
    static i32 static_message_id() { return (int)MessageID::SetWindowSize; }
    virtual StringView message_name() const override { return "WebContentServer::SetWindowSize"sv; }

    static ErrorOr<NonnullOwnPtr<SetWindowSize>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto size = TRY((decoder.decode<Web::DevicePixelSize>()));
        return make<SetWindowSize>(move(page_id), move(size));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::DevicePixelSize size)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetWindowSize));
        TRY(stream.encode(page_id));
        TRY(stream.encode(size));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_size);
    }

    u64 page_id() const { return m_page_id; }

    Web::DevicePixelSize size() const { return m_size; }

private:
    u64 m_page_id;
    Web::DevicePixelSize m_size;
};

class DidUpdateWindowRect final : public IPC::Message {
public:
    DidUpdateWindowRect(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    DidUpdateWindowRect(DidUpdateWindowRect const&) = default;
    DidUpdateWindowRect(DidUpdateWindowRect&&) = default;
    DidUpdateWindowRect& operator=(DidUpdateWindowRect const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    DidUpdateWindowRect(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::DidUpdateWindowRect; }
    static i32 static_message_id() { return (int)MessageID::DidUpdateWindowRect; }
    virtual StringView message_name() const override { return "WebContentServer::DidUpdateWindowRect"sv; }

    static ErrorOr<NonnullOwnPtr<DidUpdateWindowRect>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidUpdateWindowRect>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidUpdateWindowRect));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class ResetZoom final : public IPC::Message {
public:
    ResetZoom(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ResetZoom(ResetZoom const&) = default;
    ResetZoom(ResetZoom&&) = default;
    ResetZoom& operator=(ResetZoom const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ResetZoom(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ResetZoom; }
    static i32 static_message_id() { return (int)MessageID::ResetZoom; }
    virtual StringView message_name() const override { return "WebContentServer::ResetZoom"sv; }

    static ErrorOr<NonnullOwnPtr<ResetZoom>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ResetZoom>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ResetZoom));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class HandleFileReturn final : public IPC::Message {
public:
    HandleFileReturn(u64 page_id, i32 error, Optional<IPC::File> file, i32 request_id)
        : m_page_id(move(page_id))
        , m_error(move(error))
        , m_file(move(file))
        , m_request_id(move(request_id))
    {
    }

    HandleFileReturn(HandleFileReturn const&) = default;
    HandleFileReturn(HandleFileReturn&&) = default;
    HandleFileReturn& operator=(HandleFileReturn const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::HandleFileReturn; }
    static i32 static_message_id() { return (int)MessageID::HandleFileReturn; }
    virtual StringView message_name() const override { return "WebContentServer::HandleFileReturn"sv; }

    static ErrorOr<NonnullOwnPtr<HandleFileReturn>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto error = TRY((decoder.decode<i32>()));
        auto file = TRY((decoder.decode<Optional<IPC::File>>()));
        auto request_id = TRY((decoder.decode<i32>()));
        return make<HandleFileReturn>(move(page_id), move(error), move(file), move(request_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, i32 error, Optional<IPC::File> const& file, i32 request_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::HandleFileReturn));
        TRY(stream.encode(page_id));
        TRY(stream.encode(error));
        TRY(stream.encode(file));
        TRY(stream.encode(request_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_error, m_file, m_request_id);
    }

    u64 page_id() const { return m_page_id; }

    i32 error() const { return m_error; }

    Optional<IPC::File> const& file() const { return m_file; }
    Optional<IPC::File> take_file() { return move(m_file); }

    i32 request_id() const { return m_request_id; }

private:
    u64 m_page_id;
    i32 m_error;
    Optional<IPC::File> m_file;
    i32 m_request_id;
};

class SetSystemVisibilityState final : public IPC::Message {
public:
    SetSystemVisibilityState(u64 page_id, Web::HTML::VisibilityState visibility_state)
        : m_page_id(move(page_id))
        , m_visibility_state(move(visibility_state))
    {
    }

    SetSystemVisibilityState(SetSystemVisibilityState const&) = default;
    SetSystemVisibilityState(SetSystemVisibilityState&&) = default;
    SetSystemVisibilityState& operator=(SetSystemVisibilityState const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetSystemVisibilityState; }
    static i32 static_message_id() { return (int)MessageID::SetSystemVisibilityState; }
    virtual StringView message_name() const override { return "WebContentServer::SetSystemVisibilityState"sv; }

    static ErrorOr<NonnullOwnPtr<SetSystemVisibilityState>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto visibility_state = TRY((decoder.decode<Web::HTML::VisibilityState>()));
        return make<SetSystemVisibilityState>(move(page_id), move(visibility_state));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::HTML::VisibilityState visibility_state)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetSystemVisibilityState));
        TRY(stream.encode(page_id));
        TRY(stream.encode(visibility_state));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_visibility_state);
    }

    u64 page_id() const { return m_page_id; }

    Web::HTML::VisibilityState visibility_state() const { return m_visibility_state; }

private:
    u64 m_page_id;
    Web::HTML::VisibilityState m_visibility_state;
};

class AlertClosed final : public IPC::Message {
public:
    AlertClosed(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    AlertClosed(AlertClosed const&) = default;
    AlertClosed(AlertClosed&&) = default;
    AlertClosed& operator=(AlertClosed const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    AlertClosed(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::AlertClosed; }
    static i32 static_message_id() { return (int)MessageID::AlertClosed; }
    virtual StringView message_name() const override { return "WebContentServer::AlertClosed"sv; }

    static ErrorOr<NonnullOwnPtr<AlertClosed>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<AlertClosed>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::AlertClosed));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class ConfirmClosed final : public IPC::Message {
public:
    ConfirmClosed(u64 page_id, bool accepted)
        : m_page_id(move(page_id))
        , m_accepted(move(accepted))
    {
    }

    ConfirmClosed(ConfirmClosed const&) = default;
    ConfirmClosed(ConfirmClosed&&) = default;
    ConfirmClosed& operator=(ConfirmClosed const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ConfirmClosed; }
    static i32 static_message_id() { return (int)MessageID::ConfirmClosed; }
    virtual StringView message_name() const override { return "WebContentServer::ConfirmClosed"sv; }

    static ErrorOr<NonnullOwnPtr<ConfirmClosed>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto accepted = TRY((decoder.decode<bool>()));
        return make<ConfirmClosed>(move(page_id), move(accepted));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, bool accepted)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ConfirmClosed));
        TRY(stream.encode(page_id));
        TRY(stream.encode(accepted));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_accepted);
    }

    u64 page_id() const { return m_page_id; }

    bool accepted() const { return m_accepted; }

private:
    u64 m_page_id;
    bool m_accepted;
};

class PromptClosed final : public IPC::Message {
public:
    PromptClosed(u64 page_id, Optional<String> response)
        : m_page_id(move(page_id))
        , m_response(move(response))
    {
    }

    PromptClosed(PromptClosed const&) = default;
    PromptClosed(PromptClosed&&) = default;
    PromptClosed& operator=(PromptClosed const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::PromptClosed; }
    static i32 static_message_id() { return (int)MessageID::PromptClosed; }
    virtual StringView message_name() const override { return "WebContentServer::PromptClosed"sv; }

    static ErrorOr<NonnullOwnPtr<PromptClosed>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto response = TRY((decoder.decode<Optional<String>>()));
        return make<PromptClosed>(move(page_id), move(response));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Optional<String> const& response)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::PromptClosed));
        TRY(stream.encode(page_id));
        TRY(stream.encode(response));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_response);
    }

    u64 page_id() const { return m_page_id; }

    Optional<String> const& response() const { return m_response; }
    Optional<String> take_response() { return move(m_response); }

private:
    u64 m_page_id;
    Optional<String> m_response;
};

class ColorPickerUpdate final : public IPC::Message {
public:
    ColorPickerUpdate(u64 page_id, Optional<Color> picked_color, Web::HTML::ColorPickerUpdateState state)
        : m_page_id(move(page_id))
        , m_picked_color(move(picked_color))
        , m_state(move(state))
    {
    }

    ColorPickerUpdate(ColorPickerUpdate const&) = default;
    ColorPickerUpdate(ColorPickerUpdate&&) = default;
    ColorPickerUpdate& operator=(ColorPickerUpdate const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ColorPickerUpdate; }
    static i32 static_message_id() { return (int)MessageID::ColorPickerUpdate; }
    virtual StringView message_name() const override { return "WebContentServer::ColorPickerUpdate"sv; }

    static ErrorOr<NonnullOwnPtr<ColorPickerUpdate>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto picked_color = TRY((decoder.decode<Optional<Color>>()));
        auto state = TRY((decoder.decode<Web::HTML::ColorPickerUpdateState>()));
        return make<ColorPickerUpdate>(move(page_id), move(picked_color), move(state));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Optional<Color> const& picked_color, Web::HTML::ColorPickerUpdateState const& state)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ColorPickerUpdate));
        TRY(stream.encode(page_id));
        TRY(stream.encode(picked_color));
        TRY(stream.encode(state));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_picked_color, m_state);
    }

    u64 page_id() const { return m_page_id; }

    Optional<Color> const& picked_color() const { return m_picked_color; }
    Optional<Color> take_picked_color() { return move(m_picked_color); }

    Web::HTML::ColorPickerUpdateState const& state() const { return m_state; }
    Web::HTML::ColorPickerUpdateState take_state() { return move(m_state); }

private:
    u64 m_page_id;
    Optional<Color> m_picked_color;
    Web::HTML::ColorPickerUpdateState m_state;
};

class FilePickerClosed final : public IPC::Message {
public:
    FilePickerClosed(u64 page_id, Vector<Web::HTML::SelectedFile> selected_files)
        : m_page_id(move(page_id))
        , m_selected_files(move(selected_files))
    {
    }

    FilePickerClosed(FilePickerClosed const&) = default;
    FilePickerClosed(FilePickerClosed&&) = default;
    FilePickerClosed& operator=(FilePickerClosed const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::FilePickerClosed; }
    static i32 static_message_id() { return (int)MessageID::FilePickerClosed; }
    virtual StringView message_name() const override { return "WebContentServer::FilePickerClosed"sv; }

    static ErrorOr<NonnullOwnPtr<FilePickerClosed>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto selected_files = TRY((decoder.decode<Vector<Web::HTML::SelectedFile>>()));
        return make<FilePickerClosed>(move(page_id), move(selected_files));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, ReadonlySpan<Web::HTML::SelectedFile> selected_files)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::FilePickerClosed));
        TRY(stream.encode(page_id));
        TRY(stream.encode(selected_files));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_selected_files);
    }

    u64 page_id() const { return m_page_id; }

    Vector<Web::HTML::SelectedFile> const& selected_files() const { return m_selected_files; }
    Vector<Web::HTML::SelectedFile> take_selected_files() { return move(m_selected_files); }

private:
    u64 m_page_id;
    Vector<Web::HTML::SelectedFile> m_selected_files;
};

class SelectDropdownClosed final : public IPC::Message {
public:
    SelectDropdownClosed(u64 page_id, Optional<u32> selected_item_id)
        : m_page_id(move(page_id))
        , m_selected_item_id(move(selected_item_id))
    {
    }

    SelectDropdownClosed(SelectDropdownClosed const&) = default;
    SelectDropdownClosed(SelectDropdownClosed&&) = default;
    SelectDropdownClosed& operator=(SelectDropdownClosed const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SelectDropdownClosed; }
    static i32 static_message_id() { return (int)MessageID::SelectDropdownClosed; }
    virtual StringView message_name() const override { return "WebContentServer::SelectDropdownClosed"sv; }

    static ErrorOr<NonnullOwnPtr<SelectDropdownClosed>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto selected_item_id = TRY((decoder.decode<Optional<u32>>()));
        return make<SelectDropdownClosed>(move(page_id), move(selected_item_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Optional<u32> const& selected_item_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SelectDropdownClosed));
        TRY(stream.encode(page_id));
        TRY(stream.encode(selected_item_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_selected_item_id);
    }

    u64 page_id() const { return m_page_id; }

    Optional<u32> const& selected_item_id() const { return m_selected_item_id; }
    Optional<u32> take_selected_item_id() { return move(m_selected_item_id); }

private:
    u64 m_page_id;
    Optional<u32> m_selected_item_id;
};

class RetrievedClipboardEntries final : public IPC::Message {
public:
    RetrievedClipboardEntries(u64 page_id, u64 request_id, Vector<Web::Clipboard::SystemClipboardItem> items)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_items(move(items))
    {
    }

    RetrievedClipboardEntries(RetrievedClipboardEntries const&) = default;
    RetrievedClipboardEntries(RetrievedClipboardEntries&&) = default;
    RetrievedClipboardEntries& operator=(RetrievedClipboardEntries const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::RetrievedClipboardEntries; }
    static i32 static_message_id() { return (int)MessageID::RetrievedClipboardEntries; }
    virtual StringView message_name() const override { return "WebContentServer::RetrievedClipboardEntries"sv; }

    static ErrorOr<NonnullOwnPtr<RetrievedClipboardEntries>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto request_id = TRY((decoder.decode<u64>()));
        auto items = TRY((decoder.decode<Vector<Web::Clipboard::SystemClipboardItem>>()));
        return make<RetrievedClipboardEntries>(move(page_id), move(request_id), move(items));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, u64 request_id, ReadonlySpan<Web::Clipboard::SystemClipboardItem> items)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::RetrievedClipboardEntries));
        TRY(stream.encode(page_id));
        TRY(stream.encode(request_id));
        TRY(stream.encode(items));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_request_id, m_items);
    }

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    Vector<Web::Clipboard::SystemClipboardItem> const& items() const { return m_items; }
    Vector<Web::Clipboard::SystemClipboardItem> take_items() { return move(m_items); }

private:
    u64 m_page_id;
    u64 m_request_id;
    Vector<Web::Clipboard::SystemClipboardItem> m_items;
};

class ToggleMediaPlayState final : public IPC::Message {
public:
    ToggleMediaPlayState(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ToggleMediaPlayState(ToggleMediaPlayState const&) = default;
    ToggleMediaPlayState(ToggleMediaPlayState&&) = default;
    ToggleMediaPlayState& operator=(ToggleMediaPlayState const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ToggleMediaPlayState(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ToggleMediaPlayState; }
    static i32 static_message_id() { return (int)MessageID::ToggleMediaPlayState; }
    virtual StringView message_name() const override { return "WebContentServer::ToggleMediaPlayState"sv; }

    static ErrorOr<NonnullOwnPtr<ToggleMediaPlayState>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ToggleMediaPlayState>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ToggleMediaPlayState));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class ToggleMediaMuteState final : public IPC::Message {
public:
    ToggleMediaMuteState(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ToggleMediaMuteState(ToggleMediaMuteState const&) = default;
    ToggleMediaMuteState(ToggleMediaMuteState&&) = default;
    ToggleMediaMuteState& operator=(ToggleMediaMuteState const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ToggleMediaMuteState(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ToggleMediaMuteState; }
    static i32 static_message_id() { return (int)MessageID::ToggleMediaMuteState; }
    virtual StringView message_name() const override { return "WebContentServer::ToggleMediaMuteState"sv; }

    static ErrorOr<NonnullOwnPtr<ToggleMediaMuteState>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ToggleMediaMuteState>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ToggleMediaMuteState));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class ToggleMediaLoopState final : public IPC::Message {
public:
    ToggleMediaLoopState(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ToggleMediaLoopState(ToggleMediaLoopState const&) = default;
    ToggleMediaLoopState(ToggleMediaLoopState&&) = default;
    ToggleMediaLoopState& operator=(ToggleMediaLoopState const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ToggleMediaLoopState(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ToggleMediaLoopState; }
    static i32 static_message_id() { return (int)MessageID::ToggleMediaLoopState; }
    virtual StringView message_name() const override { return "WebContentServer::ToggleMediaLoopState"sv; }

    static ErrorOr<NonnullOwnPtr<ToggleMediaLoopState>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ToggleMediaLoopState>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ToggleMediaLoopState));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class ToggleMediaFullscreenState final : public IPC::Message {
public:
    ToggleMediaFullscreenState(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ToggleMediaFullscreenState(ToggleMediaFullscreenState const&) = default;
    ToggleMediaFullscreenState(ToggleMediaFullscreenState&&) = default;
    ToggleMediaFullscreenState& operator=(ToggleMediaFullscreenState const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ToggleMediaFullscreenState(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ToggleMediaFullscreenState; }
    static i32 static_message_id() { return (int)MessageID::ToggleMediaFullscreenState; }
    virtual StringView message_name() const override { return "WebContentServer::ToggleMediaFullscreenState"sv; }

    static ErrorOr<NonnullOwnPtr<ToggleMediaFullscreenState>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ToggleMediaFullscreenState>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ToggleMediaFullscreenState));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class ToggleMediaControlsState final : public IPC::Message {
public:
    ToggleMediaControlsState(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ToggleMediaControlsState(ToggleMediaControlsState const&) = default;
    ToggleMediaControlsState(ToggleMediaControlsState&&) = default;
    ToggleMediaControlsState& operator=(ToggleMediaControlsState const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ToggleMediaControlsState(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ToggleMediaControlsState; }
    static i32 static_message_id() { return (int)MessageID::ToggleMediaControlsState; }
    virtual StringView message_name() const override { return "WebContentServer::ToggleMediaControlsState"sv; }

    static ErrorOr<NonnullOwnPtr<ToggleMediaControlsState>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ToggleMediaControlsState>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ToggleMediaControlsState));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class TogglePageMuteState final : public IPC::Message {
public:
    TogglePageMuteState(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    TogglePageMuteState(TogglePageMuteState const&) = default;
    TogglePageMuteState(TogglePageMuteState&&) = default;
    TogglePageMuteState& operator=(TogglePageMuteState const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    TogglePageMuteState(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::TogglePageMuteState; }
    static i32 static_message_id() { return (int)MessageID::TogglePageMuteState; }
    virtual StringView message_name() const override { return "WebContentServer::TogglePageMuteState"sv; }

    static ErrorOr<NonnullOwnPtr<TogglePageMuteState>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<TogglePageMuteState>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::TogglePageMuteState));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class SetUserStyle final : public IPC::Message {
public:
    SetUserStyle(u64 page_id, String source)
        : m_page_id(move(page_id))
        , m_source(move(source))
    {
    }

    SetUserStyle(SetUserStyle const&) = default;
    SetUserStyle(SetUserStyle&&) = default;
    SetUserStyle& operator=(SetUserStyle const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetUserStyle; }
    static i32 static_message_id() { return (int)MessageID::SetUserStyle; }
    virtual StringView message_name() const override { return "WebContentServer::SetUserStyle"sv; }

    static ErrorOr<NonnullOwnPtr<SetUserStyle>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto source = TRY((decoder.decode<String>()));
        return make<SetUserStyle>(move(page_id), move(source));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView source)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetUserStyle));
        TRY(stream.encode(page_id));
        TRY(stream.encode(source));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_source);
    }

    u64 page_id() const { return m_page_id; }

    String const& source() const { return m_source; }
    String take_source() { return move(m_source); }

private:
    u64 m_page_id;
    String m_source;
};

class SystemTimeZoneChanged final : public IPC::Message {
public:
    SystemTimeZoneChanged() = default;

    SystemTimeZoneChanged(SystemTimeZoneChanged const&) = default;
    SystemTimeZoneChanged(SystemTimeZoneChanged&&) = default;
    SystemTimeZoneChanged& operator=(SystemTimeZoneChanged const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SystemTimeZoneChanged; }
    static i32 static_message_id() { return (int)MessageID::SystemTimeZoneChanged; }
    virtual StringView message_name() const override { return "WebContentServer::SystemTimeZoneChanged"sv; }

    static ErrorOr<NonnullOwnPtr<SystemTimeZoneChanged>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        return make<SystemTimeZoneChanged>();
    }

    static ErrorOr<IPC::MessageBuffer> static_encode()
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SystemTimeZoneChanged));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode();
    }

private:
};

class SetDocumentCookieVersionBuffer final : public IPC::Message {
public:
    SetDocumentCookieVersionBuffer(u64 page_id, Core::AnonymousBuffer document_cookie_version_buffer)
        : m_page_id(move(page_id))
        , m_document_cookie_version_buffer(move(document_cookie_version_buffer))
    {
    }

    SetDocumentCookieVersionBuffer(SetDocumentCookieVersionBuffer const&) = default;
    SetDocumentCookieVersionBuffer(SetDocumentCookieVersionBuffer&&) = default;
    SetDocumentCookieVersionBuffer& operator=(SetDocumentCookieVersionBuffer const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetDocumentCookieVersionBuffer; }
    static i32 static_message_id() { return (int)MessageID::SetDocumentCookieVersionBuffer; }
    virtual StringView message_name() const override { return "WebContentServer::SetDocumentCookieVersionBuffer"sv; }

    static ErrorOr<NonnullOwnPtr<SetDocumentCookieVersionBuffer>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto document_cookie_version_buffer = TRY((decoder.decode<Core::AnonymousBuffer>()));
        return make<SetDocumentCookieVersionBuffer>(move(page_id), move(document_cookie_version_buffer));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Core::AnonymousBuffer const& document_cookie_version_buffer)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetDocumentCookieVersionBuffer));
        TRY(stream.encode(page_id));
        TRY(stream.encode(document_cookie_version_buffer));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_document_cookie_version_buffer);
    }

    u64 page_id() const { return m_page_id; }

    Core::AnonymousBuffer const& document_cookie_version_buffer() const { return m_document_cookie_version_buffer; }
    Core::AnonymousBuffer take_document_cookie_version_buffer() { return move(m_document_cookie_version_buffer); }

private:
    u64 m_page_id;
    Core::AnonymousBuffer m_document_cookie_version_buffer;
};

class SetDocumentCookieVersionIndex final : public IPC::Message {
public:
    SetDocumentCookieVersionIndex(u64 page_id, i64 document_id, Core::SharedVersionIndex document_index)
        : m_page_id(move(page_id))
        , m_document_id(move(document_id))
        , m_document_index(move(document_index))
    {
    }

    SetDocumentCookieVersionIndex(SetDocumentCookieVersionIndex const&) = default;
    SetDocumentCookieVersionIndex(SetDocumentCookieVersionIndex&&) = default;
    SetDocumentCookieVersionIndex& operator=(SetDocumentCookieVersionIndex const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::SetDocumentCookieVersionIndex; }
    static i32 static_message_id() { return (int)MessageID::SetDocumentCookieVersionIndex; }
    virtual StringView message_name() const override { return "WebContentServer::SetDocumentCookieVersionIndex"sv; }

    static ErrorOr<NonnullOwnPtr<SetDocumentCookieVersionIndex>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto document_id = TRY((decoder.decode<i64>()));
        auto document_index = TRY((decoder.decode<Core::SharedVersionIndex>()));
        return make<SetDocumentCookieVersionIndex>(move(page_id), move(document_id), move(document_index));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, i64 document_id, Core::SharedVersionIndex const& document_index)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetDocumentCookieVersionIndex));
        TRY(stream.encode(page_id));
        TRY(stream.encode(document_id));
        TRY(stream.encode(document_index));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_document_id, m_document_index);
    }

    u64 page_id() const { return m_page_id; }

    i64 document_id() const { return m_document_id; }

    Core::SharedVersionIndex const& document_index() const { return m_document_index; }
    Core::SharedVersionIndex take_document_index() { return move(m_document_index); }

private:
    u64 m_page_id;
    i64 m_document_id;
    Core::SharedVersionIndex m_document_index;
};

class CookiesChanged final : public IPC::Message {
public:
    CookiesChanged(u64 page_id, Vector<HTTP::Cookie::Cookie> cookies)
        : m_page_id(move(page_id))
        , m_cookies(move(cookies))
    {
    }

    CookiesChanged(CookiesChanged const&) = default;
    CookiesChanged(CookiesChanged&&) = default;
    CookiesChanged& operator=(CookiesChanged const&) = default;

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::CookiesChanged; }
    static i32 static_message_id() { return (int)MessageID::CookiesChanged; }
    virtual StringView message_name() const override { return "WebContentServer::CookiesChanged"sv; }

    static ErrorOr<NonnullOwnPtr<CookiesChanged>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto cookies = TRY((decoder.decode<Vector<HTTP::Cookie::Cookie>>()));
        return make<CookiesChanged>(move(page_id), move(cookies));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, ReadonlySpan<HTTP::Cookie::Cookie> cookies)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::CookiesChanged));
        TRY(stream.encode(page_id));
        TRY(stream.encode(cookies));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_cookies);
    }

    u64 page_id() const { return m_page_id; }

    Vector<HTTP::Cookie::Cookie> const& cookies() const { return m_cookies; }
    Vector<HTTP::Cookie::Cookie> take_cookies() { return move(m_cookies); }

private:
    u64 m_page_id;
    Vector<HTTP::Cookie::Cookie> m_cookies;
};

class BroadcastChannelMessage final : public IPC::Message {
public:
    BroadcastChannelMessage(Web::HTML::BroadcastChannelMessage message)
        : m_message(move(message))
    {
    }

    BroadcastChannelMessage(BroadcastChannelMessage const&) = default;
    BroadcastChannelMessage(BroadcastChannelMessage&&) = default;
    BroadcastChannelMessage& operator=(BroadcastChannelMessage const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::HTML::BroadcastChannelMessage>)
    BroadcastChannelMessage(WrappedReturnType&& value)
        : m_message(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::BroadcastChannelMessage; }
    static i32 static_message_id() { return (int)MessageID::BroadcastChannelMessage; }
    virtual StringView message_name() const override { return "WebContentServer::BroadcastChannelMessage"sv; }

    static ErrorOr<NonnullOwnPtr<BroadcastChannelMessage>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto message = TRY((decoder.decode<Web::HTML::BroadcastChannelMessage>()));
        return make<BroadcastChannelMessage>(move(message));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(Web::HTML::BroadcastChannelMessage const& message)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::BroadcastChannelMessage));
        TRY(stream.encode(message));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_message);
    }

    Web::HTML::BroadcastChannelMessage const& message() const { return m_message; }
    Web::HTML::BroadcastChannelMessage take_message() { return move(m_message); }

private:
    Web::HTML::BroadcastChannelMessage m_message;
};

class RequestClose final : public IPC::Message {
public:
    RequestClose(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    RequestClose(RequestClose const&) = default;
    RequestClose(RequestClose&&) = default;
    RequestClose& operator=(RequestClose const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    RequestClose(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::RequestClose; }
    static i32 static_message_id() { return (int)MessageID::RequestClose; }
    virtual StringView message_name() const override { return "WebContentServer::RequestClose"sv; }

    static ErrorOr<NonnullOwnPtr<RequestClose>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<RequestClose>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::RequestClose));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

class ExitFullscreen final : public IPC::Message {
public:
    ExitFullscreen(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

    ExitFullscreen(ExitFullscreen const&) = default;
    ExitFullscreen(ExitFullscreen&&) = default;
    ExitFullscreen& operator=(ExitFullscreen const&) = default;

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ExitFullscreen(WrappedReturnType&& value)
        : m_page_id(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4289017466;

    virtual u32 endpoint_magic() const override { return ENDPOINT_MAGIC; }
    virtual i32 message_id() const override { return (int)MessageID::ExitFullscreen; }
    static i32 static_message_id() { return (int)MessageID::ExitFullscreen; }
    virtual StringView message_name() const override { return "WebContentServer::ExitFullscreen"sv; }

    static ErrorOr<NonnullOwnPtr<ExitFullscreen>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ExitFullscreen>(move(page_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ExitFullscreen));
        TRY(stream.encode(page_id));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id);
    }

    u64 page_id() const { return m_page_id; }

private:
    u64 m_page_id;
};

} // namespace Messages::WebContentServer

template<typename LocalEndpoint, typename PeerEndpoint>
class WebContentServerProxy {
public:
    // Used to disambiguate the constructor call.
    struct Tag { };

    WebContentServerProxy(IPC::Connection<LocalEndpoint, PeerEndpoint>& connection, Tag)
        : m_connection(connection)
    {
    }

    int init_transport(int peer_pid)
    {
        return m_connection.template send_sync<Messages::WebContentServer::InitTransport>(peer_pid)->peer_pid();
    }

    void async_init_transport(int peer_pid)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InitTransport::static_encode(peer_pid));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<int> try_init_transport(int peer_pid)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::InitTransport>(peer_pid))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_close_server()
    {
        auto message_buffer = MUST(Messages::WebContentServer::CloseServer::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    String get_window_handle(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentServer::GetWindowHandle>(page_id)->take_handle();
    }

    void async_get_window_handle(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::GetWindowHandle::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<String> try_get_window_handle(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::GetWindowHandle>(page_id))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_set_window_handle(u64 page_id, StringView handle)
    {
        VERIFY(Utf8View { handle }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::SetWindowHandle::static_encode(page_id, handle));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_window_handle(u64 page_id, String const& handle)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetWindowHandle::static_encode(page_id, handle));
        (void)m_connection.post_message(message_buffer);
    }

    void async_connect_to_webdriver(u64 page_id, StringView webdriver_endpoint)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ConnectToWebdriver::static_encode(page_id, webdriver_endpoint));
        (void)m_connection.post_message(message_buffer);
    }

    void async_connect_to_web_ui(u64 page_id, IPC::TransportHandle const& handle)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ConnectToWebUi::static_encode(page_id, move(handle)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_connect_to_request_server(IPC::TransportHandle const& handle)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ConnectToRequestServer::static_encode(move(handle)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_connect_to_image_decoder(IPC::TransportHandle const& handle)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ConnectToImageDecoder::static_encode(move(handle)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_connect_to_compositor(IPC::TransportHandle const& handle)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ConnectToCompositor::static_encode(move(handle)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_update_system_theme(u64 page_id, Core::AnonymousBuffer const& theme_buffer)
    {
        auto message_buffer = MUST(Messages::WebContentServer::UpdateSystemTheme::static_encode(page_id, move(theme_buffer)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_update_screen_rects(u64 page_id, ReadonlySpan<Web::DevicePixelRect> rects, u32 main_screen_index)
    {
        auto message_buffer = MUST(Messages::WebContentServer::UpdateScreenRects::static_encode(page_id, rects, main_screen_index));
        (void)m_connection.post_message(message_buffer);
    }

    void async_load_url(u64 page_id, URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentServer::LoadUrl::static_encode(page_id, move(url)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_load_html(u64 page_id, StringView html)
    {
        auto message_buffer = MUST(Messages::WebContentServer::LoadHtml::static_encode(page_id, html));
        (void)m_connection.post_message(message_buffer);
    }

    void async_reload(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::Reload::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_traverse_the_history_by_delta(u64 page_id, i32 delta)
    {
        auto message_buffer = MUST(Messages::WebContentServer::TraverseTheHistoryByDelta::static_encode(page_id, delta));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_viewport(u64 page_id, Web::DevicePixelSize size, double device_pixel_ratio, Web::ViewportIsFullscreen const& is_fullscreen)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetViewport::static_encode(page_id, size, device_pixel_ratio, move(is_fullscreen)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_key_event(u64 page_id, Web::KeyEvent const& event)
    {
        auto message_buffer = MUST(Messages::WebContentServer::KeyEvent::static_encode(page_id, move(event)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_mouse_event(u64 page_id, Web::MouseEvent const& event)
    {
        auto message_buffer = MUST(Messages::WebContentServer::MouseEvent::static_encode(page_id, move(event)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_drag_event(u64 page_id, Web::DragEvent const& event)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DragEvent::static_encode(page_id, move(event)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_pinch_event(u64 page_id, Web::PinchEvent const& event)
    {
        auto message_buffer = MUST(Messages::WebContentServer::PinchEvent::static_encode(page_id, move(event)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_debug_request(u64 page_id, StringView request, StringView argument)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DebugRequest::static_encode(page_id, request, argument));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_source(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::GetSource::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_dom_tree(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectDomTree::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_dom_node(u64 page_id, WebView::DOMNodeProperties::Type const& property_type, Web::UniqueNodeID const& node_id, Optional<Web::CSS::PseudoElement> const& pseudo_element)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectDomNode::static_encode(page_id, move(property_type), move(node_id), move(pseudo_element)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_clear_inspected_dom_node(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ClearInspectedDomNode::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_highlight_dom_node(u64 page_id, Web::UniqueNodeID const& node_id, Optional<Web::CSS::PseudoElement> const& pseudo_element)
    {
        auto message_buffer = MUST(Messages::WebContentServer::HighlightDomNode::static_encode(page_id, move(node_id), move(pseudo_element)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_accessibility_tree(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectAccessibilityTree::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_hovered_node_id(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::GetHoveredNodeId::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_js_console_input(u64 page_id, StringView js_source)
    {
        VERIFY(Utf8View { js_source }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::JsConsoleInput::static_encode(page_id, js_source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_js_console_input(u64 page_id, String const& js_source)
    {
        auto message_buffer = MUST(Messages::WebContentServer::JsConsoleInput::static_encode(page_id, js_source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_run_javascript(u64 page_id, StringView js_source)
    {
        VERIFY(Utf8View { js_source }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::RunJavascript::static_encode(page_id, js_source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_run_javascript(u64 page_id, String const& js_source)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RunJavascript::static_encode(page_id, js_source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_list_style_sheets(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ListStyleSheets::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_request_style_sheet_source(u64 page_id, Web::CSS::StyleSheetIdentifier const& identifier)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RequestStyleSheetSource::static_encode(page_id, move(identifier)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_listen_for_dom_mutations(u64 page_id, bool listen_for_dom_mutations)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetListenForDomMutations::static_encode(page_id, listen_for_dom_mutations));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_connect_devtools_client(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DidConnectDevtoolsClient::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_disconnect_devtools_client(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DidDisconnectDevtoolsClient::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_dom_node_inner_html(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::GetDomNodeInnerHtml::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_dom_node_outer_html(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::GetDomNodeOuterHtml::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_dom_node_outer_html(u64 page_id, Web::UniqueNodeID const& node_id, StringView html)
    {
        VERIFY(Utf8View { html }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::SetDomNodeOuterHtml::static_encode(page_id, move(node_id), html));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_dom_node_outer_html(u64 page_id, Web::UniqueNodeID const& node_id, String const& html)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetDomNodeOuterHtml::static_encode(page_id, move(node_id), html));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_dom_node_text(u64 page_id, Web::UniqueNodeID const& node_id, StringView text)
    {
        VERIFY(Utf8View { text }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::SetDomNodeText::static_encode(page_id, move(node_id), text));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_dom_node_text(u64 page_id, Web::UniqueNodeID const& node_id, String const& text)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetDomNodeText::static_encode(page_id, move(node_id), text));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_dom_node_tag(u64 page_id, Web::UniqueNodeID const& node_id, StringView name)
    {
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::SetDomNodeTag::static_encode(page_id, move(node_id), name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_dom_node_tag(u64 page_id, Web::UniqueNodeID const& node_id, String const& name)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetDomNodeTag::static_encode(page_id, move(node_id), name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_add_dom_node_attributes(u64 page_id, Web::UniqueNodeID const& node_id, ReadonlySpan<WebView::Attribute> attributes)
    {
        auto message_buffer = MUST(Messages::WebContentServer::AddDomNodeAttributes::static_encode(page_id, move(node_id), attributes));
        (void)m_connection.post_message(message_buffer);
    }

    void async_replace_dom_node_attribute(u64 page_id, Web::UniqueNodeID const& node_id, StringView name, ReadonlySpan<WebView::Attribute> replacement_attributes)
    {
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::ReplaceDomNodeAttribute::static_encode(page_id, move(node_id), name, replacement_attributes));
        (void)m_connection.post_message(message_buffer);
    }

    void async_replace_dom_node_attribute(u64 page_id, Web::UniqueNodeID const& node_id, String const& name, Vector<WebView::Attribute> const& replacement_attributes)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ReplaceDomNodeAttribute::static_encode(page_id, move(node_id), name, replacement_attributes));
        (void)m_connection.post_message(message_buffer);
    }

    void async_create_child_element(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CreateChildElement::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_create_child_text_node(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CreateChildTextNode::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_insert_dom_node_before(u64 page_id, Web::UniqueNodeID const& node_id, Web::UniqueNodeID const& parent_node_id, Optional<Web::UniqueNodeID> const& sibling_node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InsertDomNodeBefore::static_encode(page_id, move(node_id), move(parent_node_id), move(sibling_node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_clone_dom_node(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CloneDomNode::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_remove_dom_node(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RemoveDomNode::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_take_document_screenshot(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::TakeDocumentScreenshot::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_take_dom_node_screenshot(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::TakeDomNodeScreenshot::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_request_internal_page_info(u64 page_id, WebView::PageInfoType type)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RequestInternalPageInfo::static_encode(page_id, type));
        (void)m_connection.post_message(message_buffer);
    }

    ByteString get_selected_text(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentServer::GetSelectedText>(page_id)->take_selection();
    }

    void async_get_selected_text(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::GetSelectedText::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<ByteString> try_get_selected_text(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::GetSelectedText>(page_id))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    ByteString cut_selected_text(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentServer::CutSelectedText>(page_id)->take_selection();
    }

    void async_cut_selected_text(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CutSelectedText::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<ByteString> try_cut_selected_text(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::CutSelectedText>(page_id))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_select_all(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SelectAll::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_paste(u64 page_id, Utf16View const& text)
    {
        VERIFY(text.validate());
        auto message_buffer = MUST(Messages::WebContentServer::Paste::static_encode(page_id, move(text)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_paste(u64 page_id, Utf16String const& text)
    {
        auto message_buffer = MUST(Messages::WebContentServer::Paste::static_encode(page_id, move(text)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_find_in_page(u64 page_id, StringView query, AK::CaseSensitivity case_sensitivity)
    {
        VERIFY(Utf8View { query }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::FindInPage::static_encode(page_id, query, case_sensitivity));
        (void)m_connection.post_message(message_buffer);
    }

    void async_find_in_page(u64 page_id, String const& query, AK::CaseSensitivity case_sensitivity)
    {
        auto message_buffer = MUST(Messages::WebContentServer::FindInPage::static_encode(page_id, query, case_sensitivity));
        (void)m_connection.post_message(message_buffer);
    }

    void async_find_in_page_next_match(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::FindInPageNextMatch::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_find_in_page_previous_match(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::FindInPagePreviousMatch::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_content_filters(u64 page_id, ReadonlySpan<String> filters)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetContentFilters::static_encode(page_id, filters));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_autoplay_allowed_on_all_websites(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetAutoplayAllowedOnAllWebsites::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_autoplay_allowlist(u64 page_id, ReadonlySpan<String> allowlist)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetAutoplayAllowlist::static_encode(page_id, allowlist));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_proxy_mappings(u64 page_id, ReadonlySpan<ByteString> proxies, HashMap<ByteString, size_t> const& mappings)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetProxyMappings::static_encode(page_id, proxies, move(mappings)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_preferred_color_scheme(u64 page_id, Web::CSS::PreferredColorScheme const& color_scheme)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetPreferredColorScheme::static_encode(page_id, move(color_scheme)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_preferred_contrast(u64 page_id, Web::CSS::PreferredContrast const& contrast)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetPreferredContrast::static_encode(page_id, move(contrast)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_preferred_motion(u64 page_id, Web::CSS::PreferredMotion const& motion)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetPreferredMotion::static_encode(page_id, move(motion)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_preferred_languages(u64 page_id, ReadonlySpan<String> preferred_languages)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetPreferredLanguages::static_encode(page_id, preferred_languages));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_browsing_behavior(u64 page_id, WebView::BrowsingBehavior const& browsing_behavior)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetBrowsingBehavior::static_encode(page_id, move(browsing_behavior)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_enable_global_privacy_control(u64 page_id, bool enable)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetEnableGlobalPrivacyControl::static_encode(page_id, enable));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_has_focus(u64 page_id, bool has_focus)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetHasFocus::static_encode(page_id, has_focus));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_is_scripting_enabled(u64 page_id, bool is_scripting_enabled)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetIsScriptingEnabled::static_encode(page_id, is_scripting_enabled));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_zoom_level(u64 page_id, double zoom_level)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetZoomLevel::static_encode(page_id, zoom_level));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_maximum_frames_per_second(u64 page_id, double maximum_frames_per_second)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetMaximumFramesPerSecond::static_encode(page_id, maximum_frames_per_second));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_window_position(u64 page_id, Web::DevicePixelPoint position)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetWindowPosition::static_encode(page_id, position));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_window_size(u64 page_id, Web::DevicePixelSize size)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetWindowSize::static_encode(page_id, size));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_update_window_rect(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DidUpdateWindowRect::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_reset_zoom(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ResetZoom::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_handle_file_return(u64 page_id, i32 error, Optional<IPC::File> const& file, i32 request_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::HandleFileReturn::static_encode(page_id, error, move(file), request_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_system_visibility_state(u64 page_id, Web::HTML::VisibilityState visibility_state)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetSystemVisibilityState::static_encode(page_id, visibility_state));
        (void)m_connection.post_message(message_buffer);
    }

    void async_alert_closed(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::AlertClosed::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_confirm_closed(u64 page_id, bool accepted)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ConfirmClosed::static_encode(page_id, accepted));
        (void)m_connection.post_message(message_buffer);
    }

    void async_prompt_closed(u64 page_id, Optional<String> const& response)
    {
        auto message_buffer = MUST(Messages::WebContentServer::PromptClosed::static_encode(page_id, move(response)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_color_picker_update(u64 page_id, Optional<Color> const& picked_color, Web::HTML::ColorPickerUpdateState const& state)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ColorPickerUpdate::static_encode(page_id, move(picked_color), move(state)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_file_picker_closed(u64 page_id, ReadonlySpan<Web::HTML::SelectedFile> selected_files)
    {
        auto message_buffer = MUST(Messages::WebContentServer::FilePickerClosed::static_encode(page_id, selected_files));
        (void)m_connection.post_message(message_buffer);
    }

    void async_select_dropdown_closed(u64 page_id, Optional<u32> const& selected_item_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SelectDropdownClosed::static_encode(page_id, move(selected_item_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_retrieved_clipboard_entries(u64 page_id, u64 request_id, ReadonlySpan<Web::Clipboard::SystemClipboardItem> items)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RetrievedClipboardEntries::static_encode(page_id, request_id, items));
        (void)m_connection.post_message(message_buffer);
    }

    void async_toggle_media_play_state(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ToggleMediaPlayState::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_toggle_media_mute_state(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ToggleMediaMuteState::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_toggle_media_loop_state(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ToggleMediaLoopState::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_toggle_media_fullscreen_state(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ToggleMediaFullscreenState::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_toggle_media_controls_state(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ToggleMediaControlsState::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_toggle_page_mute_state(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::TogglePageMuteState::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_user_style(u64 page_id, StringView source)
    {
        VERIFY(Utf8View { source }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::SetUserStyle::static_encode(page_id, source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_user_style(u64 page_id, String const& source)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetUserStyle::static_encode(page_id, source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_system_time_zone_changed()
    {
        auto message_buffer = MUST(Messages::WebContentServer::SystemTimeZoneChanged::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_document_cookie_version_buffer(u64 page_id, Core::AnonymousBuffer const& document_cookie_version_buffer)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetDocumentCookieVersionBuffer::static_encode(page_id, move(document_cookie_version_buffer)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_document_cookie_version_index(u64 page_id, i64 document_id, Core::SharedVersionIndex const& document_index)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetDocumentCookieVersionIndex::static_encode(page_id, document_id, move(document_index)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_cookies_changed(u64 page_id, ReadonlySpan<HTTP::Cookie::Cookie> cookies)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CookiesChanged::static_encode(page_id, cookies));
        (void)m_connection.post_message(message_buffer);
    }

    void async_broadcast_channel_message(Web::HTML::BroadcastChannelMessage const& message)
    {
        auto message_buffer = MUST(Messages::WebContentServer::BroadcastChannelMessage::static_encode(move(message)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_request_close(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RequestClose::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_exit_fullscreen(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ExitFullscreen::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

private:
    IPC::Connection<LocalEndpoint, PeerEndpoint>& m_connection;
};

template<typename LocalEndpoint, typename PeerEndpoint>
class WebContentServerProxy;
class WebContentServerStub;

class WebContentServerEndpoint {
public:
    template<typename LocalEndpoint>
    using Proxy = WebContentServerProxy<LocalEndpoint, WebContentServerEndpoint>;
    using Stub = WebContentServerStub;

    static u32 static_magic() { return 4289017466; }

    static ErrorOr<NonnullOwnPtr<IPC::Message>> decode_message(ReadonlyBytes buffer, [[maybe_unused]] Queue<IPC::Attachment>& attachments)
    {
        FixedMemoryStream stream { buffer };
        auto message_endpoint_magic = TRY(stream.read_value<u32>());

        if (message_endpoint_magic != static_magic())
            return Error::from_string_literal("Endpoint magic number mismatch, not my message!");

        auto message_id = TRY(stream.read_value<i32>());

        switch (message_id) {
        case (int)Messages::WebContentServer::MessageID::InitTransport:
            return Messages::WebContentServer::InitTransport::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InitTransportResponse:
            return Messages::WebContentServer::InitTransportResponse::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CloseServer:
            return Messages::WebContentServer::CloseServer::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetWindowHandle:
            return Messages::WebContentServer::GetWindowHandle::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetWindowHandleResponse:
            return Messages::WebContentServer::GetWindowHandleResponse::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetWindowHandle:
            return Messages::WebContentServer::SetWindowHandle::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ConnectToWebdriver:
            return Messages::WebContentServer::ConnectToWebdriver::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ConnectToWebUi:
            return Messages::WebContentServer::ConnectToWebUi::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ConnectToRequestServer:
            return Messages::WebContentServer::ConnectToRequestServer::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ConnectToImageDecoder:
            return Messages::WebContentServer::ConnectToImageDecoder::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ConnectToCompositor:
            return Messages::WebContentServer::ConnectToCompositor::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::UpdateSystemTheme:
            return Messages::WebContentServer::UpdateSystemTheme::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::UpdateScreenRects:
            return Messages::WebContentServer::UpdateScreenRects::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::LoadUrl:
            return Messages::WebContentServer::LoadUrl::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::LoadHtml:
            return Messages::WebContentServer::LoadHtml::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::Reload:
            return Messages::WebContentServer::Reload::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::TraverseTheHistoryByDelta:
            return Messages::WebContentServer::TraverseTheHistoryByDelta::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetViewport:
            return Messages::WebContentServer::SetViewport::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::KeyEvent:
            return Messages::WebContentServer::KeyEvent::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::MouseEvent:
            return Messages::WebContentServer::MouseEvent::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DragEvent:
            return Messages::WebContentServer::DragEvent::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::PinchEvent:
            return Messages::WebContentServer::PinchEvent::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DebugRequest:
            return Messages::WebContentServer::DebugRequest::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetSource:
            return Messages::WebContentServer::GetSource::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectDomTree:
            return Messages::WebContentServer::InspectDomTree::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectDomNode:
            return Messages::WebContentServer::InspectDomNode::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ClearInspectedDomNode:
            return Messages::WebContentServer::ClearInspectedDomNode::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::HighlightDomNode:
            return Messages::WebContentServer::HighlightDomNode::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectAccessibilityTree:
            return Messages::WebContentServer::InspectAccessibilityTree::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetHoveredNodeId:
            return Messages::WebContentServer::GetHoveredNodeId::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::JsConsoleInput:
            return Messages::WebContentServer::JsConsoleInput::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RunJavascript:
            return Messages::WebContentServer::RunJavascript::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ListStyleSheets:
            return Messages::WebContentServer::ListStyleSheets::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RequestStyleSheetSource:
            return Messages::WebContentServer::RequestStyleSheetSource::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetListenForDomMutations:
            return Messages::WebContentServer::SetListenForDomMutations::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DidConnectDevtoolsClient:
            return Messages::WebContentServer::DidConnectDevtoolsClient::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DidDisconnectDevtoolsClient:
            return Messages::WebContentServer::DidDisconnectDevtoolsClient::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetDomNodeInnerHtml:
            return Messages::WebContentServer::GetDomNodeInnerHtml::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetDomNodeOuterHtml:
            return Messages::WebContentServer::GetDomNodeOuterHtml::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetDomNodeOuterHtml:
            return Messages::WebContentServer::SetDomNodeOuterHtml::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetDomNodeText:
            return Messages::WebContentServer::SetDomNodeText::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetDomNodeTag:
            return Messages::WebContentServer::SetDomNodeTag::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::AddDomNodeAttributes:
            return Messages::WebContentServer::AddDomNodeAttributes::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ReplaceDomNodeAttribute:
            return Messages::WebContentServer::ReplaceDomNodeAttribute::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CreateChildElement:
            return Messages::WebContentServer::CreateChildElement::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CreateChildTextNode:
            return Messages::WebContentServer::CreateChildTextNode::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InsertDomNodeBefore:
            return Messages::WebContentServer::InsertDomNodeBefore::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CloneDomNode:
            return Messages::WebContentServer::CloneDomNode::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RemoveDomNode:
            return Messages::WebContentServer::RemoveDomNode::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::TakeDocumentScreenshot:
            return Messages::WebContentServer::TakeDocumentScreenshot::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::TakeDomNodeScreenshot:
            return Messages::WebContentServer::TakeDomNodeScreenshot::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RequestInternalPageInfo:
            return Messages::WebContentServer::RequestInternalPageInfo::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetSelectedText:
            return Messages::WebContentServer::GetSelectedText::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetSelectedTextResponse:
            return Messages::WebContentServer::GetSelectedTextResponse::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CutSelectedText:
            return Messages::WebContentServer::CutSelectedText::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CutSelectedTextResponse:
            return Messages::WebContentServer::CutSelectedTextResponse::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SelectAll:
            return Messages::WebContentServer::SelectAll::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::Paste:
            return Messages::WebContentServer::Paste::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::FindInPage:
            return Messages::WebContentServer::FindInPage::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::FindInPageNextMatch:
            return Messages::WebContentServer::FindInPageNextMatch::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::FindInPagePreviousMatch:
            return Messages::WebContentServer::FindInPagePreviousMatch::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetContentFilters:
            return Messages::WebContentServer::SetContentFilters::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetAutoplayAllowedOnAllWebsites:
            return Messages::WebContentServer::SetAutoplayAllowedOnAllWebsites::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetAutoplayAllowlist:
            return Messages::WebContentServer::SetAutoplayAllowlist::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetProxyMappings:
            return Messages::WebContentServer::SetProxyMappings::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetPreferredColorScheme:
            return Messages::WebContentServer::SetPreferredColorScheme::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetPreferredContrast:
            return Messages::WebContentServer::SetPreferredContrast::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetPreferredMotion:
            return Messages::WebContentServer::SetPreferredMotion::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetPreferredLanguages:
            return Messages::WebContentServer::SetPreferredLanguages::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetBrowsingBehavior:
            return Messages::WebContentServer::SetBrowsingBehavior::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetEnableGlobalPrivacyControl:
            return Messages::WebContentServer::SetEnableGlobalPrivacyControl::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetHasFocus:
            return Messages::WebContentServer::SetHasFocus::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetIsScriptingEnabled:
            return Messages::WebContentServer::SetIsScriptingEnabled::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetZoomLevel:
            return Messages::WebContentServer::SetZoomLevel::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetMaximumFramesPerSecond:
            return Messages::WebContentServer::SetMaximumFramesPerSecond::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetWindowPosition:
            return Messages::WebContentServer::SetWindowPosition::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetWindowSize:
            return Messages::WebContentServer::SetWindowSize::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DidUpdateWindowRect:
            return Messages::WebContentServer::DidUpdateWindowRect::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ResetZoom:
            return Messages::WebContentServer::ResetZoom::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::HandleFileReturn:
            return Messages::WebContentServer::HandleFileReturn::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetSystemVisibilityState:
            return Messages::WebContentServer::SetSystemVisibilityState::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::AlertClosed:
            return Messages::WebContentServer::AlertClosed::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ConfirmClosed:
            return Messages::WebContentServer::ConfirmClosed::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::PromptClosed:
            return Messages::WebContentServer::PromptClosed::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ColorPickerUpdate:
            return Messages::WebContentServer::ColorPickerUpdate::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::FilePickerClosed:
            return Messages::WebContentServer::FilePickerClosed::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SelectDropdownClosed:
            return Messages::WebContentServer::SelectDropdownClosed::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RetrievedClipboardEntries:
            return Messages::WebContentServer::RetrievedClipboardEntries::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaPlayState:
            return Messages::WebContentServer::ToggleMediaPlayState::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaMuteState:
            return Messages::WebContentServer::ToggleMediaMuteState::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaLoopState:
            return Messages::WebContentServer::ToggleMediaLoopState::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaFullscreenState:
            return Messages::WebContentServer::ToggleMediaFullscreenState::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaControlsState:
            return Messages::WebContentServer::ToggleMediaControlsState::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::TogglePageMuteState:
            return Messages::WebContentServer::TogglePageMuteState::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetUserStyle:
            return Messages::WebContentServer::SetUserStyle::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SystemTimeZoneChanged:
            return Messages::WebContentServer::SystemTimeZoneChanged::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetDocumentCookieVersionBuffer:
            return Messages::WebContentServer::SetDocumentCookieVersionBuffer::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetDocumentCookieVersionIndex:
            return Messages::WebContentServer::SetDocumentCookieVersionIndex::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CookiesChanged:
            return Messages::WebContentServer::CookiesChanged::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::BroadcastChannelMessage:
            return Messages::WebContentServer::BroadcastChannelMessage::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RequestClose:
            return Messages::WebContentServer::RequestClose::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ExitFullscreen:
            return Messages::WebContentServer::ExitFullscreen::decode(stream, attachments);
        default:
            return Error::from_string_literal("Failed to decode WebContentServer message");
        }

        VERIFY_NOT_REACHED();
    }
};

class WebContentServerStub : public IPC::Stub {
public:
    WebContentServerStub() { }
    virtual ~WebContentServerStub() override { }

    virtual u32 magic() const override { return 4289017466; }
    virtual ByteString name() const override { return "WebContentServer"; }

    virtual ErrorOr<OwnPtr<IPC::MessageBuffer>> handle(NonnullOwnPtr<IPC::Message> message) override
    {
        switch (message->message_id()) {
        case (int)Messages::WebContentServer::MessageID::InitTransport:
            return handle_init_transport(*message);
        case (int)Messages::WebContentServer::MessageID::CloseServer:
            return handle_close_server();
        case (int)Messages::WebContentServer::MessageID::GetWindowHandle:
            return handle_get_window_handle(*message);
        case (int)Messages::WebContentServer::MessageID::SetWindowHandle:
            return handle_set_window_handle(*message);
        case (int)Messages::WebContentServer::MessageID::ConnectToWebdriver:
            return handle_connect_to_webdriver(*message);
        case (int)Messages::WebContentServer::MessageID::ConnectToWebUi:
            return handle_connect_to_web_ui(*message);
        case (int)Messages::WebContentServer::MessageID::ConnectToRequestServer:
            return handle_connect_to_request_server(*message);
        case (int)Messages::WebContentServer::MessageID::ConnectToImageDecoder:
            return handle_connect_to_image_decoder(*message);
        case (int)Messages::WebContentServer::MessageID::ConnectToCompositor:
            return handle_connect_to_compositor(*message);
        case (int)Messages::WebContentServer::MessageID::UpdateSystemTheme:
            return handle_update_system_theme(*message);
        case (int)Messages::WebContentServer::MessageID::UpdateScreenRects:
            return handle_update_screen_rects(*message);
        case (int)Messages::WebContentServer::MessageID::LoadUrl:
            return handle_load_url(*message);
        case (int)Messages::WebContentServer::MessageID::LoadHtml:
            return handle_load_html(*message);
        case (int)Messages::WebContentServer::MessageID::Reload:
            return handle_reload(*message);
        case (int)Messages::WebContentServer::MessageID::TraverseTheHistoryByDelta:
            return handle_traverse_the_history_by_delta(*message);
        case (int)Messages::WebContentServer::MessageID::SetViewport:
            return handle_set_viewport(*message);
        case (int)Messages::WebContentServer::MessageID::KeyEvent:
            return handle_key_event(*message);
        case (int)Messages::WebContentServer::MessageID::MouseEvent:
            return handle_mouse_event(*message);
        case (int)Messages::WebContentServer::MessageID::DragEvent:
            return handle_drag_event(*message);
        case (int)Messages::WebContentServer::MessageID::PinchEvent:
            return handle_pinch_event(*message);
        case (int)Messages::WebContentServer::MessageID::DebugRequest:
            return handle_debug_request(*message);
        case (int)Messages::WebContentServer::MessageID::GetSource:
            return handle_get_source(*message);
        case (int)Messages::WebContentServer::MessageID::InspectDomTree:
            return handle_inspect_dom_tree(*message);
        case (int)Messages::WebContentServer::MessageID::InspectDomNode:
            return handle_inspect_dom_node(*message);
        case (int)Messages::WebContentServer::MessageID::ClearInspectedDomNode:
            return handle_clear_inspected_dom_node(*message);
        case (int)Messages::WebContentServer::MessageID::HighlightDomNode:
            return handle_highlight_dom_node(*message);
        case (int)Messages::WebContentServer::MessageID::InspectAccessibilityTree:
            return handle_inspect_accessibility_tree(*message);
        case (int)Messages::WebContentServer::MessageID::GetHoveredNodeId:
            return handle_get_hovered_node_id(*message);
        case (int)Messages::WebContentServer::MessageID::JsConsoleInput:
            return handle_js_console_input(*message);
        case (int)Messages::WebContentServer::MessageID::RunJavascript:
            return handle_run_javascript(*message);
        case (int)Messages::WebContentServer::MessageID::ListStyleSheets:
            return handle_list_style_sheets(*message);
        case (int)Messages::WebContentServer::MessageID::RequestStyleSheetSource:
            return handle_request_style_sheet_source(*message);
        case (int)Messages::WebContentServer::MessageID::SetListenForDomMutations:
            return handle_set_listen_for_dom_mutations(*message);
        case (int)Messages::WebContentServer::MessageID::DidConnectDevtoolsClient:
            return handle_did_connect_devtools_client(*message);
        case (int)Messages::WebContentServer::MessageID::DidDisconnectDevtoolsClient:
            return handle_did_disconnect_devtools_client(*message);
        case (int)Messages::WebContentServer::MessageID::GetDomNodeInnerHtml:
            return handle_get_dom_node_inner_html(*message);
        case (int)Messages::WebContentServer::MessageID::GetDomNodeOuterHtml:
            return handle_get_dom_node_outer_html(*message);
        case (int)Messages::WebContentServer::MessageID::SetDomNodeOuterHtml:
            return handle_set_dom_node_outer_html(*message);
        case (int)Messages::WebContentServer::MessageID::SetDomNodeText:
            return handle_set_dom_node_text(*message);
        case (int)Messages::WebContentServer::MessageID::SetDomNodeTag:
            return handle_set_dom_node_tag(*message);
        case (int)Messages::WebContentServer::MessageID::AddDomNodeAttributes:
            return handle_add_dom_node_attributes(*message);
        case (int)Messages::WebContentServer::MessageID::ReplaceDomNodeAttribute:
            return handle_replace_dom_node_attribute(*message);
        case (int)Messages::WebContentServer::MessageID::CreateChildElement:
            return handle_create_child_element(*message);
        case (int)Messages::WebContentServer::MessageID::CreateChildTextNode:
            return handle_create_child_text_node(*message);
        case (int)Messages::WebContentServer::MessageID::InsertDomNodeBefore:
            return handle_insert_dom_node_before(*message);
        case (int)Messages::WebContentServer::MessageID::CloneDomNode:
            return handle_clone_dom_node(*message);
        case (int)Messages::WebContentServer::MessageID::RemoveDomNode:
            return handle_remove_dom_node(*message);
        case (int)Messages::WebContentServer::MessageID::TakeDocumentScreenshot:
            return handle_take_document_screenshot(*message);
        case (int)Messages::WebContentServer::MessageID::TakeDomNodeScreenshot:
            return handle_take_dom_node_screenshot(*message);
        case (int)Messages::WebContentServer::MessageID::RequestInternalPageInfo:
            return handle_request_internal_page_info(*message);
        case (int)Messages::WebContentServer::MessageID::GetSelectedText:
            return handle_get_selected_text(*message);
        case (int)Messages::WebContentServer::MessageID::CutSelectedText:
            return handle_cut_selected_text(*message);
        case (int)Messages::WebContentServer::MessageID::SelectAll:
            return handle_select_all(*message);
        case (int)Messages::WebContentServer::MessageID::Paste:
            return handle_paste(*message);
        case (int)Messages::WebContentServer::MessageID::FindInPage:
            return handle_find_in_page(*message);
        case (int)Messages::WebContentServer::MessageID::FindInPageNextMatch:
            return handle_find_in_page_next_match(*message);
        case (int)Messages::WebContentServer::MessageID::FindInPagePreviousMatch:
            return handle_find_in_page_previous_match(*message);
        case (int)Messages::WebContentServer::MessageID::SetContentFilters:
            return handle_set_content_filters(*message);
        case (int)Messages::WebContentServer::MessageID::SetAutoplayAllowedOnAllWebsites:
            return handle_set_autoplay_allowed_on_all_websites(*message);
        case (int)Messages::WebContentServer::MessageID::SetAutoplayAllowlist:
            return handle_set_autoplay_allowlist(*message);
        case (int)Messages::WebContentServer::MessageID::SetProxyMappings:
            return handle_set_proxy_mappings(*message);
        case (int)Messages::WebContentServer::MessageID::SetPreferredColorScheme:
            return handle_set_preferred_color_scheme(*message);
        case (int)Messages::WebContentServer::MessageID::SetPreferredContrast:
            return handle_set_preferred_contrast(*message);
        case (int)Messages::WebContentServer::MessageID::SetPreferredMotion:
            return handle_set_preferred_motion(*message);
        case (int)Messages::WebContentServer::MessageID::SetPreferredLanguages:
            return handle_set_preferred_languages(*message);
        case (int)Messages::WebContentServer::MessageID::SetBrowsingBehavior:
            return handle_set_browsing_behavior(*message);
        case (int)Messages::WebContentServer::MessageID::SetEnableGlobalPrivacyControl:
            return handle_set_enable_global_privacy_control(*message);
        case (int)Messages::WebContentServer::MessageID::SetHasFocus:
            return handle_set_has_focus(*message);
        case (int)Messages::WebContentServer::MessageID::SetIsScriptingEnabled:
            return handle_set_is_scripting_enabled(*message);
        case (int)Messages::WebContentServer::MessageID::SetZoomLevel:
            return handle_set_zoom_level(*message);
        case (int)Messages::WebContentServer::MessageID::SetMaximumFramesPerSecond:
            return handle_set_maximum_frames_per_second(*message);
        case (int)Messages::WebContentServer::MessageID::SetWindowPosition:
            return handle_set_window_position(*message);
        case (int)Messages::WebContentServer::MessageID::SetWindowSize:
            return handle_set_window_size(*message);
        case (int)Messages::WebContentServer::MessageID::DidUpdateWindowRect:
            return handle_did_update_window_rect(*message);
        case (int)Messages::WebContentServer::MessageID::ResetZoom:
            return handle_reset_zoom(*message);
        case (int)Messages::WebContentServer::MessageID::HandleFileReturn:
            return handle_handle_file_return(*message);
        case (int)Messages::WebContentServer::MessageID::SetSystemVisibilityState:
            return handle_set_system_visibility_state(*message);
        case (int)Messages::WebContentServer::MessageID::AlertClosed:
            return handle_alert_closed(*message);
        case (int)Messages::WebContentServer::MessageID::ConfirmClosed:
            return handle_confirm_closed(*message);
        case (int)Messages::WebContentServer::MessageID::PromptClosed:
            return handle_prompt_closed(*message);
        case (int)Messages::WebContentServer::MessageID::ColorPickerUpdate:
            return handle_color_picker_update(*message);
        case (int)Messages::WebContentServer::MessageID::FilePickerClosed:
            return handle_file_picker_closed(*message);
        case (int)Messages::WebContentServer::MessageID::SelectDropdownClosed:
            return handle_select_dropdown_closed(*message);
        case (int)Messages::WebContentServer::MessageID::RetrievedClipboardEntries:
            return handle_retrieved_clipboard_entries(*message);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaPlayState:
            return handle_toggle_media_play_state(*message);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaMuteState:
            return handle_toggle_media_mute_state(*message);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaLoopState:
            return handle_toggle_media_loop_state(*message);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaFullscreenState:
            return handle_toggle_media_fullscreen_state(*message);
        case (int)Messages::WebContentServer::MessageID::ToggleMediaControlsState:
            return handle_toggle_media_controls_state(*message);
        case (int)Messages::WebContentServer::MessageID::TogglePageMuteState:
            return handle_toggle_page_mute_state(*message);
        case (int)Messages::WebContentServer::MessageID::SetUserStyle:
            return handle_set_user_style(*message);
        case (int)Messages::WebContentServer::MessageID::SystemTimeZoneChanged:
            return handle_system_time_zone_changed();
        case (int)Messages::WebContentServer::MessageID::SetDocumentCookieVersionBuffer:
            return handle_set_document_cookie_version_buffer(*message);
        case (int)Messages::WebContentServer::MessageID::SetDocumentCookieVersionIndex:
            return handle_set_document_cookie_version_index(*message);
        case (int)Messages::WebContentServer::MessageID::CookiesChanged:
            return handle_cookies_changed(*message);
        case (int)Messages::WebContentServer::MessageID::BroadcastChannelMessage:
            return handle_broadcast_channel_message(*message);
        case (int)Messages::WebContentServer::MessageID::RequestClose:
            return handle_request_close(*message);
        case (int)Messages::WebContentServer::MessageID::ExitFullscreen:
            return handle_exit_fullscreen(*message);
        default:
            return Error::from_string_literal("Unknown message ID for WebContentServer endpoint");
        }
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_init_transport(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InitTransport&>(message);
        auto response = init_transport(request.peer_pid());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_close_server()
    {
        close_server();
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_window_handle(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::GetWindowHandle&>(message);
        auto response = get_window_handle(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_window_handle(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetWindowHandle&>(message);
        set_window_handle(request.page_id(), request.take_handle());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_connect_to_webdriver(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ConnectToWebdriver&>(message);
        connect_to_webdriver(request.page_id(), request.take_webdriver_endpoint());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_connect_to_web_ui(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ConnectToWebUi&>(message);
        connect_to_web_ui(request.page_id(), request.take_handle());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_connect_to_request_server(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ConnectToRequestServer&>(message);
        connect_to_request_server(request.take_handle());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_connect_to_image_decoder(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ConnectToImageDecoder&>(message);
        connect_to_image_decoder(request.take_handle());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_connect_to_compositor(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ConnectToCompositor&>(message);
        connect_to_compositor(request.take_handle());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_update_system_theme(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::UpdateSystemTheme&>(message);
        update_system_theme(request.page_id(), request.take_theme_buffer());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_update_screen_rects(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::UpdateScreenRects&>(message);
        update_screen_rects(request.page_id(), request.take_rects(), request.main_screen_index());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_load_url(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::LoadUrl&>(message);
        load_url(request.page_id(), request.take_url());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_load_html(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::LoadHtml&>(message);
        load_html(request.page_id(), request.take_html());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_reload(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::Reload&>(message);
        reload(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_traverse_the_history_by_delta(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::TraverseTheHistoryByDelta&>(message);
        traverse_the_history_by_delta(request.page_id(), request.delta());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_viewport(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetViewport&>(message);
        set_viewport(request.page_id(), request.size(), request.device_pixel_ratio(), request.take_is_fullscreen());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_key_event(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::KeyEvent&>(message);
        key_event(request.page_id(), request.take_event());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_mouse_event(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::MouseEvent&>(message);
        mouse_event(request.page_id(), request.take_event());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_drag_event(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DragEvent&>(message);
        drag_event(request.page_id(), request.take_event());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_pinch_event(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::PinchEvent&>(message);
        pinch_event(request.page_id(), request.take_event());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_debug_request(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DebugRequest&>(message);
        debug_request(request.page_id(), request.take_request(), request.take_argument());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_source(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::GetSource&>(message);
        get_source(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_inspect_dom_tree(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectDomTree&>(message);
        inspect_dom_tree(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_inspect_dom_node(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectDomNode&>(message);
        inspect_dom_node(request.page_id(), request.take_property_type(), request.take_node_id(), request.take_pseudo_element());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_clear_inspected_dom_node(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ClearInspectedDomNode&>(message);
        clear_inspected_dom_node(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_highlight_dom_node(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::HighlightDomNode&>(message);
        highlight_dom_node(request.page_id(), request.take_node_id(), request.take_pseudo_element());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_inspect_accessibility_tree(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectAccessibilityTree&>(message);
        inspect_accessibility_tree(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_hovered_node_id(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::GetHoveredNodeId&>(message);
        get_hovered_node_id(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_js_console_input(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::JsConsoleInput&>(message);
        js_console_input(request.page_id(), request.take_js_source());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_run_javascript(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RunJavascript&>(message);
        run_javascript(request.page_id(), request.take_js_source());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_list_style_sheets(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ListStyleSheets&>(message);
        list_style_sheets(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_request_style_sheet_source(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RequestStyleSheetSource&>(message);
        request_style_sheet_source(request.page_id(), request.take_identifier());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_listen_for_dom_mutations(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetListenForDomMutations&>(message);
        set_listen_for_dom_mutations(request.page_id(), request.listen_for_dom_mutations());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_connect_devtools_client(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DidConnectDevtoolsClient&>(message);
        did_connect_devtools_client(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_disconnect_devtools_client(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DidDisconnectDevtoolsClient&>(message);
        did_disconnect_devtools_client(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_dom_node_inner_html(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::GetDomNodeInnerHtml&>(message);
        get_dom_node_inner_html(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_dom_node_outer_html(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::GetDomNodeOuterHtml&>(message);
        get_dom_node_outer_html(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_dom_node_outer_html(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetDomNodeOuterHtml&>(message);
        set_dom_node_outer_html(request.page_id(), request.take_node_id(), request.take_html());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_dom_node_text(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetDomNodeText&>(message);
        set_dom_node_text(request.page_id(), request.take_node_id(), request.take_text());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_dom_node_tag(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetDomNodeTag&>(message);
        set_dom_node_tag(request.page_id(), request.take_node_id(), request.take_name());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_add_dom_node_attributes(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::AddDomNodeAttributes&>(message);
        add_dom_node_attributes(request.page_id(), request.take_node_id(), request.take_attributes());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_replace_dom_node_attribute(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ReplaceDomNodeAttribute&>(message);
        replace_dom_node_attribute(request.page_id(), request.take_node_id(), request.take_name(), request.take_replacement_attributes());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_create_child_element(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CreateChildElement&>(message);
        create_child_element(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_create_child_text_node(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CreateChildTextNode&>(message);
        create_child_text_node(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_insert_dom_node_before(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InsertDomNodeBefore&>(message);
        insert_dom_node_before(request.page_id(), request.take_node_id(), request.take_parent_node_id(), request.take_sibling_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_clone_dom_node(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CloneDomNode&>(message);
        clone_dom_node(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_remove_dom_node(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RemoveDomNode&>(message);
        remove_dom_node(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_take_document_screenshot(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::TakeDocumentScreenshot&>(message);
        take_document_screenshot(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_take_dom_node_screenshot(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::TakeDomNodeScreenshot&>(message);
        take_dom_node_screenshot(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_request_internal_page_info(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RequestInternalPageInfo&>(message);
        request_internal_page_info(request.page_id(), request.type());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_selected_text(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::GetSelectedText&>(message);
        auto response = get_selected_text(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_cut_selected_text(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CutSelectedText&>(message);
        auto response = cut_selected_text(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_select_all(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SelectAll&>(message);
        select_all(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_paste(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::Paste&>(message);
        paste(request.page_id(), request.take_text());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_in_page(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::FindInPage&>(message);
        find_in_page(request.page_id(), request.take_query(), request.case_sensitivity());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_in_page_next_match(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::FindInPageNextMatch&>(message);
        find_in_page_next_match(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_in_page_previous_match(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::FindInPagePreviousMatch&>(message);
        find_in_page_previous_match(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_content_filters(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetContentFilters&>(message);
        set_content_filters(request.page_id(), request.take_filters());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_autoplay_allowed_on_all_websites(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetAutoplayAllowedOnAllWebsites&>(message);
        set_autoplay_allowed_on_all_websites(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_autoplay_allowlist(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetAutoplayAllowlist&>(message);
        set_autoplay_allowlist(request.page_id(), request.take_allowlist());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_proxy_mappings(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetProxyMappings&>(message);
        set_proxy_mappings(request.page_id(), request.take_proxies(), request.take_mappings());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_preferred_color_scheme(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetPreferredColorScheme&>(message);
        set_preferred_color_scheme(request.page_id(), request.take_color_scheme());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_preferred_contrast(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetPreferredContrast&>(message);
        set_preferred_contrast(request.page_id(), request.take_contrast());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_preferred_motion(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetPreferredMotion&>(message);
        set_preferred_motion(request.page_id(), request.take_motion());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_preferred_languages(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetPreferredLanguages&>(message);
        set_preferred_languages(request.page_id(), request.take_preferred_languages());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_browsing_behavior(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetBrowsingBehavior&>(message);
        set_browsing_behavior(request.page_id(), request.take_browsing_behavior());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_enable_global_privacy_control(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetEnableGlobalPrivacyControl&>(message);
        set_enable_global_privacy_control(request.page_id(), request.enable());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_has_focus(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetHasFocus&>(message);
        set_has_focus(request.page_id(), request.has_focus());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_is_scripting_enabled(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetIsScriptingEnabled&>(message);
        set_is_scripting_enabled(request.page_id(), request.is_scripting_enabled());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_zoom_level(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetZoomLevel&>(message);
        set_zoom_level(request.page_id(), request.zoom_level());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_maximum_frames_per_second(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetMaximumFramesPerSecond&>(message);
        set_maximum_frames_per_second(request.page_id(), request.maximum_frames_per_second());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_window_position(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetWindowPosition&>(message);
        set_window_position(request.page_id(), request.position());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_window_size(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetWindowSize&>(message);
        set_window_size(request.page_id(), request.size());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_window_rect(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DidUpdateWindowRect&>(message);
        did_update_window_rect(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_reset_zoom(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ResetZoom&>(message);
        reset_zoom(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_handle_file_return(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::HandleFileReturn&>(message);
        handle_file_return(request.page_id(), request.error(), request.take_file(), request.request_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_system_visibility_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetSystemVisibilityState&>(message);
        set_system_visibility_state(request.page_id(), request.visibility_state());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_alert_closed(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::AlertClosed&>(message);
        alert_closed(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_confirm_closed(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ConfirmClosed&>(message);
        confirm_closed(request.page_id(), request.accepted());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_prompt_closed(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::PromptClosed&>(message);
        prompt_closed(request.page_id(), request.take_response());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_color_picker_update(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ColorPickerUpdate&>(message);
        color_picker_update(request.page_id(), request.take_picked_color(), request.take_state());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_file_picker_closed(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::FilePickerClosed&>(message);
        file_picker_closed(request.page_id(), request.take_selected_files());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_select_dropdown_closed(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SelectDropdownClosed&>(message);
        select_dropdown_closed(request.page_id(), request.take_selected_item_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_retrieved_clipboard_entries(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RetrievedClipboardEntries&>(message);
        retrieved_clipboard_entries(request.page_id(), request.request_id(), request.take_items());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_toggle_media_play_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ToggleMediaPlayState&>(message);
        toggle_media_play_state(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_toggle_media_mute_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ToggleMediaMuteState&>(message);
        toggle_media_mute_state(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_toggle_media_loop_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ToggleMediaLoopState&>(message);
        toggle_media_loop_state(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_toggle_media_fullscreen_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ToggleMediaFullscreenState&>(message);
        toggle_media_fullscreen_state(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_toggle_media_controls_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ToggleMediaControlsState&>(message);
        toggle_media_controls_state(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_toggle_page_mute_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::TogglePageMuteState&>(message);
        toggle_page_mute_state(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_user_style(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetUserStyle&>(message);
        set_user_style(request.page_id(), request.take_source());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_system_time_zone_changed()
    {
        system_time_zone_changed();
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_document_cookie_version_buffer(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetDocumentCookieVersionBuffer&>(message);
        set_document_cookie_version_buffer(request.page_id(), request.take_document_cookie_version_buffer());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_document_cookie_version_index(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetDocumentCookieVersionIndex&>(message);
        set_document_cookie_version_index(request.page_id(), request.document_id(), request.take_document_index());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_cookies_changed(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CookiesChanged&>(message);
        cookies_changed(request.page_id(), request.take_cookies());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_broadcast_channel_message(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::BroadcastChannelMessage&>(message);
        broadcast_channel_message(request.take_message());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_request_close(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RequestClose&>(message);
        request_close(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_exit_fullscreen(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ExitFullscreen&>(message);
        exit_fullscreen(request.page_id());
        return nullptr;
    }

    virtual Messages::WebContentServer::InitTransportResponse init_transport(int peer_pid) = 0;
    virtual void close_server() = 0;
    virtual Messages::WebContentServer::GetWindowHandleResponse get_window_handle(u64 page_id) = 0;
    virtual void set_window_handle(u64 page_id, String handle) = 0;
    virtual void connect_to_webdriver(u64 page_id, ByteString webdriver_endpoint) = 0;
    virtual void connect_to_web_ui(u64 page_id, IPC::TransportHandle handle) = 0;
    virtual void connect_to_request_server(IPC::TransportHandle handle) = 0;
    virtual void connect_to_image_decoder(IPC::TransportHandle handle) = 0;
    virtual void connect_to_compositor(IPC::TransportHandle handle) = 0;
    virtual void update_system_theme(u64 page_id, Core::AnonymousBuffer theme_buffer) = 0;
    virtual void update_screen_rects(u64 page_id, Vector<Web::DevicePixelRect> rects, u32 main_screen_index) = 0;
    virtual void load_url(u64 page_id, URL::URL url) = 0;
    virtual void load_html(u64 page_id, ByteString html) = 0;
    virtual void reload(u64 page_id) = 0;
    virtual void traverse_the_history_by_delta(u64 page_id, i32 delta) = 0;
    virtual void set_viewport(u64 page_id, Web::DevicePixelSize size, double device_pixel_ratio, Web::ViewportIsFullscreen is_fullscreen) = 0;
    virtual void key_event(u64 page_id, Web::KeyEvent event) = 0;
    virtual void mouse_event(u64 page_id, Web::MouseEvent event) = 0;
    virtual void drag_event(u64 page_id, Web::DragEvent event) = 0;
    virtual void pinch_event(u64 page_id, Web::PinchEvent event) = 0;
    virtual void debug_request(u64 page_id, ByteString request, ByteString argument) = 0;
    virtual void get_source(u64 page_id) = 0;
    virtual void inspect_dom_tree(u64 page_id) = 0;
    virtual void inspect_dom_node(u64 page_id, WebView::DOMNodeProperties::Type property_type, Web::UniqueNodeID node_id, Optional<Web::CSS::PseudoElement> pseudo_element) = 0;
    virtual void clear_inspected_dom_node(u64 page_id) = 0;
    virtual void highlight_dom_node(u64 page_id, Web::UniqueNodeID node_id, Optional<Web::CSS::PseudoElement> pseudo_element) = 0;
    virtual void inspect_accessibility_tree(u64 page_id) = 0;
    virtual void get_hovered_node_id(u64 page_id) = 0;
    virtual void js_console_input(u64 page_id, String js_source) = 0;
    virtual void run_javascript(u64 page_id, String js_source) = 0;
    virtual void list_style_sheets(u64 page_id) = 0;
    virtual void request_style_sheet_source(u64 page_id, Web::CSS::StyleSheetIdentifier identifier) = 0;
    virtual void set_listen_for_dom_mutations(u64 page_id, bool listen_for_dom_mutations) = 0;
    virtual void did_connect_devtools_client(u64 page_id) = 0;
    virtual void did_disconnect_devtools_client(u64 page_id) = 0;
    virtual void get_dom_node_inner_html(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void get_dom_node_outer_html(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void set_dom_node_outer_html(u64 page_id, Web::UniqueNodeID node_id, String html) = 0;
    virtual void set_dom_node_text(u64 page_id, Web::UniqueNodeID node_id, String text) = 0;
    virtual void set_dom_node_tag(u64 page_id, Web::UniqueNodeID node_id, String name) = 0;
    virtual void add_dom_node_attributes(u64 page_id, Web::UniqueNodeID node_id, Vector<WebView::Attribute> attributes) = 0;
    virtual void replace_dom_node_attribute(u64 page_id, Web::UniqueNodeID node_id, String name, Vector<WebView::Attribute> replacement_attributes) = 0;
    virtual void create_child_element(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void create_child_text_node(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void insert_dom_node_before(u64 page_id, Web::UniqueNodeID node_id, Web::UniqueNodeID parent_node_id, Optional<Web::UniqueNodeID> sibling_node_id) = 0;
    virtual void clone_dom_node(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void remove_dom_node(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void take_document_screenshot(u64 page_id) = 0;
    virtual void take_dom_node_screenshot(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void request_internal_page_info(u64 page_id, WebView::PageInfoType type) = 0;
    virtual Messages::WebContentServer::GetSelectedTextResponse get_selected_text(u64 page_id) = 0;
    virtual Messages::WebContentServer::CutSelectedTextResponse cut_selected_text(u64 page_id) = 0;
    virtual void select_all(u64 page_id) = 0;
    virtual void paste(u64 page_id, Utf16String text) = 0;
    virtual void find_in_page(u64 page_id, String query, AK::CaseSensitivity case_sensitivity) = 0;
    virtual void find_in_page_next_match(u64 page_id) = 0;
    virtual void find_in_page_previous_match(u64 page_id) = 0;
    virtual void set_content_filters(u64 page_id, Vector<String> filters) = 0;
    virtual void set_autoplay_allowed_on_all_websites(u64 page_id) = 0;
    virtual void set_autoplay_allowlist(u64 page_id, Vector<String> allowlist) = 0;
    virtual void set_proxy_mappings(u64 page_id, Vector<ByteString> proxies, HashMap<ByteString, size_t> mappings) = 0;
    virtual void set_preferred_color_scheme(u64 page_id, Web::CSS::PreferredColorScheme color_scheme) = 0;
    virtual void set_preferred_contrast(u64 page_id, Web::CSS::PreferredContrast contrast) = 0;
    virtual void set_preferred_motion(u64 page_id, Web::CSS::PreferredMotion motion) = 0;
    virtual void set_preferred_languages(u64 page_id, Vector<String> preferred_languages) = 0;
    virtual void set_browsing_behavior(u64 page_id, WebView::BrowsingBehavior browsing_behavior) = 0;
    virtual void set_enable_global_privacy_control(u64 page_id, bool enable) = 0;
    virtual void set_has_focus(u64 page_id, bool has_focus) = 0;
    virtual void set_is_scripting_enabled(u64 page_id, bool is_scripting_enabled) = 0;
    virtual void set_zoom_level(u64 page_id, double zoom_level) = 0;
    virtual void set_maximum_frames_per_second(u64 page_id, double maximum_frames_per_second) = 0;
    virtual void set_window_position(u64 page_id, Web::DevicePixelPoint position) = 0;
    virtual void set_window_size(u64 page_id, Web::DevicePixelSize size) = 0;
    virtual void did_update_window_rect(u64 page_id) = 0;
    virtual void reset_zoom(u64 page_id) = 0;
    virtual void handle_file_return(u64 page_id, i32 error, Optional<IPC::File> file, i32 request_id) = 0;
    virtual void set_system_visibility_state(u64 page_id, Web::HTML::VisibilityState visibility_state) = 0;
    virtual void alert_closed(u64 page_id) = 0;
    virtual void confirm_closed(u64 page_id, bool accepted) = 0;
    virtual void prompt_closed(u64 page_id, Optional<String> response) = 0;
    virtual void color_picker_update(u64 page_id, Optional<Color> picked_color, Web::HTML::ColorPickerUpdateState state) = 0;
    virtual void file_picker_closed(u64 page_id, Vector<Web::HTML::SelectedFile> selected_files) = 0;
    virtual void select_dropdown_closed(u64 page_id, Optional<u32> selected_item_id) = 0;
    virtual void retrieved_clipboard_entries(u64 page_id, u64 request_id, Vector<Web::Clipboard::SystemClipboardItem> items) = 0;
    virtual void toggle_media_play_state(u64 page_id) = 0;
    virtual void toggle_media_mute_state(u64 page_id) = 0;
    virtual void toggle_media_loop_state(u64 page_id) = 0;
    virtual void toggle_media_fullscreen_state(u64 page_id) = 0;
    virtual void toggle_media_controls_state(u64 page_id) = 0;
    virtual void toggle_page_mute_state(u64 page_id) = 0;
    virtual void set_user_style(u64 page_id, String source) = 0;
    virtual void system_time_zone_changed() = 0;
    virtual void set_document_cookie_version_buffer(u64 page_id, Core::AnonymousBuffer document_cookie_version_buffer) = 0;
    virtual void set_document_cookie_version_index(u64 page_id, i64 document_id, Core::SharedVersionIndex document_index) = 0;
    virtual void cookies_changed(u64 page_id, Vector<HTTP::Cookie::Cookie> cookies) = 0;
    virtual void broadcast_channel_message(Web::HTML::BroadcastChannelMessage message) = 0;
    virtual void request_close(u64 page_id) = 0;
    virtual void exit_fullscreen(u64 page_id) = 0;
};

#if defined(AK_COMPILER_CLANG)
#pragma clang diagnostic pop
#endif