#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/HSTS/ParsedHSTSPolicy.h>
#include <LibHTTP/Header.h>
#include <LibRequests/NetworkError.h>
#include <LibRequests/RequestTimingInfo.h>
#include <LibURL/URL.h>
#include <LibWeb/Bindings/Navigation.h>
#include <LibWeb/Bindings/MainThreadVM.h>
#include <LibWeb/Clipboard/SystemClipboard.h>
#include <LibWeb/Compositor/Types.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/LocalNavigable.h>
#include <LibWeb/HTML/NavigableId.h>
#include <LibWeb/HTML/ReplicatedNavigableState.h>
#include <LibWeb/HTML/SelectedFile.h>
#include <LibWeb/HTML/SelectItem.h>
#include <LibWeb/HTML/SessionHistoryEntry.h>
#include <LibWeb/HTML/WebViewHints.h>
#include <LibWeb/HTML/WorkerAgentTypes.h>
#include <LibWeb/Page/EventResult.h>
#include <LibWeb/HTML/Scripting/ScriptRegistry.h>
#include <LibWeb/Page/Page.h>
#include <LibWeb/Page/ScreenWakeLockHandle.h>
#include <LibWeb/WebDriver/Response.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 {
    AllocateCompositorContextId = 1,
    AllocateCompositorContextIdResponse = 2,
    DidDestroyCompositorContext = 3,
    DecideNavigationProcess = 4,
    DecideNavigationProcessResponse = 5,
    DidRequestNewProcessForNavigation = 6,
    DidRequestNewProcessForChildFrameNavigation = 7,
    DidCreateChildFrame = 8,
    DidUpdateChildFrameViewport = 9,
    DidCommitChildFrameNavigation = 10,
    DidChangeTopLevelActiveDocument = 11,
    DidDestroyChildFrame = 12,
    DidStartWebdriverNavigation = 13,
    DidStartLoading = 14,
    DidCancelLoading = 15,
    DidFinishLoading = 16,
    DidStartDownloadWithoutRequest = 17,
    DidStartDownloadWithoutRequestResponse = 18,
    DidStartDownload = 19,
    DidStartDownloadResponse = 20,
    DidReceiveDownloadData = 21,
    DidFinishDownload = 22,
    DidFailDownload = 23,
    DidRequestRefresh = 24,
    DidRequestCursorChange = 25,
    DidChangeTitle = 26,
    DidChangeUrl = 27,
    DidRequestTooltipOverride = 28,
    DidStopTooltipOverride = 29,
    DidEnterTooltipArea = 30,
    DidLeaveTooltipArea = 31,
    DidHoverLink = 32,
    DidUnhoverLink = 33,
    DidClickLink = 34,
    DidMiddleClickLink = 35,
    DidRequestContextMenu = 36,
    DidRequestLinkContextMenu = 37,
    DidRequestImageContextMenu = 38,
    DidRequestMediaContextMenu = 39,
    DidRequestAlert = 40,
    DidRequestConfirm = 41,
    DidRequestPrompt = 42,
    DidRequestSetPromptText = 43,
    DidRequestAcceptDialog = 44,
    DidRequestDismissDialog = 45,
    DidGetSource = 46,
    DidInspectDomTree = 47,
    DidInspectStorage = 48,
    DidInspectDomNode = 49,
    DidInspectGridLayouts = 50,
    DidInspectCurrentGrid = 51,
    DidInspectCurrentFlexbox = 52,
    DidInspectIndexedDatabase = 53,
    DidInspectAccessibilityTree = 54,
    DidGetHoveredNodeId = 55,
    DidGetNodeIdAtPosition = 56,
    DidFinishEditingDomNode = 57,
    DidMutateDom = 58,
    DidGetDomNodeHtml = 59,
    DidListStyleSheets = 60,
    DidGetStyleSheetSource = 61,
    DidListDevtoolsSources = 62,
    DidGetDevtoolsSource = 63,
    DidAddDevtoolsSource = 64,
    DidResolveDomNodeUrl = 65,
    DidTakeScreenshot = 66,
    DidGetInternalPageInfo = 67,
    DidChangeFavicon = 68,
    DidRequestDocumentCookieVersionIndex = 69,
    DidRequestAllCookiesWebdriver = 70,
    DidRequestAllCookiesWebdriverResponse = 71,
    DidRequestAllCookiesCookiestore = 72,
    DidRequestAllCookiesCookiestoreResponse = 73,
    DidRequestNamedCookie = 74,
    DidRequestNamedCookieResponse = 75,
    DidRequestCookie = 76,
    DidRequestCookieResponse = 77,
    DidSetCookie = 78,
    DidSetCookieResponse = 79,
    DidUpdateCookie = 80,
    DidExpireCookiesWithTimeOffset = 81,
    DidRequestDeleteAllCookies = 82,
    DidStoreHstsPolicy = 83,
    DidIsKnownHstsHost = 84,
    DidIsKnownHstsHostResponse = 85,
    DidRequestStorageItem = 86,
    DidRequestStorageItemResponse = 87,
    DidSetStorageItem = 88,
    DidSetStorageItemResponse = 89,
    DidRemoveStorageItem = 90,
    DidRemoveStorageItemResponse = 91,
    DidRequestStorageKeys = 92,
    DidRequestStorageKeysResponse = 93,
    DidClearStorage = 94,
    DidClearStorageResponse = 95,
    DidRequestStorageUsage = 96,
    DidRequestStorageUsageResponse = 97,
    DidChangeStorageItem = 98,
    DidUpdateIndexedDatabase = 99,
    DidPostBroadcastChannelMessage = 100,
    DidUpdateResourceCount = 101,
    DidRequestNewWebView = 102,
    DidRequestNewWebViewResponse = 103,
    DidRequestActivateTab = 104,
    DidCloseBrowsingContext = 105,
    DidChangeNeedsBeforeunloadCheck = 106,
    DidRequestTraverseTheHistoryByDelta = 107,
    DidRequestTraverseTheHistoryByDeltaResponse = 108,
    DidRequestWebdriverHistoryTraversal = 109,
    DidRequestWebdriverLoadUrlFromUi = 110,
    DidRequestWebdriverLoadUrlFromUiResponse = 111,
    DidRequestWebdriverTraverseHistoryFromUi = 112,
    DidRequestWebdriverTraverseHistoryFromUiResponse = 113,
    DidRequestWebdriverMarkWebContentSessionHistoryStale = 114,
    DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse = 115,
    DidRequestWebdriverSessionHistory = 116,
    DidRequestWebdriverSessionHistoryResponse = 117,
    DidRequestWebdriverNavigationCompletion = 118,
    DidRequestRestoreWindow = 119,
    DidRequestRepositionWindow = 120,
    DidRequestResizeWindow = 121,
    DidRequestMaximizeWindow = 122,
    DidRequestMinimizeWindow = 123,
    DidRequestFullscreenWindow = 124,
    DidRequestExitFullscreen = 125,
    DidRequestFile = 126,
    DidRequestColorPicker = 127,
    DidRequestFilePicker = 128,
    DidRequestSelectDropdown = 129,
    DidFinishHandlingInputEvent = 130,
    DidUpdateInputMethodState = 131,
    DidChangeThemeColor = 132,
    DidChangeBackgroundColor = 133,
    DidInsertClipboardEntry = 134,
    DidRequestClipboardEntries = 135,
    DidRequestPrimaryPaste = 136,
    DidUpdatePrimarySelection = 137,
    DidUpdateSessionHistory = 138,
    DidRequestUiProcessSessionHistoryForTesting = 139,
    DidRequestUiProcessSessionHistoryForTestingResponse = 140,
    DidRequestSiteIsolationProcessTreeForTesting = 141,
    DidRequestSiteIsolationProcessTreeForTestingResponse = 142,
    DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting = 143,
    DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTestingResponse = 144,
    DidSetTopLevelSessionHistory = 145,
    DidTraverseTheHistoryToStep = 146,
    DidCheckIfTraverseHistoryStepIsCanceled = 147,
    DidResetSessionHistoryForTesting = 148,
    DidChangeAudioPlayState = 149,
    DidChangeScreenWakeLockState = 150,
    DidExecuteJsConsoleInput = 151,
    DidOutputJsConsoleMessage = 152,
    DidStartNetworkRequest = 153,
    DidReceiveNetworkResponseHeaders = 154,
    DidReceiveNetworkResponseBody = 155,
    DidFinishNetworkRequest = 156,
    DidFinishTest = 157,
    DidSetTestTimeout = 158,
    DidReceiveReferenceTestMetadata = 159,
    DidSetBrowserZoom = 160,
    DidFindInPage = 161,
    StartWorkerAgent = 162,
    StartWorkerAgentResponse = 163,
    CloseWorkerAgent = 164,
};

class AllocateCompositorContextIdResponse final : public IPC::Message {
public:
    AllocateCompositorContextIdResponse(Web::Compositor::CompositorContextId context_id)
        : m_context_id(move(context_id))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::Compositor::CompositorContextId>)
    AllocateCompositorContextIdResponse(WrappedReturnType&& value)
        : m_context_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::AllocateCompositorContextIdResponse; }
    static i32 static_message_id() { return (int)MessageID::AllocateCompositorContextIdResponse; }
    virtual StringView message_name() const override { return "WebContentClient::AllocateCompositorContextIdResponse"sv; }

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

    static ErrorOr<IPC::MessageBuffer> static_encode(Web::Compositor::CompositorContextId const& context_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::AllocateCompositorContextIdResponse));
        TRY(stream.encode(context_id));
        return buffer;
    }

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

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

private:
    Web::Compositor::CompositorContextId m_context_id;
};

class AllocateCompositorContextId final : public IPC::Message {
public:
    typedef class AllocateCompositorContextIdResponse ResponseType;

    AllocateCompositorContextId(u64 page_id, Web::Compositor::PagePresentationRegistration page_presentation_registration)
        : m_page_id(move(page_id))
        , m_page_presentation_registration(move(page_presentation_registration))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::Compositor::PagePresentationRegistration const& page_presentation_registration() const { return m_page_presentation_registration; }
    Web::Compositor::PagePresentationRegistration take_page_presentation_registration() { return move(m_page_presentation_registration); }

private:
    u64 m_page_id;
    Web::Compositor::PagePresentationRegistration m_page_presentation_registration;
};

class DidDestroyCompositorContext final : public IPC::Message {
public:
    DidDestroyCompositorContext(Web::Compositor::CompositorContextId context_id)
        : m_context_id(move(context_id))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::Compositor::CompositorContextId>)
    DidDestroyCompositorContext(WrappedReturnType&& value)
        : m_context_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::DidDestroyCompositorContext; }
    static i32 static_message_id() { return (int)MessageID::DidDestroyCompositorContext; }
    virtual StringView message_name() const override { return "WebContentClient::DidDestroyCompositorContext"sv; }

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

    static ErrorOr<IPC::MessageBuffer> static_encode(Web::Compositor::CompositorContextId const& context_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidDestroyCompositorContext));
        TRY(stream.encode(context_id));
        return buffer;
    }

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

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

private:
    Web::Compositor::CompositorContextId m_context_id;
};

class DecideNavigationProcessResponse final : public IPC::Message {
public:
    DecideNavigationProcessResponse(Web::NavigationProcessDecision decision)
        : m_decision(move(decision))
    {
    }

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

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

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

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

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

    Web::NavigationProcessDecision const& decision() const { return m_decision; }
    Web::NavigationProcessDecision take_decision() { return move(m_decision); }

private:
    Web::NavigationProcessDecision m_decision;
};

class DecideNavigationProcess final : public IPC::Message {
public:
    typedef class DecideNavigationProcessResponse ResponseType;

    DecideNavigationProcess(u64 page_id, Optional<Web::HTML::NavigableId> frame_id, URL::URL current_url, URL::URL target_url, Web::NavigationTarget target)
        : m_page_id(move(page_id))
        , m_frame_id(move(frame_id))
        , m_current_url(move(current_url))
        , m_target_url(move(target_url))
        , m_target(move(target))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    URL::URL const& current_url() const { return m_current_url; }
    URL::URL take_current_url() { return move(m_current_url); }

    URL::URL const& target_url() const { return m_target_url; }
    URL::URL take_target_url() { return move(m_target_url); }

    Web::NavigationTarget const& target() const { return m_target; }
    Web::NavigationTarget take_target() { return move(m_target); }

private:
    u64 m_page_id;
    Optional<Web::HTML::NavigableId> m_frame_id;
    URL::URL m_current_url;
    URL::URL m_target_url;
    Web::NavigationTarget m_target;
};

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

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

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

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

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

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

    static ErrorOr<NonnullOwnPtr<DidRequestNewProcessForChildFrameNavigation>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto frame_id = TRY((decoder.decode<Web::HTML::NavigableId>()));
        auto url = TRY((decoder.decode<URL::URL>()));
        auto document_resource = TRY((decoder.decode<Variant<Empty, String, Web::HTML::POSTResource>>()));
        auto history_handling = TRY((decoder.decode<Web::Bindings::NavigationHistoryBehavior>()));
        return make<DidRequestNewProcessForChildFrameNavigation>(move(page_id), move(frame_id), move(url), move(document_resource), move(history_handling));
    }

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

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

    u64 page_id() const { return m_page_id; }

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

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

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

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

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

