#pragma once

#include <LibCore/AnonymousBuffer.h>
#include <LibGfx/Color.h>
#include <LibIPC/TransportHandle.h>
#include <LibGfx/Cursor.h>
#include <LibGfx/ShareableBitmap.h>
#include <LibHTTP/Cookie/Cookie.h>
#include <LibHTTP/Cookie/ParsedCookie.h>
#include <LibHTTP/Header.h>
#include <LibRequests/NetworkError.h>
#include <LibRequests/RequestTimingInfo.h>
#include <LibURL/URL.h>
#include <LibWeb/Bindings/MainThreadVM.h>
#include <LibWeb/Clipboard/SystemClipboard.h>
#include <LibWeb/CSS/Selector.h>
#include <LibWeb/CSS/StyleSheetIdentifier.h>
#include <LibWeb/HTML/ActivateTab.h>
#include <LibWeb/HTML/AudioPlayState.h>
#include <LibWeb/HTML/BroadcastChannelMessage.h>
#include <LibWeb/HTML/FileFilter.h>
#include <LibWeb/HTML/SelectedFile.h>
#include <LibWeb/HTML/SelectItem.h>
#include <LibWeb/HTML/WebViewHints.h>
#include <LibWeb/Page/EventResult.h>
#include <LibWeb/Page/Page.h>
#include <LibWebView/Attribute.h>
#include <LibWebView/ConsoleOutput.h>
#include <LibWebView/DOMNodeProperties.h>
#include <LibWeb/StorageAPI/StorageEndpoint.h>
#include <LibWebView/StorageSetResult.h>
#include <LibWebView/Mutation.h>
#include <LibWebView/PageInfo.h>
#include <LibWebView/ProcessHandle.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::WebContentClient {

enum class MessageID : i32 {
    DidRequestNewProcessForNavigation = 1,
    DidStartLoading = 2,
    DidFinishLoading = 3,
    DidRequestRefresh = 4,
    DidRequestCursorChange = 5,
    DidChangeTitle = 6,
    DidChangeUrl = 7,
    DidRequestTooltipOverride = 8,
    DidStopTooltipOverride = 9,
    DidEnterTooltipArea = 10,
    DidLeaveTooltipArea = 11,
    DidHoverLink = 12,
    DidUnhoverLink = 13,
    DidClickLink = 14,
    DidMiddleClickLink = 15,
    DidRequestContextMenu = 16,
    DidRequestLinkContextMenu = 17,
    DidRequestImageContextMenu = 18,
    DidRequestMediaContextMenu = 19,
    DidRequestAlert = 20,
    DidRequestConfirm = 21,
    DidRequestPrompt = 22,
    DidRequestSetPromptText = 23,
    DidRequestAcceptDialog = 24,
    DidRequestDismissDialog = 25,
    DidGetSource = 26,
    DidInspectDomTree = 27,
    DidInspectDomNode = 28,
    DidInspectAccessibilityTree = 29,
    DidGetHoveredNodeId = 30,
    DidFinishEditingDomNode = 31,
    DidMutateDom = 32,
    DidGetDomNodeHtml = 33,
    DidListStyleSheets = 34,
    DidGetStyleSheetSource = 35,
    DidTakeScreenshot = 36,
    DidGetInternalPageInfo = 37,
    DidChangeFavicon = 38,
    DidRequestDocumentCookieVersionIndex = 39,
    DidRequestAllCookiesWebdriver = 40,
    DidRequestAllCookiesWebdriverResponse = 41,
    DidRequestAllCookiesCookiestore = 42,
    DidRequestAllCookiesCookiestoreResponse = 43,
    DidRequestNamedCookie = 44,
    DidRequestNamedCookieResponse = 45,
    DidRequestCookie = 46,
    DidRequestCookieResponse = 47,
    DidSetCookie = 48,
    DidSetCookieResponse = 49,
    DidUpdateCookie = 50,
    DidExpireCookiesWithTimeOffset = 51,
    DidRequestStorageItem = 52,
    DidRequestStorageItemResponse = 53,
    DidSetStorageItem = 54,
    DidSetStorageItemResponse = 55,
    DidRemoveStorageItem = 56,
    DidRemoveStorageItemResponse = 57,
    DidRequestStorageKeys = 58,
    DidRequestStorageKeysResponse = 59,
    DidClearStorage = 60,
    DidClearStorageResponse = 61,
    DidPostBroadcastChannelMessage = 62,
    DidUpdateResourceCount = 63,
    DidRequestNewWebView = 64,
    DidRequestNewWebViewResponse = 65,
    DidRequestActivateTab = 66,
    DidCloseBrowsingContext = 67,
    DidRequestRestoreWindow = 68,
    DidRequestRepositionWindow = 69,
    DidRequestResizeWindow = 70,
    DidRequestMaximizeWindow = 71,
    DidRequestMinimizeWindow = 72,
    DidRequestFullscreenWindow = 73,
    DidRequestExitFullscreen = 74,
    DidRequestFile = 75,
    DidRequestColorPicker = 76,
    DidRequestFilePicker = 77,
    DidRequestSelectDropdown = 78,
    DidFinishHandlingInputEvent = 79,
    DidChangeThemeColor = 80,
    DidInsertClipboardEntry = 81,
    DidRequestClipboardEntries = 82,
    DidUpdateNavigationButtonsState = 83,
    DidChangeAudioPlayState = 84,
    DidExecuteJsConsoleInput = 85,
    DidOutputJsConsoleMessage = 86,
    DidStartNetworkRequest = 87,
    DidReceiveNetworkResponseHeaders = 88,
    DidReceiveNetworkResponseBody = 89,
    DidFinishNetworkRequest = 90,
    DidFinishTest = 91,
    DidSetTestTimeout = 92,
    DidReceiveReferenceTestMetadata = 93,
    DidReceiveTestVariantMetadata = 94,
    DidSetBrowserZoom = 95,
    DidFindInPage = 96,
    RequestWorkerAgent = 97,
    RequestWorkerAgentResponse = 98,
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

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

class DidStartLoading final : public IPC::Message {
public:
    DidStartLoading(u64 page_id, URL::URL url, bool is_redirect)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_is_redirect(move(is_redirect))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    bool is_redirect() const { return m_is_redirect; }

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

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

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestRefresh>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidRequestRefresh>(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::DidRequestRefresh));
        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 DidRequestCursorChange final : public IPC::Message {
public:
    DidRequestCursorChange(u64 page_id, Gfx::Cursor cursor)
        : m_page_id(move(page_id))
        , m_cursor(move(cursor))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Gfx::Cursor const& cursor() const { return m_cursor; }
    Gfx::Cursor take_cursor() { return move(m_cursor); }

private:
    u64 m_page_id;
    Gfx::Cursor m_cursor;
};

class DidChangeTitle final : public IPC::Message {
public:
    DidChangeTitle(u64 page_id, Utf16String title)
        : m_page_id(move(page_id))
        , m_title(move(title))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Utf16String const& title() const { return m_title; }
    Utf16String take_title() { return move(m_title); }

private:
    u64 m_page_id;
    Utf16String m_title;
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

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

class DidRequestTooltipOverride final : public IPC::Message {
public:
    DidRequestTooltipOverride(u64 page_id, Gfx::IntPoint position, ByteString title)
        : m_page_id(move(page_id))
        , m_position(move(position))
        , m_title(move(title))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Gfx::IntPoint position, StringView title)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestTooltipOverride));
        TRY(stream.encode(page_id));
        TRY(stream.encode(position));
        TRY(stream.encode(title));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Gfx::IntPoint position() const { return m_position; }

    ByteString const& title() const { return m_title; }
    ByteString take_title() { return move(m_title); }

private:
    u64 m_page_id;
    Gfx::IntPoint m_position;
    ByteString m_title;
};

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidStopTooltipOverride>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidStopTooltipOverride>(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::DidStopTooltipOverride));
        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 DidEnterTooltipArea final : public IPC::Message {
public:
    DidEnterTooltipArea(u64 page_id, ByteString title)
        : m_page_id(move(page_id))
        , m_title(move(title))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    ByteString const& title() const { return m_title; }
    ByteString take_title() { return move(m_title); }

private:
    u64 m_page_id;
    ByteString m_title;
};

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidLeaveTooltipArea>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidLeaveTooltipArea>(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::DidLeaveTooltipArea));
        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 DidHoverLink final : public IPC::Message {
public:
    DidHoverLink(u64 page_id, URL::URL url)
        : m_page_id(move(page_id))
        , m_url(move(url))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

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

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidUnhoverLink>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidUnhoverLink>(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::DidUnhoverLink));
        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 DidClickLink final : public IPC::Message {
public:
    DidClickLink(u64 page_id, URL::URL url, ByteString target, unsigned modifiers)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_target(move(target))
        , m_modifiers(move(modifiers))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidClickLink>> 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 target = TRY((decoder.decode<ByteString>()));
        auto modifiers = TRY((decoder.decode<unsigned>()));
        return make<DidClickLink>(move(page_id), move(url), move(target), move(modifiers));
    }

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

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

    u64 page_id() const { return m_page_id; }

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

    ByteString const& target() const { return m_target; }
    ByteString take_target() { return move(m_target); }

    unsigned modifiers() const { return m_modifiers; }

private:
    u64 m_page_id;
    URL::URL m_url;
    ByteString m_target;
    unsigned m_modifiers;
};

class DidMiddleClickLink final : public IPC::Message {
public:
    DidMiddleClickLink(u64 page_id, URL::URL url, ByteString target, unsigned modifiers)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_target(move(target))
        , m_modifiers(move(modifiers))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidMiddleClickLink>> 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 target = TRY((decoder.decode<ByteString>()));
        auto modifiers = TRY((decoder.decode<unsigned>()));
        return make<DidMiddleClickLink>(move(page_id), move(url), move(target), move(modifiers));
    }

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

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

    u64 page_id() const { return m_page_id; }

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

    ByteString const& target() const { return m_target; }
    ByteString take_target() { return move(m_target); }

    unsigned modifiers() const { return m_modifiers; }

private:
    u64 m_page_id;
    URL::URL m_url;
    ByteString m_target;
    unsigned m_modifiers;
};

class DidRequestContextMenu final : public IPC::Message {
public:
    DidRequestContextMenu(u64 page_id, Gfx::IntPoint content_position, Web::ContextMenuForInputEventsTarget for_input_events_target)
        : m_page_id(move(page_id))
        , m_content_position(move(content_position))
        , m_for_input_events_target(move(for_input_events_target))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Gfx::IntPoint content_position, Web::ContextMenuForInputEventsTarget const& for_input_events_target)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestContextMenu));
        TRY(stream.encode(page_id));
        TRY(stream.encode(content_position));
        TRY(stream.encode(for_input_events_target));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Gfx::IntPoint content_position() const { return m_content_position; }

    Web::ContextMenuForInputEventsTarget const& for_input_events_target() const { return m_for_input_events_target; }
    Web::ContextMenuForInputEventsTarget take_for_input_events_target() { return move(m_for_input_events_target); }

private:
    u64 m_page_id;
    Gfx::IntPoint m_content_position;
    Web::ContextMenuForInputEventsTarget m_for_input_events_target;
};

class DidRequestLinkContextMenu final : public IPC::Message {
public:
    DidRequestLinkContextMenu(u64 page_id, Gfx::IntPoint content_position, URL::URL url, ByteString target, unsigned modifiers)
        : m_page_id(move(page_id))
        , m_content_position(move(content_position))
        , m_url(move(url))
        , m_target(move(target))
        , m_modifiers(move(modifiers))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestLinkContextMenu>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto content_position = TRY((decoder.decode<Gfx::IntPoint>()));
        auto url = TRY((decoder.decode<URL::URL>()));
        auto target = TRY((decoder.decode<ByteString>()));
        auto modifiers = TRY((decoder.decode<unsigned>()));
        return make<DidRequestLinkContextMenu>(move(page_id), move(content_position), move(url), move(target), move(modifiers));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Gfx::IntPoint content_position, URL::URL const& url, StringView target, unsigned modifiers)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestLinkContextMenu));
        TRY(stream.encode(page_id));
        TRY(stream.encode(content_position));
        TRY(stream.encode(url));
        TRY(stream.encode(target));
        TRY(stream.encode(modifiers));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Gfx::IntPoint content_position() const { return m_content_position; }

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

    ByteString const& target() const { return m_target; }
    ByteString take_target() { return move(m_target); }

    unsigned modifiers() const { return m_modifiers; }

private:
    u64 m_page_id;
    Gfx::IntPoint m_content_position;
    URL::URL m_url;
    ByteString m_target;
    unsigned m_modifiers;
};

class DidRequestImageContextMenu final : public IPC::Message {
public:
    DidRequestImageContextMenu(u64 page_id, Gfx::IntPoint content_position, URL::URL url, ByteString target, unsigned modifiers, Optional<Gfx::ShareableBitmap> bitmap)
        : m_page_id(move(page_id))
        , m_content_position(move(content_position))
        , m_url(move(url))
        , m_target(move(target))
        , m_modifiers(move(modifiers))
        , m_bitmap(move(bitmap))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestImageContextMenu>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto content_position = TRY((decoder.decode<Gfx::IntPoint>()));
        auto url = TRY((decoder.decode<URL::URL>()));
        auto target = TRY((decoder.decode<ByteString>()));
        auto modifiers = TRY((decoder.decode<unsigned>()));
        auto bitmap = TRY((decoder.decode<Optional<Gfx::ShareableBitmap>>()));
        return make<DidRequestImageContextMenu>(move(page_id), move(content_position), move(url), move(target), move(modifiers), move(bitmap));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Gfx::IntPoint content_position, URL::URL const& url, StringView target, unsigned modifiers, Optional<Gfx::ShareableBitmap> const& bitmap)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestImageContextMenu));
        TRY(stream.encode(page_id));
        TRY(stream.encode(content_position));
        TRY(stream.encode(url));
        TRY(stream.encode(target));
        TRY(stream.encode(modifiers));
        TRY(stream.encode(bitmap));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Gfx::IntPoint content_position() const { return m_content_position; }

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

    ByteString const& target() const { return m_target; }
    ByteString take_target() { return move(m_target); }

    unsigned modifiers() const { return m_modifiers; }

    Optional<Gfx::ShareableBitmap> const& bitmap() const { return m_bitmap; }
    Optional<Gfx::ShareableBitmap> take_bitmap() { return move(m_bitmap); }

private:
    u64 m_page_id;
    Gfx::IntPoint m_content_position;
    URL::URL m_url;
    ByteString m_target;
    unsigned m_modifiers;
    Optional<Gfx::ShareableBitmap> m_bitmap;
};

