#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/Bindings/Navigation.h>
#include <LibWeb/Clipboard/SystemClipboard.h>
#include <LibWeb/Compositor/Types.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/AudioPlayState.h>
#include <LibWeb/HTML/AutoplayPolicy.h>
#include <LibWeb/HTML/ColorPickerUpdateState.h>
#include <LibWeb/HTML/BroadcastChannelMessage.h>
#include <LibWeb/HTML/NavigableId.h>
#include <LibWeb/HTML/SelectedFile.h>
#include <LibWeb/HTML/SessionHistoryEntry.h>
#include <LibWeb/HTML/VisibilityState.h>
#include <LibWeb/HTML/WorkerAgentTypes.h>
#include <LibWeb/Page/InputEvent.h>
#include <LibWeb/HTML/Scripting/ScriptRegistry.h>
#include <LibWeb/StorageAPI/StorageEndpoint.h>
#include <LibWeb/Page/ViewportIsFullscreen.h>
#include <LibWeb/WebDriver/ExecuteScript.h>
#include <LibWeb/WebDriver/Response.h>
#include <LibWebView/Attribute.h>
#include <LibWebView/DictionaryLookup.h>
#include <LibWebView/DOMNodeProperties.h>
#include <LibWebView/PageInfo.h>
#include <LibWebView/Settings.h>
#include <LibWebView/StorageSetResult.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,
    Initialize = 3,
    CloseServer = 4,
    GetWindowHandle = 5,
    GetWindowHandleResponse = 6,
    SetWindowHandle = 7,
    ConnectToWebdriver = 8,
    CompleteWebdriverHistoryTraversal = 9,
    CompleteWebdriverNavigationCompletion = 10,
    ConnectToWebUi = 11,
    ConnectToRequestServer = 12,
    ConnectToImageDecoder = 13,
    ConnectToCompositorProcess = 14,
    CompositorProcessReconnected = 15,
    UpdateSystemTheme = 16,
    UpdateScreenRects = 17,
    LoadUrl = 18,
    LoadUrlWithDocumentResource = 19,
    LoadHtml = 20,
    LoadHtmlWithUrl = 21,
    Reload = 22,
    CancelDownload = 23,
    RunIframeLoadEventSteps = 24,
    SetPageParentContext = 25,
    SetRemoteChildFrameCompositorContext = 26,
    TraverseTheHistoryToStep = 27,
    CheckIfTraverseHistoryStepIsCanceled = 28,
    SetTopLevelSessionHistory = 29,
    ResetSessionHistoryForTesting = 30,
    SetViewport = 31,
    KeyEvent = 32,
    MouseEvent = 33,
    DragEvent = 34,
    PinchEvent = 35,
    DebugRequest = 36,
    GetSource = 37,
    InspectDomTree = 38,
    InspectStorage = 39,
    SetSessionStorageItem = 40,
    SetSessionStorageItemResponse = 41,
    RemoveSessionStorageItem = 42,
    RemoveSessionStorageItemResponse = 43,
    ClearSessionStorage = 44,
    ClearSessionStorageResponse = 45,
    InspectDomNode = 46,
    InspectGridLayouts = 47,
    InspectCurrentGrid = 48,
    InspectCurrentFlexbox = 49,
    InspectIndexedDatabaseStorage = 50,
    InspectIndexedDatabaseObjects = 51,
    DeleteIndexedDatabase = 52,
    ClearIndexedDatabaseObjectStore = 53,
    DeleteIndexedDatabaseRecord = 54,
    ClearInspectedDomNode = 55,
    HighlightDomNode = 56,
    HighlightFlexbox = 57,
    ClearFlexboxHighlight = 58,
    HighlightGrid = 59,
    ClearGridHighlight = 60,
    InspectAccessibilityTree = 61,
    GetHoveredNodeId = 62,
    GetNodeIdAtPosition = 63,
    JsConsoleInput = 64,
    RunJavascript = 65,
    ListStyleSheets = 66,
    RequestStyleSheetSource = 67,
    ListDevtoolsSources = 68,
    RequestDevtoolsSource = 69,
    ResolveDomNodeUrl = 70,
    SetListenForDomMutations = 71,
    DidConnectDevtoolsClient = 72,
    DidDisconnectDevtoolsClient = 73,
    GetDomNodeInnerHtml = 74,
    GetDomNodeOuterHtml = 75,
    SetDomNodeOuterHtml = 76,
    SetDomNodeText = 77,
    SetDomNodeTag = 78,
    AddDomNodeAttributes = 79,
    ReplaceDomNodeAttribute = 80,
    CreateChildElement = 81,
    CreateChildTextNode = 82,
    InsertDomNodeBefore = 83,
    CloneDomNode = 84,
    RemoveDomNode = 85,
    TakeDocumentScreenshot = 86,
    TakeDomNodeScreenshot = 87,
    RequestInternalPageInfo = 88,
    GetSelectedText = 89,
    GetSelectedTextResponse = 90,
    GetSelectedTextForLookup = 91,
    GetSelectedTextForLookupResponse = 92,
    SelectWordForDictionaryLookup = 93,
    SelectWordForDictionaryLookupResponse = 94,
    CutSelectedText = 95,
    CutSelectedTextResponse = 96,
    SelectAll = 97,
    Paste = 98,
    SetMarkedTextFromInputMethod = 99,
    CommitTextFromInputMethod = 100,
    UnmarkTextFromInputMethod = 101,
    FindInPage = 102,
    FindInPageNextMatch = 103,
    FindInPagePreviousMatch = 104,
    SetContentBlockers = 105,
    SetAutoplaySettings = 106,
    SetProxyMappings = 107,
    SetPreferredColorScheme = 108,
    SetPreferredContrast = 109,
    SetPreferredMotion = 110,
    SetPreferredLanguages = 111,
    SetBrowsingBehavior = 112,
    SetEnableGlobalPrivacyControl = 113,
    SetHasFocus = 114,
    SetIsScriptingEnabled = 115,
    SetZoomLevel = 116,
    SetMaximumFramesPerSecond = 117,
    SetWindowPosition = 118,
    SetWindowSize = 119,
    DidUpdateWindowRect = 120,
    ResetZoom = 121,
    HandleFileReturn = 122,
    DidDeleteAllCookies = 123,
    SetSystemVisibilityState = 124,
    AlertClosed = 125,
    ConfirmClosed = 126,
    PromptClosed = 127,
    ColorPickerUpdate = 128,
    FilePickerClosed = 129,
    SelectDropdownClosed = 130,
    RetrievedClipboardEntries = 131,
    ToggleMediaPlayState = 132,
    ToggleMediaMuteState = 133,
    ToggleMediaLoopState = 134,
    ToggleMediaFullscreenState = 135,
    ToggleMediaControlsState = 136,
    SetPageMuteState = 137,
    SetUserStyle = 138,
    SystemTimeZoneChanged = 139,
    SetDocumentCookieVersionBuffer = 140,
    SetDocumentCookieVersionIndex = 141,
    CookiesChanged = 142,
    BroadcastChannelMessage = 143,
    DidWorkerAgentFinishLoadingScript = 144,
    DidWorkerAgentFailLoadingScript = 145,
    DidWorkerAgentReportException = 146,
    DidWorkerAgentClose = 147,
    RequestClose = 148,
    ExitFullscreen = 149,
};

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 Initialize final : public IPC::Message {
public:
    Initialize(u64 initial_page_id, Web::HTML::NavigableId root_navigable_id, Web::HTML::NavigableIdAllocator navigable_id_allocator)
        : m_initial_page_id(move(initial_page_id))
        , m_root_navigable_id(move(root_navigable_id))
        , m_navigable_id_allocator(move(navigable_id_allocator))
    {
    }

    Initialize(Initialize const&) = default;
    Initialize(Initialize&&) = default;
    Initialize& operator=(Initialize 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::Initialize; }
    static i32 static_message_id() { return (int)MessageID::Initialize; }
    virtual StringView message_name() const override { return "WebContentServer::Initialize"sv; }

    static ErrorOr<NonnullOwnPtr<Initialize>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto initial_page_id = TRY((decoder.decode<u64>()));
        auto root_navigable_id = TRY((decoder.decode<Web::HTML::NavigableId>()));
        auto navigable_id_allocator = TRY((decoder.decode<Web::HTML::NavigableIdAllocator>()));
        return make<Initialize>(move(initial_page_id), move(root_navigable_id), move(navigable_id_allocator));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 initial_page_id, Web::HTML::NavigableId const& root_navigable_id, Web::HTML::NavigableIdAllocator const& navigable_id_allocator)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::Initialize));
        TRY(stream.encode(initial_page_id));
        TRY(stream.encode(root_navigable_id));
        TRY(stream.encode(navigable_id_allocator));
        return buffer;
    }

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

    u64 initial_page_id() const { return m_initial_page_id; }

    Web::HTML::NavigableId const& root_navigable_id() const { return m_root_navigable_id; }
    Web::HTML::NavigableId take_root_navigable_id() { return move(m_root_navigable_id); }

    Web::HTML::NavigableIdAllocator const& navigable_id_allocator() const { return m_navigable_id_allocator; }
    Web::HTML::NavigableIdAllocator take_navigable_id_allocator() { return move(m_navigable_id_allocator); }

private:
    u64 m_initial_page_id;
    Web::HTML::NavigableId m_root_navigable_id;
    Web::HTML::NavigableIdAllocator m_navigable_id_allocator;
};

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 CompleteWebdriverHistoryTraversal final : public IPC::Message {
public:
    CompleteWebdriverHistoryTraversal(u64 page_id, u64 request_id, bool accepted, bool will_replace_web_content_process, bool will_change_top_level_entry)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_accepted(move(accepted))
        , m_will_replace_web_content_process(move(will_replace_web_content_process))
        , m_will_change_top_level_entry(move(will_change_top_level_entry))
    {
    }

    CompleteWebdriverHistoryTraversal(CompleteWebdriverHistoryTraversal const&) = default;
    CompleteWebdriverHistoryTraversal(CompleteWebdriverHistoryTraversal&&) = default;
    CompleteWebdriverHistoryTraversal& operator=(CompleteWebdriverHistoryTraversal 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::CompleteWebdriverHistoryTraversal; }
    static i32 static_message_id() { return (int)MessageID::CompleteWebdriverHistoryTraversal; }
    virtual StringView message_name() const override { return "WebContentServer::CompleteWebdriverHistoryTraversal"sv; }

    static ErrorOr<NonnullOwnPtr<CompleteWebdriverHistoryTraversal>> 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 accepted = TRY((decoder.decode<bool>()));
        auto will_replace_web_content_process = TRY((decoder.decode<bool>()));
        auto will_change_top_level_entry = TRY((decoder.decode<bool>()));
        return make<CompleteWebdriverHistoryTraversal>(move(page_id), move(request_id), move(accepted), move(will_replace_web_content_process), move(will_change_top_level_entry));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    bool accepted() const { return m_accepted; }

    bool will_replace_web_content_process() const { return m_will_replace_web_content_process; }

    bool will_change_top_level_entry() const { return m_will_change_top_level_entry; }

private:
    u64 m_page_id;
    u64 m_request_id;
    bool m_accepted;
    bool m_will_replace_web_content_process;
    bool m_will_change_top_level_entry;
};

class CompleteWebdriverNavigationCompletion final : public IPC::Message {
public:
    CompleteWebdriverNavigationCompletion(u64 page_id, u64 request_id, Web::WebDriver::Response response)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_response(move(response))
    {
    }

    CompleteWebdriverNavigationCompletion(CompleteWebdriverNavigationCompletion const&) = default;
    CompleteWebdriverNavigationCompletion(CompleteWebdriverNavigationCompletion&&) = default;
    CompleteWebdriverNavigationCompletion& operator=(CompleteWebdriverNavigationCompletion 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::CompleteWebdriverNavigationCompletion; }
    static i32 static_message_id() { return (int)MessageID::CompleteWebdriverNavigationCompletion; }
    virtual StringView message_name() const override { return "WebContentServer::CompleteWebdriverNavigationCompletion"sv; }