class DidCreateChildFrame final : public IPC::Message {
public:
    DidCreateChildFrame(u64 page_id, Web::HTML::NavigableId parent_frame_id, Web::HTML::NavigableId frame_id, Web::HTML::ReplicatedNavigableState replicated_state)
        : m_page_id(move(page_id))
        , m_parent_frame_id(move(parent_frame_id))
        , m_frame_id(move(frame_id))
        , m_replicated_state(move(replicated_state))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::NavigableId const& parent_frame_id() const { return m_parent_frame_id; }
    Web::HTML::NavigableId take_parent_frame_id() { return move(m_parent_frame_id); }

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

    Web::HTML::ReplicatedNavigableState const& replicated_state() const { return m_replicated_state; }
    Web::HTML::ReplicatedNavigableState take_replicated_state() { return move(m_replicated_state); }

private:
    u64 m_page_id;
    Web::HTML::NavigableId m_parent_frame_id;
    Web::HTML::NavigableId m_frame_id;
    Web::HTML::ReplicatedNavigableState m_replicated_state;
};

class DidUpdateChildFrameViewport final : public IPC::Message {
public:
    DidUpdateChildFrameViewport(u64 page_id, Web::HTML::NavigableId frame_id, Web::DevicePixelRect viewport_rect, double device_pixel_ratio)
        : m_page_id(move(page_id))
        , m_frame_id(move(frame_id))
        , m_viewport_rect(move(viewport_rect))
        , m_device_pixel_ratio(move(device_pixel_ratio))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    Web::DevicePixelRect viewport_rect() const { return m_viewport_rect; }

    double device_pixel_ratio() const { return m_device_pixel_ratio; }

private:
    u64 m_page_id;
    Web::HTML::NavigableId m_frame_id;
    Web::DevicePixelRect m_viewport_rect;
    double m_device_pixel_ratio;
};

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

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    Web::HTML::ReplicatedNavigableState const& replicated_state() const { return m_replicated_state; }
    Web::HTML::ReplicatedNavigableState take_replicated_state() { return move(m_replicated_state); }

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

class DidChangeTopLevelActiveDocument final : public IPC::Message {
public:
    DidChangeTopLevelActiveDocument(u64 page_id, Web::HTML::ReplicatedNavigableState replicated_state)
        : m_page_id(move(page_id))
        , m_replicated_state(move(replicated_state))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::ReplicatedNavigableState const& replicated_state() const { return m_replicated_state; }
    Web::HTML::ReplicatedNavigableState take_replicated_state() { return move(m_replicated_state); }

private:
    u64 m_page_id;
    Web::HTML::ReplicatedNavigableState m_replicated_state;
};

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

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

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

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

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

    static ErrorOr<NonnullOwnPtr<DidStartWebdriverNavigation>> 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<DidStartWebdriverNavigation>(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::DidStartWebdriverNavigation));
        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, Variant<Empty, String, Web::HTML::POSTResource> document_resource, bool is_redirect, Web::Bindings::NavigationHistoryBehavior history_handling)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_document_resource(move(document_resource))
        , m_is_redirect(move(is_redirect))
        , m_history_handling(move(history_handling))
    {
    }

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

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

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

    u64 page_id() const { return m_page_id; }

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

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

    bool is_redirect() const { return m_is_redirect; }

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

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

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

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

    static ErrorOr<NonnullOwnPtr<DidCancelLoading>> 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<DidCancelLoading>(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::DidCancelLoading));
        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 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 DidStartDownloadWithoutRequestResponse final : public IPC::Message {
public:
    DidStartDownloadWithoutRequestResponse(Optional<u64> download_id)
        : m_download_id(move(download_id))
    {
    }

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

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

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

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

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

    Optional<u64> const& download_id() const { return m_download_id; }
    Optional<u64> take_download_id() { return move(m_download_id); }

private:
    Optional<u64> m_download_id;
};

class DidStartDownloadWithoutRequest final : public IPC::Message {
public:
    typedef class DidStartDownloadWithoutRequestResponse ResponseType;

    DidStartDownloadWithoutRequest(u64 page_id, URL::URL url, ByteString suggested_filename, Optional<u64> total_size)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_suggested_filename(move(suggested_filename))
        , m_total_size(move(total_size))
    {
    }

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

    static ErrorOr<NonnullOwnPtr<DidStartDownloadWithoutRequest>> 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 suggested_filename = TRY((decoder.decode<ByteString>()));
        auto total_size = TRY((decoder.decode<Optional<u64>>()));
        return make<DidStartDownloadWithoutRequest>(move(page_id), move(url), move(suggested_filename), move(total_size));
    }

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

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

    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& suggested_filename() const { return m_suggested_filename; }
    ByteString take_suggested_filename() { return move(m_suggested_filename); }

    Optional<u64> const& total_size() const { return m_total_size; }
    Optional<u64> take_total_size() { return move(m_total_size); }

private:
    u64 m_page_id;
    URL::URL m_url;
    ByteString m_suggested_filename;
    Optional<u64> m_total_size;
};

class DidStartDownloadResponse final : public IPC::Message {
public:
    DidStartDownloadResponse(Optional<u64> download_id)
        : m_download_id(move(download_id))
    {
    }

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

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

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

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

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

    Optional<u64> const& download_id() const { return m_download_id; }
    Optional<u64> take_download_id() { return move(m_download_id); }

private:
    Optional<u64> m_download_id;
};

class DidStartDownload final : public IPC::Message {
public:
    typedef class DidStartDownloadResponse ResponseType;

    DidStartDownload(u64 page_id, URL::URL url, ByteString suggested_filename, Optional<u64> total_size, int request_server_client_id, u64 request_server_request_id, ByteBuffer initial_data)
        : m_page_id(move(page_id))
        , m_url(move(url))
        , m_suggested_filename(move(suggested_filename))
        , m_total_size(move(total_size))
        , m_request_server_client_id(move(request_server_client_id))
        , m_request_server_request_id(move(request_server_request_id))
        , m_initial_data(move(initial_data))
    {
    }

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

    static ErrorOr<NonnullOwnPtr<DidStartDownload>> 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 suggested_filename = TRY((decoder.decode<ByteString>()));
        auto total_size = TRY((decoder.decode<Optional<u64>>()));
        auto request_server_client_id = TRY((decoder.decode<int>()));
        auto request_server_request_id = TRY((decoder.decode<u64>()));
        auto initial_data = TRY((decoder.decode<ByteBuffer>()));
        return make<DidStartDownload>(move(page_id), move(url), move(suggested_filename), move(total_size), move(request_server_client_id), move(request_server_request_id), move(initial_data));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, URL::URL const& url, StringView suggested_filename, Optional<u64> const& total_size, int request_server_client_id, u64 request_server_request_id, ReadonlyBytes initial_data)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidStartDownload));
        TRY(stream.encode(page_id));
        TRY(stream.encode(url));
        TRY(stream.encode(suggested_filename));
        TRY(stream.encode(total_size));
        TRY(stream.encode(request_server_client_id));
        TRY(stream.encode(request_server_request_id));
        TRY(stream.encode(initial_data));
        return buffer;
    }

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

    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& suggested_filename() const { return m_suggested_filename; }
    ByteString take_suggested_filename() { return move(m_suggested_filename); }

    Optional<u64> const& total_size() const { return m_total_size; }
    Optional<u64> take_total_size() { return move(m_total_size); }

    int request_server_client_id() const { return m_request_server_client_id; }

    u64 request_server_request_id() const { return m_request_server_request_id; }

    ByteBuffer const& initial_data() const { return m_initial_data; }
    ByteBuffer take_initial_data() { return move(m_initial_data); }

private:
    u64 m_page_id;
    URL::URL m_url;
    ByteString m_suggested_filename;
    Optional<u64> m_total_size;
    int m_request_server_client_id;
    u64 m_request_server_request_id;
    ByteBuffer m_initial_data;
};

class DidReceiveDownloadData final : public IPC::Message {
public:
    DidReceiveDownloadData(u64 page_id, u64 download_id, ByteBuffer data)
        : m_page_id(move(page_id))
        , m_download_id(move(download_id))
        , m_data(move(data))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 download_id() const { return m_download_id; }

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

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

class DidFinishDownload final : public IPC::Message {
public:
    DidFinishDownload(u64 page_id, u64 download_id)
        : m_page_id(move(page_id))
        , m_download_id(move(download_id))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 download_id() const { return m_download_id; }

private:
    u64 m_page_id;
    u64 m_download_id;
};

class DidFailDownload final : public IPC::Message {
public:
    DidFailDownload(u64 page_id, u64 download_id, String error)
        : m_page_id(move(page_id))
        , m_download_id(move(download_id))
        , m_error(move(error))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 download_id() const { return m_download_id; }

    String const& error() const { return m_error; }
    String take_error() { return move(m_error); }

private:
    u64 m_page_id;
    u64 m_download_id;
    String m_error;
};

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

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    String const& storage_items() const { return m_storage_items; }
    String take_storage_items() { return move(m_storage_items); }

private:
    u64 m_page_id;
    u64 m_request_id;
    String m_storage_items;
};

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 DidInspectGridLayouts final : public IPC::Message {
public:
    DidInspectGridLayouts(u64 page_id, String grid_layouts)
        : m_page_id(move(page_id))
        , m_grid_layouts(move(grid_layouts))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    String const& grid_layouts() const { return m_grid_layouts; }
    String take_grid_layouts() { return move(m_grid_layouts); }

private:
    u64 m_page_id;
    String m_grid_layouts;
};

class DidInspectCurrentGrid final : public IPC::Message {
public:
    DidInspectCurrentGrid(u64 page_id, String grid_layout)
        : m_page_id(move(page_id))
        , m_grid_layout(move(grid_layout))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    String const& grid_layout() const { return m_grid_layout; }
    String take_grid_layout() { return move(m_grid_layout); }

private:
    u64 m_page_id;
    String m_grid_layout;
};

class DidInspectCurrentFlexbox final : public IPC::Message {
public:
    DidInspectCurrentFlexbox(u64 page_id, String flexbox_layout)
        : m_page_id(move(page_id))
        , m_flexbox_layout(move(flexbox_layout))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    String const& flexbox_layout() const { return m_flexbox_layout; }
    String take_flexbox_layout() { return move(m_flexbox_layout); }

private:
    u64 m_page_id;
    String m_flexbox_layout;
};

class DidInspectIndexedDatabase final : public IPC::Message {
public:
    DidInspectIndexedDatabase(u64 page_id, u64 request_id, String result)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_result(move(result))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

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

private:
    u64 m_page_id;
    u64 m_request_id;
    String m_result;
};

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

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_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;
    u64 m_request_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 DidListDevtoolsSources final : public IPC::Message {
public:
    DidListDevtoolsSources(u64 page_id, u64 request_id, Vector<Web::HTML::ScriptRegistry::Description> sources)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_sources(move(sources))
    {
    }

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

    static ErrorOr<NonnullOwnPtr<DidListDevtoolsSources>> 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 sources = TRY((decoder.decode<Vector<Web::HTML::ScriptRegistry::Description>>()));
        return make<DidListDevtoolsSources>(move(page_id), move(request_id), move(sources));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, u64 request_id, ReadonlySpan<Web::HTML::ScriptRegistry::Description> sources)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidListDevtoolsSources));
        TRY(stream.encode(page_id));
        TRY(stream.encode(request_id));
        TRY(stream.encode(sources));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    Vector<Web::HTML::ScriptRegistry::Description> const& sources() const { return m_sources; }
    Vector<Web::HTML::ScriptRegistry::Description> take_sources() { return move(m_sources); }

private:
    u64 m_page_id;
    u64 m_request_id;
    Vector<Web::HTML::ScriptRegistry::Description> m_sources;
};

class DidGetDevtoolsSource final : public IPC::Message {
public:
    DidGetDevtoolsSource(u64 page_id, Web::HTML::ScriptRegistry::Identifier source_id, Optional<Web::HTML::ScriptRegistry::Content> source)
        : m_page_id(move(page_id))
        , m_source_id(move(source_id))
        , m_source(move(source))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    Optional<Web::HTML::ScriptRegistry::Content> const& source() const { return m_source; }
    Optional<Web::HTML::ScriptRegistry::Content> take_source() { return move(m_source); }

private:
    u64 m_page_id;
    Web::HTML::ScriptRegistry::Identifier m_source_id;
    Optional<Web::HTML::ScriptRegistry::Content> m_source;
};