class DidRequestMediaContextMenu final : public IPC::Message {
public:
    DidRequestMediaContextMenu(u64 page_id, Gfx::IntPoint content_position, ByteString target, unsigned modifiers, Web::Page::MediaContextMenu menu)
        : m_page_id(move(page_id))
        , m_content_position(move(content_position))
        , m_target(move(target))
        , m_modifiers(move(modifiers))
        , m_menu(move(menu))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestMediaContextMenu>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto content_position = TRY((decoder.decode<Gfx::IntPoint>()));
        auto target = TRY((decoder.decode<ByteString>()));
        auto modifiers = TRY((decoder.decode<unsigned>()));
        auto menu = TRY((decoder.decode<Web::Page::MediaContextMenu>()));
        return make<DidRequestMediaContextMenu>(move(page_id), move(content_position), move(target), move(modifiers), move(menu));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Gfx::IntPoint content_position, StringView target, unsigned modifiers, Web::Page::MediaContextMenu const& menu)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestMediaContextMenu));
        TRY(stream.encode(page_id));
        TRY(stream.encode(content_position));
        TRY(stream.encode(target));
        TRY(stream.encode(modifiers));
        TRY(stream.encode(menu));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_content_position, m_target, m_modifiers, m_menu);
    }

    u64 page_id() const { return m_page_id; }

    Gfx::IntPoint content_position() const { return m_content_position; }

    ByteString const& target() const { return m_target; }
    ByteString take_target() { return move(m_target); }

    unsigned modifiers() const { return m_modifiers; }

    Web::Page::MediaContextMenu const& menu() const { return m_menu; }
    Web::Page::MediaContextMenu take_menu() { return move(m_menu); }

private:
    u64 m_page_id;
    Gfx::IntPoint m_content_position;
    ByteString m_target;
    unsigned m_modifiers;
    Web::Page::MediaContextMenu m_menu;
};

class DidRequestAlert final : public IPC::Message {
public:
    DidRequestAlert(u64 page_id, String message)
        : m_page_id(move(page_id))
        , m_message(move(message))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

private:
    u64 m_page_id;
    String m_message;
};

class DidRequestConfirm final : public IPC::Message {
public:
    DidRequestConfirm(u64 page_id, String message)
        : m_page_id(move(page_id))
        , m_message(move(message))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

private:
    u64 m_page_id;
    String m_message;
};

class DidRequestPrompt final : public IPC::Message {
public:
    DidRequestPrompt(u64 page_id, String message, String default_)
        : m_page_id(move(page_id))
        , m_message(move(message))
        , m_default_(move(default_))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    String const& default_() const { return m_default_; }
    String take_default_() { return move(m_default_); }

private:
    u64 m_page_id;
    String m_message;
    String m_default_;
};

class DidRequestSetPromptText final : public IPC::Message {
public:
    DidRequestSetPromptText(u64 page_id, String message)
        : m_page_id(move(page_id))
        , m_message(move(message))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

private:
    u64 m_page_id;
    String m_message;
};

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestDismissDialog>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidRequestDismissDialog>(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::DidRequestDismissDialog));
        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 DidGetSource final : public IPC::Message {
public:
    DidGetSource(u64 page_id, URL::URL url, URL::URL base_url, String source)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_base_url(move(base_url))
        , m_source(move(source))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    URL::URL const& base_url() const { return m_base_url; }
    URL::URL take_base_url() { return move(m_base_url); }

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

private:
    u64 m_page_id;
    URL::URL m_url;
    URL::URL m_base_url;
    String m_source;
};

class DidInspectDomTree final : public IPC::Message {
public:
    DidInspectDomTree(u64 page_id, String dom_tree)
        : m_page_id(move(page_id))
        , m_dom_tree(move(dom_tree))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    String const& dom_tree() const { return m_dom_tree; }
    String take_dom_tree() { return move(m_dom_tree); }

private:
    u64 m_page_id;
    String m_dom_tree;
};

class DidInspectDomNode final : public IPC::Message {
public:
    DidInspectDomNode(u64 page_id, WebView::DOMNodeProperties properties)
        : m_page_id(move(page_id))
        , m_properties(move(properties))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    WebView::DOMNodeProperties const& properties() const { return m_properties; }
    WebView::DOMNodeProperties take_properties() { return move(m_properties); }

private:
    u64 m_page_id;
    WebView::DOMNodeProperties m_properties;
};

class DidInspectAccessibilityTree final : public IPC::Message {
public:
    DidInspectAccessibilityTree(u64 page_id, String accessibility_tree)
        : m_page_id(move(page_id))
        , m_accessibility_tree(move(accessibility_tree))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    String const& accessibility_tree() const { return m_accessibility_tree; }
    String take_accessibility_tree() { return move(m_accessibility_tree); }

private:
    u64 m_page_id;
    String m_accessibility_tree;
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidGetHoveredNodeId>> 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<DidGetHoveredNodeId>(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::DidGetHoveredNodeId));
        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 DidFinishEditingDomNode final : public IPC::Message {
public:
    DidFinishEditingDomNode(u64 page_id, Optional<Web::UniqueNodeID> node_id)
        : m_page_id(move(page_id))
        , m_node_id(move(node_id))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidFinishEditingDomNode>> 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<Optional<Web::UniqueNodeID>>()));
        return make<DidFinishEditingDomNode>(move(page_id), move(node_id));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Optional<Web::UniqueNodeID> const& node_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidFinishEditingDomNode));
        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; }

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

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

class DidMutateDom final : public IPC::Message {
public:
    DidMutateDom(u64 page_id, WebView::Mutation mutation)
        : m_page_id(move(page_id))
        , m_mutation(move(mutation))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    WebView::Mutation const& mutation() const { return m_mutation; }
    WebView::Mutation take_mutation() { return move(m_mutation); }

private:
    u64 m_page_id;
    WebView::Mutation m_mutation;
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidGetDomNodeHtml>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto html = TRY((decoder.decode<String>()));
        return make<DidGetDomNodeHtml>(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::DidGetDomNodeHtml));
        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; }

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

private:
    u64 m_page_id;
    String m_html;
};

class DidListStyleSheets final : public IPC::Message {
public:
    DidListStyleSheets(u64 page_id, Vector<Web::CSS::StyleSheetIdentifier> style_sheets)
        : m_page_id(move(page_id))
        , m_style_sheets(move(style_sheets))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Vector<Web::CSS::StyleSheetIdentifier> const& style_sheets() const { return m_style_sheets; }
    Vector<Web::CSS::StyleSheetIdentifier> take_style_sheets() { return move(m_style_sheets); }

private:
    u64 m_page_id;
    Vector<Web::CSS::StyleSheetIdentifier> m_style_sheets;
};

class DidGetStyleSheetSource final : public IPC::Message {
public:
    DidGetStyleSheetSource(u64 page_id, Web::CSS::StyleSheetIdentifier identifier, URL::URL base_url, String source)
        : m_page_id(move(page_id))
        , m_identifier(move(identifier))
        , m_base_url(move(base_url))
        , m_source(move(source))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidGetStyleSheetSource>> 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>()));
        auto base_url = TRY((decoder.decode<URL::URL>()));
        auto source = TRY((decoder.decode<String>()));
        return make<DidGetStyleSheetSource>(move(page_id), move(identifier), move(base_url), move(source));
    }

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

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

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

    URL::URL const& base_url() const { return m_base_url; }
    URL::URL take_base_url() { return move(m_base_url); }

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

private:
    u64 m_page_id;
    Web::CSS::StyleSheetIdentifier m_identifier;
    URL::URL m_base_url;
    String m_source;
};

class DidTakeScreenshot final : public IPC::Message {
public:
    DidTakeScreenshot(u64 page_id, Gfx::ShareableBitmap screenshot)
        : m_page_id(move(page_id))
        , m_screenshot(move(screenshot))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Gfx::ShareableBitmap const& screenshot() const { return m_screenshot; }
    Gfx::ShareableBitmap take_screenshot() { return move(m_screenshot); }

private:
    u64 m_page_id;
    Gfx::ShareableBitmap m_screenshot;
};

class DidGetInternalPageInfo final : public IPC::Message {
public:
    DidGetInternalPageInfo(u64 page_id, WebView::PageInfoType type, Optional<Core::AnonymousBuffer> info)
        : m_page_id(move(page_id))
        , m_type(move(type))
        , m_info(move(info))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidGetInternalPageInfo>> 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>()));
        auto info = TRY((decoder.decode<Optional<Core::AnonymousBuffer>>()));
        return make<DidGetInternalPageInfo>(move(page_id), move(type), move(info));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, WebView::PageInfoType type, Optional<Core::AnonymousBuffer> const& info)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidGetInternalPageInfo));
        TRY(stream.encode(page_id));
        TRY(stream.encode(type));
        TRY(stream.encode(info));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

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

    Optional<Core::AnonymousBuffer> const& info() const { return m_info; }
    Optional<Core::AnonymousBuffer> take_info() { return move(m_info); }

private:
    u64 m_page_id;
    WebView::PageInfoType m_type;
    Optional<Core::AnonymousBuffer> m_info;
};

class DidChangeFavicon final : public IPC::Message {
public:
    DidChangeFavicon(u64 page_id, Gfx::ShareableBitmap favicon)
        : m_page_id(move(page_id))
        , m_favicon(move(favicon))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Gfx::ShareableBitmap const& favicon() const { return m_favicon; }
    Gfx::ShareableBitmap take_favicon() { return move(m_favicon); }

private:
    u64 m_page_id;
    Gfx::ShareableBitmap m_favicon;
};

class DidRequestDocumentCookieVersionIndex final : public IPC::Message {
public:
    DidRequestDocumentCookieVersionIndex(u64 page_id, i64 document_id, String domain)
        : m_page_id(move(page_id))
        , m_document_id(move(document_id))
        , m_domain(move(domain))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestDocumentCookieVersionIndex>> 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 domain = TRY((decoder.decode<String>()));
        return make<DidRequestDocumentCookieVersionIndex>(move(page_id), move(document_id), move(domain));
    }

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

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

    u64 page_id() const { return m_page_id; }

    i64 document_id() const { return m_document_id; }

    String const& domain() const { return m_domain; }
    String take_domain() { return move(m_domain); }

private:
    u64 m_page_id;
    i64 m_document_id;
    String m_domain;
};

class DidRequestAllCookiesWebdriverResponse final : public IPC::Message {
public:
    DidRequestAllCookiesWebdriverResponse(Vector<HTTP::Cookie::Cookie> cookies)
        : m_cookies(move(cookies))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Vector<HTTP::Cookie::Cookie>>)
    DidRequestAllCookiesWebdriverResponse(WrappedReturnType&& value)
        : m_cookies(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

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

class DidRequestAllCookiesWebdriver final : public IPC::Message {
public:
    typedef class DidRequestAllCookiesWebdriverResponse ResponseType;

    DidRequestAllCookiesWebdriver(URL::URL url)
        : m_url(move(url))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, URL::URL>)
    DidRequestAllCookiesWebdriver(WrappedReturnType&& value)
        : m_url(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

private:
    URL::URL m_url;
};

class DidRequestAllCookiesCookiestoreResponse final : public IPC::Message {
public:
    DidRequestAllCookiesCookiestoreResponse(Vector<HTTP::Cookie::Cookie> cookies)
        : m_cookies(move(cookies))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Vector<HTTP::Cookie::Cookie>>)
    DidRequestAllCookiesCookiestoreResponse(WrappedReturnType&& value)
        : m_cookies(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

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

class DidRequestAllCookiesCookiestore final : public IPC::Message {
public:
    typedef class DidRequestAllCookiesCookiestoreResponse ResponseType;

    DidRequestAllCookiesCookiestore(URL::URL url)
        : m_url(move(url))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, URL::URL>)
    DidRequestAllCookiesCookiestore(WrappedReturnType&& value)
        : m_url(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

private:
    URL::URL m_url;
};

class DidRequestNamedCookieResponse final : public IPC::Message {
public:
    DidRequestNamedCookieResponse(Optional<HTTP::Cookie::Cookie> cookie)
        : m_cookie(move(cookie))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Optional<HTTP::Cookie::Cookie>>)
    DidRequestNamedCookieResponse(WrappedReturnType&& value)
        : m_cookie(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(Optional<HTTP::Cookie::Cookie> const& cookie)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestNamedCookieResponse));
        TRY(stream.encode(cookie));
        return buffer;
    }

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

    Optional<HTTP::Cookie::Cookie> const& cookie() const { return m_cookie; }
    Optional<HTTP::Cookie::Cookie> take_cookie() { return move(m_cookie); }

private:
    Optional<HTTP::Cookie::Cookie> m_cookie;
};

class DidRequestNamedCookie final : public IPC::Message {
public:
    typedef class DidRequestNamedCookieResponse ResponseType;

    DidRequestNamedCookie(URL::URL url, String name)
        : m_url(move(url))
        , m_name(move(name))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

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

private:
    URL::URL m_url;
    String m_name;
};

class DidRequestCookieResponse final : public IPC::Message {
public:
    DidRequestCookieResponse(HTTP::Cookie::VersionedCookie cookie)
        : m_cookie(move(cookie))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, HTTP::Cookie::VersionedCookie>)
    DidRequestCookieResponse(WrappedReturnType&& value)
        : m_cookie(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestCookieResponse>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto cookie = TRY((decoder.decode<HTTP::Cookie::VersionedCookie>()));
        return make<DidRequestCookieResponse>(move(cookie));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(HTTP::Cookie::VersionedCookie const& cookie)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestCookieResponse));
        TRY(stream.encode(cookie));
        return buffer;
    }

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

    HTTP::Cookie::VersionedCookie const& cookie() const { return m_cookie; }
    HTTP::Cookie::VersionedCookie take_cookie() { return move(m_cookie); }

private:
    HTTP::Cookie::VersionedCookie m_cookie;
};

class DidRequestCookie final : public IPC::Message {
public:
    typedef class DidRequestCookieResponse ResponseType;

    DidRequestCookie(u64 page_id, URL::URL url, HTTP::Cookie::Source source)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_source(move(source))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestCookie>> 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 source = TRY((decoder.decode<HTTP::Cookie::Source>()));
        return make<DidRequestCookie>(move(page_id), move(url), move(source));
    }

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

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

    u64 page_id() const { return m_page_id; }

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

    HTTP::Cookie::Source source() const { return m_source; }

private:
    u64 m_page_id;
    URL::URL m_url;
    HTTP::Cookie::Source m_source;
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

private:
};