    static ErrorOr<NonnullOwnPtr<CompleteWebdriverNavigationCompletion>> 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 response = TRY((decoder.decode<Web::WebDriver::Response>()));
        return make<CompleteWebdriverNavigationCompletion>(move(page_id), move(request_id), move(response));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    Web::WebDriver::Response const& response() const { return m_response; }
    Web::WebDriver::Response take_response() { return move(m_response); }

private:
    u64 m_page_id;
    u64 m_request_id;
    Web::WebDriver::Response m_response;
};

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 ConnectToCompositorProcess final : public IPC::Message {
public:
    ConnectToCompositorProcess(IPC::TransportHandle handle)
        : m_handle(move(handle))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, IPC::TransportHandle>)
    ConnectToCompositorProcess(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::ConnectToCompositorProcess; }
    static i32 static_message_id() { return (int)MessageID::ConnectToCompositorProcess; }
    virtual StringView message_name() const override { return "WebContentServer::ConnectToCompositorProcess"sv; }

    static ErrorOr<NonnullOwnPtr<ConnectToCompositorProcess>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto handle = TRY((decoder.decode<IPC::TransportHandle>()));
        return make<ConnectToCompositorProcess>(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::ConnectToCompositorProcess));
        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 CompositorProcessReconnected final : public IPC::Message {
public:
    CompositorProcessReconnected() = default;

    CompositorProcessReconnected(CompositorProcessReconnected const&) = default;
    CompositorProcessReconnected(CompositorProcessReconnected&&) = default;
    CompositorProcessReconnected& operator=(CompositorProcessReconnected 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::CompositorProcessReconnected; }
    static i32 static_message_id() { return (int)MessageID::CompositorProcessReconnected; }
    virtual StringView message_name() const override { return "WebContentServer::CompositorProcessReconnected"sv; }

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

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

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

private:
};

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, Web::Bindings::NavigationHistoryBehavior history_handling)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_history_handling(move(history_handling))
    {
    }

    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>()));
        auto history_handling = TRY((decoder.decode<Web::Bindings::NavigationHistoryBehavior>()));
        return make<LoadUrl>(move(page_id), move(url), move(history_handling));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, URL::URL const& url, Web::Bindings::NavigationHistoryBehavior const& history_handling)
    {
        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));
        TRY(stream.encode(history_handling));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

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

    Web::Bindings::NavigationHistoryBehavior const& history_handling() const { return m_history_handling; }
    Web::Bindings::NavigationHistoryBehavior take_history_handling() { return move(m_history_handling); }

private:
    u64 m_page_id;
    URL::URL m_url;
    Web::Bindings::NavigationHistoryBehavior m_history_handling;
};

class LoadUrlWithDocumentResource final : public IPC::Message {
public:
    LoadUrlWithDocumentResource(u64 page_id, URL::URL url, Variant<Empty, String, Web::HTML::POSTResource> document_resource, Web::Bindings::NavigationHistoryBehavior history_handling)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_document_resource(move(document_resource))
        , m_history_handling(move(history_handling))
    {
    }

    LoadUrlWithDocumentResource(LoadUrlWithDocumentResource const&) = default;
    LoadUrlWithDocumentResource(LoadUrlWithDocumentResource&&) = default;
    LoadUrlWithDocumentResource& operator=(LoadUrlWithDocumentResource 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::LoadUrlWithDocumentResource; }
    static i32 static_message_id() { return (int)MessageID::LoadUrlWithDocumentResource; }
    virtual StringView message_name() const override { return "WebContentServer::LoadUrlWithDocumentResource"sv; }

    static ErrorOr<NonnullOwnPtr<LoadUrlWithDocumentResource>> 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>()));
        auto document_resource = TRY((decoder.decode<Variant<Empty, String, Web::HTML::POSTResource>>()));
        auto history_handling = TRY((decoder.decode<Web::Bindings::NavigationHistoryBehavior>()));
        return make<LoadUrlWithDocumentResource>(move(page_id), move(url), move(document_resource), move(history_handling));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, URL::URL const& url, Variant<Empty, String, Web::HTML::POSTResource> const& document_resource, Web::Bindings::NavigationHistoryBehavior const& history_handling)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::LoadUrlWithDocumentResource));
        TRY(stream.encode(page_id));
        TRY(stream.encode(url));
        TRY(stream.encode(document_resource));
        TRY(stream.encode(history_handling));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

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

    Variant<Empty, String, Web::HTML::POSTResource> const& document_resource() const { return m_document_resource; }
    Variant<Empty, String, Web::HTML::POSTResource> take_document_resource() { return move(m_document_resource); }

    Web::Bindings::NavigationHistoryBehavior const& history_handling() const { return m_history_handling; }
    Web::Bindings::NavigationHistoryBehavior take_history_handling() { return move(m_history_handling); }

private:
    u64 m_page_id;
    URL::URL m_url;
    Variant<Empty, String, Web::HTML::POSTResource> m_document_resource;
    Web::Bindings::NavigationHistoryBehavior m_history_handling;
};

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 LoadHtmlWithUrl final : public IPC::Message {
public:
    LoadHtmlWithUrl(u64 page_id, ByteString html, URL::URL url)
        : m_page_id(move(page_id))
        , m_html(move(html))
        , m_url(move(url))
    {
    }

    LoadHtmlWithUrl(LoadHtmlWithUrl const&) = default;
    LoadHtmlWithUrl(LoadHtmlWithUrl&&) = default;
    LoadHtmlWithUrl& operator=(LoadHtmlWithUrl 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::LoadHtmlWithUrl; }
    static i32 static_message_id() { return (int)MessageID::LoadHtmlWithUrl; }
    virtual StringView message_name() const override { return "WebContentServer::LoadHtmlWithUrl"sv; }

    static ErrorOr<NonnullOwnPtr<LoadHtmlWithUrl>> 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>()));
        auto url = TRY((decoder.decode<URL::URL>()));
        return make<LoadHtmlWithUrl>(move(page_id), move(html), move(url));
    }

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

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

    u64 page_id() const { return m_page_id; }

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

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

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

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 CancelDownload final : public IPC::Message {
public:
    CancelDownload(u64 page_id, u64 download_id)
        : m_page_id(move(page_id))
        , m_download_id(move(download_id))
    {
    }

    CancelDownload(CancelDownload const&) = default;
    CancelDownload(CancelDownload&&) = default;
    CancelDownload& operator=(CancelDownload 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::CancelDownload; }
    static i32 static_message_id() { return (int)MessageID::CancelDownload; }
    virtual StringView message_name() const override { return "WebContentServer::CancelDownload"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 download_id() const { return m_download_id; }

private:
    u64 m_page_id;
    u64 m_download_id;
};

class RunIframeLoadEventSteps final : public IPC::Message {
public:
    RunIframeLoadEventSteps(u64 page_id, Web::HTML::NavigableId frame_id)
        : m_page_id(move(page_id))
        , m_frame_id(move(frame_id))
    {
    }

    RunIframeLoadEventSteps(RunIframeLoadEventSteps const&) = default;
    RunIframeLoadEventSteps(RunIframeLoadEventSteps&&) = default;
    RunIframeLoadEventSteps& operator=(RunIframeLoadEventSteps 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::RunIframeLoadEventSteps; }
    static i32 static_message_id() { return (int)MessageID::RunIframeLoadEventSteps; }
    virtual StringView message_name() const override { return "WebContentServer::RunIframeLoadEventSteps"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::NavigableId const& frame_id() const { return m_frame_id; }
    Web::HTML::NavigableId take_frame_id() { return move(m_frame_id); }

private:
    u64 m_page_id;
    Web::HTML::NavigableId m_frame_id;
};

class SetPageParentContext final : public IPC::Message {
public:
    SetPageParentContext(u64 page_id, Optional<Web::Compositor::CompositorContextId> parent_context_id)
        : m_page_id(move(page_id))
        , m_parent_context_id(move(parent_context_id))
    {
    }

    SetPageParentContext(SetPageParentContext const&) = default;
    SetPageParentContext(SetPageParentContext&&) = default;
    SetPageParentContext& operator=(SetPageParentContext 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::SetPageParentContext; }
    static i32 static_message_id() { return (int)MessageID::SetPageParentContext; }
    virtual StringView message_name() const override { return "WebContentServer::SetPageParentContext"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    Optional<Web::Compositor::CompositorContextId> const& parent_context_id() const { return m_parent_context_id; }
    Optional<Web::Compositor::CompositorContextId> take_parent_context_id() { return move(m_parent_context_id); }

private:
    u64 m_page_id;
    Optional<Web::Compositor::CompositorContextId> m_parent_context_id;
};

class SetRemoteChildFrameCompositorContext final : public IPC::Message {
public:
    SetRemoteChildFrameCompositorContext(u64 page_id, Web::HTML::NavigableId frame_id, Optional<Web::Compositor::CompositorContextId> context_id)
        : m_page_id(move(page_id))
        , m_frame_id(move(frame_id))
        , m_context_id(move(context_id))
    {
    }

    SetRemoteChildFrameCompositorContext(SetRemoteChildFrameCompositorContext const&) = default;
    SetRemoteChildFrameCompositorContext(SetRemoteChildFrameCompositorContext&&) = default;
    SetRemoteChildFrameCompositorContext& operator=(SetRemoteChildFrameCompositorContext 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::SetRemoteChildFrameCompositorContext; }
    static i32 static_message_id() { return (int)MessageID::SetRemoteChildFrameCompositorContext; }
    virtual StringView message_name() const override { return "WebContentServer::SetRemoteChildFrameCompositorContext"sv; }

    static ErrorOr<NonnullOwnPtr<SetRemoteChildFrameCompositorContext>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto frame_id = TRY((decoder.decode<Web::HTML::NavigableId>()));
        auto context_id = TRY((decoder.decode<Optional<Web::Compositor::CompositorContextId>>()));
        return make<SetRemoteChildFrameCompositorContext>(move(page_id), move(frame_id), move(context_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::HTML::NavigableId const& frame_id, Optional<Web::Compositor::CompositorContextId> const& context_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetRemoteChildFrameCompositorContext));
        TRY(stream.encode(page_id));
        TRY(stream.encode(frame_id));
        TRY(stream.encode(context_id));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::NavigableId const& frame_id() const { return m_frame_id; }
    Web::HTML::NavigableId take_frame_id() { return move(m_frame_id); }

    Optional<Web::Compositor::CompositorContextId> const& context_id() const { return m_context_id; }
    Optional<Web::Compositor::CompositorContextId> take_context_id() { return move(m_context_id); }

private:
    u64 m_page_id;
    Web::HTML::NavigableId m_frame_id;
    Optional<Web::Compositor::CompositorContextId> m_context_id;
};

class TraverseTheHistoryToStep final : public IPC::Message {
public:
    TraverseTheHistoryToStep(u64 page_id, i32 step)
        : m_page_id(move(page_id))
        , m_step(move(step))
    {
    }

    TraverseTheHistoryToStep(TraverseTheHistoryToStep const&) = default;
    TraverseTheHistoryToStep(TraverseTheHistoryToStep&&) = default;
    TraverseTheHistoryToStep& operator=(TraverseTheHistoryToStep 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::TraverseTheHistoryToStep; }
    static i32 static_message_id() { return (int)MessageID::TraverseTheHistoryToStep; }
    virtual StringView message_name() const override { return "WebContentServer::TraverseTheHistoryToStep"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    i32 step() const { return m_step; }

private:
    u64 m_page_id;
    i32 m_step;
};

class CheckIfTraverseHistoryStepIsCanceled final : public IPC::Message {
public:
    CheckIfTraverseHistoryStepIsCanceled(u64 page_id, u64 request_id, i32 step)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_step(move(step))
    {
    }

    CheckIfTraverseHistoryStepIsCanceled(CheckIfTraverseHistoryStepIsCanceled const&) = default;
    CheckIfTraverseHistoryStepIsCanceled(CheckIfTraverseHistoryStepIsCanceled&&) = default;
    CheckIfTraverseHistoryStepIsCanceled& operator=(CheckIfTraverseHistoryStepIsCanceled 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::CheckIfTraverseHistoryStepIsCanceled; }
    static i32 static_message_id() { return (int)MessageID::CheckIfTraverseHistoryStepIsCanceled; }
    virtual StringView message_name() const override { return "WebContentServer::CheckIfTraverseHistoryStepIsCanceled"sv; }

    static ErrorOr<NonnullOwnPtr<CheckIfTraverseHistoryStepIsCanceled>> 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 step = TRY((decoder.decode<i32>()));
        return make<CheckIfTraverseHistoryStepIsCanceled>(move(page_id), move(request_id), move(step));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    i32 step() const { return m_step; }

private:
    u64 m_page_id;
    u64 m_request_id;
    i32 m_step;
};

class SetTopLevelSessionHistory final : public IPC::Message {
public:
    SetTopLevelSessionHistory(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, size_t current_top_level_entry_index, bool allow_reconstructing_current_entry)
        : m_page_id(move(page_id))
        , m_entries(move(entries))
        , m_current_top_level_entry_index(move(current_top_level_entry_index))
        , m_allow_reconstructing_current_entry(move(allow_reconstructing_current_entry))
    {
    }

    SetTopLevelSessionHistory(SetTopLevelSessionHistory const&) = default;
    SetTopLevelSessionHistory(SetTopLevelSessionHistory&&) = default;
    SetTopLevelSessionHistory& operator=(SetTopLevelSessionHistory 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::SetTopLevelSessionHistory; }
    static i32 static_message_id() { return (int)MessageID::SetTopLevelSessionHistory; }
    virtual StringView message_name() const override { return "WebContentServer::SetTopLevelSessionHistory"sv; }

    static ErrorOr<NonnullOwnPtr<SetTopLevelSessionHistory>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto entries = TRY((decoder.decode<Vector<Web::HTML::SessionHistoryEntryDescriptor>>()));
        auto current_top_level_entry_index = TRY((decoder.decode<size_t>()));
        auto allow_reconstructing_current_entry = TRY((decoder.decode<bool>()));
        return make<SetTopLevelSessionHistory>(move(page_id), move(entries), move(current_top_level_entry_index), move(allow_reconstructing_current_entry));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, ReadonlySpan<Web::HTML::SessionHistoryEntryDescriptor> entries, size_t current_top_level_entry_index, bool allow_reconstructing_current_entry)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetTopLevelSessionHistory));
        TRY(stream.encode(page_id));
        TRY(stream.encode(entries));
        TRY(stream.encode(current_top_level_entry_index));
        TRY(stream.encode(allow_reconstructing_current_entry));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Vector<Web::HTML::SessionHistoryEntryDescriptor> const& entries() const { return m_entries; }
    Vector<Web::HTML::SessionHistoryEntryDescriptor> take_entries() { return move(m_entries); }

    size_t current_top_level_entry_index() const { return m_current_top_level_entry_index; }

    bool allow_reconstructing_current_entry() const { return m_allow_reconstructing_current_entry; }

private:
    u64 m_page_id;
    Vector<Web::HTML::SessionHistoryEntryDescriptor> m_entries;
    size_t m_current_top_level_entry_index;
    bool m_allow_reconstructing_current_entry;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ResetSessionHistoryForTesting(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::ResetSessionHistoryForTesting; }
    static i32 static_message_id() { return (int)MessageID::ResetSessionHistoryForTesting; }
    virtual StringView message_name() const override { return "WebContentServer::ResetSessionHistoryForTesting"sv; }

    static ErrorOr<NonnullOwnPtr<ResetSessionHistoryForTesting>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ResetSessionHistoryForTesting>(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::ResetSessionHistoryForTesting));
        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 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 InspectStorage final : public IPC::Message {
public:
    InspectStorage(u64 page_id, Web::StorageAPI::StorageEndpointType storage_endpoint, u64 request_id)
        : m_page_id(move(page_id))
        , m_storage_endpoint(move(storage_endpoint))
        , m_request_id(move(request_id))
    {
    }

    InspectStorage(InspectStorage const&) = default;
    InspectStorage(InspectStorage&&) = default;
    InspectStorage& operator=(InspectStorage 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::InspectStorage; }
    static i32 static_message_id() { return (int)MessageID::InspectStorage; }
    virtual StringView message_name() const override { return "WebContentServer::InspectStorage"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::StorageAPI::StorageEndpointType const& storage_endpoint() const { return m_storage_endpoint; }
    Web::StorageAPI::StorageEndpointType take_storage_endpoint() { return move(m_storage_endpoint); }

    u64 request_id() const { return m_request_id; }

private:
    u64 m_page_id;
    Web::StorageAPI::StorageEndpointType m_storage_endpoint;
    u64 m_request_id;
};

class SetSessionStorageItemResponse final : public IPC::Message {
public:
    SetSessionStorageItemResponse(Optional<WebView::StorageSetResult> result)
        : m_result(move(result))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Optional<WebView::StorageSetResult>>)
    SetSessionStorageItemResponse(WrappedReturnType&& value)
        : m_result(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::SetSessionStorageItemResponse; }
    static i32 static_message_id() { return (int)MessageID::SetSessionStorageItemResponse; }
    virtual StringView message_name() const override { return "WebContentServer::SetSessionStorageItemResponse"sv; }

    static ErrorOr<NonnullOwnPtr<SetSessionStorageItemResponse>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto result = TRY((decoder.decode<Optional<WebView::StorageSetResult>>()));
        return make<SetSessionStorageItemResponse>(move(result));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(Optional<WebView::StorageSetResult> const& result)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetSessionStorageItemResponse));
        TRY(stream.encode(result));
        return buffer;
    }

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

    Optional<WebView::StorageSetResult> const& result() const { return m_result; }
    Optional<WebView::StorageSetResult> take_result() { return move(m_result); }