class DidAddDevtoolsSource final : public IPC::Message {
public:
    DidAddDevtoolsSource(u64 page_id, Web::HTML::ScriptRegistry::Description source)
        : m_page_id(move(page_id))
        , m_source(move(source))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::ScriptRegistry::Description const& source() const { return m_source; }
    Web::HTML::ScriptRegistry::Description take_source() { return move(m_source); }

private:
    u64 m_page_id;
    Web::HTML::ScriptRegistry::Description m_source;
};

class DidResolveDomNodeUrl final : public IPC::Message {
public:
    DidResolveDomNodeUrl(u64 page_id, u64 request_id, String resolved_url)
        : m_page_id(move(page_id))
        , m_request_id(move(request_id))
        , m_resolved_url(move(resolved_url))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    String const& resolved_url() const { return m_resolved_url; }
    String take_resolved_url() { return move(m_resolved_url); }

private:
    u64 m_page_id;
    u64 m_request_id;
    String m_resolved_url;
};

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

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

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

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

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

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

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

class DidStoreHstsPolicy final : public IPC::Message {
public:
    DidStoreHstsPolicy(String domain, HTTP::HSTS::ParsedHSTSPolicy policy)
        : m_domain(move(domain))
        , m_policy(move(policy))
    {
    }

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

    static ErrorOr<NonnullOwnPtr<DidStoreHstsPolicy>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto domain = TRY((decoder.decode<String>()));
        auto policy = TRY((decoder.decode<HTTP::HSTS::ParsedHSTSPolicy>()));
        return make<DidStoreHstsPolicy>(move(domain), move(policy));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(StringView domain, HTTP::HSTS::ParsedHSTSPolicy const& policy)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidStoreHstsPolicy));
        TRY(stream.encode(domain));
        TRY(stream.encode(policy));
        return buffer;
    }

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

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

    HTTP::HSTS::ParsedHSTSPolicy const& policy() const { return m_policy; }
    HTTP::HSTS::ParsedHSTSPolicy take_policy() { return move(m_policy); }

private:
    String m_domain;
    HTTP::HSTS::ParsedHSTSPolicy m_policy;
};

class DidIsKnownHstsHostResponse final : public IPC::Message {
public:
    DidIsKnownHstsHostResponse(bool result)
        : m_result(move(result))
    {
    }

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

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

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

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

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

    bool result() const { return m_result; }

private:
    bool m_result;
};

class DidIsKnownHstsHost final : public IPC::Message {
public:
    typedef class DidIsKnownHstsHostResponse ResponseType;

    DidIsKnownHstsHost(String domain)
        : m_domain(move(domain))
    {
    }

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

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

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

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

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

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

private:
    String m_domain;
};

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 DidRequestStorageUsageResponse final : public IPC::Message {
public:
    DidRequestStorageUsageResponse(u64 usage)
        : m_usage(move(usage))
    {
    }

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

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

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

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

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

    u64 usage() const { return m_usage; }

private:
    u64 m_usage;
};

class DidRequestStorageUsage final : public IPC::Message {
public:
    typedef class DidRequestStorageUsageResponse ResponseType;

    DidRequestStorageUsage(String storage_key)
        : m_storage_key(move(storage_key))
    {
    }

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

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

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

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

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

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

private:
    String m_storage_key;
};

class DidChangeStorageItem final : public IPC::Message {
public:
    DidChangeStorageItem(u64 page_id, Web::StorageAPI::StorageEndpointType storage_endpoint, String url, Optional<String> key, Optional<String> old_value, Optional<String> new_value)
        : m_page_id(move(page_id))
        , m_storage_endpoint(move(storage_endpoint))
        , m_url(move(url))
        , m_key(move(key))
        , m_old_value(move(old_value))
        , m_new_value(move(new_value))
    {
    }

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

    static ErrorOr<NonnullOwnPtr<DidChangeStorageItem>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto storage_endpoint = TRY((decoder.decode<Web::StorageAPI::StorageEndpointType>()));
        auto url = TRY((decoder.decode<String>()));
        auto key = TRY((decoder.decode<Optional<String>>()));
        auto old_value = TRY((decoder.decode<Optional<String>>()));
        auto new_value = TRY((decoder.decode<Optional<String>>()));
        return make<DidChangeStorageItem>(move(page_id), move(storage_endpoint), move(url), move(key), move(old_value), move(new_value));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView url, Optional<String> const& key, Optional<String> const& old_value, Optional<String> const& new_value)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidChangeStorageItem));
        TRY(stream.encode(page_id));
        TRY(stream.encode(storage_endpoint));
        TRY(stream.encode(url));
        TRY(stream.encode(key));
        TRY(stream.encode(old_value));
        TRY(stream.encode(new_value));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

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

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

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

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

    Optional<String> const& new_value() const { return m_new_value; }
    Optional<String> take_new_value() { return move(m_new_value); }

private:
    u64 m_page_id;
    Web::StorageAPI::StorageEndpointType m_storage_endpoint;
    String m_url;
    Optional<String> m_key;
    Optional<String> m_old_value;
    Optional<String> m_new_value;
};

class DidUpdateIndexedDatabase final : public IPC::Message {
public:
    DidUpdateIndexedDatabase(u64 page_id, String update)
        : m_page_id(move(page_id))
        , m_update(move(update))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    String const& update() const { return m_update; }
    String take_update() { return move(m_update); }

private:
    u64 m_page_id;
    String m_update;
};

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(u64 new_page_id, String handle)
        : m_new_page_id(move(new_page_id))
        , m_handle(move(handle))
    {
    }

    DidRequestNewWebViewResponse(DidRequestNewWebViewResponse const&) = default;
    DidRequestNewWebViewResponse(DidRequestNewWebViewResponse&&) = default;
    DidRequestNewWebViewResponse& operator=(DidRequestNewWebViewResponse 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::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 new_page_id = TRY((decoder.decode<u64>()));
        auto handle = TRY((decoder.decode<String>()));
        return make<DidRequestNewWebViewResponse>(move(new_page_id), move(handle));
    }

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

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

    u64 new_page_id() const { return m_new_page_id; }

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

private:
    u64 m_new_page_id;
    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)
        : m_page_id(move(page_id))
        , m_activate_tab(move(activate_tab))
        , m_hints(move(hints))
    {
    }

    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>()));
        return make<DidRequestNewWebView>(move(page_id), move(activate_tab), move(hints));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Web::HTML::ActivateTab const& activate_tab, Web::HTML::WebViewHints const& hints)
    {
        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));
        return buffer;
    }

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

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

private:
    u64 m_page_id;
    Web::HTML::ActivateTab m_activate_tab;
    Web::HTML::WebViewHints m_hints;
};

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 DidChangeNeedsBeforeunloadCheck final : public IPC::Message {
public:
    DidChangeNeedsBeforeunloadCheck(u64 page_id, bool needs_beforeunload_check)
        : m_page_id(move(page_id))
        , m_needs_beforeunload_check(move(needs_beforeunload_check))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    bool needs_beforeunload_check() const { return m_needs_beforeunload_check; }

private:
    u64 m_page_id;
    bool m_needs_beforeunload_check;
};

class DidRequestTraverseTheHistoryByDeltaResponse final : public IPC::Message {
public:
    DidRequestTraverseTheHistoryByDeltaResponse(bool accepted)
        : m_accepted(move(accepted))
    {
    }

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

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

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

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

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

    bool accepted() const { return m_accepted; }

private:
    bool m_accepted;
};

class DidRequestTraverseTheHistoryByDelta final : public IPC::Message {
public:
    typedef class DidRequestTraverseTheHistoryByDeltaResponse ResponseType;

    DidRequestTraverseTheHistoryByDelta(u64 page_id, i32 delta, Web::HistoryTraversalPrecheck history_traversal_precheck)
        : m_page_id(move(page_id))
        , m_delta(move(delta))
        , m_history_traversal_precheck(move(history_traversal_precheck))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    i32 delta() const { return m_delta; }

    Web::HistoryTraversalPrecheck const& history_traversal_precheck() const { return m_history_traversal_precheck; }
    Web::HistoryTraversalPrecheck take_history_traversal_precheck() { return move(m_history_traversal_precheck); }

private:
    u64 m_page_id;
    i32 m_delta;
    Web::HistoryTraversalPrecheck m_history_traversal_precheck;
};

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

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    i32 delta() const { return m_delta; }

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

class DidRequestWebdriverLoadUrlFromUiResponse final : public IPC::Message {
public:
    DidRequestWebdriverLoadUrlFromUiResponse(Web::WebDriver::Response response)
        : m_response(move(response))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    DidRequestWebdriverLoadUrlFromUiResponse(WrappedReturnType&& value)
        : m_response(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::DidRequestWebdriverLoadUrlFromUiResponse; }
    static i32 static_message_id() { return (int)MessageID::DidRequestWebdriverLoadUrlFromUiResponse; }
    virtual StringView message_name() const override { return "WebContentClient::DidRequestWebdriverLoadUrlFromUiResponse"sv; }

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

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

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

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

private:
    Web::WebDriver::Response m_response;
};

class DidRequestWebdriverLoadUrlFromUi final : public IPC::Message {
public:
    typedef class DidRequestWebdriverLoadUrlFromUiResponse ResponseType;

    DidRequestWebdriverLoadUrlFromUi(u64 page_id, URL::URL url)
        : m_page_id(move(page_id))
        , m_url(move(url))
    {
    }

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

    static ErrorOr<NonnullOwnPtr<DidRequestWebdriverLoadUrlFromUi>> 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<DidRequestWebdriverLoadUrlFromUi>(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::DidRequestWebdriverLoadUrlFromUi));
        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 DidRequestWebdriverTraverseHistoryFromUiResponse final : public IPC::Message {
public:
    DidRequestWebdriverTraverseHistoryFromUiResponse(Web::WebDriver::Response response)
        : m_response(move(response))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    DidRequestWebdriverTraverseHistoryFromUiResponse(WrappedReturnType&& value)
        : m_response(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::DidRequestWebdriverTraverseHistoryFromUiResponse; }
    static i32 static_message_id() { return (int)MessageID::DidRequestWebdriverTraverseHistoryFromUiResponse; }
    virtual StringView message_name() const override { return "WebContentClient::DidRequestWebdriverTraverseHistoryFromUiResponse"sv; }

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

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

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

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

private:
    Web::WebDriver::Response m_response;
};

class DidRequestWebdriverTraverseHistoryFromUi final : public IPC::Message {
public:
    typedef class DidRequestWebdriverTraverseHistoryFromUiResponse ResponseType;

    DidRequestWebdriverTraverseHistoryFromUi(u64 page_id, i32 delta)
        : m_page_id(move(page_id))
        , m_delta(move(delta))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    i32 delta() const { return m_delta; }

private:
    u64 m_page_id;
    i32 m_delta;
};

class DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse final : public IPC::Message {
public:
    DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse(Web::WebDriver::Response response)
        : m_response(move(response))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse(WrappedReturnType&& value)
        : m_response(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::DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse; }
    static i32 static_message_id() { return (int)MessageID::DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse; }
    virtual StringView message_name() const override { return "WebContentClient::DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse"sv; }

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

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

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

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

private:
    Web::WebDriver::Response m_response;
};

class DidRequestWebdriverMarkWebContentSessionHistoryStale final : public IPC::Message {
public:
    typedef class DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse ResponseType;

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

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

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

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    DidRequestWebdriverSessionHistoryResponse(WrappedReturnType&& value)
        : m_response(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::DidRequestWebdriverSessionHistoryResponse; }
    static i32 static_message_id() { return (int)MessageID::DidRequestWebdriverSessionHistoryResponse; }
    virtual StringView message_name() const override { return "WebContentClient::DidRequestWebdriverSessionHistoryResponse"sv; }

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

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

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

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

private:
    Web::WebDriver::Response m_response;
};

class DidRequestWebdriverSessionHistory final : public IPC::Message {
public:
    typedef class DidRequestWebdriverSessionHistoryResponse ResponseType;

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

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

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

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

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

    static ErrorOr<NonnullOwnPtr<DidRequestWebdriverNavigationCompletion>> 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 page_load_timeout = TRY((decoder.decode<Optional<u64>>()));
        return make<DidRequestWebdriverNavigationCompletion>(move(page_id), move(request_id), move(page_load_timeout));
    }

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    Optional<u64> const& page_load_timeout() const { return m_page_load_timeout; }
    Optional<u64> take_page_load_timeout() { return move(m_page_load_timeout); }