class DidSetCookie final : public IPC::Message {
public:
    typedef class DidSetCookieResponse ResponseType;

    DidSetCookie(URL::URL url, HTTP::Cookie::ParsedCookie cookie, HTTP::Cookie::Source source)
        : m_url(move(url))
        , m_cookie(move(cookie))
        , m_source(move(source))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidSetCookie>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto url = TRY((decoder.decode<URL::URL>()));
        auto cookie = TRY((decoder.decode<HTTP::Cookie::ParsedCookie>()));
        auto source = TRY((decoder.decode<HTTP::Cookie::Source>()));
        return make<DidSetCookie>(move(url), move(cookie), move(source));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(URL::URL const& url, HTTP::Cookie::ParsedCookie const& cookie, HTTP::Cookie::Source source)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidSetCookie));
        TRY(stream.encode(url));
        TRY(stream.encode(cookie));
        TRY(stream.encode(source));
        return buffer;
    }

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

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

    HTTP::Cookie::ParsedCookie const& cookie() const { return m_cookie; }
    HTTP::Cookie::ParsedCookie take_cookie() { return move(m_cookie); }

    HTTP::Cookie::Source source() const { return m_source; }

private:
    URL::URL m_url;
    HTTP::Cookie::ParsedCookie m_cookie;
    HTTP::Cookie::Source m_source;
};

class DidUpdateCookie final : public IPC::Message {
public:
    DidUpdateCookie(HTTP::Cookie::Cookie cookie)
        : m_cookie(move(cookie))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, HTTP::Cookie::Cookie>)
    DidUpdateCookie(WrappedReturnType&& value)
        : m_cookie(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(HTTP::Cookie::Cookie const& cookie)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidUpdateCookie));
        TRY(stream.encode(cookie));
        return buffer;
    }

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

    HTTP::Cookie::Cookie const& cookie() const { return m_cookie; }
    HTTP::Cookie::Cookie take_cookie() { return move(m_cookie); }

private:
    HTTP::Cookie::Cookie m_cookie;
};

class DidExpireCookiesWithTimeOffset final : public IPC::Message {
public:
    DidExpireCookiesWithTimeOffset(AK::Duration offset)
        : m_offset(move(offset))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, AK::Duration>)
    DidExpireCookiesWithTimeOffset(WrappedReturnType&& value)
        : m_offset(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    AK::Duration offset() const { return m_offset; }

private:
    AK::Duration m_offset;
};

class DidRequestStorageItemResponse final : public IPC::Message {
public:
    DidRequestStorageItemResponse(Optional<String> value)
        : m_value(move(value))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Optional<String>>)
    DidRequestStorageItemResponse(WrappedReturnType&& value)
        : m_value(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

private:
    Optional<String> m_value;
};

class DidRequestStorageItem final : public IPC::Message {
public:
    typedef class DidRequestStorageItemResponse ResponseType;

    DidRequestStorageItem(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key)
        : m_storage_endpoint(move(storage_endpoint))
        , m_storage_key(move(storage_key))
        , m_bottle_key(move(bottle_key))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView storage_key, StringView bottle_key)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestStorageItem));
        TRY(stream.encode(storage_endpoint));
        TRY(stream.encode(storage_key));
        TRY(stream.encode(bottle_key));
        return buffer;
    }

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

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

    String const& storage_key() const { return m_storage_key; }
    String take_storage_key() { return move(m_storage_key); }

    String const& bottle_key() const { return m_bottle_key; }
    String take_bottle_key() { return move(m_bottle_key); }

private:
    Web::StorageAPI::StorageEndpointType m_storage_endpoint;
    String m_storage_key;
    String m_bottle_key;
};

class DidSetStorageItemResponse final : public IPC::Message {
public:
    DidSetStorageItemResponse(WebView::StorageSetResult result)
        : m_result(move(result))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, WebView::StorageSetResult>)
    DidSetStorageItemResponse(WrappedReturnType&& value)
        : m_result(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

private:
    WebView::StorageSetResult m_result;
};

class DidSetStorageItem final : public IPC::Message {
public:
    typedef class DidSetStorageItemResponse ResponseType;

    DidSetStorageItem(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key, String value)
        : m_storage_endpoint(move(storage_endpoint))
        , m_storage_key(move(storage_key))
        , m_bottle_key(move(bottle_key))
        , m_value(move(value))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidSetStorageItem>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto storage_endpoint = TRY((decoder.decode<Web::StorageAPI::StorageEndpointType>()));
        auto storage_key = TRY((decoder.decode<String>()));
        auto bottle_key = TRY((decoder.decode<String>()));
        auto value = TRY((decoder.decode<String>()));
        return make<DidSetStorageItem>(move(storage_endpoint), move(storage_key), move(bottle_key), move(value));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView storage_key, StringView bottle_key, StringView value)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidSetStorageItem));
        TRY(stream.encode(storage_endpoint));
        TRY(stream.encode(storage_key));
        TRY(stream.encode(bottle_key));
        TRY(stream.encode(value));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_storage_endpoint, m_storage_key, m_bottle_key, m_value);
    }

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

    String const& storage_key() const { return m_storage_key; }
    String take_storage_key() { return move(m_storage_key); }

    String const& bottle_key() const { return m_bottle_key; }
    String take_bottle_key() { return move(m_bottle_key); }

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

private:
    Web::StorageAPI::StorageEndpointType m_storage_endpoint;
    String m_storage_key;
    String m_bottle_key;
    String m_value;
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

private:
};

class DidRemoveStorageItem final : public IPC::Message {
public:
    typedef class DidRemoveStorageItemResponse ResponseType;

    DidRemoveStorageItem(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key)
        : m_storage_endpoint(move(storage_endpoint))
        , m_storage_key(move(storage_key))
        , m_bottle_key(move(bottle_key))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView storage_key, StringView bottle_key)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRemoveStorageItem));
        TRY(stream.encode(storage_endpoint));
        TRY(stream.encode(storage_key));
        TRY(stream.encode(bottle_key));
        return buffer;
    }

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

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

    String const& storage_key() const { return m_storage_key; }
    String take_storage_key() { return move(m_storage_key); }

    String const& bottle_key() const { return m_bottle_key; }
    String take_bottle_key() { return move(m_bottle_key); }

private:
    Web::StorageAPI::StorageEndpointType m_storage_endpoint;
    String m_storage_key;
    String m_bottle_key;
};

class DidRequestStorageKeysResponse final : public IPC::Message {
public:
    DidRequestStorageKeysResponse(Vector<String> keys)
        : m_keys(move(keys))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Vector<String>>)
    DidRequestStorageKeysResponse(WrappedReturnType&& value)
        : m_keys(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    Vector<String> const& keys() const { return m_keys; }
    Vector<String> take_keys() { return move(m_keys); }

private:
    Vector<String> m_keys;
};

class DidRequestStorageKeys final : public IPC::Message {
public:
    typedef class DidRequestStorageKeysResponse ResponseType;

    DidRequestStorageKeys(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key)
        : m_storage_endpoint(move(storage_endpoint))
        , m_storage_key(move(storage_key))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

    String const& storage_key() const { return m_storage_key; }
    String take_storage_key() { return move(m_storage_key); }

private:
    Web::StorageAPI::StorageEndpointType m_storage_endpoint;
    String m_storage_key;
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

private:
};

class DidClearStorage final : public IPC::Message {
public:
    typedef class DidClearStorageResponse ResponseType;

    DidClearStorage(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key)
        : m_storage_endpoint(move(storage_endpoint))
        , m_storage_key(move(storage_key))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

    String const& storage_key() const { return m_storage_key; }
    String take_storage_key() { return move(m_storage_key); }

private:
    Web::StorageAPI::StorageEndpointType m_storage_endpoint;
    String m_storage_key;
};

class DidPostBroadcastChannelMessage final : public IPC::Message {
public:
    DidPostBroadcastChannelMessage(u64 page_id, Web::HTML::BroadcastChannelMessage message)
        : m_page_id(move(page_id))
        , m_message(move(message))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

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

class DidUpdateResourceCount final : public IPC::Message {
public:
    DidUpdateResourceCount(u64 page_id, i32 count_waiting)
        : m_page_id(move(page_id))
        , m_count_waiting(move(count_waiting))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    i32 count_waiting() const { return m_count_waiting; }

private:
    u64 m_page_id;
    i32 m_count_waiting;
};

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestNewWebViewResponse>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto handle = TRY((decoder.decode<String>()));
        return make<DidRequestNewWebViewResponse>(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::DidRequestNewWebViewResponse));
        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 DidRequestNewWebView final : public IPC::Message {
public:
    typedef class DidRequestNewWebViewResponse ResponseType;

    DidRequestNewWebView(u64 page_id, Web::HTML::ActivateTab activate_tab, Web::HTML::WebViewHints hints, Optional<u64> page_index)
        : m_page_id(move(page_id))
        , m_activate_tab(move(activate_tab))
        , m_hints(move(hints))
        , m_page_index(move(page_index))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestNewWebView>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto activate_tab = TRY((decoder.decode<Web::HTML::ActivateTab>()));
        auto hints = TRY((decoder.decode<Web::HTML::WebViewHints>()));
        auto page_index = TRY((decoder.decode<Optional<u64>>()));
        return make<DidRequestNewWebView>(move(page_id), move(activate_tab), move(hints), move(page_index));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::HTML::ActivateTab const& activate_tab, Web::HTML::WebViewHints const& hints, Optional<u64> const& page_index)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestNewWebView));
        TRY(stream.encode(page_id));
        TRY(stream.encode(activate_tab));
        TRY(stream.encode(hints));
        TRY(stream.encode(page_index));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::ActivateTab const& activate_tab() const { return m_activate_tab; }
    Web::HTML::ActivateTab take_activate_tab() { return move(m_activate_tab); }

    Web::HTML::WebViewHints const& hints() const { return m_hints; }
    Web::HTML::WebViewHints take_hints() { return move(m_hints); }

    Optional<u64> const& page_index() const { return m_page_index; }
    Optional<u64> take_page_index() { return move(m_page_index); }

private:
    u64 m_page_id;
    Web::HTML::ActivateTab m_activate_tab;
    Web::HTML::WebViewHints m_hints;
    Optional<u64> m_page_index;
};

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestRestoreWindow>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidRequestRestoreWindow>(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::DidRequestRestoreWindow));
        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 DidRequestRepositionWindow final : public IPC::Message {
public:
    DidRequestRepositionWindow(u64 page_id, Gfx::IntPoint position)
        : m_page_id(move(page_id))
        , m_position(move(position))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Gfx::IntPoint position)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestRepositionWindow));
        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; }

    Gfx::IntPoint position() const { return m_position; }

private:
    u64 m_page_id;
    Gfx::IntPoint m_position;
};

class DidRequestResizeWindow final : public IPC::Message {
public:
    DidRequestResizeWindow(u64 page_id, Gfx::IntSize size)
        : m_page_id(move(page_id))
        , m_size(move(size))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Gfx::IntSize size)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestResizeWindow));
        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; }

    Gfx::IntSize size() const { return m_size; }

private:
    u64 m_page_id;
    Gfx::IntSize m_size;
};

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestExitFullscreen>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        return make<DidRequestExitFullscreen>(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::DidRequestExitFullscreen));
        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 DidRequestFile final : public IPC::Message {
public:
    DidRequestFile(u64 page_id, ByteString path, i32 request_id)
        : m_page_id(move(page_id))
        , m_path(move(path))
        , m_request_id(move(request_id))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    ByteString const& path() const { return m_path; }
    ByteString take_path() { return move(m_path); }

    i32 request_id() const { return m_request_id; }

private:
    u64 m_page_id;
    ByteString m_path;
    i32 m_request_id;
};

class DidRequestColorPicker final : public IPC::Message {
public:
    DidRequestColorPicker(u64 page_id, Color current_color)
        : m_page_id(move(page_id))
        , m_current_color(move(current_color))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Color const& current_color() const { return m_current_color; }
    Color take_current_color() { return move(m_current_color); }

private:
    u64 m_page_id;
    Color m_current_color;
};

class DidRequestFilePicker final : public IPC::Message {
public:
    DidRequestFilePicker(u64 page_id, Web::HTML::FileFilter accepted_file_types, Web::HTML::AllowMultipleFiles allow_multiple_files)
        : m_page_id(move(page_id))
        , m_accepted_file_types(move(accepted_file_types))
        , m_allow_multiple_files(move(allow_multiple_files))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::HTML::FileFilter const& accepted_file_types, Web::HTML::AllowMultipleFiles allow_multiple_files)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestFilePicker));
        TRY(stream.encode(page_id));
        TRY(stream.encode(accepted_file_types));
        TRY(stream.encode(allow_multiple_files));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::FileFilter const& accepted_file_types() const { return m_accepted_file_types; }
    Web::HTML::FileFilter take_accepted_file_types() { return move(m_accepted_file_types); }

    Web::HTML::AllowMultipleFiles allow_multiple_files() const { return m_allow_multiple_files; }

private:
    u64 m_page_id;
    Web::HTML::FileFilter m_accepted_file_types;
    Web::HTML::AllowMultipleFiles m_allow_multiple_files;
};

class DidRequestSelectDropdown final : public IPC::Message {
public:
    DidRequestSelectDropdown(u64 page_id, Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items)
        : m_page_id(move(page_id))
        , m_content_position(move(content_position))
        , m_minimum_width(move(minimum_width))
        , m_items(move(items))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestSelectDropdown>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto content_position = TRY((decoder.decode<Gfx::IntPoint>()));
        auto minimum_width = TRY((decoder.decode<i32>()));
        auto items = TRY((decoder.decode<Vector<Web::HTML::SelectItem>>()));
        return make<DidRequestSelectDropdown>(move(page_id), move(content_position), move(minimum_width), move(items));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Gfx::IntPoint content_position, i32 minimum_width, ReadonlySpan<Web::HTML::SelectItem> items)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidRequestSelectDropdown));
        TRY(stream.encode(page_id));
        TRY(stream.encode(content_position));
        TRY(stream.encode(minimum_width));
        TRY(stream.encode(items));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Gfx::IntPoint content_position() const { return m_content_position; }

    i32 minimum_width() const { return m_minimum_width; }

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

private:
    u64 m_page_id;
    Gfx::IntPoint m_content_position;
    i32 m_minimum_width;
    Vector<Web::HTML::SelectItem> m_items;
};

class DidFinishHandlingInputEvent final : public IPC::Message {
public:
    DidFinishHandlingInputEvent(u64 page_id, Web::EventResult event_result)
        : m_page_id(move(page_id))
        , m_event_result(move(event_result))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::EventResult event_result() const { return m_event_result; }

private:
    u64 m_page_id;
    Web::EventResult m_event_result;
};