private:
    Optional<WebView::StorageSetResult> m_result;
};

class SetSessionStorageItem final : public IPC::Message {
public:
    typedef class SetSessionStorageItemResponse ResponseType;

    SetSessionStorageItem(u64 page_id, String key, String value)
        : m_page_id(move(page_id))
        , m_key(move(key))
        , m_value(move(value))
    {
    }

    SetSessionStorageItem(SetSessionStorageItem const&) = default;
    SetSessionStorageItem(SetSessionStorageItem&&) = default;
    SetSessionStorageItem& operator=(SetSessionStorageItem 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::SetSessionStorageItem; }
    static i32 static_message_id() { return (int)MessageID::SetSessionStorageItem; }
    virtual StringView message_name() const override { return "WebContentServer::SetSessionStorageItem"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    String const& key() const { return m_key; }
    String take_key() { return move(m_key); }

    String const& value() const { return m_value; }
    String take_value() { return move(m_value); }

private:
    u64 m_page_id;
    String m_key;
    String m_value;
};

class RemoveSessionStorageItemResponse final : public IPC::Message {
public:
    RemoveSessionStorageItemResponse(Optional<String> old_value)
        : m_old_value(move(old_value))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Optional<String>>)
    RemoveSessionStorageItemResponse(WrappedReturnType&& value)
        : m_old_value(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::RemoveSessionStorageItemResponse; }
    static i32 static_message_id() { return (int)MessageID::RemoveSessionStorageItemResponse; }
    virtual StringView message_name() const override { return "WebContentServer::RemoveSessionStorageItemResponse"sv; }

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

    static ErrorOr<IPC::MessageBuffer> static_encode(Optional<String> const& old_value)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::RemoveSessionStorageItemResponse));
        TRY(stream.encode(old_value));
        return buffer;
    }

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

    Optional<String> const& old_value() const { return m_old_value; }
    Optional<String> take_old_value() { return move(m_old_value); }

private:
    Optional<String> m_old_value;
};

class RemoveSessionStorageItem final : public IPC::Message {
public:
    typedef class RemoveSessionStorageItemResponse ResponseType;

    RemoveSessionStorageItem(u64 page_id, String key)
        : m_page_id(move(page_id))
        , m_key(move(key))
    {
    }

    RemoveSessionStorageItem(RemoveSessionStorageItem const&) = default;
    RemoveSessionStorageItem(RemoveSessionStorageItem&&) = default;
    RemoveSessionStorageItem& operator=(RemoveSessionStorageItem 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::RemoveSessionStorageItem; }
    static i32 static_message_id() { return (int)MessageID::RemoveSessionStorageItem; }
    virtual StringView message_name() const override { return "WebContentServer::RemoveSessionStorageItem"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    String const& key() const { return m_key; }
    String take_key() { return move(m_key); }

private:
    u64 m_page_id;
    String m_key;
};

class ClearSessionStorageResponse final : public IPC::Message {
public:
    ClearSessionStorageResponse(bool did_clear)
        : m_did_clear(move(did_clear))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, bool>)
    ClearSessionStorageResponse(WrappedReturnType&& value)
        : m_did_clear(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::ClearSessionStorageResponse; }
    static i32 static_message_id() { return (int)MessageID::ClearSessionStorageResponse; }
    virtual StringView message_name() const override { return "WebContentServer::ClearSessionStorageResponse"sv; }

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

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

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

    bool did_clear() const { return m_did_clear; }

private:
    bool m_did_clear;
};

class ClearSessionStorage final : public IPC::Message {
public:
    typedef class ClearSessionStorageResponse ResponseType;

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    ClearSessionStorage(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::ClearSessionStorage; }
    static i32 static_message_id() { return (int)MessageID::ClearSessionStorage; }
    virtual StringView message_name() const override { return "WebContentServer::ClearSessionStorage"sv; }

    static ErrorOr<NonnullOwnPtr<ClearSessionStorage>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<ClearSessionStorage>(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::ClearSessionStorage));
        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, JsonValue options)
        : m_page_id(move(page_id))
        , m_property_type(move(property_type))
        , m_node_id(move(node_id))
        , m_pseudo_element(move(pseudo_element))
        , m_options(move(options))
    {
    }

    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>>()));
        auto options = TRY((decoder.decode<JsonValue>()));
        return make<InspectDomNode>(move(page_id), move(property_type), move(node_id), move(pseudo_element), move(options));
    }

    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, JsonValue const& options)
    {
        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));
        TRY(stream.encode(options));
        return buffer;
    }

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

    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); }

    JsonValue const& options() const { return m_options; }
    JsonValue take_options() { return move(m_options); }

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

class InspectGridLayouts final : public IPC::Message {
public:
    InspectGridLayouts(u64 page_id, Web::UniqueNodeID root_node_id)
        : m_page_id(move(page_id))
        , m_root_node_id(move(root_node_id))
    {
    }

    InspectGridLayouts(InspectGridLayouts const&) = default;
    InspectGridLayouts(InspectGridLayouts&&) = default;
    InspectGridLayouts& operator=(InspectGridLayouts 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::InspectGridLayouts; }
    static i32 static_message_id() { return (int)MessageID::InspectGridLayouts; }
    virtual StringView message_name() const override { return "WebContentServer::InspectGridLayouts"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::UniqueNodeID const& root_node_id() const { return m_root_node_id; }
    Web::UniqueNodeID take_root_node_id() { return move(m_root_node_id); }

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

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

    InspectCurrentGrid(InspectCurrentGrid const&) = default;
    InspectCurrentGrid(InspectCurrentGrid&&) = default;
    InspectCurrentGrid& operator=(InspectCurrentGrid 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::InspectCurrentGrid; }
    static i32 static_message_id() { return (int)MessageID::InspectCurrentGrid; }
    virtual StringView message_name() const override { return "WebContentServer::InspectCurrentGrid"sv; }

    static ErrorOr<NonnullOwnPtr<InspectCurrentGrid>> 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<InspectCurrentGrid>(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::InspectCurrentGrid));
        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 InspectCurrentFlexbox final : public IPC::Message {
public:
    InspectCurrentFlexbox(u64 page_id, Web::UniqueNodeID node_id, bool only_look_at_parents)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_only_look_at_parents(move(only_look_at_parents))
    {
    }

    InspectCurrentFlexbox(InspectCurrentFlexbox const&) = default;
    InspectCurrentFlexbox(InspectCurrentFlexbox&&) = default;
    InspectCurrentFlexbox& operator=(InspectCurrentFlexbox 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::InspectCurrentFlexbox; }
    static i32 static_message_id() { return (int)MessageID::InspectCurrentFlexbox; }
    virtual StringView message_name() const override { return "WebContentServer::InspectCurrentFlexbox"sv; }

    static ErrorOr<NonnullOwnPtr<InspectCurrentFlexbox>> 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 only_look_at_parents = TRY((decoder.decode<bool>()));
        return make<InspectCurrentFlexbox>(move(page_id), move(node_id), move(only_look_at_parents));
    }

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

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

    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); }

    bool only_look_at_parents() const { return m_only_look_at_parents; }

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

class InspectIndexedDatabaseStorage final : public IPC::Message {
public:
    InspectIndexedDatabaseStorage(u64 page_id, u64 request_id)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
    {
    }

    InspectIndexedDatabaseStorage(InspectIndexedDatabaseStorage const&) = default;
    InspectIndexedDatabaseStorage(InspectIndexedDatabaseStorage&&) = default;
    InspectIndexedDatabaseStorage& operator=(InspectIndexedDatabaseStorage 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::InspectIndexedDatabaseStorage; }
    static i32 static_message_id() { return (int)MessageID::InspectIndexedDatabaseStorage; }
    virtual StringView message_name() const override { return "WebContentServer::InspectIndexedDatabaseStorage"sv; }

    static ErrorOr<NonnullOwnPtr<InspectIndexedDatabaseStorage>> 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>()));
        return make<InspectIndexedDatabaseStorage>(move(page_id), move(request_id));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

private:
    u64 m_page_id;
    u64 m_request_id;
};

class InspectIndexedDatabaseObjects final : public IPC::Message {
public:
    InspectIndexedDatabaseObjects(u64 page_id, u64 request_id, String host, JsonValue names, JsonValue options)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_host(move(host))
        , m_names(move(names))
        , m_options(move(options))
    {
    }

    InspectIndexedDatabaseObjects(InspectIndexedDatabaseObjects const&) = default;
    InspectIndexedDatabaseObjects(InspectIndexedDatabaseObjects&&) = default;
    InspectIndexedDatabaseObjects& operator=(InspectIndexedDatabaseObjects 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::InspectIndexedDatabaseObjects; }
    static i32 static_message_id() { return (int)MessageID::InspectIndexedDatabaseObjects; }
    virtual StringView message_name() const override { return "WebContentServer::InspectIndexedDatabaseObjects"sv; }

    static ErrorOr<NonnullOwnPtr<InspectIndexedDatabaseObjects>> 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 host = TRY((decoder.decode<String>()));
        auto names = TRY((decoder.decode<JsonValue>()));
        auto options = TRY((decoder.decode<JsonValue>()));
        return make<InspectIndexedDatabaseObjects>(move(page_id), move(request_id), move(host), move(names), move(options));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, u64 request_id, StringView host, JsonValue const& names, JsonValue const& options)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::InspectIndexedDatabaseObjects));
        TRY(stream.encode(page_id));
        TRY(stream.encode(request_id));
        TRY(stream.encode(host));
        TRY(stream.encode(names));
        TRY(stream.encode(options));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    String const& host() const { return m_host; }
    String take_host() { return move(m_host); }

    JsonValue const& names() const { return m_names; }
    JsonValue take_names() { return move(m_names); }

    JsonValue const& options() const { return m_options; }
    JsonValue take_options() { return move(m_options); }