private:
    u64 m_page_id;
    u64 m_request_id;
    Optional<u64> m_page_load_timeout;
};

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 DidUpdateInputMethodState final : public IPC::Message {
public:
    DidUpdateInputMethodState(u64 page_id, Optional<Web::DevicePixelRect> caret_rect, bool is_enabled, i32 cursor_position, i32 anchor_position, Utf16String text_before_cursor, Utf16String text_after_cursor)
        : m_page_id(move(page_id))
        , m_caret_rect(move(caret_rect))
        , m_is_enabled(move(is_enabled))
        , m_cursor_position(move(cursor_position))
        , m_anchor_position(move(anchor_position))
        , m_text_before_cursor(move(text_before_cursor))
        , m_text_after_cursor(move(text_after_cursor))
    {
    }

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

    static ErrorOr<NonnullOwnPtr<DidUpdateInputMethodState>> decode(Stream& stream, Queue<IPC::Attachment>& attachments)
    {
        IPC::Decoder decoder { stream, attachments };
        auto page_id = TRY((decoder.decode<u64>()));
        auto caret_rect = TRY((decoder.decode<Optional<Web::DevicePixelRect>>()));
        auto is_enabled = TRY((decoder.decode<bool>()));
        auto cursor_position = TRY((decoder.decode<i32>()));
        auto anchor_position = TRY((decoder.decode<i32>()));
        auto text_before_cursor = TRY((decoder.decode<Utf16String>()));
        auto text_after_cursor = TRY((decoder.decode<Utf16String>()));
        return make<DidUpdateInputMethodState>(move(page_id), move(caret_rect), move(is_enabled), move(cursor_position), move(anchor_position), move(text_before_cursor), move(text_after_cursor));
    }

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, Optional<Web::DevicePixelRect> const& caret_rect, bool is_enabled, i32 cursor_position, i32 anchor_position, Utf16View const& text_before_cursor, Utf16View const& text_after_cursor)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidUpdateInputMethodState));
        TRY(stream.encode(page_id));
        TRY(stream.encode(caret_rect));
        TRY(stream.encode(is_enabled));
        TRY(stream.encode(cursor_position));
        TRY(stream.encode(anchor_position));
        TRY(stream.encode(text_before_cursor));
        TRY(stream.encode(text_after_cursor));
        return buffer;
    }

    virtual ErrorOr<IPC::MessageBuffer> encode() const override
    {
        return static_encode(m_page_id, m_caret_rect, m_is_enabled, m_cursor_position, m_anchor_position, m_text_before_cursor, m_text_after_cursor);
    }

    u64 page_id() const { return m_page_id; }

    Optional<Web::DevicePixelRect> const& caret_rect() const { return m_caret_rect; }
    Optional<Web::DevicePixelRect> take_caret_rect() { return move(m_caret_rect); }

    bool is_enabled() const { return m_is_enabled; }

    i32 cursor_position() const { return m_cursor_position; }

    i32 anchor_position() const { return m_anchor_position; }

    Utf16String const& text_before_cursor() const { return m_text_before_cursor; }
    Utf16String take_text_before_cursor() { return move(m_text_before_cursor); }

    Utf16String const& text_after_cursor() const { return m_text_after_cursor; }
    Utf16String take_text_after_cursor() { return move(m_text_after_cursor); }

private:
    u64 m_page_id;
    Optional<Web::DevicePixelRect> m_caret_rect;
    bool m_is_enabled;
    i32 m_cursor_position;
    i32 m_anchor_position;
    Utf16String m_text_before_cursor;
    Utf16String m_text_after_cursor;
};

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 DidChangeBackgroundColor final : public IPC::Message {
public:
    DidChangeBackgroundColor(u64 page_id, Gfx::Color color)
        : m_page_id(move(page_id))
        , m_color(move(color))
    {
    }

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

    static ErrorOr<NonnullOwnPtr<DidChangeBackgroundColor>> 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<DidChangeBackgroundColor>(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::DidChangeBackgroundColor));
        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 DidRequestPrimaryPaste final : public IPC::Message {
public:
    DidRequestPrimaryPaste(u64 page_id)
        : m_page_id(move(page_id))
    {
    }

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

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

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

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

    static ErrorOr<NonnullOwnPtr<DidUpdatePrimarySelection>> 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<DidUpdatePrimarySelection>(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::DidUpdatePrimarySelection));
        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 DidUpdateSessionHistory final : public IPC::Message {
public:
    DidUpdateSessionHistory(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
        : m_page_id(move(page_id))
        , m_entries(move(entries))
        , m_used_steps(move(used_steps))
        , m_current_used_step_index(move(current_used_step_index))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    Vector<i32> const& used_steps() const { return m_used_steps; }
    Vector<i32> take_used_steps() { return move(m_used_steps); }

    size_t current_used_step_index() const { return m_current_used_step_index; }

private:
    u64 m_page_id;
    Vector<Web::HTML::SessionHistoryEntryDescriptor> m_entries;
    Vector<i32> m_used_steps;
    size_t m_current_used_step_index;
};

class DidRequestUiProcessSessionHistoryForTestingResponse final : public IPC::Message {
public:
    DidRequestUiProcessSessionHistoryForTestingResponse(String session_history)
        : m_session_history(move(session_history))
    {
    }

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

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

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

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

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

    String const& session_history() const { return m_session_history; }
    String take_session_history() { return move(m_session_history); }

private:
    String m_session_history;
};

class DidRequestUiProcessSessionHistoryForTesting final : public IPC::Message {
public:
    typedef class DidRequestUiProcessSessionHistoryForTestingResponse ResponseType;

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

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

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

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

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

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

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

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

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

    String const& process_tree() const { return m_process_tree; }
    String take_process_tree() { return move(m_process_tree); }

private:
    String m_process_tree;
};

class DidRequestSiteIsolationProcessTreeForTesting final : public IPC::Message {
public:
    typedef class DidRequestSiteIsolationProcessTreeForTestingResponse ResponseType;

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

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

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

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

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

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

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

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

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

    String const& session_history() const { return m_session_history; }
    String take_session_history() { return move(m_session_history); }

private:
    String m_session_history;
};

class DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting final : public IPC::Message {
public:
    typedef class DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTestingResponse ResponseType;

    DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
        : m_page_id(move(page_id))
        , m_entries(move(entries))
        , m_used_steps(move(used_steps))
        , m_current_used_step_index(move(current_used_step_index))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

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

    Vector<i32> const& used_steps() const { return m_used_steps; }
    Vector<i32> take_used_steps() { return move(m_used_steps); }

    size_t current_used_step_index() const { return m_current_used_step_index; }

private:
    u64 m_page_id;
    Vector<Web::HTML::SessionHistoryEntryDescriptor> m_entries;
    Vector<i32> m_used_steps;
    size_t m_current_used_step_index;
};

class DidSetTopLevelSessionHistory final : public IPC::Message {
public:
    DidSetTopLevelSessionHistory(u64 page_id, bool accepted, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
        : m_page_id(move(page_id))
        , m_accepted(move(accepted))
        , m_entries(move(entries))
        , m_used_steps(move(used_steps))
        , m_current_used_step_index(move(current_used_step_index))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    bool accepted() const { return m_accepted; }

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

    Vector<i32> const& used_steps() const { return m_used_steps; }
    Vector<i32> take_used_steps() { return move(m_used_steps); }

    size_t current_used_step_index() const { return m_current_used_step_index; }

private:
    u64 m_page_id;
    bool m_accepted;
    Vector<Web::HTML::SessionHistoryEntryDescriptor> m_entries;
    Vector<i32> m_used_steps;
    size_t m_current_used_step_index;
};

class DidTraverseTheHistoryToStep final : public IPC::Message {
public:
    DidTraverseTheHistoryToStep(u64 page_id, i32 step, bool step_was_available, Web::HTML::HistoryStepResult result)
        : m_page_id(move(page_id))
        , m_step(move(step))
        , m_step_was_available(move(step_was_available))
        , m_result(move(result))
    {
    }

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(u64 page_id, i32 step, bool step_was_available, Web::HTML::HistoryStepResult const& result)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::DidTraverseTheHistoryToStep));
        TRY(stream.encode(page_id));
        TRY(stream.encode(step));
        TRY(stream.encode(step_was_available));
        TRY(stream.encode(result));
        return buffer;
    }

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

    u64 page_id() const { return m_page_id; }

    i32 step() const { return m_step; }

    bool step_was_available() const { return m_step_was_available; }

    Web::HTML::HistoryStepResult const& result() const { return m_result; }
    Web::HTML::HistoryStepResult take_result() { return move(m_result); }

private:
    u64 m_page_id;
    i32 m_step;
    bool m_step_was_available;
    Web::HTML::HistoryStepResult m_result;
};

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

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

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

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

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

    u64 page_id() const { return m_page_id; }

    u64 request_id() const { return m_request_id; }

    i32 step() const { return m_step; }

    bool canceled() const { return m_canceled; }

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

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

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

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

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

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::ScreenWakeLockState const& wake_lock_state() const { return m_wake_lock_state; }
    Web::ScreenWakeLockState take_wake_lock_state() { return move(m_wake_lock_state); }

private:
    u64 m_page_id;
    Web::ScreenWakeLockState m_wake_lock_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 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 StartWorkerAgentResponse final : public IPC::Message {
public:
    StartWorkerAgentResponse(Web::HTML::WorkerAgentId agent_id)
        : m_agent_id(move(agent_id))
    {
    }

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

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

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

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

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

    Web::HTML::WorkerAgentId const& agent_id() const { return m_agent_id; }
    Web::HTML::WorkerAgentId take_agent_id() { return move(m_agent_id); }

private:
    Web::HTML::WorkerAgentId m_agent_id;
};

class StartWorkerAgent final : public IPC::Message {
public:
    typedef class StartWorkerAgentResponse ResponseType;

    StartWorkerAgent(u64 page_id, Web::HTML::WorkerAgentStartRequest request)
        : m_page_id(move(page_id))
        , m_request(move(request))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::WorkerAgentStartRequest const& request() const { return m_request; }
    Web::HTML::WorkerAgentStartRequest take_request() { return move(m_request); }

private:
    u64 m_page_id;
    Web::HTML::WorkerAgentStartRequest m_request;
};

class CloseWorkerAgent final : public IPC::Message {
public:
    CloseWorkerAgent(u64 page_id, Web::HTML::WorkerAgentId agent_id, Web::HTML::WorkerAgentOwnerToken owner_token)
        : m_page_id(move(page_id))
        , m_agent_id(move(agent_id))
        , m_owner_token(move(owner_token))
    {
    }

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

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

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

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

    u64 page_id() const { return m_page_id; }