class DidChangeThemeColor final : public IPC::Message {
public:
    DidChangeThemeColor(u64 page_id, Gfx::Color color)
        : m_page_id(move(page_id))
        , m_color(move(color))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Gfx::Color color() const { return m_color; }

private:
    u64 m_page_id;
    Gfx::Color m_color;
};

class DidInsertClipboardEntry final : public IPC::Message {
public:
    DidInsertClipboardEntry(u64 page_id, Web::Clipboard::SystemClipboardRepresentation entry, String presentation_style)
        : m_page_id(move(page_id))
        , m_entry(move(entry))
        , m_presentation_style(move(presentation_style))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::Clipboard::SystemClipboardRepresentation const& entry, StringView presentation_style)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidInsertClipboardEntry));
        TRY(stream.encode(page_id));
        TRY(stream.encode(entry));
        TRY(stream.encode(presentation_style));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    Web::Clipboard::SystemClipboardRepresentation const& entry() const { return m_entry; }
    Web::Clipboard::SystemClipboardRepresentation take_entry() { return move(m_entry); }

    String const& presentation_style() const { return m_presentation_style; }
    String take_presentation_style() { return move(m_presentation_style); }

private:
    u64 m_page_id;
    Web::Clipboard::SystemClipboardRepresentation m_entry;
    String m_presentation_style;
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidRequestClipboardEntries>> 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<DidRequestClipboardEntries>(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::DidRequestClipboardEntries));
        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 DidUpdateNavigationButtonsState final : public IPC::Message {
public:
    DidUpdateNavigationButtonsState(u64 page_id, bool back_enabled, bool forward_enabled)
        : m_page_id(move(page_id))
        , m_back_enabled(move(back_enabled))
        , m_forward_enabled(move(forward_enabled))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    bool back_enabled() const { return m_back_enabled; }

    bool forward_enabled() const { return m_forward_enabled; }

private:
    u64 m_page_id;
    bool m_back_enabled;
    bool m_forward_enabled;
};

class DidChangeAudioPlayState final : public IPC::Message {
public:
    DidChangeAudioPlayState(u64 page_id, Web::HTML::AudioPlayState play_state)
        : m_page_id(move(page_id))
        , m_play_state(move(play_state))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::AudioPlayState play_state() const { return m_play_state; }

private:
    u64 m_page_id;
    Web::HTML::AudioPlayState m_play_state;
};

class DidExecuteJsConsoleInput final : public IPC::Message {
public:
    DidExecuteJsConsoleInput(u64 page_id, JsonValue result)
        : m_page_id(move(page_id))
        , m_result(move(result))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    JsonValue const& result() const { return m_result; }
    JsonValue take_result() { return move(m_result); }

private:
    u64 m_page_id;
    JsonValue m_result;
};

class DidOutputJsConsoleMessage final : public IPC::Message {
public:
    DidOutputJsConsoleMessage(u64 page_id, WebView::ConsoleOutput console_output)
        : m_page_id(move(page_id))
        , m_console_output(move(console_output))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    WebView::ConsoleOutput const& console_output() const { return m_console_output; }
    WebView::ConsoleOutput take_console_output() { return move(m_console_output); }

private:
    u64 m_page_id;
    WebView::ConsoleOutput m_console_output;
};

class DidStartNetworkRequest final : public IPC::Message {
public:
    DidStartNetworkRequest(u64 page_id, u64 request_id, URL::URL url, ByteString method, Vector<HTTP::Header> request_headers, ByteBuffer request_body, Optional<String> initiator_type)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_url(move(url))
        , m_method(move(method))
        , m_request_headers(move(request_headers))
        , m_request_body(move(request_body))
        , m_initiator_type(move(initiator_type))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidStartNetworkRequest>> 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 url = TRY((decoder.decode<URL::URL>()));
        auto method = TRY((decoder.decode<ByteString>()));
        auto request_headers = TRY((decoder.decode<Vector<HTTP::Header>>()));
        auto request_body = TRY((decoder.decode<ByteBuffer>()));
        auto initiator_type = TRY((decoder.decode<Optional<String>>()));
        return make<DidStartNetworkRequest>(move(page_id), move(request_id), move(url), move(method), move(request_headers), move(request_body), move(initiator_type));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, u64 request_id, URL::URL const& url, StringView method, ReadonlySpan<HTTP::Header> request_headers, ReadonlyBytes request_body, Optional<String> const& initiator_type)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidStartNetworkRequest));
        TRY(stream.encode(page_id));
        TRY(stream.encode(request_id));
        TRY(stream.encode(url));
        TRY(stream.encode(method));
        TRY(stream.encode(request_headers));
        TRY(stream.encode(request_body));
        TRY(stream.encode(initiator_type));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

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

    ByteString const& method() const { return m_method; }
    ByteString take_method() { return move(m_method); }

    Vector<HTTP::Header> const& request_headers() const { return m_request_headers; }
    Vector<HTTP::Header> take_request_headers() { return move(m_request_headers); }

    ByteBuffer const& request_body() const { return m_request_body; }
    ByteBuffer take_request_body() { return move(m_request_body); }

    Optional<String> const& initiator_type() const { return m_initiator_type; }
    Optional<String> take_initiator_type() { return move(m_initiator_type); }

private:
    u64 m_page_id;
    u64 m_request_id;
    URL::URL m_url;
    ByteString m_method;
    Vector<HTTP::Header> m_request_headers;
    ByteBuffer m_request_body;
    Optional<String> m_initiator_type;
};

class DidReceiveNetworkResponseHeaders final : public IPC::Message {
public:
    DidReceiveNetworkResponseHeaders(u64 page_id, u64 request_id, u32 status_code, Optional<String> reason_phrase, Vector<HTTP::Header> response_headers)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_status_code(move(status_code))
        , m_reason_phrase(move(reason_phrase))
        , m_response_headers(move(response_headers))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidReceiveNetworkResponseHeaders>> 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 status_code = TRY((decoder.decode<u32>()));
        auto reason_phrase = TRY((decoder.decode<Optional<String>>()));
        auto response_headers = TRY((decoder.decode<Vector<HTTP::Header>>()));
        return make<DidReceiveNetworkResponseHeaders>(move(page_id), move(request_id), move(status_code), move(reason_phrase), move(response_headers));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, u64 request_id, u32 status_code, Optional<String> const& reason_phrase, ReadonlySpan<HTTP::Header> response_headers)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidReceiveNetworkResponseHeaders));
        TRY(stream.encode(page_id));
        TRY(stream.encode(request_id));
        TRY(stream.encode(status_code));
        TRY(stream.encode(reason_phrase));
        TRY(stream.encode(response_headers));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    u32 status_code() const { return m_status_code; }

    Optional<String> const& reason_phrase() const { return m_reason_phrase; }
    Optional<String> take_reason_phrase() { return move(m_reason_phrase); }

    Vector<HTTP::Header> const& response_headers() const { return m_response_headers; }
    Vector<HTTP::Header> take_response_headers() { return move(m_response_headers); }

private:
    u64 m_page_id;
    u64 m_request_id;
    u32 m_status_code;
    Optional<String> m_reason_phrase;
    Vector<HTTP::Header> m_response_headers;
};

class DidReceiveNetworkResponseBody final : public IPC::Message {
public:
    DidReceiveNetworkResponseBody(u64 page_id, u64 request_id, ByteBuffer data)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_data(move(data))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    ByteBuffer const& data() const { return m_data; }
    ByteBuffer take_data() { return move(m_data); }

private:
    u64 m_page_id;
    u64 m_request_id;
    ByteBuffer m_data;
};

class DidFinishNetworkRequest final : public IPC::Message {
public:
    DidFinishNetworkRequest(u64 page_id, u64 request_id, u64 body_size, Requests::RequestTimingInfo timing_info, Optional<Requests::NetworkError> network_error)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_body_size(move(body_size))
        , m_timing_info(move(timing_info))
        , m_network_error(move(network_error))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

    static ErrorOr<NonnullOwnPtr<DidFinishNetworkRequest>> 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 body_size = TRY((decoder.decode<u64>()));
        auto timing_info = TRY((decoder.decode<Requests::RequestTimingInfo>()));
        auto network_error = TRY((decoder.decode<Optional<Requests::NetworkError>>()));
        return make<DidFinishNetworkRequest>(move(page_id), move(request_id), move(body_size), move(timing_info), move(network_error));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, u64 request_id, u64 body_size, Requests::RequestTimingInfo const& timing_info, Optional<Requests::NetworkError> const& network_error)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidFinishNetworkRequest));
        TRY(stream.encode(page_id));
        TRY(stream.encode(request_id));
        TRY(stream.encode(body_size));
        TRY(stream.encode(timing_info));
        TRY(stream.encode(network_error));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    u64 body_size() const { return m_body_size; }

    Requests::RequestTimingInfo const& timing_info() const { return m_timing_info; }
    Requests::RequestTimingInfo take_timing_info() { return move(m_timing_info); }

    Optional<Requests::NetworkError> const& network_error() const { return m_network_error; }
    Optional<Requests::NetworkError> take_network_error() { return move(m_network_error); }

private:
    u64 m_page_id;
    u64 m_request_id;
    u64 m_body_size;
    Requests::RequestTimingInfo m_timing_info;
    Optional<Requests::NetworkError> m_network_error;
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, StringView text)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidFinishTest));
        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; }

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

private:
    u64 m_page_id;
    String m_text;
};

class DidSetTestTimeout final : public IPC::Message {
public:
    DidSetTestTimeout(u64 page_id, double milliseconds)
        : m_page_id(move(page_id))
        , m_milliseconds(move(milliseconds))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    double milliseconds() const { return m_milliseconds; }

private:
    u64 m_page_id;
    double m_milliseconds;
};

class DidReceiveReferenceTestMetadata final : public IPC::Message {
public:
    DidReceiveReferenceTestMetadata(u64 page_id, JsonValue result)
        : m_page_id(move(page_id))
        , m_result(move(result))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    JsonValue const& result() const { return m_result; }
    JsonValue take_result() { return move(m_result); }

private:
    u64 m_page_id;
    JsonValue m_result;
};

class DidReceiveTestVariantMetadata final : public IPC::Message {
public:
    DidReceiveTestVariantMetadata(u64 page_id, JsonValue result)
        : m_page_id(move(page_id))
        , m_result(move(result))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    JsonValue const& result() const { return m_result; }
    JsonValue take_result() { return move(m_result); }

private:
    u64 m_page_id;
    JsonValue m_result;
};

class DidSetBrowserZoom final : public IPC::Message {
public:
    DidSetBrowserZoom(u64 page_id, double factor)
        : m_page_id(move(page_id))
        , m_factor(move(factor))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    double factor() const { return m_factor; }

private:
    u64 m_page_id;
    double m_factor;
};

class DidFindInPage final : public IPC::Message {
public:
    DidFindInPage(u64 page_id, size_t current_match_index, Optional<size_t> total_match_count)
        : m_page_id(move(page_id))
        , m_current_match_index(move(current_match_index))
        , m_total_match_count(move(total_match_count))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    size_t current_match_index() const { return m_current_match_index; }

    Optional<size_t> const& total_match_count() const { return m_total_match_count; }
    Optional<size_t> take_total_match_count() { return move(m_total_match_count); }

private:
    u64 m_page_id;
    size_t m_current_match_index;
    Optional<size_t> m_total_match_count;
};

class RequestWorkerAgentResponse final : public IPC::Message {
public:
    RequestWorkerAgentResponse(IPC::TransportHandle handle, IPC::TransportHandle request_server_handle, IPC::TransportHandle image_decoder_handle)
        : m_handle(move(handle))
        , m_request_server_handle(move(request_server_handle))
        , m_image_decoder_handle(move(image_decoder_handle))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

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

    IPC::TransportHandle const& request_server_handle() const { return m_request_server_handle; }
    IPC::TransportHandle take_request_server_handle() { return move(m_request_server_handle); }

    IPC::TransportHandle const& image_decoder_handle() const { return m_image_decoder_handle; }
    IPC::TransportHandle take_image_decoder_handle() { return move(m_image_decoder_handle); }

private:
    IPC::TransportHandle m_handle;
    IPC::TransportHandle m_request_server_handle;
    IPC::TransportHandle m_image_decoder_handle;
};

class RequestWorkerAgent final : public IPC::Message {
public:
    typedef class RequestWorkerAgentResponse ResponseType;