private:
    u64 m_page_id;
    u64 m_request_id;
    String m_host;
    JsonValue m_names;
    JsonValue m_options;
};

class DeleteIndexedDatabase final : public IPC::Message {
public:
    DeleteIndexedDatabase(u64 page_id, u64 request_id, String host, String name)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_host(move(host))
        , m_name(move(name))
    {
    }

    DeleteIndexedDatabase(DeleteIndexedDatabase const&) = default;
    DeleteIndexedDatabase(DeleteIndexedDatabase&&) = default;
    DeleteIndexedDatabase& operator=(DeleteIndexedDatabase 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::DeleteIndexedDatabase; }
    static i32 static_message_id() { return (int)MessageID::DeleteIndexedDatabase; }
    virtual StringView message_name() const override { return "WebContentServer::DeleteIndexedDatabase"sv; }

    static ErrorOr<NonnullOwnPtr<DeleteIndexedDatabase>> 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 host = TRY((decoder.decode<String>()));
        auto name = TRY((decoder.decode<String>()));
        return make<DeleteIndexedDatabase>(move(page_id), move(request_id), move(host), move(name));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    String const& host() const { return m_host; }
    String take_host() { return move(m_host); }

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

private:
    u64 m_page_id;
    u64 m_request_id;
    String m_host;
    String m_name;
};

class ClearIndexedDatabaseObjectStore final : public IPC::Message {
public:
    ClearIndexedDatabaseObjectStore(u64 page_id, u64 request_id, String host, String name)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_host(move(host))
        , m_name(move(name))
    {
    }

    ClearIndexedDatabaseObjectStore(ClearIndexedDatabaseObjectStore const&) = default;
    ClearIndexedDatabaseObjectStore(ClearIndexedDatabaseObjectStore&&) = default;
    ClearIndexedDatabaseObjectStore& operator=(ClearIndexedDatabaseObjectStore 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::ClearIndexedDatabaseObjectStore; }
    static i32 static_message_id() { return (int)MessageID::ClearIndexedDatabaseObjectStore; }
    virtual StringView message_name() const override { return "WebContentServer::ClearIndexedDatabaseObjectStore"sv; }

    static ErrorOr<NonnullOwnPtr<ClearIndexedDatabaseObjectStore>> 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 host = TRY((decoder.decode<String>()));
        auto name = TRY((decoder.decode<String>()));
        return make<ClearIndexedDatabaseObjectStore>(move(page_id), move(request_id), move(host), move(name));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    String const& host() const { return m_host; }
    String take_host() { return move(m_host); }

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

private:
    u64 m_page_id;
    u64 m_request_id;
    String m_host;
    String m_name;
};

class DeleteIndexedDatabaseRecord final : public IPC::Message {
public:
    DeleteIndexedDatabaseRecord(u64 page_id, u64 request_id, String host, String name)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_host(move(host))
        , m_name(move(name))
    {
    }

    DeleteIndexedDatabaseRecord(DeleteIndexedDatabaseRecord const&) = default;
    DeleteIndexedDatabaseRecord(DeleteIndexedDatabaseRecord&&) = default;
    DeleteIndexedDatabaseRecord& operator=(DeleteIndexedDatabaseRecord 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::DeleteIndexedDatabaseRecord; }
    static i32 static_message_id() { return (int)MessageID::DeleteIndexedDatabaseRecord; }
    virtual StringView message_name() const override { return "WebContentServer::DeleteIndexedDatabaseRecord"sv; }

    static ErrorOr<NonnullOwnPtr<DeleteIndexedDatabaseRecord>> 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 host = TRY((decoder.decode<String>()));
        auto name = TRY((decoder.decode<String>()));
        return make<DeleteIndexedDatabaseRecord>(move(page_id), move(request_id), move(host), move(name));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    String const& host() const { return m_host; }
    String take_host() { return move(m_host); }

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

private:
    u64 m_page_id;
    u64 m_request_id;
    String m_host;
    String m_name;
};

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 HighlightFlexbox final : public IPC::Message {
public:
    HighlightFlexbox(u64 page_id, Web::UniqueNodeID node_id, JsonValue options)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_options(move(options))
    {
    }

    HighlightFlexbox(HighlightFlexbox const&) = default;
    HighlightFlexbox(HighlightFlexbox&&) = default;
    HighlightFlexbox& operator=(HighlightFlexbox 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::HighlightFlexbox; }
    static i32 static_message_id() { return (int)MessageID::HighlightFlexbox; }
    virtual StringView message_name() const override { return "WebContentServer::HighlightFlexbox"sv; }

    static ErrorOr<NonnullOwnPtr<HighlightFlexbox>> 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 options = TRY((decoder.decode<JsonValue>()));
        return make<HighlightFlexbox>(move(page_id), move(node_id), move(options));
    }

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

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

    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); }

    JsonValue const& options() const { return m_options; }
    JsonValue take_options() { return move(m_options); }

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

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

    ClearFlexboxHighlight(ClearFlexboxHighlight const&) = default;
    ClearFlexboxHighlight(ClearFlexboxHighlight&&) = default;
    ClearFlexboxHighlight& operator=(ClearFlexboxHighlight 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::ClearFlexboxHighlight; }
    static i32 static_message_id() { return (int)MessageID::ClearFlexboxHighlight; }
    virtual StringView message_name() const override { return "WebContentServer::ClearFlexboxHighlight"sv; }

    static ErrorOr<NonnullOwnPtr<ClearFlexboxHighlight>> 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<ClearFlexboxHighlight>(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::ClearFlexboxHighlight));
        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 HighlightGrid final : public IPC::Message {
public:
    HighlightGrid(u64 page_id, Web::UniqueNodeID node_id, JsonValue options)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
        , m_options(move(options))
    {
    }

    HighlightGrid(HighlightGrid const&) = default;
    HighlightGrid(HighlightGrid&&) = default;
    HighlightGrid& operator=(HighlightGrid 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::HighlightGrid; }
    static i32 static_message_id() { return (int)MessageID::HighlightGrid; }
    virtual StringView message_name() const override { return "WebContentServer::HighlightGrid"sv; }

    static ErrorOr<NonnullOwnPtr<HighlightGrid>> 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 options = TRY((decoder.decode<JsonValue>()));
        return make<HighlightGrid>(move(page_id), move(node_id), move(options));
    }

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

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

    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); }

    JsonValue const& options() const { return m_options; }
    JsonValue take_options() { return move(m_options); }

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

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

    ClearGridHighlight(ClearGridHighlight const&) = default;
    ClearGridHighlight(ClearGridHighlight&&) = default;
    ClearGridHighlight& operator=(ClearGridHighlight 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::ClearGridHighlight; }
    static i32 static_message_id() { return (int)MessageID::ClearGridHighlight; }
    virtual StringView message_name() const override { return "WebContentServer::ClearGridHighlight"sv; }

    static ErrorOr<NonnullOwnPtr<ClearGridHighlight>> 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<ClearGridHighlight>(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::ClearGridHighlight));
        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 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 GetNodeIdAtPosition final : public IPC::Message {
public:
    GetNodeIdAtPosition(u64 page_id, u64 request_id, Web::DevicePixelPoint position)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_position(move(position))
    {
    }

    GetNodeIdAtPosition(GetNodeIdAtPosition const&) = default;
    GetNodeIdAtPosition(GetNodeIdAtPosition&&) = default;
    GetNodeIdAtPosition& operator=(GetNodeIdAtPosition 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::GetNodeIdAtPosition; }
    static i32 static_message_id() { return (int)MessageID::GetNodeIdAtPosition; }
    virtual StringView message_name() const override { return "WebContentServer::GetNodeIdAtPosition"sv; }

    static ErrorOr<NonnullOwnPtr<GetNodeIdAtPosition>> 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 position = TRY((decoder.decode<Web::DevicePixelPoint>()));
        return make<GetNodeIdAtPosition>(move(page_id), move(request_id), move(position));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

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

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

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 ListDevtoolsSources final : public IPC::Message {
public:
    ListDevtoolsSources(u64 page_id, u64 request_id)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
    {
    }

    ListDevtoolsSources(ListDevtoolsSources const&) = default;
    ListDevtoolsSources(ListDevtoolsSources&&) = default;
    ListDevtoolsSources& operator=(ListDevtoolsSources 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::ListDevtoolsSources; }
    static i32 static_message_id() { return (int)MessageID::ListDevtoolsSources; }
    virtual StringView message_name() const override { return "WebContentServer::ListDevtoolsSources"sv; }

    static ErrorOr<NonnullOwnPtr<ListDevtoolsSources>> 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>()));
        return make<ListDevtoolsSources>(move(page_id), move(request_id));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

private:
    u64 m_page_id;
    u64 m_request_id;
};

class RequestDevtoolsSource final : public IPC::Message {
public:
    RequestDevtoolsSource(u64 page_id, Web::HTML::ScriptRegistry::Identifier source_id)
        : m_page_id(move(page_id))
        , m_source_id(move(source_id))
    {
    }

    RequestDevtoolsSource(RequestDevtoolsSource const&) = default;
    RequestDevtoolsSource(RequestDevtoolsSource&&) = default;
    RequestDevtoolsSource& operator=(RequestDevtoolsSource 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::RequestDevtoolsSource; }
    static i32 static_message_id() { return (int)MessageID::RequestDevtoolsSource; }
    virtual StringView message_name() const override { return "WebContentServer::RequestDevtoolsSource"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::ScriptRegistry::Identifier const& source_id() const { return m_source_id; }
    Web::HTML::ScriptRegistry::Identifier take_source_id() { return move(m_source_id); }

private:
    u64 m_page_id;
    Web::HTML::ScriptRegistry::Identifier m_source_id;
};

class ResolveDomNodeUrl final : public IPC::Message {
public:
    ResolveDomNodeUrl(u64 page_id, u64 request_id, Optional<Web::UniqueNodeID> node_id, String url)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_node_id(move(node_id))
        , m_url(move(url))
    {
    }

    ResolveDomNodeUrl(ResolveDomNodeUrl const&) = default;
    ResolveDomNodeUrl(ResolveDomNodeUrl&&) = default;
    ResolveDomNodeUrl& operator=(ResolveDomNodeUrl 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::ResolveDomNodeUrl; }
    static i32 static_message_id() { return (int)MessageID::ResolveDomNodeUrl; }
    virtual StringView message_name() const override { return "WebContentServer::ResolveDomNodeUrl"sv; }

    static ErrorOr<NonnullOwnPtr<ResolveDomNodeUrl>> 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 node_id = TRY((decoder.decode<Optional<Web::UniqueNodeID>>()));
        auto url = TRY((decoder.decode<String>()));
        return make<ResolveDomNodeUrl>(move(page_id), move(request_id), move(node_id), move(url));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

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

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

private:
    u64 m_page_id;
    u64 m_request_id;
    Optional<Web::UniqueNodeID> m_node_id;
    String m_url;
};

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, Utf16FlyString 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<Utf16FlyString>()));
        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, Utf16FlyString const& 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); }

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

private:
    u64 m_page_id;
    Web::UniqueNodeID m_node_id;
    Utf16FlyString 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, Utf16FlyString 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<Utf16FlyString>()));
        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, Utf16FlyString const& 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); }

    Utf16FlyString const& name() const { return m_name; }
    Utf16FlyString 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;
    Utf16FlyString 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 GetSelectedTextForLookupResponse final : public IPC::Message {
public:
    GetSelectedTextForLookupResponse(Optional<WebView::DictionaryLookup> lookup)
        : m_lookup(move(lookup))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Optional<WebView::DictionaryLookup>>)
    GetSelectedTextForLookupResponse(WrappedReturnType&& value)
        : m_lookup(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::GetSelectedTextForLookupResponse; }
    static i32 static_message_id() { return (int)MessageID::GetSelectedTextForLookupResponse; }
    virtual StringView message_name() const override { return "WebContentServer::GetSelectedTextForLookupResponse"sv; }

    static ErrorOr<NonnullOwnPtr<GetSelectedTextForLookupResponse>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto lookup = TRY((decoder.decode<Optional<WebView::DictionaryLookup>>()));
        return make<GetSelectedTextForLookupResponse>(move(lookup));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(Optional<WebView::DictionaryLookup> const& lookup)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::GetSelectedTextForLookupResponse));
        TRY(stream.encode(lookup));
        return buffer;
    }

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

    Optional<WebView::DictionaryLookup> const& lookup() const { return m_lookup; }
    Optional<WebView::DictionaryLookup> take_lookup() { return move(m_lookup); }

private:
    Optional<WebView::DictionaryLookup> m_lookup;
};

class GetSelectedTextForLookup final : public IPC::Message {
public:
    typedef class GetSelectedTextForLookupResponse ResponseType;

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    GetSelectedTextForLookup(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::GetSelectedTextForLookup; }
    static i32 static_message_id() { return (int)MessageID::GetSelectedTextForLookup; }
    virtual StringView message_name() const override { return "WebContentServer::GetSelectedTextForLookup"sv; }