    Web::HTML::WorkerAgentId const& agent_id() const { return m_agent_id; }
    Web::HTML::WorkerAgentId take_agent_id() { return move(m_agent_id); }

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

private:
    u64 m_page_id;
    Web::HTML::WorkerAgentId m_agent_id;
    Web::HTML::WorkerAgentOwnerToken m_owner_token;
};

} // 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)
    {
    }

    Web::Compositor::CompositorContextId allocate_compositor_context_id(u64 page_id, Web::Compositor::PagePresentationRegistration page_presentation_registration)
    {
        return m_connection.template send_sync<Messages::WebContentClient::AllocateCompositorContextId>(page_id, move(page_presentation_registration))->take_context_id();
    }

    void async_allocate_compositor_context_id(u64 page_id, Web::Compositor::PagePresentationRegistration const& page_presentation_registration)
    {
        auto message_buffer = MUST(Messages::WebContentClient::AllocateCompositorContextId::static_encode(page_id, move(page_presentation_registration)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::Compositor::CompositorContextId> try_allocate_compositor_context_id(u64 page_id, Web::Compositor::PagePresentationRegistration page_presentation_registration)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::AllocateCompositorContextId>(page_id, move(page_presentation_registration)))
            return result->take_context_id();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_destroy_compositor_context(Web::Compositor::CompositorContextId const& context_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidDestroyCompositorContext::static_encode(move(context_id)));
        (void)m_connection.post_message(message_buffer);
    }

    Web::NavigationProcessDecision decide_navigation_process(u64 page_id, Optional<Web::HTML::NavigableId> frame_id, URL::URL current_url, URL::URL target_url, Web::NavigationTarget target)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DecideNavigationProcess>(page_id, move(frame_id), move(current_url), move(target_url), move(target))->take_decision();
    }

    void async_decide_navigation_process(u64 page_id, Optional<Web::HTML::NavigableId> const& frame_id, URL::URL const& current_url, URL::URL const& target_url, Web::NavigationTarget const& target)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DecideNavigationProcess::static_encode(page_id, move(frame_id), move(current_url), move(target_url), move(target)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::NavigationProcessDecision> try_decide_navigation_process(u64 page_id, Optional<Web::HTML::NavigableId> frame_id, URL::URL current_url, URL::URL target_url, Web::NavigationTarget target)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DecideNavigationProcess>(page_id, move(frame_id), move(current_url), move(target_url), move(target)))
            return result->take_decision();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_request_new_process_for_navigation(u64 page_id, URL::URL const& url, Variant<Empty, String, Web::HTML::POSTResource> const& document_resource, Web::Bindings::NavigationHistoryBehavior const& history_handling)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestNewProcessForNavigation::static_encode(page_id, move(url), move(document_resource), move(history_handling)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_new_process_for_child_frame_navigation(u64 page_id, Web::HTML::NavigableId const& frame_id, URL::URL const& url, Variant<Empty, String, Web::HTML::POSTResource> const& document_resource, Web::Bindings::NavigationHistoryBehavior const& history_handling)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestNewProcessForChildFrameNavigation::static_encode(page_id, move(frame_id), move(url), move(document_resource), move(history_handling)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_create_child_frame(u64 page_id, Web::HTML::NavigableId const& parent_frame_id, Web::HTML::NavigableId const& frame_id, Web::HTML::ReplicatedNavigableState const& replicated_state)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidCreateChildFrame::static_encode(page_id, move(parent_frame_id), move(frame_id), move(replicated_state)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_update_child_frame_viewport(u64 page_id, Web::HTML::NavigableId const& frame_id, Web::DevicePixelRect viewport_rect, double device_pixel_ratio)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateChildFrameViewport::static_encode(page_id, move(frame_id), viewport_rect, device_pixel_ratio));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_commit_child_frame_navigation(u64 page_id, Web::HTML::NavigableId const& frame_id, Web::HTML::ReplicatedNavigableState const& replicated_state)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidCommitChildFrameNavigation::static_encode(page_id, move(frame_id), move(replicated_state)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_change_top_level_active_document(u64 page_id, Web::HTML::ReplicatedNavigableState const& replicated_state)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeTopLevelActiveDocument::static_encode(page_id, move(replicated_state)));
        (void)m_connection.post_message(message_buffer);
    }

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

    void async_did_start_webdriver_navigation(u64 page_id, URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidStartWebdriverNavigation::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, Variant<Empty, String, Web::HTML::POSTResource> const& document_resource, bool is_redirect, Web::Bindings::NavigationHistoryBehavior const& history_handling)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidStartLoading::static_encode(page_id, move(url), move(document_resource), is_redirect, move(history_handling)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_cancel_loading(u64 page_id, URL::URL const& url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidCancelLoading::static_encode(page_id, move(url)));
        (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);
    }

    Optional<u64> did_start_download_without_request(u64 page_id, URL::URL url, ByteString suggested_filename, Optional<u64> total_size)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidStartDownloadWithoutRequest>(page_id, move(url), move(suggested_filename), move(total_size))->take_download_id();
    }

    void async_did_start_download_without_request(u64 page_id, URL::URL const& url, StringView suggested_filename, Optional<u64> const& total_size)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidStartDownloadWithoutRequest::static_encode(page_id, move(url), suggested_filename, move(total_size)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Optional<u64>> try_did_start_download_without_request(u64 page_id, URL::URL url, ByteString suggested_filename, Optional<u64> total_size)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidStartDownloadWithoutRequest>(page_id, move(url), move(suggested_filename), move(total_size)))
            return result->take_download_id();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Optional<u64> did_start_download(u64 page_id, URL::URL url, ByteString suggested_filename, Optional<u64> total_size, int request_server_client_id, u64 request_server_request_id, ByteBuffer initial_data)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidStartDownload>(page_id, move(url), move(suggested_filename), move(total_size), request_server_client_id, request_server_request_id, move(initial_data))->take_download_id();
    }

    void async_did_start_download(u64 page_id, URL::URL const& url, StringView suggested_filename, Optional<u64> const& total_size, int request_server_client_id, u64 request_server_request_id, ReadonlyBytes initial_data)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidStartDownload::static_encode(page_id, move(url), suggested_filename, move(total_size), request_server_client_id, request_server_request_id, initial_data));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Optional<u64>> try_did_start_download(u64 page_id, URL::URL url, ByteString suggested_filename, Optional<u64> total_size, int request_server_client_id, u64 request_server_request_id, ByteBuffer initial_data)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidStartDownload>(page_id, move(url), move(suggested_filename), move(total_size), request_server_client_id, request_server_request_id, move(initial_data)))
            return result->take_download_id();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_receive_download_data(u64 page_id, u64 download_id, ReadonlyBytes data)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidReceiveDownloadData::static_encode(page_id, download_id, data));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_finish_download(u64 page_id, u64 download_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidFinishDownload::static_encode(page_id, download_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_fail_download(u64 page_id, u64 download_id, StringView error)
    {
        VERIFY(Utf8View { error }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidFailDownload::static_encode(page_id, download_id, error));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_fail_download(u64 page_id, u64 download_id, String const& error)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidFailDownload::static_encode(page_id, download_id, error));
        (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_storage(u64 page_id, u64 request_id, StringView storage_items)
    {
        VERIFY(Utf8View { storage_items }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectStorage::static_encode(page_id, request_id, storage_items));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_storage(u64 page_id, u64 request_id, String const& storage_items)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectStorage::static_encode(page_id, request_id, storage_items));
        (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_grid_layouts(u64 page_id, StringView grid_layouts)
    {
        VERIFY(Utf8View { grid_layouts }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectGridLayouts::static_encode(page_id, grid_layouts));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_grid_layouts(u64 page_id, String const& grid_layouts)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectGridLayouts::static_encode(page_id, grid_layouts));
        (void)m_connection.post_message(message_buffer);
    }

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

    void async_did_inspect_current_grid(u64 page_id, String const& grid_layout)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectCurrentGrid::static_encode(page_id, grid_layout));
        (void)m_connection.post_message(message_buffer);
    }

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

    void async_did_inspect_current_flexbox(u64 page_id, String const& flexbox_layout)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectCurrentFlexbox::static_encode(page_id, flexbox_layout));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_indexed_database(u64 page_id, u64 request_id, StringView result)
    {
        VERIFY(Utf8View { result }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectIndexedDatabase::static_encode(page_id, request_id, result));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_inspect_indexed_database(u64 page_id, u64 request_id, String const& result)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidInspectIndexedDatabase::static_encode(page_id, request_id, result));
        (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_get_node_id_at_position(u64 page_id, u64 request_id, Web::UniqueNodeID const& node_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidGetNodeIdAtPosition::static_encode(page_id, request_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_list_devtools_sources(u64 page_id, u64 request_id, ReadonlySpan<Web::HTML::ScriptRegistry::Description> sources)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidListDevtoolsSources::static_encode(page_id, request_id, sources));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_get_devtools_source(u64 page_id, Web::HTML::ScriptRegistry::Identifier const& source_id, Optional<Web::HTML::ScriptRegistry::Content> const& source)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidGetDevtoolsSource::static_encode(page_id, move(source_id), move(source)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_add_devtools_source(u64 page_id, Web::HTML::ScriptRegistry::Description const& source)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidAddDevtoolsSource::static_encode(page_id, move(source)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_resolve_dom_node_url(u64 page_id, u64 request_id, StringView resolved_url)
    {
        VERIFY(Utf8View { resolved_url }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidResolveDomNodeUrl::static_encode(page_id, request_id, resolved_url));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_resolve_dom_node_url(u64 page_id, u64 request_id, String const& resolved_url)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidResolveDomNodeUrl::static_encode(page_id, request_id, resolved_url));
        (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 result->take_cookies();
        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 result->take_cookies();
        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 result->take_cookie();
        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 result->take_cookie();
        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);
    }

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

    void async_did_store_hsts_policy(StringView domain, HTTP::HSTS::ParsedHSTSPolicy const& policy)
    {
        VERIFY(Utf8View { domain }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidStoreHstsPolicy::static_encode(domain, move(policy)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_store_hsts_policy(String const& domain, HTTP::HSTS::ParsedHSTSPolicy const& policy)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidStoreHstsPolicy::static_encode(domain, move(policy)));
        (void)m_connection.post_message(message_buffer);
    }

    bool did_is_known_hsts_host(String domain)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidIsKnownHstsHost>(move(domain))->result();
    }

    void async_did_is_known_hsts_host(StringView domain)
    {
        VERIFY(Utf8View { domain }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidIsKnownHstsHost::static_encode(domain));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_is_known_hsts_host(String const& domain)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidIsKnownHstsHost::static_encode(domain));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<bool> try_did_is_known_hsts_host(String domain)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidIsKnownHstsHost>(move(domain)))
            return result->result();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    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 result->take_value();
        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 result->take_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 result->take_keys();
        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;
    }

    u64 did_request_storage_usage(String storage_key)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestStorageUsage>(move(storage_key))->usage();
    }

    void async_did_request_storage_usage(StringView storage_key)
    {
        VERIFY(Utf8View { storage_key }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestStorageUsage::static_encode(storage_key));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_request_storage_usage(String const& storage_key)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestStorageUsage::static_encode(storage_key));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<u64> try_did_request_storage_usage(String storage_key)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestStorageUsage>(move(storage_key)))
            return result->usage();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_change_storage_item(u64 page_id, Web::StorageAPI::StorageEndpointType const& storage_endpoint, StringView url, Optional<String> const& key, Optional<String> const& old_value, Optional<String> const& new_value)
    {
        VERIFY(Utf8View { url }.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeStorageItem::static_encode(page_id, move(storage_endpoint), url, move(key), move(old_value), move(new_value)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_change_storage_item(u64 page_id, Web::StorageAPI::StorageEndpointType const& storage_endpoint, String const& url, Optional<String> const& key, Optional<String> const& old_value, Optional<String> const& new_value)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeStorageItem::static_encode(page_id, move(storage_endpoint), url, move(key), move(old_value), move(new_value)));
        (void)m_connection.post_message(message_buffer);
    }

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

    void async_did_update_indexed_database(u64 page_id, String const& update)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateIndexedDatabase::static_encode(page_id, update));
        (void)m_connection.post_message(message_buffer);
    }

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

    Messages::WebContentClient::DidRequestNewWebViewResponse did_request_new_web_view(u64 page_id, Web::HTML::ActivateTab activate_tab, Web::HTML::WebViewHints hints)
    {
        return move(*m_connection.template send_sync<Messages::WebContentClient::DidRequestNewWebView>(page_id, move(activate_tab), move(hints)));
    }

    void async_did_request_new_web_view(u64 page_id, Web::HTML::ActivateTab const& activate_tab, Web::HTML::WebViewHints const& hints)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestNewWebView::static_encode(page_id, move(activate_tab), move(hints)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Messages::WebContentClient::DidRequestNewWebViewResponse> try_did_request_new_web_view(u64 page_id, Web::HTML::ActivateTab activate_tab, Web::HTML::WebViewHints hints)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestNewWebView>(page_id, move(activate_tab), move(hints)))
            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_change_needs_beforeunload_check(u64 page_id, bool needs_beforeunload_check)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeNeedsBeforeunloadCheck::static_encode(page_id, needs_beforeunload_check));
        (void)m_connection.post_message(message_buffer);
    }

    bool did_request_traverse_the_history_by_delta(u64 page_id, i32 delta, Web::HistoryTraversalPrecheck history_traversal_precheck)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestTraverseTheHistoryByDelta>(page_id, delta, move(history_traversal_precheck))->accepted();
    }

    void async_did_request_traverse_the_history_by_delta(u64 page_id, i32 delta, Web::HistoryTraversalPrecheck const& history_traversal_precheck)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestTraverseTheHistoryByDelta::static_encode(page_id, delta, move(history_traversal_precheck)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<bool> try_did_request_traverse_the_history_by_delta(u64 page_id, i32 delta, Web::HistoryTraversalPrecheck history_traversal_precheck)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestTraverseTheHistoryByDelta>(page_id, delta, move(history_traversal_precheck)))
            return result->accepted();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_request_webdriver_history_traversal(u64 page_id, u64 request_id, i32 delta)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestWebdriverHistoryTraversal::static_encode(page_id, request_id, delta));
        (void)m_connection.post_message(message_buffer);
    }

    Web::WebDriver::Response did_request_webdriver_load_url_from_ui(u64 page_id, URL::URL url)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestWebdriverLoadUrlFromUi>(page_id, move(url))->take_response();
    }

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

    IPC::IPCErrorOr<Web::WebDriver::Response> try_did_request_webdriver_load_url_from_ui(u64 page_id, URL::URL url)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestWebdriverLoadUrlFromUi>(page_id, move(url)))
            return result->take_response();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response did_request_webdriver_traverse_history_from_ui(u64 page_id, i32 delta)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestWebdriverTraverseHistoryFromUi>(page_id, delta)->take_response();
    }

    void async_did_request_webdriver_traverse_history_from_ui(u64 page_id, i32 delta)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestWebdriverTraverseHistoryFromUi::static_encode(page_id, delta));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_did_request_webdriver_traverse_history_from_ui(u64 page_id, i32 delta)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestWebdriverTraverseHistoryFromUi>(page_id, delta))
            return result->take_response();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response did_request_webdriver_mark_web_content_session_history_stale(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestWebdriverMarkWebContentSessionHistoryStale>(page_id)->take_response();
    }

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

    IPC::IPCErrorOr<Web::WebDriver::Response> try_did_request_webdriver_mark_web_content_session_history_stale(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestWebdriverMarkWebContentSessionHistoryStale>(page_id))
            return result->take_response();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response did_request_webdriver_session_history(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestWebdriverSessionHistory>(page_id)->take_response();
    }

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

    IPC::IPCErrorOr<Web::WebDriver::Response> try_did_request_webdriver_session_history(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestWebdriverSessionHistory>(page_id))
            return result->take_response();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_request_webdriver_navigation_completion(u64 page_id, u64 request_id, Optional<u64> const& page_load_timeout)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestWebdriverNavigationCompletion::static_encode(page_id, request_id, move(page_load_timeout)));
        (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_update_input_method_state(u64 page_id, Optional<Web::DevicePixelRect> const& caret_rect, bool is_enabled, i32 cursor_position, i32 anchor_position, Utf16View const& text_before_cursor, Utf16View const& text_after_cursor)
    {
        VERIFY(text_before_cursor.validate());
        VERIFY(text_after_cursor.validate());
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateInputMethodState::static_encode(page_id, move(caret_rect), is_enabled, cursor_position, anchor_position, move(text_before_cursor), move(text_after_cursor)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_update_input_method_state(u64 page_id, Optional<Web::DevicePixelRect> const& caret_rect, bool is_enabled, i32 cursor_position, i32 anchor_position, Utf16String const& text_before_cursor, Utf16String const& text_after_cursor)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateInputMethodState::static_encode(page_id, move(caret_rect), is_enabled, cursor_position, anchor_position, move(text_before_cursor), move(text_after_cursor)));
        (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_change_background_color(u64 page_id, Gfx::Color color)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeBackgroundColor::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_request_primary_paste(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidRequestPrimaryPaste::static_encode(page_id));
        (void)m_connection.post_message(message_buffer);
    }

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

    void async_did_update_primary_selection(u64 page_id, String const& text)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdatePrimarySelection::static_encode(page_id, text));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_update_session_history(u64 page_id, ReadonlySpan<Web::HTML::SessionHistoryEntryDescriptor> entries, ReadonlySpan<i32> used_steps, size_t current_used_step_index)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateSessionHistory::static_encode(page_id, entries, used_steps, current_used_step_index));
        (void)m_connection.post_message(message_buffer);
    }

    String did_request_ui_process_session_history_for_testing(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestUiProcessSessionHistoryForTesting>(page_id)->take_session_history();
    }

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

    IPC::IPCErrorOr<String> try_did_request_ui_process_session_history_for_testing(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestUiProcessSessionHistoryForTesting>(page_id))
            return result->take_session_history();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    String did_request_site_isolation_process_tree_for_testing(u64 page_id)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidRequestSiteIsolationProcessTreeForTesting>(page_id)->take_process_tree();
    }

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

    IPC::IPCErrorOr<String> try_did_request_site_isolation_process_tree_for_testing(u64 page_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidRequestSiteIsolationProcessTreeForTesting>(page_id))
            return result->take_process_tree();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    String did_update_session_history_and_request_ui_process_session_history_for_testing(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
    {
        return m_connection.template send_sync<Messages::WebContentClient::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting>(page_id, move(entries), move(used_steps), current_used_step_index)->take_session_history();
    }

    void async_did_update_session_history_and_request_ui_process_session_history_for_testing(u64 page_id, ReadonlySpan<Web::HTML::SessionHistoryEntryDescriptor> entries, ReadonlySpan<i32> used_steps, size_t current_used_step_index)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting::static_encode(page_id, entries, used_steps, current_used_step_index));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<String> try_did_update_session_history_and_request_ui_process_session_history_for_testing(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting>(page_id, move(entries), move(used_steps), current_used_step_index))
            return result->take_session_history();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_did_set_top_level_session_history(u64 page_id, bool accepted, ReadonlySpan<Web::HTML::SessionHistoryEntryDescriptor> entries, ReadonlySpan<i32> used_steps, size_t current_used_step_index)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidSetTopLevelSessionHistory::static_encode(page_id, accepted, entries, used_steps, current_used_step_index));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_traverse_the_history_to_step(u64 page_id, i32 step, bool step_was_available, Web::HTML::HistoryStepResult const& result)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidTraverseTheHistoryToStep::static_encode(page_id, step, step_was_available, move(result)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_check_if_traverse_history_step_is_canceled(u64 page_id, u64 request_id, i32 step, bool canceled)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidCheckIfTraverseHistoryStepIsCanceled::static_encode(page_id, request_id, step, canceled));
        (void)m_connection.post_message(message_buffer);
    }

    void async_did_reset_session_history_for_testing(u64 page_id)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidResetSessionHistoryForTesting::static_encode(page_id));
        (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_change_screen_wake_lock_state(u64 page_id, Web::ScreenWakeLockState const& wake_lock_state)
    {
        auto message_buffer = MUST(Messages::WebContentClient::DidChangeScreenWakeLockState::static_encode(page_id, move(wake_lock_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_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);
    }

    Web::HTML::WorkerAgentId start_worker_agent(u64 page_id, Web::HTML::WorkerAgentStartRequest request)
    {
        return m_connection.template send_sync<Messages::WebContentClient::StartWorkerAgent>(page_id, move(request))->take_agent_id();
    }

    void async_start_worker_agent(u64 page_id, Web::HTML::WorkerAgentStartRequest const& request)
    {
        auto message_buffer = MUST(Messages::WebContentClient::StartWorkerAgent::static_encode(page_id, move(request)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::HTML::WorkerAgentId> try_start_worker_agent(u64 page_id, Web::HTML::WorkerAgentStartRequest request)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebContentClient::StartWorkerAgent>(page_id, move(request)))
            return result->take_agent_id();
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_close_worker_agent(u64 page_id, Web::HTML::WorkerAgentId const& agent_id, Web::HTML::WorkerAgentOwnerToken const& owner_token)
    {
        auto message_buffer = MUST(Messages::WebContentClient::CloseWorkerAgent::static_encode(page_id, move(agent_id), move(owner_token)));
        (void)m_connection.post_message(message_buffer);
    }

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::AllocateCompositorContextId:
            return Messages::WebContentClient::AllocateCompositorContextId::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::AllocateCompositorContextIdResponse:
            return Messages::WebContentClient::AllocateCompositorContextIdResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidDestroyCompositorContext:
            return Messages::WebContentClient::DidDestroyCompositorContext::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DecideNavigationProcess:
            return Messages::WebContentClient::DecideNavigationProcess::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DecideNavigationProcessResponse:
            return Messages::WebContentClient::DecideNavigationProcessResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestNewProcessForNavigation:
            return Messages::WebContentClient::DidRequestNewProcessForNavigation::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestNewProcessForChildFrameNavigation:
            return Messages::WebContentClient::DidRequestNewProcessForChildFrameNavigation::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidCreateChildFrame:
            return Messages::WebContentClient::DidCreateChildFrame::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdateChildFrameViewport:
            return Messages::WebContentClient::DidUpdateChildFrameViewport::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidCommitChildFrameNavigation:
            return Messages::WebContentClient::DidCommitChildFrameNavigation::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeTopLevelActiveDocument:
            return Messages::WebContentClient::DidChangeTopLevelActiveDocument::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidDestroyChildFrame:
            return Messages::WebContentClient::DidDestroyChildFrame::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStartWebdriverNavigation:
            return Messages::WebContentClient::DidStartWebdriverNavigation::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStartLoading:
            return Messages::WebContentClient::DidStartLoading::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidCancelLoading:
            return Messages::WebContentClient::DidCancelLoading::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFinishLoading:
            return Messages::WebContentClient::DidFinishLoading::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStartDownloadWithoutRequest:
            return Messages::WebContentClient::DidStartDownloadWithoutRequest::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStartDownloadWithoutRequestResponse:
            return Messages::WebContentClient::DidStartDownloadWithoutRequestResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStartDownload:
            return Messages::WebContentClient::DidStartDownload::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStartDownloadResponse:
            return Messages::WebContentClient::DidStartDownloadResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidReceiveDownloadData:
            return Messages::WebContentClient::DidReceiveDownloadData::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFinishDownload:
            return Messages::WebContentClient::DidFinishDownload::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidFailDownload:
            return Messages::WebContentClient::DidFailDownload::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::DidInspectStorage:
            return Messages::WebContentClient::DidInspectStorage::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInspectDomNode:
            return Messages::WebContentClient::DidInspectDomNode::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInspectGridLayouts:
            return Messages::WebContentClient::DidInspectGridLayouts::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInspectCurrentGrid:
            return Messages::WebContentClient::DidInspectCurrentGrid::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInspectCurrentFlexbox:
            return Messages::WebContentClient::DidInspectCurrentFlexbox::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidInspectIndexedDatabase:
            return Messages::WebContentClient::DidInspectIndexedDatabase::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::DidGetNodeIdAtPosition:
            return Messages::WebContentClient::DidGetNodeIdAtPosition::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::DidListDevtoolsSources:
            return Messages::WebContentClient::DidListDevtoolsSources::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidGetDevtoolsSource:
            return Messages::WebContentClient::DidGetDevtoolsSource::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidAddDevtoolsSource:
            return Messages::WebContentClient::DidAddDevtoolsSource::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidResolveDomNodeUrl:
            return Messages::WebContentClient::DidResolveDomNodeUrl::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::DidRequestDeleteAllCookies:
            return Messages::WebContentClient::DidRequestDeleteAllCookies::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidStoreHstsPolicy:
            return Messages::WebContentClient::DidStoreHstsPolicy::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidIsKnownHstsHost:
            return Messages::WebContentClient::DidIsKnownHstsHost::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidIsKnownHstsHostResponse:
            return Messages::WebContentClient::DidIsKnownHstsHostResponse::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::DidRequestStorageUsage:
            return Messages::WebContentClient::DidRequestStorageUsage::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestStorageUsageResponse:
            return Messages::WebContentClient::DidRequestStorageUsageResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeStorageItem:
            return Messages::WebContentClient::DidChangeStorageItem::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdateIndexedDatabase:
            return Messages::WebContentClient::DidUpdateIndexedDatabase::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::DidChangeNeedsBeforeunloadCheck:
            return Messages::WebContentClient::DidChangeNeedsBeforeunloadCheck::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestTraverseTheHistoryByDelta:
            return Messages::WebContentClient::DidRequestTraverseTheHistoryByDelta::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestTraverseTheHistoryByDeltaResponse:
            return Messages::WebContentClient::DidRequestTraverseTheHistoryByDeltaResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverHistoryTraversal:
            return Messages::WebContentClient::DidRequestWebdriverHistoryTraversal::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverLoadUrlFromUi:
            return Messages::WebContentClient::DidRequestWebdriverLoadUrlFromUi::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverLoadUrlFromUiResponse:
            return Messages::WebContentClient::DidRequestWebdriverLoadUrlFromUiResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverTraverseHistoryFromUi:
            return Messages::WebContentClient::DidRequestWebdriverTraverseHistoryFromUi::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverTraverseHistoryFromUiResponse:
            return Messages::WebContentClient::DidRequestWebdriverTraverseHistoryFromUiResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverMarkWebContentSessionHistoryStale:
            return Messages::WebContentClient::DidRequestWebdriverMarkWebContentSessionHistoryStale::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse:
            return Messages::WebContentClient::DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverSessionHistory:
            return Messages::WebContentClient::DidRequestWebdriverSessionHistory::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverSessionHistoryResponse:
            return Messages::WebContentClient::DidRequestWebdriverSessionHistoryResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverNavigationCompletion:
            return Messages::WebContentClient::DidRequestWebdriverNavigationCompletion::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::DidUpdateInputMethodState:
            return Messages::WebContentClient::DidUpdateInputMethodState::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeThemeColor:
            return Messages::WebContentClient::DidChangeThemeColor::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeBackgroundColor:
            return Messages::WebContentClient::DidChangeBackgroundColor::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::DidRequestPrimaryPaste:
            return Messages::WebContentClient::DidRequestPrimaryPaste::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdatePrimarySelection:
            return Messages::WebContentClient::DidUpdatePrimarySelection::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdateSessionHistory:
            return Messages::WebContentClient::DidUpdateSessionHistory::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestUiProcessSessionHistoryForTesting:
            return Messages::WebContentClient::DidRequestUiProcessSessionHistoryForTesting::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestUiProcessSessionHistoryForTestingResponse:
            return Messages::WebContentClient::DidRequestUiProcessSessionHistoryForTestingResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestSiteIsolationProcessTreeForTesting:
            return Messages::WebContentClient::DidRequestSiteIsolationProcessTreeForTesting::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidRequestSiteIsolationProcessTreeForTestingResponse:
            return Messages::WebContentClient::DidRequestSiteIsolationProcessTreeForTestingResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting:
            return Messages::WebContentClient::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTestingResponse:
            return Messages::WebContentClient::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTestingResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidSetTopLevelSessionHistory:
            return Messages::WebContentClient::DidSetTopLevelSessionHistory::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidTraverseTheHistoryToStep:
            return Messages::WebContentClient::DidTraverseTheHistoryToStep::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidCheckIfTraverseHistoryStepIsCanceled:
            return Messages::WebContentClient::DidCheckIfTraverseHistoryStepIsCanceled::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidResetSessionHistoryForTesting:
            return Messages::WebContentClient::DidResetSessionHistoryForTesting::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeAudioPlayState:
            return Messages::WebContentClient::DidChangeAudioPlayState::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::DidChangeScreenWakeLockState:
            return Messages::WebContentClient::DidChangeScreenWakeLockState::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::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::StartWorkerAgent:
            return Messages::WebContentClient::StartWorkerAgent::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::StartWorkerAgentResponse:
            return Messages::WebContentClient::StartWorkerAgentResponse::decode(stream, attachments);
        case (int)Messages::WebContentClient::MessageID::CloseWorkerAgent:
            return Messages::WebContentClient::CloseWorkerAgent::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::AllocateCompositorContextId:
            return handle_allocate_compositor_context_id(*message);
        case (int)Messages::WebContentClient::MessageID::DidDestroyCompositorContext:
            return handle_did_destroy_compositor_context(*message);
        case (int)Messages::WebContentClient::MessageID::DecideNavigationProcess:
            return handle_decide_navigation_process(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestNewProcessForNavigation:
            return handle_did_request_new_process_for_navigation(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestNewProcessForChildFrameNavigation:
            return handle_did_request_new_process_for_child_frame_navigation(*message);
        case (int)Messages::WebContentClient::MessageID::DidCreateChildFrame:
            return handle_did_create_child_frame(*message);
        case (int)Messages::WebContentClient::MessageID::DidUpdateChildFrameViewport:
            return handle_did_update_child_frame_viewport(*message);
        case (int)Messages::WebContentClient::MessageID::DidCommitChildFrameNavigation:
            return handle_did_commit_child_frame_navigation(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeTopLevelActiveDocument:
            return handle_did_change_top_level_active_document(*message);
        case (int)Messages::WebContentClient::MessageID::DidDestroyChildFrame:
            return handle_did_destroy_child_frame(*message);
        case (int)Messages::WebContentClient::MessageID::DidStartWebdriverNavigation:
            return handle_did_start_webdriver_navigation(*message);
        case (int)Messages::WebContentClient::MessageID::DidStartLoading:
            return handle_did_start_loading(*message);
        case (int)Messages::WebContentClient::MessageID::DidCancelLoading:
            return handle_did_cancel_loading(*message);
        case (int)Messages::WebContentClient::MessageID::DidFinishLoading:
            return handle_did_finish_loading(*message);
        case (int)Messages::WebContentClient::MessageID::DidStartDownloadWithoutRequest:
            return handle_did_start_download_without_request(*message);
        case (int)Messages::WebContentClient::MessageID::DidStartDownload:
            return handle_did_start_download(*message);
        case (int)Messages::WebContentClient::MessageID::DidReceiveDownloadData:
            return handle_did_receive_download_data(*message);
        case (int)Messages::WebContentClient::MessageID::DidFinishDownload:
            return handle_did_finish_download(*message);
        case (int)Messages::WebContentClient::MessageID::DidFailDownload:
            return handle_did_fail_download(*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::DidInspectStorage:
            return handle_did_inspect_storage(*message);
        case (int)Messages::WebContentClient::MessageID::DidInspectDomNode:
            return handle_did_inspect_dom_node(*message);
        case (int)Messages::WebContentClient::MessageID::DidInspectGridLayouts:
            return handle_did_inspect_grid_layouts(*message);
        case (int)Messages::WebContentClient::MessageID::DidInspectCurrentGrid:
            return handle_did_inspect_current_grid(*message);
        case (int)Messages::WebContentClient::MessageID::DidInspectCurrentFlexbox:
            return handle_did_inspect_current_flexbox(*message);
        case (int)Messages::WebContentClient::MessageID::DidInspectIndexedDatabase:
            return handle_did_inspect_indexed_database(*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::DidGetNodeIdAtPosition:
            return handle_did_get_node_id_at_position(*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::DidListDevtoolsSources:
            return handle_did_list_devtools_sources(*message);
        case (int)Messages::WebContentClient::MessageID::DidGetDevtoolsSource:
            return handle_did_get_devtools_source(*message);
        case (int)Messages::WebContentClient::MessageID::DidAddDevtoolsSource:
            return handle_did_add_devtools_source(*message);
        case (int)Messages::WebContentClient::MessageID::DidResolveDomNodeUrl:
            return handle_did_resolve_dom_node_url(*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::DidRequestDeleteAllCookies:
            return handle_did_request_delete_all_cookies(*message);
        case (int)Messages::WebContentClient::MessageID::DidStoreHstsPolicy:
            return handle_did_store_hsts_policy(*message);
        case (int)Messages::WebContentClient::MessageID::DidIsKnownHstsHost:
            return handle_did_is_known_hsts_host(*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::DidRequestStorageUsage:
            return handle_did_request_storage_usage(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeStorageItem:
            return handle_did_change_storage_item(*message);
        case (int)Messages::WebContentClient::MessageID::DidUpdateIndexedDatabase:
            return handle_did_update_indexed_database(*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::DidChangeNeedsBeforeunloadCheck:
            return handle_did_change_needs_beforeunload_check(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestTraverseTheHistoryByDelta:
            return handle_did_request_traverse_the_history_by_delta(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverHistoryTraversal:
            return handle_did_request_webdriver_history_traversal(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverLoadUrlFromUi:
            return handle_did_request_webdriver_load_url_from_ui(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverTraverseHistoryFromUi:
            return handle_did_request_webdriver_traverse_history_from_ui(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverMarkWebContentSessionHistoryStale:
            return handle_did_request_webdriver_mark_web_content_session_history_stale(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverSessionHistory:
            return handle_did_request_webdriver_session_history(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestWebdriverNavigationCompletion:
            return handle_did_request_webdriver_navigation_completion(*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::DidUpdateInputMethodState:
            return handle_did_update_input_method_state(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeThemeColor:
            return handle_did_change_theme_color(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeBackgroundColor:
            return handle_did_change_background_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::DidRequestPrimaryPaste:
            return handle_did_request_primary_paste(*message);
        case (int)Messages::WebContentClient::MessageID::DidUpdatePrimarySelection:
            return handle_did_update_primary_selection(*message);
        case (int)Messages::WebContentClient::MessageID::DidUpdateSessionHistory:
            return handle_did_update_session_history(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestUiProcessSessionHistoryForTesting:
            return handle_did_request_ui_process_session_history_for_testing(*message);
        case (int)Messages::WebContentClient::MessageID::DidRequestSiteIsolationProcessTreeForTesting:
            return handle_did_request_site_isolation_process_tree_for_testing(*message);
        case (int)Messages::WebContentClient::MessageID::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting:
            return handle_did_update_session_history_and_request_ui_process_session_history_for_testing(*message);
        case (int)Messages::WebContentClient::MessageID::DidSetTopLevelSessionHistory:
            return handle_did_set_top_level_session_history(*message);
        case (int)Messages::WebContentClient::MessageID::DidTraverseTheHistoryToStep:
            return handle_did_traverse_the_history_to_step(*message);
        case (int)Messages::WebContentClient::MessageID::DidCheckIfTraverseHistoryStepIsCanceled:
            return handle_did_check_if_traverse_history_step_is_canceled(*message);
        case (int)Messages::WebContentClient::MessageID::DidResetSessionHistoryForTesting:
            return handle_did_reset_session_history_for_testing(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeAudioPlayState:
            return handle_did_change_audio_play_state(*message);
        case (int)Messages::WebContentClient::MessageID::DidChangeScreenWakeLockState:
            return handle_did_change_screen_wake_lock_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::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::StartWorkerAgent:
            return handle_start_worker_agent(*message);
        case (int)Messages::WebContentClient::MessageID::CloseWorkerAgent:
            return handle_close_worker_agent(*message);
        default:
            return Error::from_string_literal("Unknown message ID for WebContentClient endpoint");
        }
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_allocate_compositor_context_id(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::AllocateCompositorContextId&>(message);
        auto response = allocate_compositor_context_id(request.page_id(), request.take_page_presentation_registration());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_destroy_compositor_context(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidDestroyCompositorContext&>(message);
        did_destroy_compositor_context(request.take_context_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_decide_navigation_process(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DecideNavigationProcess&>(message);
        auto response = decide_navigation_process(request.page_id(), request.take_frame_id(), request.take_current_url(), request.take_target_url(), request.take_target());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

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

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_new_process_for_child_frame_navigation(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestNewProcessForChildFrameNavigation&>(message);
        did_request_new_process_for_child_frame_navigation(request.page_id(), request.take_frame_id(), request.take_url(), request.take_document_resource(), request.take_history_handling());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_create_child_frame(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidCreateChildFrame&>(message);
        did_create_child_frame(request.page_id(), request.take_parent_frame_id(), request.take_frame_id(), request.take_replicated_state());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_child_frame_viewport(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdateChildFrameViewport&>(message);
        did_update_child_frame_viewport(request.page_id(), request.take_frame_id(), request.viewport_rect(), request.device_pixel_ratio());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_commit_child_frame_navigation(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidCommitChildFrameNavigation&>(message);
        did_commit_child_frame_navigation(request.page_id(), request.take_frame_id(), request.take_replicated_state());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_change_top_level_active_document(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeTopLevelActiveDocument&>(message);
        did_change_top_level_active_document(request.page_id(), request.take_replicated_state());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_destroy_child_frame(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidDestroyChildFrame&>(message);
        did_destroy_child_frame(request.page_id(), request.take_frame_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_start_webdriver_navigation(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidStartWebdriverNavigation&>(message);
        did_start_webdriver_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.take_document_resource(), request.is_redirect(), request.take_history_handling());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_cancel_loading(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidCancelLoading&>(message);
        did_cancel_loading(request.page_id(), request.take_url());
        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_start_download_without_request(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidStartDownloadWithoutRequest&>(message);
        auto response = did_start_download_without_request(request.page_id(), request.take_url(), request.take_suggested_filename(), request.take_total_size());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_start_download(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidStartDownload&>(message);
        auto response = did_start_download(request.page_id(), request.take_url(), request.take_suggested_filename(), request.take_total_size(), request.request_server_client_id(), request.request_server_request_id(), request.take_initial_data());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_receive_download_data(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidReceiveDownloadData&>(message);
        did_receive_download_data(request.page_id(), request.download_id(), request.take_data());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_finish_download(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidFinishDownload&>(message);
        did_finish_download(request.page_id(), request.download_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_fail_download(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidFailDownload&>(message);
        did_fail_download(request.page_id(), request.download_id(), request.take_error());
        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_storage(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInspectStorage&>(message);
        did_inspect_storage(request.page_id(), request.request_id(), request.take_storage_items());
        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_grid_layouts(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInspectGridLayouts&>(message);
        did_inspect_grid_layouts(request.page_id(), request.take_grid_layouts());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_inspect_current_grid(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInspectCurrentGrid&>(message);
        did_inspect_current_grid(request.page_id(), request.take_grid_layout());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_inspect_current_flexbox(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInspectCurrentFlexbox&>(message);
        did_inspect_current_flexbox(request.page_id(), request.take_flexbox_layout());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_inspect_indexed_database(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidInspectIndexedDatabase&>(message);
        did_inspect_indexed_database(request.page_id(), request.request_id(), request.take_result());
        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_get_node_id_at_position(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidGetNodeIdAtPosition&>(message);
        did_get_node_id_at_position(request.page_id(), request.request_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_list_devtools_sources(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidListDevtoolsSources&>(message);
        did_list_devtools_sources(request.page_id(), request.request_id(), request.take_sources());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_get_devtools_source(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidGetDevtoolsSource&>(message);
        did_get_devtools_source(request.page_id(), request.take_source_id(), request.take_source());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_add_devtools_source(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidAddDevtoolsSource&>(message);
        did_add_devtools_source(request.page_id(), request.take_source());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_resolve_dom_node_url(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidResolveDomNodeUrl&>(message);
        did_resolve_dom_node_url(request.page_id(), request.request_id(), request.take_resolved_url());
        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_delete_all_cookies(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestDeleteAllCookies&>(message);
        did_request_delete_all_cookies(request.page_id(), request.request_id(), request.take_url());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_store_hsts_policy(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidStoreHstsPolicy&>(message);
        did_store_hsts_policy(request.take_domain(), request.take_policy());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_is_known_hsts_host(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidIsKnownHstsHost&>(message);
        auto response = did_is_known_hsts_host(request.take_domain());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    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_request_storage_usage(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestStorageUsage&>(message);
        auto response = did_request_storage_usage(request.take_storage_key());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_change_storage_item(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeStorageItem&>(message);
        did_change_storage_item(request.page_id(), request.take_storage_endpoint(), request.take_url(), request.take_key(), request.take_old_value(), request.take_new_value());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_indexed_database(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdateIndexedDatabase&>(message);
        did_update_indexed_database(request.page_id(), request.take_update());
        return nullptr;
    }

    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());
        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_change_needs_beforeunload_check(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeNeedsBeforeunloadCheck&>(message);
        did_change_needs_beforeunload_check(request.page_id(), request.needs_beforeunload_check());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_traverse_the_history_by_delta(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestTraverseTheHistoryByDelta&>(message);
        auto response = did_request_traverse_the_history_by_delta(request.page_id(), request.delta(), request.take_history_traversal_precheck());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_webdriver_history_traversal(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestWebdriverHistoryTraversal&>(message);
        did_request_webdriver_history_traversal(request.page_id(), request.request_id(), request.delta());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_webdriver_load_url_from_ui(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestWebdriverLoadUrlFromUi&>(message);
        auto response = did_request_webdriver_load_url_from_ui(request.page_id(), request.take_url());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_webdriver_traverse_history_from_ui(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestWebdriverTraverseHistoryFromUi&>(message);
        auto response = did_request_webdriver_traverse_history_from_ui(request.page_id(), request.delta());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_webdriver_mark_web_content_session_history_stale(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestWebdriverMarkWebContentSessionHistoryStale&>(message);
        auto response = did_request_webdriver_mark_web_content_session_history_stale(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_webdriver_session_history(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestWebdriverSessionHistory&>(message);
        auto response = did_request_webdriver_session_history(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_webdriver_navigation_completion(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestWebdriverNavigationCompletion&>(message);
        did_request_webdriver_navigation_completion(request.page_id(), request.request_id(), request.take_page_load_timeout());
        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_update_input_method_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdateInputMethodState&>(message);
        did_update_input_method_state(request.page_id(), request.take_caret_rect(), request.is_enabled(), request.cursor_position(), request.anchor_position(), request.take_text_before_cursor(), request.take_text_after_cursor());
        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_change_background_color(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeBackgroundColor&>(message);
        did_change_background_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_request_primary_paste(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestPrimaryPaste&>(message);
        did_request_primary_paste(request.page_id());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_primary_selection(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdatePrimarySelection&>(message);
        did_update_primary_selection(request.page_id(), request.take_text());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_session_history(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdateSessionHistory&>(message);
        did_update_session_history(request.page_id(), request.take_entries(), request.take_used_steps(), request.current_used_step_index());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_ui_process_session_history_for_testing(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestUiProcessSessionHistoryForTesting&>(message);
        auto response = did_request_ui_process_session_history_for_testing(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_request_site_isolation_process_tree_for_testing(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidRequestSiteIsolationProcessTreeForTesting&>(message);
        auto response = did_request_site_isolation_process_tree_for_testing(request.page_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_update_session_history_and_request_ui_process_session_history_for_testing(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTesting&>(message);
        auto response = did_update_session_history_and_request_ui_process_session_history_for_testing(request.page_id(), request.take_entries(), request.take_used_steps(), request.current_used_step_index());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_set_top_level_session_history(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidSetTopLevelSessionHistory&>(message);
        did_set_top_level_session_history(request.page_id(), request.accepted(), request.take_entries(), request.take_used_steps(), request.current_used_step_index());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_traverse_the_history_to_step(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidTraverseTheHistoryToStep&>(message);
        did_traverse_the_history_to_step(request.page_id(), request.step(), request.step_was_available(), request.take_result());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_check_if_traverse_history_step_is_canceled(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidCheckIfTraverseHistoryStepIsCanceled&>(message);
        did_check_if_traverse_history_step_is_canceled(request.page_id(), request.request_id(), request.step(), request.canceled());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_did_reset_session_history_for_testing(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidResetSessionHistoryForTesting&>(message);
        did_reset_session_history_for_testing(request.page_id());
        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_change_screen_wake_lock_state(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::DidChangeScreenWakeLockState&>(message);
        did_change_screen_wake_lock_state(request.page_id(), request.take_wake_lock_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_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_start_worker_agent(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::StartWorkerAgent&>(message);
        auto response = start_worker_agent(request.page_id(), request.take_request());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_close_worker_agent(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebContentClient::CloseWorkerAgent&>(message);
        close_worker_agent(request.page_id(), request.take_agent_id(), request.take_owner_token());
        return nullptr;
    }

    virtual Messages::WebContentClient::AllocateCompositorContextIdResponse allocate_compositor_context_id(u64 page_id, Web::Compositor::PagePresentationRegistration page_presentation_registration) = 0;
    virtual void did_destroy_compositor_context(Web::Compositor::CompositorContextId context_id) = 0;
    virtual Messages::WebContentClient::DecideNavigationProcessResponse decide_navigation_process(u64 page_id, Optional<Web::HTML::NavigableId> frame_id, URL::URL current_url, URL::URL target_url, Web::NavigationTarget target) = 0;
    virtual void did_request_new_process_for_navigation(u64 page_id, URL::URL url, Variant<Empty, String, Web::HTML::POSTResource> document_resource, Web::Bindings::NavigationHistoryBehavior history_handling) = 0;
    virtual void did_request_new_process_for_child_frame_navigation(u64 page_id, Web::HTML::NavigableId frame_id, URL::URL url, Variant<Empty, String, Web::HTML::POSTResource> document_resource, Web::Bindings::NavigationHistoryBehavior history_handling) = 0;
    virtual void did_create_child_frame(u64 page_id, Web::HTML::NavigableId parent_frame_id, Web::HTML::NavigableId frame_id, Web::HTML::ReplicatedNavigableState replicated_state) = 0;
    virtual void did_update_child_frame_viewport(u64 page_id, Web::HTML::NavigableId frame_id, Web::DevicePixelRect viewport_rect, double device_pixel_ratio) = 0;
    virtual void did_commit_child_frame_navigation(u64 page_id, Web::HTML::NavigableId frame_id, Web::HTML::ReplicatedNavigableState replicated_state) = 0;
    virtual void did_change_top_level_active_document(u64 page_id, Web::HTML::ReplicatedNavigableState replicated_state) = 0;
    virtual void did_destroy_child_frame(u64 page_id, Web::HTML::NavigableId frame_id) = 0;
    virtual void did_start_webdriver_navigation(u64 page_id, URL::URL url) = 0;
    virtual void did_start_loading(u64 page_id, URL::URL url, Variant<Empty, String, Web::HTML::POSTResource> document_resource, bool is_redirect, Web::Bindings::NavigationHistoryBehavior history_handling) = 0;
    virtual void did_cancel_loading(u64 page_id, URL::URL url) = 0;
    virtual void did_finish_loading(u64 page_id, URL::URL url) = 0;
    virtual Messages::WebContentClient::DidStartDownloadWithoutRequestResponse did_start_download_without_request(u64 page_id, URL::URL url, ByteString suggested_filename, Optional<u64> total_size) = 0;
    virtual Messages::WebContentClient::DidStartDownloadResponse did_start_download(u64 page_id, URL::URL url, ByteString suggested_filename, Optional<u64> total_size, int request_server_client_id, u64 request_server_request_id, ByteBuffer initial_data) = 0;
    virtual void did_receive_download_data(u64 page_id, u64 download_id, ByteBuffer data) = 0;
    virtual void did_finish_download(u64 page_id, u64 download_id) = 0;
    virtual void did_fail_download(u64 page_id, u64 download_id, String error) = 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_storage(u64 page_id, u64 request_id, String storage_items) = 0;
    virtual void did_inspect_dom_node(u64 page_id, WebView::DOMNodeProperties properties) = 0;
    virtual void did_inspect_grid_layouts(u64 page_id, String grid_layouts) = 0;
    virtual void did_inspect_current_grid(u64 page_id, String grid_layout) = 0;
    virtual void did_inspect_current_flexbox(u64 page_id, String flexbox_layout) = 0;
    virtual void did_inspect_indexed_database(u64 page_id, u64 request_id, String result) = 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_get_node_id_at_position(u64 page_id, u64 request_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_list_devtools_sources(u64 page_id, u64 request_id, Vector<Web::HTML::ScriptRegistry::Description> sources) = 0;
    virtual void did_get_devtools_source(u64 page_id, Web::HTML::ScriptRegistry::Identifier source_id, Optional<Web::HTML::ScriptRegistry::Content> source) = 0;
    virtual void did_add_devtools_source(u64 page_id, Web::HTML::ScriptRegistry::Description source) = 0;
    virtual void did_resolve_dom_node_url(u64 page_id, u64 request_id, String resolved_url) = 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 void did_request_delete_all_cookies(u64 page_id, u64 request_id, URL::URL url) = 0;
    virtual void did_store_hsts_policy(String domain, HTTP::HSTS::ParsedHSTSPolicy policy) = 0;
    virtual Messages::WebContentClient::DidIsKnownHstsHostResponse did_is_known_hsts_host(String domain) = 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 Messages::WebContentClient::DidRequestStorageUsageResponse did_request_storage_usage(String storage_key) = 0;
    virtual void did_change_storage_item(u64 page_id, Web::StorageAPI::StorageEndpointType storage_endpoint, String url, Optional<String> key, Optional<String> old_value, Optional<String> new_value) = 0;
    virtual void did_update_indexed_database(u64 page_id, String update) = 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) = 0;
    virtual void did_request_activate_tab(u64 page_id) = 0;
    virtual void did_close_browsing_context(u64 page_id) = 0;
    virtual void did_change_needs_beforeunload_check(u64 page_id, bool needs_beforeunload_check) = 0;
    virtual Messages::WebContentClient::DidRequestTraverseTheHistoryByDeltaResponse did_request_traverse_the_history_by_delta(u64 page_id, i32 delta, Web::HistoryTraversalPrecheck history_traversal_precheck) = 0;
    virtual void did_request_webdriver_history_traversal(u64 page_id, u64 request_id, i32 delta) = 0;
    virtual Messages::WebContentClient::DidRequestWebdriverLoadUrlFromUiResponse did_request_webdriver_load_url_from_ui(u64 page_id, URL::URL url) = 0;
    virtual Messages::WebContentClient::DidRequestWebdriverTraverseHistoryFromUiResponse did_request_webdriver_traverse_history_from_ui(u64 page_id, i32 delta) = 0;
    virtual Messages::WebContentClient::DidRequestWebdriverMarkWebContentSessionHistoryStaleResponse did_request_webdriver_mark_web_content_session_history_stale(u64 page_id) = 0;
    virtual Messages::WebContentClient::DidRequestWebdriverSessionHistoryResponse did_request_webdriver_session_history(u64 page_id) = 0;
    virtual void did_request_webdriver_navigation_completion(u64 page_id, u64 request_id, Optional<u64> page_load_timeout) = 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_update_input_method_state(u64 page_id, Optional<Web::DevicePixelRect> caret_rect, bool is_enabled, i32 cursor_position, i32 anchor_position, Utf16String text_before_cursor, Utf16String text_after_cursor) = 0;
    virtual void did_change_theme_color(u64 page_id, Gfx::Color color) = 0;
    virtual void did_change_background_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_request_primary_paste(u64 page_id) = 0;
    virtual void did_update_primary_selection(u64 page_id, String text) = 0;
    virtual void did_update_session_history(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index) = 0;
    virtual Messages::WebContentClient::DidRequestUiProcessSessionHistoryForTestingResponse did_request_ui_process_session_history_for_testing(u64 page_id) = 0;
    virtual Messages::WebContentClient::DidRequestSiteIsolationProcessTreeForTestingResponse did_request_site_isolation_process_tree_for_testing(u64 page_id) = 0;
    virtual Messages::WebContentClient::DidUpdateSessionHistoryAndRequestUiProcessSessionHistoryForTestingResponse did_update_session_history_and_request_ui_process_session_history_for_testing(u64 page_id, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index) = 0;
    virtual void did_set_top_level_session_history(u64 page_id, bool accepted, Vector<Web::HTML::SessionHistoryEntryDescriptor> entries, Vector<i32> used_steps, size_t current_used_step_index) = 0;
    virtual void did_traverse_the_history_to_step(u64 page_id, i32 step, bool step_was_available, Web::HTML::HistoryStepResult result) = 0;
    virtual void did_check_if_traverse_history_step_is_canceled(u64 page_id, u64 request_id, i32 step, bool canceled) = 0;
    virtual void did_reset_session_history_for_testing(u64 page_id) = 0;
    virtual void did_change_audio_play_state(u64 page_id, Web::HTML::AudioPlayState play_state) = 0;
    virtual void did_change_screen_wake_lock_state(u64 page_id, Web::ScreenWakeLockState wake_lock_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_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::StartWorkerAgentResponse start_worker_agent(u64 page_id, Web::HTML::WorkerAgentStartRequest request) = 0;
    virtual void close_worker_agent(u64 page_id, Web::HTML::WorkerAgentId agent_id, Web::HTML::WorkerAgentOwnerToken owner_token) = 0;
};

#if defined(AK_COMPILER_CLANG)
#pragma clang diagnostic pop
#endif