    RequestWorkerAgent(u64 page_id, Web::Bindings::AgentType worker_type)
        : m_page_id(move(page_id))
        , m_worker_type(move(worker_type))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 2565717604;

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::Bindings::AgentType const& worker_type() const { return m_worker_type; }
    Web::Bindings::AgentType take_worker_type() { return move(m_worker_type); }

private:
    u64 m_page_id;
    Web::Bindings::AgentType m_worker_type;
};

} // namespace Messages::WebContentClient

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

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

    void async_did_request_new_process_for_navigation(u64 page_id, URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestNewProcessForNavigation::static_encode(page_id, move(url)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_start_loading(u64 page_id, URL::URL const& url, bool is_redirect)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidStartLoading::static_encode(page_id, move(url), is_redirect));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_finish_loading(u64 page_id, URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidFinishLoading::static_encode(page_id, move(url)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_refresh(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestRefresh::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_cursor_change(u64 page_id, Gfx::Cursor const& cursor)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestCursorChange::static_encode(page_id, move(cursor)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_change_title(u64 page_id, Utf16View const& title)
    {
        VERIFY(title.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeTitle::static_encode(page_id, move(title)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_change_title(u64 page_id, Utf16String const& title)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeTitle::static_encode(page_id, move(title)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_change_url(u64 page_id, URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeUrl::static_encode(page_id, move(url)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_tooltip_override(u64 page_id, Gfx::IntPoint position, StringView title)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestTooltipOverride::static_encode(page_id, position, title));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_stop_tooltip_override(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidStopTooltipOverride::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_enter_tooltip_area(u64 page_id, StringView title)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidEnterTooltipArea::static_encode(page_id, title));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_leave_tooltip_area(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidLeaveTooltipArea::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_hover_link(u64 page_id, URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidHoverLink::static_encode(page_id, move(url)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_unhover_link(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUnhoverLink::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_click_link(u64 page_id, URL::URL const& url, StringView target, unsigned modifiers)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidClickLink::static_encode(page_id, move(url), target, modifiers));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_middle_click_link(u64 page_id, URL::URL const& url, StringView target, unsigned modifiers)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidMiddleClickLink::static_encode(page_id, move(url), target, modifiers));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_context_menu(u64 page_id, Gfx::IntPoint content_position, Web::ContextMenuForInputEventsTarget const& for_input_events_target)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestContextMenu::static_encode(page_id, content_position, move(for_input_events_target)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_link_context_menu(u64 page_id, Gfx::IntPoint content_position, URL::URL const& url, StringView target, unsigned modifiers)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestLinkContextMenu::static_encode(page_id, content_position, move(url), target, modifiers));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_image_context_menu(u64 page_id, Gfx::IntPoint content_position, URL::URL const& url, StringView target, unsigned modifiers, Optional<Gfx::ShareableBitmap> const& bitmap)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestImageContextMenu::static_encode(page_id, content_position, move(url), target, modifiers, move(bitmap)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_media_context_menu(u64 page_id, Gfx::IntPoint content_position, StringView target, unsigned modifiers, Web::Page::MediaContextMenu const& menu)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestMediaContextMenu::static_encode(page_id, content_position, target, modifiers, move(menu)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_alert(u64 page_id, StringView message)
    {
        VERIFY(Utf8View { message }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestAlert::static_encode(page_id, message));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_alert(u64 page_id, String const& message)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestAlert::static_encode(page_id, message));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_confirm(u64 page_id, StringView message)
    {
        VERIFY(Utf8View { message }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestConfirm::static_encode(page_id, message));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_confirm(u64 page_id, String const& message)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestConfirm::static_encode(page_id, message));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_prompt(u64 page_id, StringView message, StringView default_)
    {
        VERIFY(Utf8View { message }.validate());
        VERIFY(Utf8View { default_ }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestPrompt::static_encode(page_id, message, default_));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_prompt(u64 page_id, String const& message, String const& default_)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestPrompt::static_encode(page_id, message, default_));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_set_prompt_text(u64 page_id, StringView message)
    {
        VERIFY(Utf8View { message }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestSetPromptText::static_encode(page_id, message));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_set_prompt_text(u64 page_id, String const& message)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestSetPromptText::static_encode(page_id, message));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_accept_dialog(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestAcceptDialog::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_dismiss_dialog(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestDismissDialog::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_get_source(u64 page_id, URL::URL const& url, URL::URL const& base_url, StringView source)
    {
        VERIFY(Utf8View { source }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidGetSource::static_encode(page_id, move(url), move(base_url), source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_get_source(u64 page_id, URL::URL const& url, URL::URL const& base_url, String const& source)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidGetSource::static_encode(page_id, move(url), move(base_url), source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_dom_tree(u64 page_id, StringView dom_tree)
    {
        VERIFY(Utf8View { dom_tree }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectDomTree::static_encode(page_id, dom_tree));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_dom_tree(u64 page_id, String const& dom_tree)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectDomTree::static_encode(page_id, dom_tree));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_dom_node(u64 page_id, WebView::DOMNodeProperties const& properties)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectDomNode::static_encode(page_id, move(properties)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_accessibility_tree(u64 page_id, StringView accessibility_tree)
    {
        VERIFY(Utf8View { accessibility_tree }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectAccessibilityTree::static_encode(page_id, accessibility_tree));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_accessibility_tree(u64 page_id, String const& accessibility_tree)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectAccessibilityTree::static_encode(page_id, accessibility_tree));
        (void)m_connection.post_message(message_buffer);
    }

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

    void async_did_finish_editing_dom_node(u64 page_id, Optional<Web::UniqueNodeID> const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidFinishEditingDomNode::static_encode(page_id, move(node_id)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_mutate_dom(u64 page_id, WebView::Mutation const& mutation)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidMutateDom::static_encode(page_id, move(mutation)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_get_dom_node_html(u64 page_id, StringView html)
    {
        VERIFY(Utf8View { html }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidGetDomNodeHtml::static_encode(page_id, html));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_get_dom_node_html(u64 page_id, String const& html)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidGetDomNodeHtml::static_encode(page_id, html));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_list_style_sheets(u64 page_id, ReadonlySpan<Web::CSS::StyleSheetIdentifier> style_sheets)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidListStyleSheets::static_encode(page_id, style_sheets));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_get_style_sheet_source(u64 page_id, Web::CSS::StyleSheetIdentifier const& identifier, URL::URL const& base_url, StringView source)
    {
        VERIFY(Utf8View { source }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidGetStyleSheetSource::static_encode(page_id, move(identifier), move(base_url), source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_get_style_sheet_source(u64 page_id, Web::CSS::StyleSheetIdentifier const& identifier, URL::URL const& base_url, String const& source)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidGetStyleSheetSource::static_encode(page_id, move(identifier), move(base_url), source));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_take_screenshot(u64 page_id, Gfx::ShareableBitmap const& screenshot)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidTakeScreenshot::static_encode(page_id, move(screenshot)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_get_internal_page_info(u64 page_id, WebView::PageInfoType type, Optional<Core::AnonymousBuffer> const& info)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidGetInternalPageInfo::static_encode(page_id, type, move(info)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_change_favicon(u64 page_id, Gfx::ShareableBitmap const& favicon)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeFavicon::static_encode(page_id, move(favicon)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_document_cookie_version_index(u64 page_id, i64 document_id, StringView domain)
    {
        VERIFY(Utf8View { domain }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestDocumentCookieVersionIndex::static_encode(page_id, document_id, domain));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_document_cookie_version_index(u64 page_id, i64 document_id, String const& domain)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestDocumentCookieVersionIndex::static_encode(page_id, document_id, domain));
        (void)m_connection.post_message(message_buffer);
    }

    Vector<HTTP::Cookie::Cookie> did_request_all_cookies_webdriver(URL::URL url)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestAllCookiesWebdriver>(move(url))->take_cookies();
    }

    void async_did_request_all_cookies_webdriver(URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestAllCookiesWebdriver::static_encode(move(url)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Vector<HTTP::Cookie::Cookie>> try_did_request_all_cookies_webdriver(URL::URL url)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestAllCookiesWebdriver>(move(url)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Vector<HTTP::Cookie::Cookie> did_request_all_cookies_cookiestore(URL::URL url)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestAllCookiesCookiestore>(move(url))->take_cookies();
    }

    void async_did_request_all_cookies_cookiestore(URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestAllCookiesCookiestore::static_encode(move(url)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Vector<HTTP::Cookie::Cookie>> try_did_request_all_cookies_cookiestore(URL::URL url)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestAllCookiesCookiestore>(move(url)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Optional<HTTP::Cookie::Cookie> did_request_named_cookie(URL::URL url, String name)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestNamedCookie>(move(url), move(name))->take_cookie();
    }

    void async_did_request_named_cookie(URL::URL const& url, StringView name)
    {
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestNamedCookie::static_encode(move(url), name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_named_cookie(URL::URL const& url, String const& name)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestNamedCookie::static_encode(move(url), name));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Optional<HTTP::Cookie::Cookie>> try_did_request_named_cookie(URL::URL url, String name)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestNamedCookie>(move(url), move(name)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    HTTP::Cookie::VersionedCookie did_request_cookie(u64 page_id, URL::URL url, HTTP::Cookie::Source source)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestCookie>(page_id, move(url), source)->take_cookie();
    }

    void async_did_request_cookie(u64 page_id, URL::URL const& url, HTTP::Cookie::Source source)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestCookie::static_encode(page_id, move(url), source));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<HTTP::Cookie::VersionedCookie> try_did_request_cookie(u64 page_id, URL::URL url, HTTP::Cookie::Source source)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestCookie>(page_id, move(url), source))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void did_set_cookie(URL::URL url, HTTP::Cookie::ParsedCookie cookie, HTTP::Cookie::Source source)
    {
        (void)m_connection.template send_sync<Messages::WebContentClient::DidSetCookie>(move(url), move(cookie), source);
    }

    void async_did_set_cookie(URL::URL const& url, HTTP::Cookie::ParsedCookie const& cookie, HTTP::Cookie::Source source)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidSetCookie::static_encode(move(url), move(cookie), source));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<void> try_did_set_cookie(URL::URL url, HTTP::Cookie::ParsedCookie cookie, HTTP::Cookie::Source source)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidSetCookie>(move(url), move(cookie), source))
            return {};
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_update_cookie(HTTP::Cookie::Cookie const& cookie)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateCookie::static_encode(move(cookie)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_expire_cookies_with_time_offset(AK::Duration offset)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidExpireCookiesWithTimeOffset::static_encode(offset));
        (void)m_connection.post_message(message_buffer);
    }

    Optional<String> did_request_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestStorageItem>(move(storage_endpoint), move(storage_key), move(bottle_key))->take_value();
    }

    void async_did_request_storage_item(Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView storage_key, StringView bottle_key)
    {
        VERIFY(Utf8View { storage_key }.validate());
        VERIFY(Utf8View { bottle_key }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestStorageItem::static_encode(move(storage_endpoint), storage_key, bottle_key));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_storage_item(Web::StorageAPI::StorageEndpointType const& storage_endpoint, String const& storage_key, String const& bottle_key)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestStorageItem::static_encode(move(storage_endpoint), storage_key, bottle_key));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Optional<String>> try_did_request_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestStorageItem>(move(storage_endpoint), move(storage_key), move(bottle_key)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    WebView::StorageSetResult did_set_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key, String value)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidSetStorageItem>(move(storage_endpoint), move(storage_key), move(bottle_key), move(value))->take_result();
    }

    void async_did_set_storage_item(Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView storage_key, StringView bottle_key, StringView value)
    {
        VERIFY(Utf8View { storage_key }.validate());
        VERIFY(Utf8View { bottle_key }.validate());
        VERIFY(Utf8View { value }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidSetStorageItem::static_encode(move(storage_endpoint), storage_key, bottle_key, value));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_set_storage_item(Web::StorageAPI::StorageEndpointType const& storage_endpoint, String const& storage_key, String const& bottle_key, String const& value)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidSetStorageItem::static_encode(move(storage_endpoint), storage_key, bottle_key, value));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<WebView::StorageSetResult> try_did_set_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key, String value)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidSetStorageItem>(move(storage_endpoint), move(storage_key), move(bottle_key), move(value)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void did_remove_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key)
    {
        (void)m_connection.template send_sync<Messages::WebContentClient::DidRemoveStorageItem>(move(storage_endpoint), move(storage_key), move(bottle_key));
    }

    void async_did_remove_storage_item(Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView storage_key, StringView bottle_key)
    {
        VERIFY(Utf8View { storage_key }.validate());
        VERIFY(Utf8View { bottle_key }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRemoveStorageItem::static_encode(move(storage_endpoint), storage_key, bottle_key));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_remove_storage_item(Web::StorageAPI::StorageEndpointType const& storage_endpoint, String const& storage_key, String const& bottle_key)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRemoveStorageItem::static_encode(move(storage_endpoint), storage_key, bottle_key));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<void> try_did_remove_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRemoveStorageItem>(move(storage_endpoint), move(storage_key), move(bottle_key)))
            return {};
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Vector<String> did_request_storage_keys(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestStorageKeys>(move(storage_endpoint), move(storage_key))->take_keys();
    }

    void async_did_request_storage_keys(Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView storage_key)
    {
        VERIFY(Utf8View { storage_key }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestStorageKeys::static_encode(move(storage_endpoint), storage_key));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_storage_keys(Web::StorageAPI::StorageEndpointType const& storage_endpoint, String const& storage_key)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestStorageKeys::static_encode(move(storage_endpoint), storage_key));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Vector<String>> try_did_request_storage_keys(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestStorageKeys>(move(storage_endpoint), move(storage_key)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void did_clear_storage(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key)
    {
        (void)m_connection.template send_sync<Messages::WebContentClient::DidClearStorage>(move(storage_endpoint), move(storage_key));
    }

    void async_did_clear_storage(Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView storage_key)
    {
        VERIFY(Utf8View { storage_key }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidClearStorage::static_encode(move(storage_endpoint), storage_key));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_clear_storage(Web::StorageAPI::StorageEndpointType const& storage_endpoint, String const& storage_key)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidClearStorage::static_encode(move(storage_endpoint), storage_key));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<void> try_did_clear_storage(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidClearStorage>(move(storage_endpoint), move(storage_key)))
            return {};
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_post_broadcast_channel_message(u64 page_id, Web::HTML::BroadcastChannelMessage const& message)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidPostBroadcastChannelMessage::static_encode(page_id, move(message)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_update_resource_count(u64 page_id, i32 count_waiting)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateResourceCount::static_encode(page_id, count_waiting));
        (void)m_connection.post_message(message_buffer);
    }

    String did_request_new_web_view(u64 page_id, Web::HTML::ActivateTab activate_tab, Web::HTML::WebViewHints hints, Optional<u64> page_index)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestNewWebView>(page_id, move(activate_tab), move(hints), move(page_index))->take_handle();
    }

    void async_did_request_new_web_view(u64 page_id, Web::HTML::ActivateTab const& activate_tab, Web::HTML::WebViewHints const& hints, Optional<u64> const& page_index)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestNewWebView::static_encode(page_id, move(activate_tab), move(hints), move(page_index)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<String> try_did_request_new_web_view(u64 page_id, Web::HTML::ActivateTab activate_tab, Web::HTML::WebViewHints hints, Optional<u64> page_index)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestNewWebView>(page_id, move(activate_tab), move(hints), move(page_index)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_request_activate_tab(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestActivateTab::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_close_browsing_context(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidCloseBrowsingContext::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_restore_window(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestRestoreWindow::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_reposition_window(u64 page_id, Gfx::IntPoint position)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestRepositionWindow::static_encode(page_id, position));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_resize_window(u64 page_id, Gfx::IntSize size)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestResizeWindow::static_encode(page_id, size));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_maximize_window(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestMaximizeWindow::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_minimize_window(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestMinimizeWindow::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_fullscreen_window(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestFullscreenWindow::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_exit_fullscreen(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestExitFullscreen::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_file(u64 page_id, StringView path, i32 request_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestFile::static_encode(page_id, path, request_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_color_picker(u64 page_id, Color const& current_color)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestColorPicker::static_encode(page_id, move(current_color)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_file_picker(u64 page_id, Web::HTML::FileFilter const& accepted_file_types, Web::HTML::AllowMultipleFiles allow_multiple_files)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestFilePicker::static_encode(page_id, move(accepted_file_types), allow_multiple_files));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_select_dropdown(u64 page_id, Gfx::IntPoint content_position, i32 minimum_width, ReadonlySpan<Web::HTML::SelectItem> items)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestSelectDropdown::static_encode(page_id, content_position, minimum_width, items));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_finish_handling_input_event(u64 page_id, Web::EventResult event_result)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidFinishHandlingInputEvent::static_encode(page_id, event_result));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_change_theme_color(u64 page_id, Gfx::Color color)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeThemeColor::static_encode(page_id, color));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_insert_clipboard_entry(u64 page_id, Web::Clipboard::SystemClipboardRepresentation const& entry, StringView presentation_style)
    {
        VERIFY(Utf8View { presentation_style }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidInsertClipboardEntry::static_encode(page_id, move(entry), presentation_style));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_insert_clipboard_entry(u64 page_id, Web::Clipboard::SystemClipboardRepresentation const& entry, String const& presentation_style)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInsertClipboardEntry::static_encode(page_id, move(entry), presentation_style));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_clipboard_entries(u64 page_id, u64 request_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestClipboardEntries::static_encode(page_id, request_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_update_navigation_buttons_state(u64 page_id, bool back_enabled, bool forward_enabled)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateNavigationButtonsState::static_encode(page_id, back_enabled, forward_enabled));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_change_audio_play_state(u64 page_id, Web::HTML::AudioPlayState play_state)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeAudioPlayState::static_encode(page_id, play_state));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_execute_js_console_input(u64 page_id, JsonValue const& result)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidExecuteJsConsoleInput::static_encode(page_id, move(result)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_output_js_console_message(u64 page_id, WebView::ConsoleOutput const& console_output)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidOutputJsConsoleMessage::static_encode(page_id, move(console_output)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_start_network_request(u64 page_id, u64 request_id, URL::URL const& url, StringView method, ReadonlySpan<HTTP::Header> request_headers, ReadonlyBytes request_body, Optional<String> const& initiator_type)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidStartNetworkRequest::static_encode(page_id, request_id, move(url), method, request_headers, request_body, move(initiator_type)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_receive_network_response_headers(u64 page_id, u64 request_id, u32 status_code, Optional<String> const& reason_phrase, ReadonlySpan<HTTP::Header> response_headers)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidReceiveNetworkResponseHeaders::static_encode(page_id, request_id, status_code, move(reason_phrase), response_headers));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_receive_network_response_body(u64 page_id, u64 request_id, ReadonlyBytes data)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidReceiveNetworkResponseBody::static_encode(page_id, request_id, data));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_finish_network_request(u64 page_id, u64 request_id, u64 body_size, Requests::RequestTimingInfo const& timing_info, Optional<Requests::NetworkError> const& network_error)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidFinishNetworkRequest::static_encode(page_id, request_id, body_size, move(timing_info), move(network_error)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_finish_test(u64 page_id, StringView text)
    {
        VERIFY(Utf8View { text }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidFinishTest::static_encode(page_id, text));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_finish_test(u64 page_id, String const& text)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidFinishTest::static_encode(page_id, text));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_set_test_timeout(u64 page_id, double milliseconds)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidSetTestTimeout::static_encode(page_id, milliseconds));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_receive_reference_test_metadata(u64 page_id, JsonValue const& result)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidReceiveReferenceTestMetadata::static_encode(page_id, move(result)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_receive_test_variant_metadata(u64 page_id, JsonValue const& result)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidReceiveTestVariantMetadata::static_encode(page_id, move(result)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_set_browser_zoom(u64 page_id, double factor)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidSetBrowserZoom::static_encode(page_id, factor));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_find_in_page(u64 page_id, size_t current_match_index, Optional<size_t> const& total_match_count)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidFindInPage::static_encode(page_id, current_match_index, move(total_match_count)));
        (void)m_connection.post_message(message_buffer);
    }

    Messages::WebContentClient::RequestWorkerAgentResponse request_worker_agent(u64 page_id, Web::Bindings::AgentType worker_type)
    {
        return move(*m_connection.template send_sync<Messages::WebContentClient::RequestWorkerAgent>(page_id, move(worker_type)));
    }

    void async_request_worker_agent(u64 page_id, Web::Bindings::AgentType const& worker_type)
    {
        auto message_buffer = MUST(Messages::WebContentClient::RequestWorkerAgent::static_encode(page_id, move(worker_type)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Messages::WebContentClient::RequestWorkerAgentResponse> try_request_worker_agent(u64 page_id, Web::Bindings::AgentType worker_type)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::RequestWorkerAgent>(page_id, move(worker_type)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

private:
    IPC::Connection<LocalEndpoint, PeerEndpoint>& m_connection;
};

template<typename LocalEndpoint, typename PeerEndpoint>
class WebContentClientProxy;
class WebContentClientStub;

class WebContentClientEndpoint {
public:
    template<typename LocalEndpoint>
    using Proxy = WebContentClientProxy<LocalEndpoint, WebContentClientEndpoint>;
    using Stub = WebContentClientStub;

    static u32 static_magic() { return 2565717604; }

    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::WebContentClient::MessageID::DidRequestNewProcessForNavigation:
            return Messages::WebContentClient::DidRequestNewProcessForNavigation::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStartLoading:
            return Messages::WebContentClient::DidStartLoading::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFinishLoading:
            return Messages::WebContentClient::DidFinishLoading::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestRefresh:
            return Messages::WebContentClient::DidRequestRefresh::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestCursorChange:
            return Messages::WebContentClient::DidRequestCursorChange::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeTitle:
            return Messages::WebContentClient::DidChangeTitle::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeUrl:
            return Messages::WebContentClient::DidChangeUrl::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestTooltipOverride:
            return Messages::WebContentClient::DidRequestTooltipOverride::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStopTooltipOverride:
            return Messages::WebContentClient::DidStopTooltipOverride::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidEnterTooltipArea:
            return Messages::WebContentClient::DidEnterTooltipArea::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidLeaveTooltipArea:
            return Messages::WebContentClient::DidLeaveTooltipArea::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidHoverLink:
            return Messages::WebContentClient::DidHoverLink::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUnhoverLink:
            return Messages::WebContentClient::DidUnhoverLink::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidClickLink:
            return Messages::WebContentClient::DidClickLink::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidMiddleClickLink:
            return Messages::WebContentClient::DidMiddleClickLink::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestContextMenu:
            return Messages::WebContentClient::DidRequestContextMenu::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestLinkContextMenu:
            return Messages::WebContentClient::DidRequestLinkContextMenu::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestImageContextMenu:
            return Messages::WebContentClient::DidRequestImageContextMenu::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestMediaContextMenu:
            return Messages::WebContentClient::DidRequestMediaContextMenu::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestAlert:
            return Messages::WebContentClient::DidRequestAlert::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestConfirm:
            return Messages::WebContentClient::DidRequestConfirm::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestPrompt:
            return Messages::WebContentClient::DidRequestPrompt::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestSetPromptText:
            return Messages::WebContentClient::DidRequestSetPromptText::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestAcceptDialog:
            return Messages::WebContentClient::DidRequestAcceptDialog::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestDismissDialog:
            return Messages::WebContentClient::DidRequestDismissDialog::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidGetSource:
            return Messages::WebContentClient::DidGetSource::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInspectDomTree:
            return Messages::WebContentClient::DidInspectDomTree::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInspectDomNode:
            return Messages::WebContentClient::DidInspectDomNode::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInspectAccessibilityTree:
            return Messages::WebContentClient::DidInspectAccessibilityTree::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidGetHoveredNodeId:
            return Messages::WebContentClient::DidGetHoveredNodeId::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFinishEditingDomNode:
            return Messages::WebContentClient::DidFinishEditingDomNode::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidMutateDom:
            return Messages::WebContentClient::DidMutateDom::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidGetDomNodeHtml:
            return Messages::WebContentClient::DidGetDomNodeHtml::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidListStyleSheets:
            return Messages::WebContentClient::DidListStyleSheets::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidGetStyleSheetSource:
            return Messages::WebContentClient::DidGetStyleSheetSource::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidTakeScreenshot:
            return Messages::WebContentClient::DidTakeScreenshot::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidGetInternalPageInfo:
            return Messages::WebContentClient::DidGetInternalPageInfo::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeFavicon:
            return Messages::WebContentClient::DidChangeFavicon::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestDocumentCookieVersionIndex:
            return Messages::WebContentClient::DidRequestDocumentCookieVersionIndex::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestAllCookiesWebdriver:
            return Messages::WebContentClient::DidRequestAllCookiesWebdriver::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestAllCookiesWebdriverResponse:
            return Messages::WebContentClient::DidRequestAllCookiesWebdriverResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestAllCookiesCookiestore:
            return Messages::WebContentClient::DidRequestAllCookiesCookiestore::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestAllCookiesCookiestoreResponse:
            return Messages::WebContentClient::DidRequestAllCookiesCookiestoreResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestNamedCookie:
            return Messages::WebContentClient::DidRequestNamedCookie::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestNamedCookieResponse:
            return Messages::WebContentClient::DidRequestNamedCookieResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestCookie:
            return Messages::WebContentClient::DidRequestCookie::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestCookieResponse:
            return Messages::WebContentClient::DidRequestCookieResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidSetCookie:
            return Messages::WebContentClient::DidSetCookie::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidSetCookieResponse:
            return Messages::WebContentClient::DidSetCookieResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdateCookie:
            return Messages::WebContentClient::DidUpdateCookie::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidExpireCookiesWithTimeOffset:
            return Messages::WebContentClient::DidExpireCookiesWithTimeOffset::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestStorageItem:
            return Messages::WebContentClient::DidRequestStorageItem::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestStorageItemResponse:
            return Messages::WebContentClient::DidRequestStorageItemResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidSetStorageItem:
            return Messages::WebContentClient::DidSetStorageItem::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidSetStorageItemResponse:
            return Messages::WebContentClient::DidSetStorageItemResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRemoveStorageItem:
            return Messages::WebContentClient::DidRemoveStorageItem::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRemoveStorageItemResponse:
            return Messages::WebContentClient::DidRemoveStorageItemResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestStorageKeys:
            return Messages::WebContentClient::DidRequestStorageKeys::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestStorageKeysResponse:
            return Messages::WebContentClient::DidRequestStorageKeysResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidClearStorage:
            return Messages::WebContentClient::DidClearStorage::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidClearStorageResponse:
            return Messages::WebContentClient::DidClearStorageResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidPostBroadcastChannelMessage:
            return Messages::WebContentClient::DidPostBroadcastChannelMessage::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdateResourceCount:
            return Messages::WebContentClient::DidUpdateResourceCount::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestNewWebView:
            return Messages::WebContentClient::DidRequestNewWebView::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestNewWebViewResponse:
            return Messages::WebContentClient::DidRequestNewWebViewResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestActivateTab:
            return Messages::WebContentClient::DidRequestActivateTab::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidCloseBrowsingContext:
            return Messages::WebContentClient::DidCloseBrowsingContext::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestRestoreWindow:
            return Messages::WebContentClient::DidRequestRestoreWindow::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestRepositionWindow:
            return Messages::WebContentClient::DidRequestRepositionWindow::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestResizeWindow:
            return Messages::WebContentClient::DidRequestResizeWindow::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestMaximizeWindow:
            return Messages::WebContentClient::DidRequestMaximizeWindow::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestMinimizeWindow:
            return Messages::WebContentClient::DidRequestMinimizeWindow::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestFullscreenWindow:
            return Messages::WebContentClient::DidRequestFullscreenWindow::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestExitFullscreen:
            return Messages::WebContentClient::DidRequestExitFullscreen::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestFile:
            return Messages::WebContentClient::DidRequestFile::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestColorPicker:
            return Messages::WebContentClient::DidRequestColorPicker::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestFilePicker:
            return Messages::WebContentClient::DidRequestFilePicker::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestSelectDropdown:
            return Messages::WebContentClient::DidRequestSelectDropdown::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFinishHandlingInputEvent:
            return Messages::WebContentClient::DidFinishHandlingInputEvent::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeThemeColor:
            return Messages::WebContentClient::DidChangeThemeColor::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInsertClipboardEntry:
            return Messages::WebContentClient::DidInsertClipboardEntry::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestClipboardEntries:
            return Messages::WebContentClient::DidRequestClipboardEntries::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdateNavigationButtonsState:
            return Messages::WebContentClient::DidUpdateNavigationButtonsState::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeAudioPlayState:
            return Messages::WebContentClient::DidChangeAudioPlayState::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidExecuteJsConsoleInput:
            return Messages::WebContentClient::DidExecuteJsConsoleInput::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidOutputJsConsoleMessage:
            return Messages::WebContentClient::DidOutputJsConsoleMessage::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStartNetworkRequest:
            return Messages::WebContentClient::DidStartNetworkRequest::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidReceiveNetworkResponseHeaders:
            return Messages::WebContentClient::DidReceiveNetworkResponseHeaders::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidReceiveNetworkResponseBody:
            return Messages::WebContentClient::DidReceiveNetworkResponseBody::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFinishNetworkRequest:
            return Messages::WebContentClient::DidFinishNetworkRequest::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFinishTest:
            return Messages::WebContentClient::DidFinishTest::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidSetTestTimeout:
            return Messages::WebContentClient::DidSetTestTimeout::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidReceiveReferenceTestMetadata:
            return Messages::WebContentClient::DidReceiveReferenceTestMetadata::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidReceiveTestVariantMetadata:
            return Messages::WebContentClient::DidReceiveTestVariantMetadata::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidSetBrowserZoom:
            return Messages::WebContentClient::DidSetBrowserZoom::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFindInPage:
            return Messages::WebContentClient::DidFindInPage::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::RequestWorkerAgent:
            return Messages::WebContentClient::RequestWorkerAgent::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::RequestWorkerAgentResponse:
            return Messages::WebContentClient::RequestWorkerAgentResponse::decode(stream, attachments);
        default:
            return Error::from_string_literal("Failed to decode WebContentClient message");
        }

        VERIFY_NOT_REACHED();
    }
};

class WebContentClientStub : public IPC::Stub {
public:
    WebContentClientStub() { }
    virtual ~WebContentClientStub() override { }

    virtual u32 magic() const override { return 2565717604; }
    virtual ByteString name() const override { return "WebContentClient"; }

    virtual ErrorOr<OwnPtr<IPC::MessageBuffer>> handle(NonnullOwnPtr<IPC::Message> message) override
    {
        switch (message->message_id()) {
        case (int)Messages::WebContentClient::MessageID::DidRequestNewProcessForNavigation:
            return handle_did_request_new_process_for_navigation(*message);
        case (int)Messages::WebContentClient::MessageID::DidStartLoading:
            return handle_did_start_loading(*message);
        case (int)Messages::WebContentClient::MessageID::DidFinishLoading:
            return handle_did_finish_loading(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestRefresh:
            return handle_did_request_refresh(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestCursorChange:
            return handle_did_request_cursor_change(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeTitle:
            return handle_did_change_title(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeUrl:
            return handle_did_change_url(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestTooltipOverride:
            return handle_did_request_tooltip_override(*message);
        case (int)Messages::WebContentClient::MessageID::DidStopTooltipOverride:
            return handle_did_stop_tooltip_override(*message);
        case (int)Messages::WebContentClient::MessageID::DidEnterTooltipArea:
            return handle_did_enter_tooltip_area(*message);
        case (int)Messages::WebContentClient::MessageID::DidLeaveTooltipArea:
            return handle_did_leave_tooltip_area(*message);
        case (int)Messages::WebContentClient::MessageID::DidHoverLink:
            return handle_did_hover_link(*message);
        case (int)Messages::WebContentClient::MessageID::DidUnhoverLink:
            return handle_did_unhover_link(*message);
        case (int)Messages::WebContentClient::MessageID::DidClickLink:
            return handle_did_click_link(*message);
        case (int)Messages::WebContentClient::MessageID::DidMiddleClickLink:
            return handle_did_middle_click_link(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestContextMenu:
            return handle_did_request_context_menu(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestLinkContextMenu:
            return handle_did_request_link_context_menu(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestImageContextMenu:
            return handle_did_request_image_context_menu(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestMediaContextMenu:
            return handle_did_request_media_context_menu(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestAlert:
            return handle_did_request_alert(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestConfirm:
            return handle_did_request_confirm(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestPrompt:
            return handle_did_request_prompt(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestSetPromptText:
            return handle_did_request_set_prompt_text(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestAcceptDialog:
            return handle_did_request_accept_dialog(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestDismissDialog:
            return handle_did_request_dismiss_dialog(*message);
        case (int)Messages::WebContentClient::MessageID::DidGetSource:
            return handle_did_get_source(*message);
        case (int)Messages::WebContentClient::MessageID::DidInspectDomTree:
            return handle_did_inspect_dom_tree(*message);
        case (int)Messages::WebContentClient::MessageID::DidInspectDomNode:
            return handle_did_inspect_dom_node(*message);
        case (int)Messages::WebContentClient::MessageID::DidInspectAccessibilityTree:
            return handle_did_inspect_accessibility_tree(*message);
        case (int)Messages::WebContentClient::MessageID::DidGetHoveredNodeId:
            return handle_did_get_hovered_node_id(*message);
        case (int)Messages::WebContentClient::MessageID::DidFinishEditingDomNode:
            return handle_did_finish_editing_dom_node(*message);
        case (int)Messages::WebContentClient::MessageID::DidMutateDom:
            return handle_did_mutate_dom(*message);
        case (int)Messages::WebContentClient::MessageID::DidGetDomNodeHtml:
            return handle_did_get_dom_node_html(*message);
        case (int)Messages::WebContentClient::MessageID::DidListStyleSheets:
            return handle_did_list_style_sheets(*message);
        case (int)Messages::WebContentClient::MessageID::DidGetStyleSheetSource:
            return handle_did_get_style_sheet_source(*message);
        case (int)Messages::WebContentClient::MessageID::DidTakeScreenshot:
            return handle_did_take_screenshot(*message);
        case (int)Messages::WebContentClient::MessageID::DidGetInternalPageInfo:
            return handle_did_get_internal_page_info(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeFavicon:
            return handle_did_change_favicon(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestDocumentCookieVersionIndex:
            return handle_did_request_document_cookie_version_index(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestAllCookiesWebdriver:
            return handle_did_request_all_cookies_webdriver(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestAllCookiesCookiestore:
            return handle_did_request_all_cookies_cookiestore(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestNamedCookie:
            return handle_did_request_named_cookie(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestCookie:
            return handle_did_request_cookie(*message);
        case (int)Messages::WebContentClient::MessageID::DidSetCookie:
            return handle_did_set_cookie(*message);
        case (int)Messages::WebContentClient::MessageID::DidUpdateCookie:
            return handle_did_update_cookie(*message);
        case (int)Messages::WebContentClient::MessageID::DidExpireCookiesWithTimeOffset:
            return handle_did_expire_cookies_with_time_offset(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestStorageItem:
            return handle_did_request_storage_item(*message);
        case (int)Messages::WebContentClient::MessageID::DidSetStorageItem:
            return handle_did_set_storage_item(*message);
        case (int)Messages::WebContentClient::MessageID::DidRemoveStorageItem:
            return handle_did_remove_storage_item(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestStorageKeys:
            return handle_did_request_storage_keys(*message);
        case (int)Messages::WebContentClient::MessageID::DidClearStorage:
            return handle_did_clear_storage(*message);
        case (int)Messages::WebContentClient::MessageID::DidPostBroadcastChannelMessage:
            return handle_did_post_broadcast_channel_message(*message);
        case (int)Messages::WebContentClient::MessageID::DidUpdateResourceCount:
            return handle_did_update_resource_count(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestNewWebView:
            return handle_did_request_new_web_view(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestActivateTab:
            return handle_did_request_activate_tab(*message);
        case (int)Messages::WebContentClient::MessageID::DidCloseBrowsingContext:
            return handle_did_close_browsing_context(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestRestoreWindow:
            return handle_did_request_restore_window(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestRepositionWindow:
            return handle_did_request_reposition_window(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestResizeWindow:
            return handle_did_request_resize_window(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestMaximizeWindow:
            return handle_did_request_maximize_window(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestMinimizeWindow:
            return handle_did_request_minimize_window(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestFullscreenWindow:
            return handle_did_request_fullscreen_window(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestExitFullscreen:
            return handle_did_request_exit_fullscreen(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestFile:
            return handle_did_request_file(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestColorPicker:
            return handle_did_request_color_picker(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestFilePicker:
            return handle_did_request_file_picker(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestSelectDropdown:
            return handle_did_request_select_dropdown(*message);
        case (int)Messages::WebContentClient::MessageID::DidFinishHandlingInputEvent:
            return handle_did_finish_handling_input_event(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeThemeColor:
            return handle_did_change_theme_color(*message);
        case (int)Messages::WebContentClient::MessageID::DidInsertClipboardEntry:
            return handle_did_insert_clipboard_entry(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestClipboardEntries:
            return handle_did_request_clipboard_entries(*message);
        case (int)Messages::WebContentClient::MessageID::DidUpdateNavigationButtonsState:
            return handle_did_update_navigation_buttons_state(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeAudioPlayState:
            return handle_did_change_audio_play_state(*message);
        case (int)Messages::WebContentClient::MessageID::DidExecuteJsConsoleInput:
            return handle_did_execute_js_console_input(*message);
        case (int)Messages::WebContentClient::MessageID::DidOutputJsConsoleMessage:
            return handle_did_output_js_console_message(*message);
        case (int)Messages::WebContentClient::MessageID::DidStartNetworkRequest:
            return handle_did_start_network_request(*message);
        case (int)Messages::WebContentClient::MessageID::DidReceiveNetworkResponseHeaders:
            return handle_did_receive_network_response_headers(*message);
        case (int)Messages::WebContentClient::MessageID::DidReceiveNetworkResponseBody:
            return handle_did_receive_network_response_body(*message);
        case (int)Messages::WebContentClient::MessageID::DidFinishNetworkRequest:
            return handle_did_finish_network_request(*message);
        case (int)Messages::WebContentClient::MessageID::DidFinishTest:
            return handle_did_finish_test(*message);
        case (int)Messages::WebContentClient::MessageID::DidSetTestTimeout:
            return handle_did_set_test_timeout(*message);
        case (int)Messages::WebContentClient::MessageID::DidReceiveReferenceTestMetadata:
            return handle_did_receive_reference_test_metadata(*message);
        case (int)Messages::WebContentClient::MessageID::DidReceiveTestVariantMetadata:
            return handle_did_receive_test_variant_metadata(*message);
        case (int)Messages::WebContentClient::MessageID::DidSetBrowserZoom:
            return handle_did_set_browser_zoom(*message);
        case (int)Messages::WebContentClient::MessageID::DidFindInPage:
            return handle_did_find_in_page(*message);
        case (int)Messages::WebContentClient::MessageID::RequestWorkerAgent:
            return handle_request_worker_agent(*message);
        default:
            return Error::from_string_literal("Unknown message ID for WebContentClient endpoint");
        }
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_new_process_for_navigation(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestNewProcessForNavigation&>(message);
        did_request_new_process_for_navigation(request.page_id(), request.take_url());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_start_loading(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidStartLoading&>(message);
        did_start_loading(request.page_id(), request.take_url(), request.is_redirect());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_finish_loading(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidFinishLoading&>(message);
        did_finish_loading(request.page_id(), request.take_url());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_refresh(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestRefresh&>(message);
        did_request_refresh(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_cursor_change(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestCursorChange&>(message);
        did_request_cursor_change(request.page_id(), request.take_cursor());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_change_title(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeTitle&>(message);
        did_change_title(request.page_id(), request.take_title());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_change_url(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeUrl&>(message);
        did_change_url(request.page_id(), request.take_url());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_tooltip_override(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestTooltipOverride&>(message);
        did_request_tooltip_override(request.page_id(), request.position(), request.take_title());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_stop_tooltip_override(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidStopTooltipOverride&>(message);
        did_stop_tooltip_override(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_enter_tooltip_area(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidEnterTooltipArea&>(message);
        did_enter_tooltip_area(request.page_id(), request.take_title());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_leave_tooltip_area(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidLeaveTooltipArea&>(message);
        did_leave_tooltip_area(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_hover_link(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidHoverLink&>(message);
        did_hover_link(request.page_id(), request.take_url());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_unhover_link(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUnhoverLink&>(message);
        did_unhover_link(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_click_link(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidClickLink&>(message);
        did_click_link(request.page_id(), request.take_url(), request.take_target(), request.modifiers());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_middle_click_link(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidMiddleClickLink&>(message);
        did_middle_click_link(request.page_id(), request.take_url(), request.take_target(), request.modifiers());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_context_menu(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestContextMenu&>(message);
        did_request_context_menu(request.page_id(), request.content_position(), request.take_for_input_events_target());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_link_context_menu(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestLinkContextMenu&>(message);
        did_request_link_context_menu(request.page_id(), request.content_position(), request.take_url(), request.take_target(), request.modifiers());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_image_context_menu(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestImageContextMenu&>(message);
        did_request_image_context_menu(request.page_id(), request.content_position(), request.take_url(), request.take_target(), request.modifiers(), request.take_bitmap());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_media_context_menu(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestMediaContextMenu&>(message);
        did_request_media_context_menu(request.page_id(), request.content_position(), request.take_target(), request.modifiers(), request.take_menu());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_alert(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestAlert&>(message);
        did_request_alert(request.page_id(), request.take_message());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_confirm(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestConfirm&>(message);
        did_request_confirm(request.page_id(), request.take_message());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_prompt(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestPrompt&>(message);
        did_request_prompt(request.page_id(), request.take_message(), request.take_default_());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_set_prompt_text(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestSetPromptText&>(message);
        did_request_set_prompt_text(request.page_id(), request.take_message());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_accept_dialog(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestAcceptDialog&>(message);
        did_request_accept_dialog(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_dismiss_dialog(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestDismissDialog&>(message);
        did_request_dismiss_dialog(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_get_source(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidGetSource&>(message);
        did_get_source(request.page_id(), request.take_url(), request.take_base_url(), request.take_source());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_inspect_dom_tree(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInspectDomTree&>(message);
        did_inspect_dom_tree(request.page_id(), request.take_dom_tree());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_inspect_dom_node(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInspectDomNode&>(message);
        did_inspect_dom_node(request.page_id(), request.take_properties());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_inspect_accessibility_tree(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInspectAccessibilityTree&>(message);
        did_inspect_accessibility_tree(request.page_id(), request.take_accessibility_tree());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_get_hovered_node_id(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidGetHoveredNodeId&>(message);
        did_get_hovered_node_id(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_finish_editing_dom_node(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidFinishEditingDomNode&>(message);
        did_finish_editing_dom_node(request.page_id(), request.take_node_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_mutate_dom(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidMutateDom&>(message);
        did_mutate_dom(request.page_id(), request.take_mutation());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_get_dom_node_html(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidGetDomNodeHtml&>(message);
        did_get_dom_node_html(request.page_id(), request.take_html());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_list_style_sheets(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidListStyleSheets&>(message);
        did_list_style_sheets(request.page_id(), request.take_style_sheets());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_get_style_sheet_source(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidGetStyleSheetSource&>(message);
        did_get_style_sheet_source(request.page_id(), request.take_identifier(), request.take_base_url(), request.take_source());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_take_screenshot(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidTakeScreenshot&>(message);
        did_take_screenshot(request.page_id(), request.take_screenshot());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_get_internal_page_info(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidGetInternalPageInfo&>(message);
        did_get_internal_page_info(request.page_id(), request.type(), request.take_info());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_change_favicon(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeFavicon&>(message);
        did_change_favicon(request.page_id(), request.take_favicon());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_document_cookie_version_index(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestDocumentCookieVersionIndex&>(message);
        did_request_document_cookie_version_index(request.page_id(), request.document_id(), request.take_domain());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_all_cookies_webdriver(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestAllCookiesWebdriver&>(message);
        auto response = did_request_all_cookies_webdriver(request.take_url());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_all_cookies_cookiestore(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestAllCookiesCookiestore&>(message);
        auto response = did_request_all_cookies_cookiestore(request.take_url());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_named_cookie(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestNamedCookie&>(message);
        auto response = did_request_named_cookie(request.take_url(), request.take_name());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_cookie(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestCookie&>(message);
        auto response = did_request_cookie(request.page_id(), request.take_url(), request.source());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_set_cookie(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidSetCookie&>(message);
        did_set_cookie(request.take_url(), request.take_cookie(), request.source());
        auto response = Messages::WebContentClient::DidSetCookieResponse {};
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_cookie(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdateCookie&>(message);
        did_update_cookie(request.take_cookie());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_expire_cookies_with_time_offset(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidExpireCookiesWithTimeOffset&>(message);
        did_expire_cookies_with_time_offset(request.offset());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_storage_item(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestStorageItem&>(message);
        auto response = did_request_storage_item(request.take_storage_endpoint(), request.take_storage_key(), request.take_bottle_key());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_set_storage_item(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidSetStorageItem&>(message);
        auto response = did_set_storage_item(request.take_storage_endpoint(), request.take_storage_key(), request.take_bottle_key(), request.take_value());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_remove_storage_item(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRemoveStorageItem&>(message);
        did_remove_storage_item(request.take_storage_endpoint(), request.take_storage_key(), request.take_bottle_key());
        auto response = Messages::WebContentClient::DidRemoveStorageItemResponse {};
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_storage_keys(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestStorageKeys&>(message);
        auto response = did_request_storage_keys(request.take_storage_endpoint(), request.take_storage_key());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_clear_storage(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidClearStorage&>(message);
        did_clear_storage(request.take_storage_endpoint(), request.take_storage_key());
        auto response = Messages::WebContentClient::DidClearStorageResponse {};
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_post_broadcast_channel_message(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidPostBroadcastChannelMessage&>(message);
        did_post_broadcast_channel_message(request.page_id(), request.take_message());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_resource_count(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdateResourceCount&>(message);
        did_update_resource_count(request.page_id(), request.count_waiting());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_new_web_view(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestNewWebView&>(message);
        auto response = did_request_new_web_view(request.page_id(), request.take_activate_tab(), request.take_hints(), request.take_page_index());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_activate_tab(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestActivateTab&>(message);
        did_request_activate_tab(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_close_browsing_context(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidCloseBrowsingContext&>(message);
        did_close_browsing_context(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_restore_window(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestRestoreWindow&>(message);
        did_request_restore_window(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_reposition_window(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestRepositionWindow&>(message);
        did_request_reposition_window(request.page_id(), request.position());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_resize_window(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestResizeWindow&>(message);
        did_request_resize_window(request.page_id(), request.size());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_maximize_window(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestMaximizeWindow&>(message);
        did_request_maximize_window(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_minimize_window(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestMinimizeWindow&>(message);
        did_request_minimize_window(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_fullscreen_window(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestFullscreenWindow&>(message);
        did_request_fullscreen_window(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_exit_fullscreen(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestExitFullscreen&>(message);
        did_request_exit_fullscreen(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_file(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestFile&>(message);
        did_request_file(request.page_id(), request.take_path(), request.request_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_color_picker(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestColorPicker&>(message);
        did_request_color_picker(request.page_id(), request.take_current_color());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_file_picker(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestFilePicker&>(message);
        did_request_file_picker(request.page_id(), request.take_accepted_file_types(), request.allow_multiple_files());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_select_dropdown(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestSelectDropdown&>(message);
        did_request_select_dropdown(request.page_id(), request.content_position(), request.minimum_width(), request.take_items());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_finish_handling_input_event(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidFinishHandlingInputEvent&>(message);
        did_finish_handling_input_event(request.page_id(), request.event_result());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_change_theme_color(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeThemeColor&>(message);
        did_change_theme_color(request.page_id(), request.color());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_insert_clipboard_entry(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInsertClipboardEntry&>(message);
        did_insert_clipboard_entry(request.page_id(), request.take_entry(), request.take_presentation_style());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_clipboard_entries(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestClipboardEntries&>(message);
        did_request_clipboard_entries(request.page_id(), request.request_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_navigation_buttons_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdateNavigationButtonsState&>(message);
        did_update_navigation_buttons_state(request.page_id(), request.back_enabled(), request.forward_enabled());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_change_audio_play_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeAudioPlayState&>(message);
        did_change_audio_play_state(request.page_id(), request.play_state());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_execute_js_console_input(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidExecuteJsConsoleInput&>(message);
        did_execute_js_console_input(request.page_id(), request.take_result());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_output_js_console_message(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidOutputJsConsoleMessage&>(message);
        did_output_js_console_message(request.page_id(), request.take_console_output());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_start_network_request(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidStartNetworkRequest&>(message);
        did_start_network_request(request.page_id(), request.request_id(), request.take_url(), request.take_method(), request.take_request_headers(), request.take_request_body(), request.take_initiator_type());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_receive_network_response_headers(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidReceiveNetworkResponseHeaders&>(message);
        did_receive_network_response_headers(request.page_id(), request.request_id(), request.status_code(), request.take_reason_phrase(), request.take_response_headers());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_receive_network_response_body(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidReceiveNetworkResponseBody&>(message);
        did_receive_network_response_body(request.page_id(), request.request_id(), request.take_data());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_finish_network_request(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidFinishNetworkRequest&>(message);
        did_finish_network_request(request.page_id(), request.request_id(), request.body_size(), request.take_timing_info(), request.take_network_error());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_finish_test(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidFinishTest&>(message);
        did_finish_test(request.page_id(), request.take_text());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_set_test_timeout(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidSetTestTimeout&>(message);
        did_set_test_timeout(request.page_id(), request.milliseconds());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_receive_reference_test_metadata(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidReceiveReferenceTestMetadata&>(message);
        did_receive_reference_test_metadata(request.page_id(), request.take_result());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_receive_test_variant_metadata(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidReceiveTestVariantMetadata&>(message);
        did_receive_test_variant_metadata(request.page_id(), request.take_result());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_set_browser_zoom(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidSetBrowserZoom&>(message);
        did_set_browser_zoom(request.page_id(), request.factor());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_find_in_page(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidFindInPage&>(message);
        did_find_in_page(request.page_id(), request.current_match_index(), request.take_total_match_count());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_request_worker_agent(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::RequestWorkerAgent&>(message);
        auto response = request_worker_agent(request.page_id(), request.take_worker_type());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    virtual void did_request_new_process_for_navigation(u64 page_id, URL::URL url) = 0;
    virtual void did_start_loading(u64 page_id, URL::URL url, bool is_redirect) = 0;
    virtual void did_finish_loading(u64 page_id, URL::URL url) = 0;
    virtual void did_request_refresh(u64 page_id) = 0;
    virtual void did_request_cursor_change(u64 page_id, Gfx::Cursor cursor) = 0;
    virtual void did_change_title(u64 page_id, Utf16String title) = 0;
    virtual void did_change_url(u64 page_id, URL::URL url) = 0;
    virtual void did_request_tooltip_override(u64 page_id, Gfx::IntPoint position, ByteString title) = 0;
    virtual void did_stop_tooltip_override(u64 page_id) = 0;
    virtual void did_enter_tooltip_area(u64 page_id, ByteString title) = 0;
    virtual void did_leave_tooltip_area(u64 page_id) = 0;
    virtual void did_hover_link(u64 page_id, URL::URL url) = 0;
    virtual void did_unhover_link(u64 page_id) = 0;
    virtual void did_click_link(u64 page_id, URL::URL url, ByteString target, unsigned modifiers) = 0;
    virtual void did_middle_click_link(u64 page_id, URL::URL url, ByteString target, unsigned modifiers) = 0;
    virtual void did_request_context_menu(u64 page_id, Gfx::IntPoint content_position, Web::ContextMenuForInputEventsTarget for_input_events_target) = 0;
    virtual void did_request_link_context_menu(u64 page_id, Gfx::IntPoint content_position, URL::URL url, ByteString target, unsigned modifiers) = 0;
    virtual void did_request_image_context_menu(u64 page_id, Gfx::IntPoint content_position, URL::URL url, ByteString target, unsigned modifiers, Optional<Gfx::ShareableBitmap> bitmap) = 0;
    virtual void did_request_media_context_menu(u64 page_id, Gfx::IntPoint content_position, ByteString target, unsigned modifiers, Web::Page::MediaContextMenu menu) = 0;
    virtual void did_request_alert(u64 page_id, String message) = 0;
    virtual void did_request_confirm(u64 page_id, String message) = 0;
    virtual void did_request_prompt(u64 page_id, String message, String default_) = 0;
    virtual void did_request_set_prompt_text(u64 page_id, String message) = 0;
    virtual void did_request_accept_dialog(u64 page_id) = 0;
    virtual void did_request_dismiss_dialog(u64 page_id) = 0;
    virtual void did_get_source(u64 page_id, URL::URL url, URL::URL base_url, String source) = 0;
    virtual void did_inspect_dom_tree(u64 page_id, String dom_tree) = 0;
    virtual void did_inspect_dom_node(u64 page_id, WebView::DOMNodeProperties properties) = 0;
    virtual void did_inspect_accessibility_tree(u64 page_id, String accessibility_tree) = 0;
    virtual void did_get_hovered_node_id(u64 page_id, Web::UniqueNodeID node_id) = 0;
    virtual void did_finish_editing_dom_node(u64 page_id, Optional<Web::UniqueNodeID> node_id) = 0;
    virtual void did_mutate_dom(u64 page_id, WebView::Mutation mutation) = 0;
    virtual void did_get_dom_node_html(u64 page_id, String html) = 0;
    virtual void did_list_style_sheets(u64 page_id, Vector<Web::CSS::StyleSheetIdentifier> style_sheets) = 0;
    virtual void did_get_style_sheet_source(u64 page_id, Web::CSS::StyleSheetIdentifier identifier, URL::URL base_url, String source) = 0;
    virtual void did_take_screenshot(u64 page_id, Gfx::ShareableBitmap screenshot) = 0;
    virtual void did_get_internal_page_info(u64 page_id, WebView::PageInfoType type, Optional<Core::AnonymousBuffer> info) = 0;
    virtual void did_change_favicon(u64 page_id, Gfx::ShareableBitmap favicon) = 0;
    virtual void did_request_document_cookie_version_index(u64 page_id, i64 document_id, String domain) = 0;
    virtual Messages::WebContentClient::DidRequestAllCookiesWebdriverResponse did_request_all_cookies_webdriver(URL::URL url) = 0;
    virtual Messages::WebContentClient::DidRequestAllCookiesCookiestoreResponse did_request_all_cookies_cookiestore(URL::URL url) = 0;
    virtual Messages::WebContentClient::DidRequestNamedCookieResponse did_request_named_cookie(URL::URL url, String name) = 0;
    virtual Messages::WebContentClient::DidRequestCookieResponse did_request_cookie(u64 page_id, URL::URL url, HTTP::Cookie::Source source) = 0;
    virtual void did_set_cookie(URL::URL url, HTTP::Cookie::ParsedCookie cookie, HTTP::Cookie::Source source) = 0;
    virtual void did_update_cookie(HTTP::Cookie::Cookie cookie) = 0;
    virtual void did_expire_cookies_with_time_offset(AK::Duration offset) = 0;
    virtual Messages::WebContentClient::DidRequestStorageItemResponse did_request_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key) = 0;
    virtual Messages::WebContentClient::DidSetStorageItemResponse did_set_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key, String value) = 0;
    virtual void did_remove_storage_item(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key, String bottle_key) = 0;
    virtual Messages::WebContentClient::DidRequestStorageKeysResponse did_request_storage_keys(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key) = 0;
    virtual void did_clear_storage(Web::StorageAPI::StorageEndpointType storage_endpoint, String storage_key) = 0;
    virtual void did_post_broadcast_channel_message(u64 page_id, Web::HTML::BroadcastChannelMessage message) = 0;
    virtual void did_update_resource_count(u64 page_id, i32 count_waiting) = 0;
    virtual Messages::WebContentClient::DidRequestNewWebViewResponse did_request_new_web_view(u64 page_id, Web::HTML::ActivateTab activate_tab, Web::HTML::WebViewHints hints, Optional<u64> page_index) = 0;
    virtual void did_request_activate_tab(u64 page_id) = 0;
    virtual void did_close_browsing_context(u64 page_id) = 0;
    virtual void did_request_restore_window(u64 page_id) = 0;
    virtual void did_request_reposition_window(u64 page_id, Gfx::IntPoint position) = 0;
    virtual void did_request_resize_window(u64 page_id, Gfx::IntSize size) = 0;
    virtual void did_request_maximize_window(u64 page_id) = 0;
    virtual void did_request_minimize_window(u64 page_id) = 0;
    virtual void did_request_fullscreen_window(u64 page_id) = 0;
    virtual void did_request_exit_fullscreen(u64 page_id) = 0;
    virtual void did_request_file(u64 page_id, ByteString path, i32 request_id) = 0;
    virtual void did_request_color_picker(u64 page_id, Color current_color) = 0;
    virtual void did_request_file_picker(u64 page_id, Web::HTML::FileFilter accepted_file_types, Web::HTML::AllowMultipleFiles allow_multiple_files) = 0;
    virtual void did_request_select_dropdown(u64 page_id, Gfx::IntPoint content_position, i32 minimum_width, Vector<Web::HTML::SelectItem> items) = 0;
    virtual void did_finish_handling_input_event(u64 page_id, Web::EventResult event_result) = 0;
    virtual void did_change_theme_color(u64 page_id, Gfx::Color color) = 0;
    virtual void did_insert_clipboard_entry(u64 page_id, Web::Clipboard::SystemClipboardRepresentation entry, String presentation_style) = 0;
    virtual void did_request_clipboard_entries(u64 page_id, u64 request_id) = 0;
    virtual void did_update_navigation_buttons_state(u64 page_id, bool back_enabled, bool forward_enabled) = 0;
    virtual void did_change_audio_play_state(u64 page_id, Web::HTML::AudioPlayState play_state) = 0;
    virtual void did_execute_js_console_input(u64 page_id, JsonValue result) = 0;
    virtual void did_output_js_console_message(u64 page_id, WebView::ConsoleOutput console_output) = 0;
    virtual void did_start_network_request(u64 page_id, u64 request_id, URL::URL url, ByteString method, Vector<HTTP::Header> request_headers, ByteBuffer request_body, Optional<String> initiator_type) = 0;
    virtual void did_receive_network_response_headers(u64 page_id, u64 request_id, u32 status_code, Optional<String> reason_phrase, Vector<HTTP::Header> response_headers) = 0;
    virtual void did_receive_network_response_body(u64 page_id, u64 request_id, ByteBuffer data) = 0;
    virtual void did_finish_network_request(u64 page_id, u64 request_id, u64 body_size, Requests::RequestTimingInfo timing_info, Optional<Requests::NetworkError> network_error) = 0;
    virtual void did_finish_test(u64 page_id, String text) = 0;
    virtual void did_set_test_timeout(u64 page_id, double milliseconds) = 0;
    virtual void did_receive_reference_test_metadata(u64 page_id, JsonValue result) = 0;
    virtual void did_receive_test_variant_metadata(u64 page_id, JsonValue result) = 0;
    virtual void did_set_browser_zoom(u64 page_id, double factor) = 0;
    virtual void did_find_in_page(u64 page_id, size_t current_match_index, Optional<size_t> total_match_count) = 0;
    virtual Messages::WebContentClient::RequestWorkerAgentResponse request_worker_agent(u64 page_id, Web::Bindings::AgentType worker_type) = 0;
};

#if defined(AK_COMPILER_CLANG)
#pragma clang diagnostic pop
#endif