    static ErrorOr<NonnullOwnPtr<GetSelectedTextForLookup>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<GetSelectedTextForLookup>(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::GetSelectedTextForLookup));
        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 SelectWordForDictionaryLookupResponse final : public IPC::Message {
public:
    SelectWordForDictionaryLookupResponse(bool selected)
        : m_selected(move(selected))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, bool>)
    SelectWordForDictionaryLookupResponse(WrappedReturnType&& value)
        : m_selected(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::SelectWordForDictionaryLookupResponse; }
    static i32 static_message_id() { return (int)MessageID::SelectWordForDictionaryLookupResponse; }
    virtual StringView message_name() const override { return "WebContentServer::SelectWordForDictionaryLookupResponse"sv; }

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

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

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

    bool selected() const { return m_selected; }

private:
    bool m_selected;
};

class SelectWordForDictionaryLookup final : public IPC::Message {
public:
    typedef class SelectWordForDictionaryLookupResponse ResponseType;

    SelectWordForDictionaryLookup(u64 page_id, Web::DevicePixelPoint position)
        : m_page_id(move(page_id))
        , m_position(move(position))
    {
    }

    SelectWordForDictionaryLookup(SelectWordForDictionaryLookup const&) = default;
    SelectWordForDictionaryLookup(SelectWordForDictionaryLookup&&) = default;
    SelectWordForDictionaryLookup& operator=(SelectWordForDictionaryLookup 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::SelectWordForDictionaryLookup; }
    static i32 static_message_id() { return (int)MessageID::SelectWordForDictionaryLookup; }
    virtual StringView message_name() const override { return "WebContentServer::SelectWordForDictionaryLookup"sv; }

    static ErrorOr<NonnullOwnPtr<SelectWordForDictionaryLookup>> 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<SelectWordForDictionaryLookup>(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::SelectWordForDictionaryLookup));
        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 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 SetMarkedTextFromInputMethod final : public IPC::Message {
public:
    SetMarkedTextFromInputMethod(u64 page_id, Utf16String text)
        : m_page_id(move(page_id))
        , m_text(move(text))
    {
    }

    SetMarkedTextFromInputMethod(SetMarkedTextFromInputMethod const&) = default;
    SetMarkedTextFromInputMethod(SetMarkedTextFromInputMethod&&) = default;
    SetMarkedTextFromInputMethod& operator=(SetMarkedTextFromInputMethod 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::SetMarkedTextFromInputMethod; }
    static i32 static_message_id() { return (int)MessageID::SetMarkedTextFromInputMethod; }
    virtual StringView message_name() const override { return "WebContentServer::SetMarkedTextFromInputMethod"sv; }

    static ErrorOr<NonnullOwnPtr<SetMarkedTextFromInputMethod>> 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<SetMarkedTextFromInputMethod>(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::SetMarkedTextFromInputMethod));
        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 CommitTextFromInputMethod final : public IPC::Message {
public:
    CommitTextFromInputMethod(u64 page_id, Utf16String text, i32 replacement_start, i32 replacement_length)
        : m_page_id(move(page_id))
        , m_text(move(text))
        , m_replacement_start(move(replacement_start))
        , m_replacement_length(move(replacement_length))
    {
    }

    CommitTextFromInputMethod(CommitTextFromInputMethod const&) = default;
    CommitTextFromInputMethod(CommitTextFromInputMethod&&) = default;
    CommitTextFromInputMethod& operator=(CommitTextFromInputMethod 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::CommitTextFromInputMethod; }
    static i32 static_message_id() { return (int)MessageID::CommitTextFromInputMethod; }
    virtual StringView message_name() const override { return "WebContentServer::CommitTextFromInputMethod"sv; }

    static ErrorOr<NonnullOwnPtr<CommitTextFromInputMethod>> 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>()));
        auto replacement_start = TRY((decoder.decode<i32>()));
        auto replacement_length = TRY((decoder.decode<i32>()));
        return make<CommitTextFromInputMethod>(move(page_id), move(text), move(replacement_start), move(replacement_length));
    }

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

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

    u64 page_id() const { return m_page_id; }

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

    i32 replacement_start() const { return m_replacement_start; }

    i32 replacement_length() const { return m_replacement_length; }

private:
    u64 m_page_id;
    Utf16String m_text;
    i32 m_replacement_start;
    i32 m_replacement_length;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, u64>)
    UnmarkTextFromInputMethod(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::UnmarkTextFromInputMethod; }
    static i32 static_message_id() { return (int)MessageID::UnmarkTextFromInputMethod; }
    virtual StringView message_name() const override { return "WebContentServer::UnmarkTextFromInputMethod"sv; }

    static ErrorOr<NonnullOwnPtr<UnmarkTextFromInputMethod>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<UnmarkTextFromInputMethod>(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::UnmarkTextFromInputMethod));
        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 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 SetContentBlockers final : public IPC::Message {
public:
    SetContentBlockers(u64 page_id, Core::AnonymousBuffer patterns)
        : m_page_id(move(page_id))
        , m_patterns(move(patterns))
    {
    }

    SetContentBlockers(SetContentBlockers const&) = default;
    SetContentBlockers(SetContentBlockers&&) = default;
    SetContentBlockers& operator=(SetContentBlockers 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::SetContentBlockers; }
    static i32 static_message_id() { return (int)MessageID::SetContentBlockers; }
    virtual StringView message_name() const override { return "WebContentServer::SetContentBlockers"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    Core::AnonymousBuffer const& patterns() const { return m_patterns; }
    Core::AnonymousBuffer take_patterns() { return move(m_patterns); }

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

class SetAutoplaySettings final : public IPC::Message {
public:
    SetAutoplaySettings(u64 page_id, Web::HTML::AutoplayPolicy policy, Vector<String> allowlist)
        : m_page_id(move(page_id))
        , m_policy(move(policy))
        , m_allowlist(move(allowlist))
    {
    }

    SetAutoplaySettings(SetAutoplaySettings const&) = default;
    SetAutoplaySettings(SetAutoplaySettings&&) = default;
    SetAutoplaySettings& operator=(SetAutoplaySettings 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::SetAutoplaySettings; }
    static i32 static_message_id() { return (int)MessageID::SetAutoplaySettings; }
    virtual StringView message_name() const override { return "WebContentServer::SetAutoplaySettings"sv; }

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::HTML::AutoplayPolicy const& policy, ReadonlySpan<String> allowlist)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::SetAutoplaySettings));
        TRY(stream.encode(page_id));
        TRY(stream.encode(policy));
        TRY(stream.encode(allowlist));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::AutoplayPolicy const& policy() const { return m_policy; }
    Web::HTML::AutoplayPolicy take_policy() { return move(m_policy); }

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

private:
    u64 m_page_id;
    Web::HTML::AutoplayPolicy m_policy;
    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 DidDeleteAllCookies final : public IPC::Message {
public:
    DidDeleteAllCookies(u64 page_id, u64 request_id)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
    {
    }

    DidDeleteAllCookies(DidDeleteAllCookies const&) = default;
    DidDeleteAllCookies(DidDeleteAllCookies&&) = default;
    DidDeleteAllCookies& operator=(DidDeleteAllCookies 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::DidDeleteAllCookies; }
    static i32 static_message_id() { return (int)MessageID::DidDeleteAllCookies; }
    virtual StringView message_name() const override { return "WebContentServer::DidDeleteAllCookies"sv; }

    static ErrorOr<NonnullOwnPtr<DidDeleteAllCookies>> 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>()));
        return make<DidDeleteAllCookies>(move(page_id), move(request_id));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

private:
    u64 m_page_id;
    u64 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 SetPageMuteState final : public IPC::Message {
public:
    SetPageMuteState(u64 page_id, Web::HTML::MuteState mute_state)
        : m_page_id(move(page_id))
        , m_mute_state(move(mute_state))
    {
    }

    SetPageMuteState(SetPageMuteState const&) = default;
    SetPageMuteState(SetPageMuteState&&) = default;
    SetPageMuteState& operator=(SetPageMuteState 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::SetPageMuteState; }
    static i32 static_message_id() { return (int)MessageID::SetPageMuteState; }
    virtual StringView message_name() const override { return "WebContentServer::SetPageMuteState"sv; }

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::MuteState const& mute_state() const { return m_mute_state; }
    Web::HTML::MuteState take_mute_state() { return move(m_mute_state); }

private:
    u64 m_page_id;
    Web::HTML::MuteState m_mute_state;
};

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 DidWorkerAgentFinishLoadingScript final : public IPC::Message {
public:
    DidWorkerAgentFinishLoadingScript(Web::HTML::WorkerAgentOwnerToken owner_token)
        : m_owner_token(move(owner_token))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::HTML::WorkerAgentOwnerToken>)
    DidWorkerAgentFinishLoadingScript(WrappedReturnType&& value)
        : m_owner_token(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::DidWorkerAgentFinishLoadingScript; }
    static i32 static_message_id() { return (int)MessageID::DidWorkerAgentFinishLoadingScript; }
    virtual StringView message_name() const override { return "WebContentServer::DidWorkerAgentFinishLoadingScript"sv; }

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

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

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

    Web::HTML::WorkerAgentOwnerToken const& owner_token() const { return m_owner_token; }
    Web::HTML::WorkerAgentOwnerToken take_owner_token() { return move(m_owner_token); }

private:
    Web::HTML::WorkerAgentOwnerToken m_owner_token;
};

class DidWorkerAgentFailLoadingScript final : public IPC::Message {
public:
    DidWorkerAgentFailLoadingScript(Web::HTML::WorkerAgentOwnerToken owner_token)
        : m_owner_token(move(owner_token))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::HTML::WorkerAgentOwnerToken>)
    DidWorkerAgentFailLoadingScript(WrappedReturnType&& value)
        : m_owner_token(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::DidWorkerAgentFailLoadingScript; }
    static i32 static_message_id() { return (int)MessageID::DidWorkerAgentFailLoadingScript; }
    virtual StringView message_name() const override { return "WebContentServer::DidWorkerAgentFailLoadingScript"sv; }

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

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

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

    Web::HTML::WorkerAgentOwnerToken const& owner_token() const { return m_owner_token; }
    Web::HTML::WorkerAgentOwnerToken take_owner_token() { return move(m_owner_token); }

private:
    Web::HTML::WorkerAgentOwnerToken m_owner_token;
};

class DidWorkerAgentReportException final : public IPC::Message {
public:
    DidWorkerAgentReportException(Web::HTML::WorkerAgentOwnerToken owner_token, String message, String filename, u32 lineno, u32 colno)
        : m_owner_token(move(owner_token))
        , m_message(move(message))
        , m_filename(move(filename))
        , m_lineno(move(lineno))
        , m_colno(move(colno))
    {
    }

    DidWorkerAgentReportException(DidWorkerAgentReportException const&) = default;
    DidWorkerAgentReportException(DidWorkerAgentReportException&&) = default;
    DidWorkerAgentReportException& operator=(DidWorkerAgentReportException 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::DidWorkerAgentReportException; }
    static i32 static_message_id() { return (int)MessageID::DidWorkerAgentReportException; }
    virtual StringView message_name() const override { return "WebContentServer::DidWorkerAgentReportException"sv; }

    static ErrorOr<NonnullOwnPtr<DidWorkerAgentReportException>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto owner_token = TRY((decoder.decode<Web::HTML::WorkerAgentOwnerToken>()));
        auto message = TRY((decoder.decode<String>()));
        auto filename = TRY((decoder.decode<String>()));
        auto lineno = TRY((decoder.decode<u32>()));
        auto colno = TRY((decoder.decode<u32>()));
        return make<DidWorkerAgentReportException>(move(owner_token), move(message), move(filename), move(lineno), move(colno));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(Web::HTML::WorkerAgentOwnerToken const& owner_token, StringView message, StringView filename, u32 lineno, u32 colno)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidWorkerAgentReportException));
        TRY(stream.encode(owner_token));
        TRY(stream.encode(message));
        TRY(stream.encode(filename));
        TRY(stream.encode(lineno));
        TRY(stream.encode(colno));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_owner_token, m_message, m_filename, m_lineno, m_colno);
    }

    Web::HTML::WorkerAgentOwnerToken const& owner_token() const { return m_owner_token; }
    Web::HTML::WorkerAgentOwnerToken take_owner_token() { return move(m_owner_token); }

    String const& message() const { return m_message; }
    String take_message() { return move(m_message); }

    String const& filename() const { return m_filename; }
    String take_filename() { return move(m_filename); }

    u32 lineno() const { return m_lineno; }

    u32 colno() const { return m_colno; }

private:
    Web::HTML::WorkerAgentOwnerToken m_owner_token;
    String m_message;
    String m_filename;
    u32 m_lineno;
    u32 m_colno;
};

class DidWorkerAgentClose final : public IPC::Message {
public:
    DidWorkerAgentClose(Web::HTML::WorkerAgentOwnerToken owner_token)
        : m_owner_token(move(owner_token))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::HTML::WorkerAgentOwnerToken>)
    DidWorkerAgentClose(WrappedReturnType&& value)
        : m_owner_token(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::DidWorkerAgentClose; }
    static i32 static_message_id() { return (int)MessageID::DidWorkerAgentClose; }
    virtual StringView message_name() const override { return "WebContentServer::DidWorkerAgentClose"sv; }

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

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

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

    Web::HTML::WorkerAgentOwnerToken const& owner_token() const { return m_owner_token; }
    Web::HTML::WorkerAgentOwnerToken take_owner_token() { return move(m_owner_token); }

private:
    Web::HTML::WorkerAgentOwnerToken m_owner_token;
};

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 result->peer_pid();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_initialize(u64 initial_page_id, Web::HTML::NavigableId const& root_navigable_id, Web::HTML::NavigableIdAllocator const& navigable_id_allocator)
    {
        auto message_buffer = MUST(Messages::WebContentServer::Initialize::static_encode(initial_page_id, move(root_navigable_id), move(navigable_id_allocator)));
        (void)m_connection.post_message(message_buffer);
    }

    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 result->take_handle();
        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_complete_webdriver_history_traversal(u64 page_id, u64 request_id, bool accepted, bool will_replace_web_content_process, bool will_change_top_level_entry)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CompleteWebdriverHistoryTraversal::static_encode(page_id, request_id, accepted, will_replace_web_content_process, will_change_top_level_entry));
        (void)m_connection.post_message(message_buffer);
    }

    void async_complete_webdriver_navigation_completion(u64 page_id, u64 request_id, Web::WebDriver::Response const& response)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CompleteWebdriverNavigationCompletion::static_encode(page_id, request_id, move(response)));
        (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_process(IPC::TransportHandle const& handle)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ConnectToCompositorProcess::static_encode(move(handle)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_compositor_process_reconnected()
    {
        auto message_buffer = MUST(Messages::WebContentServer::CompositorProcessReconnected::static_encode());
        (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, Web::Bindings::NavigationHistoryBehavior const& history_handling)
    {
        auto message_buffer = MUST(Messages::WebContentServer::LoadUrl::static_encode(page_id, move(url), move(history_handling)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_load_url_with_document_resource(u64 page_id, URL::URL const& url, Variant<Empty, String, Web::HTML::POSTResource> const& document_resource, Web::Bindings::NavigationHistoryBehavior const& history_handling)
    {
        auto message_buffer = MUST(Messages::WebContentServer::LoadUrlWithDocumentResource::static_encode(page_id, move(url), move(document_resource), move(history_handling)));
        (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_load_html_with_url(u64 page_id, StringView html, URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentServer::LoadHtmlWithUrl::static_encode(page_id, html, move(url)));
        (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_cancel_download(u64 page_id, u64 download_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CancelDownload::static_encode(page_id, download_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_run_iframe_load_event_steps(u64 page_id, Web::HTML::NavigableId const& frame_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RunIframeLoadEventSteps::static_encode(page_id, move(frame_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_page_parent_context(u64 page_id, Optional<Web::Compositor::CompositorContextId> const& parent_context_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetPageParentContext::static_encode(page_id, move(parent_context_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_remote_child_frame_compositor_context(u64 page_id, Web::HTML::NavigableId const& frame_id, Optional<Web::Compositor::CompositorContextId> const& context_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetRemoteChildFrameCompositorContext::static_encode(page_id, move(frame_id), move(context_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_traverse_the_history_to_step(u64 page_id, i32 step)
    {
        auto message_buffer = MUST(Messages::WebContentServer::TraverseTheHistoryToStep::static_encode(page_id, step));
        (void)m_connection.post_message(message_buffer);
    }

    void async_check_if_traverse_history_step_is_canceled(u64 page_id, u64 request_id, i32 step)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CheckIfTraverseHistoryStepIsCanceled::static_encode(page_id, request_id, step));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_top_level_session_history(u64 page_id, ReadonlySpan<Web::HTML::SessionHistoryEntryDescriptor> entries, size_t current_top_level_entry_index, bool allow_reconstructing_current_entry)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetTopLevelSessionHistory::static_encode(page_id, entries, current_top_level_entry_index, allow_reconstructing_current_entry));
        (void)m_connection.post_message(message_buffer);
    }

    void async_reset_session_history_for_testing(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ResetSessionHistoryForTesting::static_encode(page_id));
        (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_storage(u64 page_id, Web::StorageAPI::StorageEndpointType const& storage_endpoint, u64 request_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectStorage::static_encode(page_id, move(storage_endpoint), request_id));
        (void)m_connection.post_message(message_buffer);
    }

    Optional<WebView::StorageSetResult> set_session_storage_item(u64 page_id, String key, String value)
    {
        return m_connection.template send_sync<Messages::WebContentServer::SetSessionStorageItem>(page_id, move(key), move(value))->take_result();
    }

    void async_set_session_storage_item(u64 page_id, StringView key, StringView value)
    {
        VERIFY(Utf8View { key }.validate());
        VERIFY(Utf8View { value }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::SetSessionStorageItem::static_encode(page_id, key, value));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_session_storage_item(u64 page_id, String const& key, String const& value)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetSessionStorageItem::static_encode(page_id, key, value));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Optional<WebView::StorageSetResult>> try_set_session_storage_item(u64 page_id, String key, String value)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::SetSessionStorageItem>(page_id, move(key), move(value)))
            return result->take_result();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Optional<String> remove_session_storage_item(u64 page_id, String key)
    {
        return m_connection.template send_sync<Messages::WebContentServer::RemoveSessionStorageItem>(page_id, move(key))->take_old_value();
    }

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

    void async_remove_session_storage_item(u64 page_id, String const& key)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RemoveSessionStorageItem::static_encode(page_id, key));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Optional<String>> try_remove_session_storage_item(u64 page_id, String key)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::RemoveSessionStorageItem>(page_id, move(key)))
            return result->take_old_value();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    bool clear_session_storage(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentServer::ClearSessionStorage>(page_id)->did_clear();
    }

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

    IPC::IPCErrorOr<bool> try_clear_session_storage(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::ClearSessionStorage>(page_id))
            return result->did_clear();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    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, JsonValue const& options)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectDomNode::static_encode(page_id, move(property_type), move(node_id), move(pseudo_element), move(options)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_grid_layouts(u64 page_id, Web::UniqueNodeID const& root_node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectGridLayouts::static_encode(page_id, move(root_node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_current_grid(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectCurrentGrid::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_current_flexbox(u64 page_id, Web::UniqueNodeID const& node_id, bool only_look_at_parents)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectCurrentFlexbox::static_encode(page_id, move(node_id), only_look_at_parents));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_indexed_database_storage(u64 page_id, u64 request_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectIndexedDatabaseStorage::static_encode(page_id, request_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_indexed_database_objects(u64 page_id, u64 request_id, StringView host, JsonValue const& names, JsonValue const& options)
    {
        VERIFY(Utf8View { host }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::InspectIndexedDatabaseObjects::static_encode(page_id, request_id, host, move(names), move(options)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_inspect_indexed_database_objects(u64 page_id, u64 request_id, String const& host, JsonValue const& names, JsonValue const& options)
    {
        auto message_buffer = MUST(Messages::WebContentServer::InspectIndexedDatabaseObjects::static_encode(page_id, request_id, host, move(names), move(options)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_delete_indexed_database(u64 page_id, u64 request_id, StringView host, StringView name)
    {
        VERIFY(Utf8View { host }.validate());
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::DeleteIndexedDatabase::static_encode(page_id, request_id, host, name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_delete_indexed_database(u64 page_id, u64 request_id, String const& host, String const& name)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DeleteIndexedDatabase::static_encode(page_id, request_id, host, name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_clear_indexed_database_object_store(u64 page_id, u64 request_id, StringView host, StringView name)
    {
        VERIFY(Utf8View { host }.validate());
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::ClearIndexedDatabaseObjectStore::static_encode(page_id, request_id, host, name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_clear_indexed_database_object_store(u64 page_id, u64 request_id, String const& host, String const& name)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ClearIndexedDatabaseObjectStore::static_encode(page_id, request_id, host, name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_delete_indexed_database_record(u64 page_id, u64 request_id, StringView host, StringView name)
    {
        VERIFY(Utf8View { host }.validate());
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::DeleteIndexedDatabaseRecord::static_encode(page_id, request_id, host, name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_delete_indexed_database_record(u64 page_id, u64 request_id, String const& host, String const& name)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DeleteIndexedDatabaseRecord::static_encode(page_id, request_id, host, name));
        (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_highlight_flexbox(u64 page_id, Web::UniqueNodeID const& node_id, JsonValue const& options)
    {
        auto message_buffer = MUST(Messages::WebContentServer::HighlightFlexbox::static_encode(page_id, move(node_id), move(options)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_clear_flexbox_highlight(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ClearFlexboxHighlight::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_highlight_grid(u64 page_id, Web::UniqueNodeID const& node_id, JsonValue const& options)
    {
        auto message_buffer = MUST(Messages::WebContentServer::HighlightGrid::static_encode(page_id, move(node_id), move(options)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_clear_grid_highlight(u64 page_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ClearGridHighlight::static_encode(page_id, move(node_id)));
        (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_get_node_id_at_position(u64 page_id, u64 request_id, Web::DevicePixelPoint position)
    {
        auto message_buffer = MUST(Messages::WebContentServer::GetNodeIdAtPosition::static_encode(page_id, request_id, position));
        (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_list_devtools_sources(u64 page_id, u64 request_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ListDevtoolsSources::static_encode(page_id, request_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_request_devtools_source(u64 page_id, Web::HTML::ScriptRegistry::Identifier const& source_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::RequestDevtoolsSource::static_encode(page_id, move(source_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_resolve_dom_node_url(u64 page_id, u64 request_id, Optional<Web::UniqueNodeID> const& node_id, StringView url)
    {
        VERIFY(Utf8View { url }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::ResolveDomNodeUrl::static_encode(page_id, request_id, move(node_id), url));
        (void)m_connection.post_message(message_buffer);
    }

    void async_resolve_dom_node_url(u64 page_id, u64 request_id, Optional<Web::UniqueNodeID> const& node_id, String const& url)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ResolveDomNodeUrl::static_encode(page_id, request_id, move(node_id), url));
        (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, Utf16FlyString const& name)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetDomNodeTag::static_encode(page_id, move(node_id), move(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, Utf16FlyString const& name, ReadonlySpan<WebView::Attribute> replacement_attributes)
    {
        auto message_buffer = MUST(Messages::WebContentServer::ReplaceDomNodeAttribute::static_encode(page_id, move(node_id), move(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 result->take_selection();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Optional<WebView::DictionaryLookup> get_selected_text_for_lookup(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentServer::GetSelectedTextForLookup>(page_id)->take_lookup();
    }

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

    IPC::IPCErrorOr<Optional<WebView::DictionaryLookup>> try_get_selected_text_for_lookup(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::GetSelectedTextForLookup>(page_id))
            return result->take_lookup();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    bool select_word_for_dictionary_lookup(u64 page_id, Web::DevicePixelPoint position)
    {
        return m_connection.template send_sync<Messages::WebContentServer::SelectWordForDictionaryLookup>(page_id, position)->selected();
    }

    void async_select_word_for_dictionary_lookup(u64 page_id, Web::DevicePixelPoint position)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SelectWordForDictionaryLookup::static_encode(page_id, position));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<bool> try_select_word_for_dictionary_lookup(u64 page_id, Web::DevicePixelPoint position)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentServer::SelectWordForDictionaryLookup>(page_id, position))
            return result->selected();
        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 result->take_selection();
        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_set_marked_text_from_input_method(u64 page_id, Utf16View const& text)
    {
        VERIFY(text.validate());
        auto message_buffer = MUST(Messages::WebContentServer::SetMarkedTextFromInputMethod::static_encode(page_id, move(text)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_marked_text_from_input_method(u64 page_id, Utf16String const& text)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetMarkedTextFromInputMethod::static_encode(page_id, move(text)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_commit_text_from_input_method(u64 page_id, Utf16View const& text, i32 replacement_start, i32 replacement_length)
    {
        VERIFY(text.validate());
        auto message_buffer = MUST(Messages::WebContentServer::CommitTextFromInputMethod::static_encode(page_id, move(text), replacement_start, replacement_length));
        (void)m_connection.post_message(message_buffer);
    }

    void async_commit_text_from_input_method(u64 page_id, Utf16String const& text, i32 replacement_start, i32 replacement_length)
    {
        auto message_buffer = MUST(Messages::WebContentServer::CommitTextFromInputMethod::static_encode(page_id, move(text), replacement_start, replacement_length));
        (void)m_connection.post_message(message_buffer);
    }

    void async_unmark_text_from_input_method(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::UnmarkTextFromInputMethod::static_encode(page_id));
        (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_blockers(u64 page_id, Core::AnonymousBuffer const& patterns)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetContentBlockers::static_encode(page_id, move(patterns)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_autoplay_settings(u64 page_id, Web::HTML::AutoplayPolicy const& policy, ReadonlySpan<String> allowlist)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetAutoplaySettings::static_encode(page_id, move(policy), 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_did_delete_all_cookies(u64 page_id, u64 request_id)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DidDeleteAllCookies::static_encode(page_id, 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_set_page_mute_state(u64 page_id, Web::HTML::MuteState const& mute_state)
    {
        auto message_buffer = MUST(Messages::WebContentServer::SetPageMuteState::static_encode(page_id, move(mute_state)));
        (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_did_worker_agent_finish_loading_script(Web::HTML::WorkerAgentOwnerToken const& owner_token)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DidWorkerAgentFinishLoadingScript::static_encode(move(owner_token)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_worker_agent_fail_loading_script(Web::HTML::WorkerAgentOwnerToken const& owner_token)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DidWorkerAgentFailLoadingScript::static_encode(move(owner_token)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_worker_agent_report_exception(Web::HTML::WorkerAgentOwnerToken const& owner_token, StringView message, StringView filename, u32 lineno, u32 colno)
    {
        VERIFY(Utf8View { message }.validate());
        VERIFY(Utf8View { filename }.validate());
        auto message_buffer = MUST(Messages::WebContentServer::DidWorkerAgentReportException::static_encode(move(owner_token), message, filename, lineno, colno));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_worker_agent_report_exception(Web::HTML::WorkerAgentOwnerToken const& owner_token, String const& message, String const& filename, u32 lineno, u32 colno)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DidWorkerAgentReportException::static_encode(move(owner_token), message, filename, lineno, colno));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_worker_agent_close(Web::HTML::WorkerAgentOwnerToken const& owner_token)
    {
        auto message_buffer = MUST(Messages::WebContentServer::DidWorkerAgentClose::static_encode(move(owner_token)));
        (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::Initialize:
            return Messages::WebContentServer::Initialize::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::CompleteWebdriverHistoryTraversal:
            return Messages::WebContentServer::CompleteWebdriverHistoryTraversal::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CompleteWebdriverNavigationCompletion:
            return Messages::WebContentServer::CompleteWebdriverNavigationCompletion::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::ConnectToCompositorProcess:
            return Messages::WebContentServer::ConnectToCompositorProcess::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CompositorProcessReconnected:
            return Messages::WebContentServer::CompositorProcessReconnected::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::LoadUrlWithDocumentResource:
            return Messages::WebContentServer::LoadUrlWithDocumentResource::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::LoadHtml:
            return Messages::WebContentServer::LoadHtml::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::LoadHtmlWithUrl:
            return Messages::WebContentServer::LoadHtmlWithUrl::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::Reload:
            return Messages::WebContentServer::Reload::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CancelDownload:
            return Messages::WebContentServer::CancelDownload::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RunIframeLoadEventSteps:
            return Messages::WebContentServer::RunIframeLoadEventSteps::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetPageParentContext:
            return Messages::WebContentServer::SetPageParentContext::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetRemoteChildFrameCompositorContext:
            return Messages::WebContentServer::SetRemoteChildFrameCompositorContext::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::TraverseTheHistoryToStep:
            return Messages::WebContentServer::TraverseTheHistoryToStep::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CheckIfTraverseHistoryStepIsCanceled:
            return Messages::WebContentServer::CheckIfTraverseHistoryStepIsCanceled::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetTopLevelSessionHistory:
            return Messages::WebContentServer::SetTopLevelSessionHistory::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ResetSessionHistoryForTesting:
            return Messages::WebContentServer::ResetSessionHistoryForTesting::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::InspectStorage:
            return Messages::WebContentServer::InspectStorage::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetSessionStorageItem:
            return Messages::WebContentServer::SetSessionStorageItem::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetSessionStorageItemResponse:
            return Messages::WebContentServer::SetSessionStorageItemResponse::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RemoveSessionStorageItem:
            return Messages::WebContentServer::RemoveSessionStorageItem::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RemoveSessionStorageItemResponse:
            return Messages::WebContentServer::RemoveSessionStorageItemResponse::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ClearSessionStorage:
            return Messages::WebContentServer::ClearSessionStorage::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ClearSessionStorageResponse:
            return Messages::WebContentServer::ClearSessionStorageResponse::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectDomNode:
            return Messages::WebContentServer::InspectDomNode::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectGridLayouts:
            return Messages::WebContentServer::InspectGridLayouts::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectCurrentGrid:
            return Messages::WebContentServer::InspectCurrentGrid::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectCurrentFlexbox:
            return Messages::WebContentServer::InspectCurrentFlexbox::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectIndexedDatabaseStorage:
            return Messages::WebContentServer::InspectIndexedDatabaseStorage::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::InspectIndexedDatabaseObjects:
            return Messages::WebContentServer::InspectIndexedDatabaseObjects::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DeleteIndexedDatabase:
            return Messages::WebContentServer::DeleteIndexedDatabase::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ClearIndexedDatabaseObjectStore:
            return Messages::WebContentServer::ClearIndexedDatabaseObjectStore::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DeleteIndexedDatabaseRecord:
            return Messages::WebContentServer::DeleteIndexedDatabaseRecord::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::HighlightFlexbox:
            return Messages::WebContentServer::HighlightFlexbox::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ClearFlexboxHighlight:
            return Messages::WebContentServer::ClearFlexboxHighlight::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::HighlightGrid:
            return Messages::WebContentServer::HighlightGrid::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ClearGridHighlight:
            return Messages::WebContentServer::ClearGridHighlight::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::GetNodeIdAtPosition:
            return Messages::WebContentServer::GetNodeIdAtPosition::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::ListDevtoolsSources:
            return Messages::WebContentServer::ListDevtoolsSources::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::RequestDevtoolsSource:
            return Messages::WebContentServer::RequestDevtoolsSource::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::ResolveDomNodeUrl:
            return Messages::WebContentServer::ResolveDomNodeUrl::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::GetSelectedTextForLookup:
            return Messages::WebContentServer::GetSelectedTextForLookup::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::GetSelectedTextForLookupResponse:
            return Messages::WebContentServer::GetSelectedTextForLookupResponse::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SelectWordForDictionaryLookup:
            return Messages::WebContentServer::SelectWordForDictionaryLookup::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SelectWordForDictionaryLookupResponse:
            return Messages::WebContentServer::SelectWordForDictionaryLookupResponse::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::SetMarkedTextFromInputMethod:
            return Messages::WebContentServer::SetMarkedTextFromInputMethod::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::CommitTextFromInputMethod:
            return Messages::WebContentServer::CommitTextFromInputMethod::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::UnmarkTextFromInputMethod:
            return Messages::WebContentServer::UnmarkTextFromInputMethod::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::SetContentBlockers:
            return Messages::WebContentServer::SetContentBlockers::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::SetAutoplaySettings:
            return Messages::WebContentServer::SetAutoplaySettings::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::DidDeleteAllCookies:
            return Messages::WebContentServer::DidDeleteAllCookies::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::SetPageMuteState:
            return Messages::WebContentServer::SetPageMuteState::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::DidWorkerAgentFinishLoadingScript:
            return Messages::WebContentServer::DidWorkerAgentFinishLoadingScript::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DidWorkerAgentFailLoadingScript:
            return Messages::WebContentServer::DidWorkerAgentFailLoadingScript::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DidWorkerAgentReportException:
            return Messages::WebContentServer::DidWorkerAgentReportException::decode(stream, attachments);
        case (int)Messages::WebContentServer::MessageID::DidWorkerAgentClose:
            return Messages::WebContentServer::DidWorkerAgentClose::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::Initialize:
            return handle_initialize(*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::CompleteWebdriverHistoryTraversal:
            return handle_complete_webdriver_history_traversal(*message);
        case (int)Messages::WebContentServer::MessageID::CompleteWebdriverNavigationCompletion:
            return handle_complete_webdriver_navigation_completion(*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::ConnectToCompositorProcess:
            return handle_connect_to_compositor_process(*message);
        case (int)Messages::WebContentServer::MessageID::CompositorProcessReconnected:
            return handle_compositor_process_reconnected();
        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::LoadUrlWithDocumentResource:
            return handle_load_url_with_document_resource(*message);
        case (int)Messages::WebContentServer::MessageID::LoadHtml:
            return handle_load_html(*message);
        case (int)Messages::WebContentServer::MessageID::LoadHtmlWithUrl:
            return handle_load_html_with_url(*message);
        case (int)Messages::WebContentServer::MessageID::Reload:
            return handle_reload(*message);
        case (int)Messages::WebContentServer::MessageID::CancelDownload:
            return handle_cancel_download(*message);
        case (int)Messages::WebContentServer::MessageID::RunIframeLoadEventSteps:
            return handle_run_iframe_load_event_steps(*message);
        case (int)Messages::WebContentServer::MessageID::SetPageParentContext:
            return handle_set_page_parent_context(*message);
        case (int)Messages::WebContentServer::MessageID::SetRemoteChildFrameCompositorContext:
            return handle_set_remote_child_frame_compositor_context(*message);
        case (int)Messages::WebContentServer::MessageID::TraverseTheHistoryToStep:
            return handle_traverse_the_history_to_step(*message);
        case (int)Messages::WebContentServer::MessageID::CheckIfTraverseHistoryStepIsCanceled:
            return handle_check_if_traverse_history_step_is_canceled(*message);
        case (int)Messages::WebContentServer::MessageID::SetTopLevelSessionHistory:
            return handle_set_top_level_session_history(*message);
        case (int)Messages::WebContentServer::MessageID::ResetSessionHistoryForTesting:
            return handle_reset_session_history_for_testing(*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::InspectStorage:
            return handle_inspect_storage(*message);
        case (int)Messages::WebContentServer::MessageID::SetSessionStorageItem:
            return handle_set_session_storage_item(*message);
        case (int)Messages::WebContentServer::MessageID::RemoveSessionStorageItem:
            return handle_remove_session_storage_item(*message);
        case (int)Messages::WebContentServer::MessageID::ClearSessionStorage:
            return handle_clear_session_storage(*message);
        case (int)Messages::WebContentServer::MessageID::InspectDomNode:
            return handle_inspect_dom_node(*message);
        case (int)Messages::WebContentServer::MessageID::InspectGridLayouts:
            return handle_inspect_grid_layouts(*message);
        case (int)Messages::WebContentServer::MessageID::InspectCurrentGrid:
            return handle_inspect_current_grid(*message);
        case (int)Messages::WebContentServer::MessageID::InspectCurrentFlexbox:
            return handle_inspect_current_flexbox(*message);
        case (int)Messages::WebContentServer::MessageID::InspectIndexedDatabaseStorage:
            return handle_inspect_indexed_database_storage(*message);
        case (int)Messages::WebContentServer::MessageID::InspectIndexedDatabaseObjects:
            return handle_inspect_indexed_database_objects(*message);
        case (int)Messages::WebContentServer::MessageID::DeleteIndexedDatabase:
            return handle_delete_indexed_database(*message);
        case (int)Messages::WebContentServer::MessageID::ClearIndexedDatabaseObjectStore:
            return handle_clear_indexed_database_object_store(*message);
        case (int)Messages::WebContentServer::MessageID::DeleteIndexedDatabaseRecord:
            return handle_delete_indexed_database_record(*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::HighlightFlexbox:
            return handle_highlight_flexbox(*message);
        case (int)Messages::WebContentServer::MessageID::ClearFlexboxHighlight:
            return handle_clear_flexbox_highlight(*message);
        case (int)Messages::WebContentServer::MessageID::HighlightGrid:
            return handle_highlight_grid(*message);
        case (int)Messages::WebContentServer::MessageID::ClearGridHighlight:
            return handle_clear_grid_highlight(*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::GetNodeIdAtPosition:
            return handle_get_node_id_at_position(*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::ListDevtoolsSources:
            return handle_list_devtools_sources(*message);
        case (int)Messages::WebContentServer::MessageID::RequestDevtoolsSource:
            return handle_request_devtools_source(*message);
        case (int)Messages::WebContentServer::MessageID::ResolveDomNodeUrl:
            return handle_resolve_dom_node_url(*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::GetSelectedTextForLookup:
            return handle_get_selected_text_for_lookup(*message);
        case (int)Messages::WebContentServer::MessageID::SelectWordForDictionaryLookup:
            return handle_select_word_for_dictionary_lookup(*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::SetMarkedTextFromInputMethod:
            return handle_set_marked_text_from_input_method(*message);
        case (int)Messages::WebContentServer::MessageID::CommitTextFromInputMethod:
            return handle_commit_text_from_input_method(*message);
        case (int)Messages::WebContentServer::MessageID::UnmarkTextFromInputMethod:
            return handle_unmark_text_from_input_method(*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::SetContentBlockers:
            return handle_set_content_blockers(*message);
        case (int)Messages::WebContentServer::MessageID::SetAutoplaySettings:
            return handle_set_autoplay_settings(*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::DidDeleteAllCookies:
            return handle_did_delete_all_cookies(*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::SetPageMuteState:
            return handle_set_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::DidWorkerAgentFinishLoadingScript:
            return handle_did_worker_agent_finish_loading_script(*message);
        case (int)Messages::WebContentServer::MessageID::DidWorkerAgentFailLoadingScript:
            return handle_did_worker_agent_fail_loading_script(*message);
        case (int)Messages::WebContentServer::MessageID::DidWorkerAgentReportException:
            return handle_did_worker_agent_report_exception(*message);
        case (int)Messages::WebContentServer::MessageID::DidWorkerAgentClose:
            return handle_did_worker_agent_close(*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_initialize(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::Initialize&>(message);
        initialize(request.initial_page_id(), request.take_root_navigable_id(), request.take_navigable_id_allocator());
        return nullptr;
    }

    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_complete_webdriver_history_traversal(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CompleteWebdriverHistoryTraversal&>(message);
        complete_webdriver_history_traversal(request.page_id(), request.request_id(), request.accepted(), request.will_replace_web_content_process(), request.will_change_top_level_entry());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_complete_webdriver_navigation_completion(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CompleteWebdriverNavigationCompletion&>(message);
        complete_webdriver_navigation_completion(request.page_id(), request.request_id(), request.take_response());
        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_process(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ConnectToCompositorProcess&>(message);
        connect_to_compositor_process(request.take_handle());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_compositor_process_reconnected()
    {
        compositor_process_reconnected();
        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(), request.take_history_handling());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_load_url_with_document_resource(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::LoadUrlWithDocumentResource&>(message);
        load_url_with_document_resource(request.page_id(), request.take_url(), request.take_document_resource(), request.take_history_handling());
        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_load_html_with_url(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::LoadHtmlWithUrl&>(message);
        load_html_with_url(request.page_id(), request.take_html(), request.take_url());
        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_cancel_download(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CancelDownload&>(message);
        cancel_download(request.page_id(), request.download_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_run_iframe_load_event_steps(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RunIframeLoadEventSteps&>(message);
        run_iframe_load_event_steps(request.page_id(), request.take_frame_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_page_parent_context(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetPageParentContext&>(message);
        set_page_parent_context(request.page_id(), request.take_parent_context_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_remote_child_frame_compositor_context(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetRemoteChildFrameCompositorContext&>(message);
        set_remote_child_frame_compositor_context(request.page_id(), request.take_frame_id(), request.take_context_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_traverse_the_history_to_step(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::TraverseTheHistoryToStep&>(message);
        traverse_the_history_to_step(request.page_id(), request.step());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_check_if_traverse_history_step_is_canceled(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CheckIfTraverseHistoryStepIsCanceled&>(message);
        check_if_traverse_history_step_is_canceled(request.page_id(), request.request_id(), request.step());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_top_level_session_history(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetTopLevelSessionHistory&>(message);
        set_top_level_session_history(request.page_id(), request.take_entries(), request.current_top_level_entry_index(), request.allow_reconstructing_current_entry());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_reset_session_history_for_testing(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ResetSessionHistoryForTesting&>(message);
        reset_session_history_for_testing(request.page_id());
        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_storage(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectStorage&>(message);
        inspect_storage(request.page_id(), request.take_storage_endpoint(), request.request_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_session_storage_item(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetSessionStorageItem&>(message);
        auto response = set_session_storage_item(request.page_id(), request.take_key(), request.take_value());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_remove_session_storage_item(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RemoveSessionStorageItem&>(message);
        auto response = remove_session_storage_item(request.page_id(), request.take_key());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_clear_session_storage(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ClearSessionStorage&>(message);
        auto response = clear_session_storage(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    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(), request.take_options());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_inspect_grid_layouts(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectGridLayouts&>(message);
        inspect_grid_layouts(request.page_id(), request.take_root_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_inspect_current_grid(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectCurrentGrid&>(message);
        inspect_current_grid(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_inspect_current_flexbox(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectCurrentFlexbox&>(message);
        inspect_current_flexbox(request.page_id(), request.take_node_id(), request.only_look_at_parents());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_inspect_indexed_database_storage(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectIndexedDatabaseStorage&>(message);
        inspect_indexed_database_storage(request.page_id(), request.request_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_inspect_indexed_database_objects(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::InspectIndexedDatabaseObjects&>(message);
        inspect_indexed_database_objects(request.page_id(), request.request_id(), request.take_host(), request.take_names(), request.take_options());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_delete_indexed_database(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DeleteIndexedDatabase&>(message);
        delete_indexed_database(request.page_id(), request.request_id(), request.take_host(), request.take_name());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_clear_indexed_database_object_store(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ClearIndexedDatabaseObjectStore&>(message);
        clear_indexed_database_object_store(request.page_id(), request.request_id(), request.take_host(), request.take_name());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_delete_indexed_database_record(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DeleteIndexedDatabaseRecord&>(message);
        delete_indexed_database_record(request.page_id(), request.request_id(), request.take_host(), request.take_name());
        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_highlight_flexbox(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::HighlightFlexbox&>(message);
        highlight_flexbox(request.page_id(), request.take_node_id(), request.take_options());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_clear_flexbox_highlight(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ClearFlexboxHighlight&>(message);
        clear_flexbox_highlight(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_highlight_grid(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::HighlightGrid&>(message);
        highlight_grid(request.page_id(), request.take_node_id(), request.take_options());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_clear_grid_highlight(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ClearGridHighlight&>(message);
        clear_grid_highlight(request.page_id(), request.take_node_id());
        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_get_node_id_at_position(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::GetNodeIdAtPosition&>(message);
        get_node_id_at_position(request.page_id(), request.request_id(), request.position());
        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_list_devtools_sources(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ListDevtoolsSources&>(message);
        list_devtools_sources(request.page_id(), request.request_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_request_devtools_source(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::RequestDevtoolsSource&>(message);
        request_devtools_source(request.page_id(), request.take_source_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_resolve_dom_node_url(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::ResolveDomNodeUrl&>(message);
        resolve_dom_node_url(request.page_id(), request.request_id(), request.take_node_id(), request.take_url());
        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_get_selected_text_for_lookup(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::GetSelectedTextForLookup&>(message);
        auto response = get_selected_text_for_lookup(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_select_word_for_dictionary_lookup(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SelectWordForDictionaryLookup&>(message);
        auto response = select_word_for_dictionary_lookup(request.page_id(), request.position());
        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_set_marked_text_from_input_method(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetMarkedTextFromInputMethod&>(message);
        set_marked_text_from_input_method(request.page_id(), request.take_text());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_commit_text_from_input_method(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::CommitTextFromInputMethod&>(message);
        commit_text_from_input_method(request.page_id(), request.take_text(), request.replacement_start(), request.replacement_length());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_unmark_text_from_input_method(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::UnmarkTextFromInputMethod&>(message);
        unmark_text_from_input_method(request.page_id());
        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_blockers(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetContentBlockers&>(message);
        set_content_blockers(request.page_id(), request.take_patterns());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_autoplay_settings(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetAutoplaySettings&>(message);
        set_autoplay_settings(request.page_id(), request.take_policy(), 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_did_delete_all_cookies(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DidDeleteAllCookies&>(message);
        did_delete_all_cookies(request.page_id(), 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_set_page_mute_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::SetPageMuteState&>(message);
        set_page_mute_state(request.page_id(), request.take_mute_state());
        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_did_worker_agent_finish_loading_script(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DidWorkerAgentFinishLoadingScript&>(message);
        did_worker_agent_finish_loading_script(request.take_owner_token());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_worker_agent_fail_loading_script(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DidWorkerAgentFailLoadingScript&>(message);
        did_worker_agent_fail_loading_script(request.take_owner_token());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_worker_agent_report_exception(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DidWorkerAgentReportException&>(message);
        did_worker_agent_report_exception(request.take_owner_token(), request.take_message(), request.take_filename(), request.lineno(), request.colno());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_worker_agent_close(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentServer::DidWorkerAgentClose&>(message);
        did_worker_agent_close(request.take_owner_token());
        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 initialize(u64 initial_page_id, Web::HTML::NavigableId root_navigable_id, Web::HTML::NavigableIdAllocator navigable_id_allocator) = 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 complete_webdriver_history_traversal(u64 page_id, u64 request_id, bool accepted, bool will_replace_web_content_process, bool will_change_top_level_entry) = 0;
    virtual void complete_webdriver_navigation_completion(u64 page_id, u64 request_id, Web::WebDriver::Response response) = 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_process(IPC::TransportHandle handle) = 0;
    virtual void compositor_process_reconnected() = 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, Web::Bindings::NavigationHistoryBehavior history_handling) = 0;
    virtual void load_url_with_document_resource(u64 page_id, URL::URL url, Variant<Empty, String, Web::HTML::POSTResource> document_resource, Web::Bindings::NavigationHistoryBehavior history_handling) = 0;
    virtual void load_html(u64 page_id, ByteString html) = 0;
    virtual void load_html_with_url(u64 page_id, ByteString html, URL::URL url) = 0;
    virtual void reload(u64 page_id) = 0;
    virtual void cancel_download(u64 page_id, u64 download_id) = 0;
    virtual void run_iframe_load_event_steps(u64 page_id, Web::HTML::NavigableId frame_id) = 0;
    virtual void set_page_parent_context(u64 page_id, Optional<Web::Compositor::CompositorContextId> parent_context_id) = 0;
    virtual void set_remote_child_frame_compositor_context(u64 page_id, Web::HTML::NavigableId frame_id, Optional<Web::Compositor::CompositorContextId> context_id) = 0;
    virtual void traverse_the_history_to_step(u64 page_id, i32 step) = 0;
    virtual void check_if_traverse_history_step_is_canceled(u64 page_id, u64 request_id, i32 step) = 0;
    virtual void set_top_level_session_history(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, size_t current_top_level_entry_index, bool allow_reconstructing_current_entry) = 0;
    virtual void reset_session_history_for_testing(u64 page_id) = 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_storage(u64 page_id, Web::StorageAPI::StorageEndpointType storage_endpoint, u64 request_id) = 0;
    virtual Messages::WebContentServer::SetSessionStorageItemResponse set_session_storage_item(u64 page_id, String key, String value) = 0;
    virtual Messages::WebContentServer::RemoveSessionStorageItemResponse remove_session_storage_item(u64 page_id, String key) = 0;
    virtual Messages::WebContentServer::ClearSessionStorageResponse clear_session_storage(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, JsonValue options) = 0;
    virtual void inspect_grid_layouts(u64 page_id, Web::UniqueNodeID root_node_id) = 0;
    virtual void inspect_current_grid(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void inspect_current_flexbox(u64 page_id, Web::UniqueNodeID node_id, bool only_look_at_parents) = 0;
    virtual void inspect_indexed_database_storage(u64 page_id, u64 request_id) = 0;
    virtual void inspect_indexed_database_objects(u64 page_id, u64 request_id, String host, JsonValue names, JsonValue options) = 0;
    virtual void delete_indexed_database(u64 page_id, u64 request_id, String host, String name) = 0;
    virtual void clear_indexed_database_object_store(u64 page_id, u64 request_id, String host, String name) = 0;
    virtual void delete_indexed_database_record(u64 page_id, u64 request_id, String host, String name) = 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 highlight_flexbox(u64 page_id, Web::UniqueNodeID node_id, JsonValue options) = 0;
    virtual void clear_flexbox_highlight(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void highlight_grid(u64 page_id, Web::UniqueNodeID node_id, JsonValue options) = 0;
    virtual void clear_grid_highlight(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void inspect_accessibility_tree(u64 page_id) = 0;
    virtual void get_hovered_node_id(u64 page_id) = 0;
    virtual void get_node_id_at_position(u64 page_id, u64 request_id, Web::DevicePixelPoint position) = 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 list_devtools_sources(u64 page_id, u64 request_id) = 0;
    virtual void request_devtools_source(u64 page_id, Web::HTML::ScriptRegistry::Identifier source_id) = 0;
    virtual void resolve_dom_node_url(u64 page_id, u64 request_id, Optional<Web::UniqueNodeID> node_id, String url) = 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, Utf16FlyString 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, Utf16FlyString 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::GetSelectedTextForLookupResponse get_selected_text_for_lookup(u64 page_id) = 0;
    virtual Messages::WebContentServer::SelectWordForDictionaryLookupResponse select_word_for_dictionary_lookup(u64 page_id, Web::DevicePixelPoint position) = 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 set_marked_text_from_input_method(u64 page_id, Utf16String text) = 0;
    virtual void commit_text_from_input_method(u64 page_id, Utf16String text, i32 replacement_start, i32 replacement_length) = 0;
    virtual void unmark_text_from_input_method(u64 page_id) = 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_blockers(u64 page_id, Core::AnonymousBuffer patterns) = 0;
    virtual void set_autoplay_settings(u64 page_id, Web::HTML::AutoplayPolicy policy, 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 did_delete_all_cookies(u64 page_id, u64 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 set_page_mute_state(u64 page_id, Web::HTML::MuteState mute_state) = 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 did_worker_agent_finish_loading_script(Web::HTML::WorkerAgentOwnerToken owner_token) = 0;
    virtual void did_worker_agent_fail_loading_script(Web::HTML::WorkerAgentOwnerToken owner_token) = 0;
    virtual void did_worker_agent_report_exception(Web::HTML::WorkerAgentOwnerToken owner_token, String message, String filename, u32 lineno, u32 colno) = 0;
    virtual void did_worker_agent_close(Web::HTML::WorkerAgentOwnerToken owner_token) = 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