#pragma once

#include <LibWeb/WebDriver/Capabilities.h>
#include <LibWeb/WebDriver/Response.h>
#include <LibWeb/WebDriver/UserPrompt.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::WebDriverClient {

enum class MessageID : i32 {
    CloseSession = 1,
    CloseSessionResponse = 2,
    SetPageLoadStrategy = 3,
    SetUserPromptHandler = 4,
    SetStrictFileInteractability = 5,
    SetIsWebdriverActive = 6,
    GetTimeouts = 7,
    GetTimeoutsResponse = 8,
    SetTimeouts = 9,
    SetTimeoutsResponse = 10,
    NavigateTo = 11,
    NavigateToResponse = 12,
    GetCurrentUrl = 13,
    GetCurrentUrlResponse = 14,
    Back = 15,
    BackResponse = 16,
    Forward = 17,
    ForwardResponse = 18,
    Refresh = 19,
    RefreshResponse = 20,
    GetTitle = 21,
    GetTitleResponse = 22,
    CloseWindow = 23,
    CloseWindowResponse = 24,
    SwitchToWindow = 25,
    SwitchToWindowResponse = 26,
    NewWindow = 27,
    NewWindowResponse = 28,
    SwitchToFrame = 29,
    SwitchToFrameResponse = 30,
    SwitchToParentFrame = 31,
    SwitchToParentFrameResponse = 32,
    GetWindowRect = 33,
    GetWindowRectResponse = 34,
    SetWindowRect = 35,
    SetWindowRectResponse = 36,
    MaximizeWindow = 37,
    MaximizeWindowResponse = 38,
    MinimizeWindow = 39,
    MinimizeWindowResponse = 40,
    FullscreenWindow = 41,
    FullscreenWindowResponse = 42,
    ConsumeUserActivation = 43,
    ConsumeUserActivationResponse = 44,
    FindElement = 45,
    FindElementResponse = 46,
    FindElements = 47,
    FindElementsResponse = 48,
    FindElementFromElement = 49,
    FindElementFromElementResponse = 50,
    FindElementsFromElement = 51,
    FindElementsFromElementResponse = 52,
    FindElementFromShadowRoot = 53,
    FindElementFromShadowRootResponse = 54,
    FindElementsFromShadowRoot = 55,
    FindElementsFromShadowRootResponse = 56,
    GetActiveElement = 57,
    GetActiveElementResponse = 58,
    GetElementShadowRoot = 59,
    GetElementShadowRootResponse = 60,
    IsElementSelected = 61,
    IsElementSelectedResponse = 62,
    GetElementAttribute = 63,
    GetElementAttributeResponse = 64,
    GetElementProperty = 65,
    GetElementPropertyResponse = 66,
    GetElementCssValue = 67,
    GetElementCssValueResponse = 68,
    GetElementText = 69,
    GetElementTextResponse = 70,
    GetElementTagName = 71,
    GetElementTagNameResponse = 72,
    GetElementRect = 73,
    GetElementRectResponse = 74,
    IsElementEnabled = 75,
    IsElementEnabledResponse = 76,
    GetComputedRole = 77,
    GetComputedRoleResponse = 78,
    GetComputedLabel = 79,
    GetComputedLabelResponse = 80,
    ElementClick = 81,
    ElementClickResponse = 82,
    ElementClear = 83,
    ElementClearResponse = 84,
    ElementSendKeys = 85,
    ElementSendKeysResponse = 86,
    GetSource = 87,
    GetSourceResponse = 88,
    ExecuteScript = 89,
    ExecuteScriptResponse = 90,
    ExecuteAsyncScript = 91,
    ExecuteAsyncScriptResponse = 92,
    GetAllCookies = 93,
    GetAllCookiesResponse = 94,
    GetNamedCookie = 95,
    GetNamedCookieResponse = 96,
    AddCookie = 97,
    AddCookieResponse = 98,
    DeleteCookie = 99,
    DeleteCookieResponse = 100,
    DeleteAllCookies = 101,
    DeleteAllCookiesResponse = 102,
    PerformActions = 103,
    PerformActionsResponse = 104,
    ReleaseActions = 105,
    ReleaseActionsResponse = 106,
    DismissAlert = 107,
    DismissAlertResponse = 108,
    AcceptAlert = 109,
    AcceptAlertResponse = 110,
    GetAlertText = 111,
    GetAlertTextResponse = 112,
    SendAlertText = 113,
    SendAlertTextResponse = 114,
    TakeScreenshot = 115,
    TakeScreenshotResponse = 116,
    TakeElementScreenshot = 117,
    TakeElementScreenshotResponse = 118,
    PrintPage = 119,
    PrintPageResponse = 120,
    EnsureTopLevelBrowsingContextIsOpen = 121,
    EnsureTopLevelBrowsingContextIsOpenResponse = 122,
};

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

class CloseSession final : public IPC::Message {
public:
    typedef class CloseSessionResponse ResponseType;

    CloseSession() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

class SetPageLoadStrategy final : public IPC::Message {
public:
    SetPageLoadStrategy(Web::WebDriver::PageLoadStrategy page_load_strategy)
        : m_page_load_strategy(move(page_load_strategy))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::PageLoadStrategy>)
    SetPageLoadStrategy(WrappedReturnType&& value)
        : m_page_load_strategy(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    Web::WebDriver::PageLoadStrategy const& page_load_strategy() const { return m_page_load_strategy; }
    Web::WebDriver::PageLoadStrategy take_page_load_strategy() { return move(m_page_load_strategy); }

private:
    Web::WebDriver::PageLoadStrategy m_page_load_strategy;
};

class SetUserPromptHandler final : public IPC::Message {
public:
    SetUserPromptHandler(Web::WebDriver::UserPromptHandler user_prompt_handler)
        : m_user_prompt_handler(move(user_prompt_handler))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::UserPromptHandler>)
    SetUserPromptHandler(WrappedReturnType&& value)
        : m_user_prompt_handler(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    Web::WebDriver::UserPromptHandler const& user_prompt_handler() const { return m_user_prompt_handler; }
    Web::WebDriver::UserPromptHandler take_user_prompt_handler() { return move(m_user_prompt_handler); }

private:
    Web::WebDriver::UserPromptHandler m_user_prompt_handler;
};

class SetStrictFileInteractability final : public IPC::Message {
public:
    SetStrictFileInteractability(bool strict_file_interactability)
        : m_strict_file_interactability(move(strict_file_interactability))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, bool>)
    SetStrictFileInteractability(WrappedReturnType&& value)
        : m_strict_file_interactability(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    bool strict_file_interactability() const { return m_strict_file_interactability; }

private:
    bool m_strict_file_interactability;
};

class SetIsWebdriverActive final : public IPC::Message {
public:
    SetIsWebdriverActive(bool active)
        : m_active(move(active))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, bool>)
    SetIsWebdriverActive(WrappedReturnType&& value)
        : m_active(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    bool active() const { return m_active; }

private:
    bool m_active;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetTimeoutsResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetTimeouts() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    SetTimeoutsResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    SetTimeouts(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    SetTimeouts(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    NavigateToResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    NavigateTo(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    NavigateTo(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetCurrentUrlResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetCurrentUrl() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    BackResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    Back() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    ForwardResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    Forward() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    RefreshResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    Refresh() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetTitleResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetTitle() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    CloseWindowResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    CloseWindow() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    SwitchToWindowResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    SwitchToWindow(String handle)
        : m_handle(move(handle))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

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

private:
    String m_handle;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    NewWindowResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    NewWindow(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    NewWindow(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    SwitchToFrameResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    SwitchToFrame(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    SwitchToFrame(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    SwitchToParentFrameResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    SwitchToParentFrame(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    SwitchToParentFrame(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetWindowRectResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetWindowRect() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    SetWindowRectResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    SetWindowRect(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    SetWindowRect(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    MaximizeWindowResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    MaximizeWindow() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    MinimizeWindowResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    MinimizeWindow() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    FullscreenWindowResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    FullscreenWindow() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    ConsumeUserActivationResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    ConsumeUserActivation() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    FindElementResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    FindElement(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    FindElement(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    FindElementsResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    FindElements(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    FindElements(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    FindElementFromElementResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    FindElementFromElement(JsonValue payload, String element_id)
        : m_payload(move(payload))
        , m_element_id(move(element_id))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(JsonValue const& payload, StringView element_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::FindElementFromElement));
        TRY(stream.encode(payload));
        TRY(stream.encode(element_id));
        return buffer;
    }

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    JsonValue m_payload;
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    FindElementsFromElementResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    FindElementsFromElement(JsonValue payload, String element_id)
        : m_payload(move(payload))
        , m_element_id(move(element_id))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(JsonValue const& payload, StringView element_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::FindElementsFromElement));
        TRY(stream.encode(payload));
        TRY(stream.encode(element_id));
        return buffer;
    }

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    JsonValue m_payload;
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    FindElementFromShadowRootResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    FindElementFromShadowRoot(JsonValue payload, String shadow_id)
        : m_payload(move(payload))
        , m_shadow_id(move(shadow_id))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(JsonValue const& payload, StringView shadow_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::FindElementFromShadowRoot));
        TRY(stream.encode(payload));
        TRY(stream.encode(shadow_id));
        return buffer;
    }

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

    String const& shadow_id() const { return m_shadow_id; }
    String take_shadow_id() { return move(m_shadow_id); }

private:
    JsonValue m_payload;
    String m_shadow_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    FindElementsFromShadowRootResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    FindElementsFromShadowRoot(JsonValue payload, String shadow_id)
        : m_payload(move(payload))
        , m_shadow_id(move(shadow_id))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(JsonValue const& payload, StringView shadow_id)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::FindElementsFromShadowRoot));
        TRY(stream.encode(payload));
        TRY(stream.encode(shadow_id));
        return buffer;
    }

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

    String const& shadow_id() const { return m_shadow_id; }
    String take_shadow_id() { return move(m_shadow_id); }

private:
    JsonValue m_payload;
    String m_shadow_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetActiveElementResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetActiveElement() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetElementShadowRootResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetElementShadowRoot(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    IsElementSelectedResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    IsElementSelected(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetElementAttributeResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetElementAttribute(String element_id, String name)
        : m_element_id(move(element_id))
        , m_name(move(name))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

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

private:
    String m_element_id;
    String m_name;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetElementPropertyResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetElementProperty(String element_id, String name)
        : m_element_id(move(element_id))
        , m_name(move(name))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

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

private:
    String m_element_id;
    String m_name;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetElementCssValueResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetElementCssValue(String element_id, String name)
        : m_element_id(move(element_id))
        , m_name(move(name))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

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

private:
    String m_element_id;
    String m_name;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetElementTextResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetElementText(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetElementTagNameResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetElementTagName(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetElementRectResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetElementRect(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    IsElementEnabledResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    IsElementEnabled(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetComputedRoleResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetComputedRole(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetComputedLabelResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetComputedLabel(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    ElementClickResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    ElementClick(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    ElementClearResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    ElementClear(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    ElementSendKeysResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    ElementSendKeys(String element_id, JsonValue payload)
        : m_element_id(move(element_id))
        , m_payload(move(payload))
    {
    }

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    static ErrorOr<IPC::MessageBuffer> static_encode(StringView element_id, JsonValue const& payload)
    {
        IPC::MessageBuffer buffer;
        IPC::Encoder stream(buffer);
        TRY(stream.encode(ENDPOINT_MAGIC));
        TRY(stream.encode((int)MessageID::ElementSendKeys));
        TRY(stream.encode(element_id));
        TRY(stream.encode(payload));
        return buffer;
    }

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    String m_element_id;
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetSourceResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetSource() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    ExecuteScriptResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    ExecuteScript(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    ExecuteScript(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    ExecuteAsyncScriptResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    ExecuteAsyncScript(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    ExecuteAsyncScript(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetAllCookiesResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetAllCookies() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetNamedCookieResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetNamedCookie(String name)
        : m_name(move(name))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

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

private:
    String m_name;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    AddCookieResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    AddCookie(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    AddCookie(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    DeleteCookieResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    DeleteCookie(String name)
        : m_name(move(name))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

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

private:
    String m_name;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    DeleteAllCookiesResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    DeleteAllCookies() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    PerformActionsResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    PerformActions(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    PerformActions(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    ReleaseActionsResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    ReleaseActions() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    DismissAlertResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    DismissAlert() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    AcceptAlertResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    AcceptAlert() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    GetAlertTextResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    GetAlertText() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    SendAlertTextResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    SendAlertText(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    SendAlertText(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    TakeScreenshotResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    TakeScreenshot() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    TakeElementScreenshotResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    TakeElementScreenshot(String element_id)
        : m_element_id(move(element_id))
    {
    }

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

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    String const& element_id() const { return m_element_id; }
    String take_element_id() { return move(m_element_id); }

private:
    String m_element_id;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    PrintPageResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    PrintPage(JsonValue payload)
        : m_payload(move(payload))
    {
    }

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, JsonValue>)
    PrintPage(WrappedReturnType&& value)
        : m_payload(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

    JsonValue const& payload() const { return m_payload; }
    JsonValue take_payload() { return move(m_payload); }

private:
    JsonValue m_payload;
};

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

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

    template<typename WrappedReturnType>
    requires(!SameAs<WrappedReturnType, Web::WebDriver::Response>)
    EnsureTopLevelBrowsingContextIsOpenResponse(WrappedReturnType&& value)
        : m_response(forward<WrappedReturnType>(value))
    {
    }

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

    EnsureTopLevelBrowsingContextIsOpen() = default;

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

    static constexpr u32 ENDPOINT_MAGIC = 4284153835;

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

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

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

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

private:
};

} // namespace Messages::WebDriverClient

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

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

    void close_session()
    {
        (void)m_connection.template send_sync<Messages::WebDriverClient::CloseSession>();
    }

    void async_close_session()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::CloseSession::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<void> try_close_session()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::CloseSession>())
            return {};
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    void async_set_page_load_strategy(Web::WebDriver::PageLoadStrategy const& page_load_strategy)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SetPageLoadStrategy::static_encode(move(page_load_strategy)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_user_prompt_handler(Web::WebDriver::UserPromptHandler const& user_prompt_handler)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SetUserPromptHandler::static_encode(move(user_prompt_handler)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_strict_file_interactability(bool strict_file_interactability)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SetStrictFileInteractability::static_encode(strict_file_interactability));
        (void)m_connection.post_message(message_buffer);
    }

    void async_set_is_webdriver_active(bool active)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SetIsWebdriverActive::static_encode(active));
        (void)m_connection.post_message(message_buffer);
    }

    Web::WebDriver::Response get_timeouts()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetTimeouts>()->take_response();
    }

    void async_get_timeouts()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetTimeouts::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_timeouts()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetTimeouts>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response set_timeouts(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::SetTimeouts>(move(payload))->take_response();
    }

    void async_set_timeouts(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SetTimeouts::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_set_timeouts(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::SetTimeouts>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response navigate_to(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::NavigateTo>(move(payload))->take_response();
    }

    void async_navigate_to(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::NavigateTo::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_navigate_to(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::NavigateTo>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_current_url()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetCurrentUrl>()->take_response();
    }

    void async_get_current_url()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetCurrentUrl::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_current_url()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetCurrentUrl>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response back()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::Back>()->take_response();
    }

    void async_back()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::Back::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_back()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::Back>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response forward()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::Forward>()->take_response();
    }

    void async_forward()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::Forward::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_forward()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::Forward>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response refresh()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::Refresh>()->take_response();
    }

    void async_refresh()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::Refresh::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_refresh()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::Refresh>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_title()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetTitle>()->take_response();
    }

    void async_get_title()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetTitle::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_title()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetTitle>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response close_window()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::CloseWindow>()->take_response();
    }

    void async_close_window()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::CloseWindow::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_close_window()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::CloseWindow>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response switch_to_window(String handle)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::SwitchToWindow>(move(handle))->take_response();
    }

    void async_switch_to_window(StringView handle)
    {
        VERIFY(Utf8View { handle }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::SwitchToWindow::static_encode(handle));
        (void)m_connection.post_message(message_buffer);
    }

    void async_switch_to_window(String const& handle)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SwitchToWindow::static_encode(handle));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_switch_to_window(String handle)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::SwitchToWindow>(move(handle)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response new_window(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::NewWindow>(move(payload))->take_response();
    }

    void async_new_window(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::NewWindow::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_new_window(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::NewWindow>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response switch_to_frame(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::SwitchToFrame>(move(payload))->take_response();
    }

    void async_switch_to_frame(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SwitchToFrame::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_switch_to_frame(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::SwitchToFrame>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response switch_to_parent_frame(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::SwitchToParentFrame>(move(payload))->take_response();
    }

    void async_switch_to_parent_frame(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SwitchToParentFrame::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_switch_to_parent_frame(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::SwitchToParentFrame>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_window_rect()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetWindowRect>()->take_response();
    }

    void async_get_window_rect()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetWindowRect::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_window_rect()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetWindowRect>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response set_window_rect(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::SetWindowRect>(move(payload))->take_response();
    }

    void async_set_window_rect(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SetWindowRect::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_set_window_rect(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::SetWindowRect>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response maximize_window()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::MaximizeWindow>()->take_response();
    }

    void async_maximize_window()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::MaximizeWindow::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_maximize_window()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::MaximizeWindow>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response minimize_window()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::MinimizeWindow>()->take_response();
    }

    void async_minimize_window()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::MinimizeWindow::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_minimize_window()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::MinimizeWindow>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response fullscreen_window()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::FullscreenWindow>()->take_response();
    }

    void async_fullscreen_window()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::FullscreenWindow::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_fullscreen_window()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::FullscreenWindow>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response consume_user_activation()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::ConsumeUserActivation>()->take_response();
    }

    void async_consume_user_activation()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::ConsumeUserActivation::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_consume_user_activation()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::ConsumeUserActivation>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response find_element(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::FindElement>(move(payload))->take_response();
    }

    void async_find_element(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::FindElement::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_find_element(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::FindElement>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response find_elements(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::FindElements>(move(payload))->take_response();
    }

    void async_find_elements(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::FindElements::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_find_elements(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::FindElements>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response find_element_from_element(JsonValue payload, String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::FindElementFromElement>(move(payload), move(element_id))->take_response();
    }

    void async_find_element_from_element(JsonValue const& payload, StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::FindElementFromElement::static_encode(move(payload), element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_find_element_from_element(JsonValue const& payload, String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::FindElementFromElement::static_encode(move(payload), element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_find_element_from_element(JsonValue payload, String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::FindElementFromElement>(move(payload), move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response find_elements_from_element(JsonValue payload, String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::FindElementsFromElement>(move(payload), move(element_id))->take_response();
    }

    void async_find_elements_from_element(JsonValue const& payload, StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::FindElementsFromElement::static_encode(move(payload), element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_find_elements_from_element(JsonValue const& payload, String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::FindElementsFromElement::static_encode(move(payload), element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_find_elements_from_element(JsonValue payload, String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::FindElementsFromElement>(move(payload), move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response find_element_from_shadow_root(JsonValue payload, String shadow_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::FindElementFromShadowRoot>(move(payload), move(shadow_id))->take_response();
    }

    void async_find_element_from_shadow_root(JsonValue const& payload, StringView shadow_id)
    {
        VERIFY(Utf8View { shadow_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::FindElementFromShadowRoot::static_encode(move(payload), shadow_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_find_element_from_shadow_root(JsonValue const& payload, String const& shadow_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::FindElementFromShadowRoot::static_encode(move(payload), shadow_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_find_element_from_shadow_root(JsonValue payload, String shadow_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::FindElementFromShadowRoot>(move(payload), move(shadow_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response find_elements_from_shadow_root(JsonValue payload, String shadow_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::FindElementsFromShadowRoot>(move(payload), move(shadow_id))->take_response();
    }

    void async_find_elements_from_shadow_root(JsonValue const& payload, StringView shadow_id)
    {
        VERIFY(Utf8View { shadow_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::FindElementsFromShadowRoot::static_encode(move(payload), shadow_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_find_elements_from_shadow_root(JsonValue const& payload, String const& shadow_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::FindElementsFromShadowRoot::static_encode(move(payload), shadow_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_find_elements_from_shadow_root(JsonValue payload, String shadow_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::FindElementsFromShadowRoot>(move(payload), move(shadow_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_active_element()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetActiveElement>()->take_response();
    }

    void async_get_active_element()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetActiveElement::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_active_element()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetActiveElement>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_element_shadow_root(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetElementShadowRoot>(move(element_id))->take_response();
    }

    void async_get_element_shadow_root(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementShadowRoot::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_element_shadow_root(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementShadowRoot::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_element_shadow_root(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetElementShadowRoot>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response is_element_selected(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::IsElementSelected>(move(element_id))->take_response();
    }

    void async_is_element_selected(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::IsElementSelected::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_is_element_selected(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::IsElementSelected::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_is_element_selected(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::IsElementSelected>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_element_attribute(String element_id, String name)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetElementAttribute>(move(element_id), move(name))->take_response();
    }

    void async_get_element_attribute(StringView element_id, StringView name)
    {
        VERIFY(Utf8View { element_id }.validate());
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementAttribute::static_encode(element_id, name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_element_attribute(String const& element_id, String const& name)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementAttribute::static_encode(element_id, name));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_element_attribute(String element_id, String name)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetElementAttribute>(move(element_id), move(name)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_element_property(String element_id, String name)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetElementProperty>(move(element_id), move(name))->take_response();
    }

    void async_get_element_property(StringView element_id, StringView name)
    {
        VERIFY(Utf8View { element_id }.validate());
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementProperty::static_encode(element_id, name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_element_property(String const& element_id, String const& name)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementProperty::static_encode(element_id, name));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_element_property(String element_id, String name)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetElementProperty>(move(element_id), move(name)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_element_css_value(String element_id, String name)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetElementCssValue>(move(element_id), move(name))->take_response();
    }

    void async_get_element_css_value(StringView element_id, StringView name)
    {
        VERIFY(Utf8View { element_id }.validate());
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementCssValue::static_encode(element_id, name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_element_css_value(String const& element_id, String const& name)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementCssValue::static_encode(element_id, name));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_element_css_value(String element_id, String name)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetElementCssValue>(move(element_id), move(name)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_element_text(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetElementText>(move(element_id))->take_response();
    }

    void async_get_element_text(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementText::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_element_text(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementText::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_element_text(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetElementText>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_element_tag_name(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetElementTagName>(move(element_id))->take_response();
    }

    void async_get_element_tag_name(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementTagName::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_element_tag_name(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementTagName::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_element_tag_name(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetElementTagName>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_element_rect(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetElementRect>(move(element_id))->take_response();
    }

    void async_get_element_rect(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementRect::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_element_rect(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetElementRect::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_element_rect(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetElementRect>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response is_element_enabled(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::IsElementEnabled>(move(element_id))->take_response();
    }

    void async_is_element_enabled(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::IsElementEnabled::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_is_element_enabled(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::IsElementEnabled::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_is_element_enabled(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::IsElementEnabled>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_computed_role(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetComputedRole>(move(element_id))->take_response();
    }

    void async_get_computed_role(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetComputedRole::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_computed_role(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetComputedRole::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_computed_role(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetComputedRole>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_computed_label(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetComputedLabel>(move(element_id))->take_response();
    }

    void async_get_computed_label(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetComputedLabel::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_computed_label(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetComputedLabel::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_computed_label(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetComputedLabel>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response element_click(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::ElementClick>(move(element_id))->take_response();
    }

    void async_element_click(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::ElementClick::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_element_click(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::ElementClick::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_element_click(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::ElementClick>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response element_clear(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::ElementClear>(move(element_id))->take_response();
    }

    void async_element_clear(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::ElementClear::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_element_clear(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::ElementClear::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_element_clear(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::ElementClear>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response element_send_keys(String element_id, JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::ElementSendKeys>(move(element_id), move(payload))->take_response();
    }

    void async_element_send_keys(StringView element_id, JsonValue const& payload)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::ElementSendKeys::static_encode(element_id, move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    void async_element_send_keys(String const& element_id, JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::ElementSendKeys::static_encode(element_id, move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_element_send_keys(String element_id, JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::ElementSendKeys>(move(element_id), move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_source()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetSource>()->take_response();
    }

    void async_get_source()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetSource::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_source()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetSource>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response execute_script(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::ExecuteScript>(move(payload))->take_response();
    }

    void async_execute_script(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::ExecuteScript::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_execute_script(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::ExecuteScript>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response execute_async_script(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::ExecuteAsyncScript>(move(payload))->take_response();
    }

    void async_execute_async_script(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::ExecuteAsyncScript::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_execute_async_script(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::ExecuteAsyncScript>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_all_cookies()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetAllCookies>()->take_response();
    }

    void async_get_all_cookies()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetAllCookies::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_all_cookies()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetAllCookies>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_named_cookie(String name)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetNamedCookie>(move(name))->take_response();
    }

    void async_get_named_cookie(StringView name)
    {
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::GetNamedCookie::static_encode(name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_get_named_cookie(String const& name)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetNamedCookie::static_encode(name));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_named_cookie(String name)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetNamedCookie>(move(name)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response add_cookie(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::AddCookie>(move(payload))->take_response();
    }

    void async_add_cookie(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::AddCookie::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_add_cookie(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::AddCookie>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response delete_cookie(String name)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::DeleteCookie>(move(name))->take_response();
    }

    void async_delete_cookie(StringView name)
    {
        VERIFY(Utf8View { name }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::DeleteCookie::static_encode(name));
        (void)m_connection.post_message(message_buffer);
    }

    void async_delete_cookie(String const& name)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::DeleteCookie::static_encode(name));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_delete_cookie(String name)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::DeleteCookie>(move(name)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response delete_all_cookies()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::DeleteAllCookies>()->take_response();
    }

    void async_delete_all_cookies()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::DeleteAllCookies::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_delete_all_cookies()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::DeleteAllCookies>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response perform_actions(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::PerformActions>(move(payload))->take_response();
    }

    void async_perform_actions(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::PerformActions::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_perform_actions(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::PerformActions>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response release_actions()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::ReleaseActions>()->take_response();
    }

    void async_release_actions()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::ReleaseActions::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_release_actions()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::ReleaseActions>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response dismiss_alert()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::DismissAlert>()->take_response();
    }

    void async_dismiss_alert()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::DismissAlert::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_dismiss_alert()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::DismissAlert>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response accept_alert()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::AcceptAlert>()->take_response();
    }

    void async_accept_alert()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::AcceptAlert::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_accept_alert()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::AcceptAlert>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response get_alert_text()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::GetAlertText>()->take_response();
    }

    void async_get_alert_text()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::GetAlertText::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_get_alert_text()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::GetAlertText>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response send_alert_text(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::SendAlertText>(move(payload))->take_response();
    }

    void async_send_alert_text(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::SendAlertText::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_send_alert_text(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::SendAlertText>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response take_screenshot()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::TakeScreenshot>()->take_response();
    }

    void async_take_screenshot()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::TakeScreenshot::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_take_screenshot()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::TakeScreenshot>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response take_element_screenshot(String element_id)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::TakeElementScreenshot>(move(element_id))->take_response();
    }

    void async_take_element_screenshot(StringView element_id)
    {
        VERIFY(Utf8View { element_id }.validate());
        auto message_buffer = MUST(Messages::WebDriverClient::TakeElementScreenshot::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    void async_take_element_screenshot(String const& element_id)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::TakeElementScreenshot::static_encode(element_id));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_take_element_screenshot(String element_id)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::TakeElementScreenshot>(move(element_id)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response print_page(JsonValue payload)
    {
        return m_connection.template send_sync<Messages::WebDriverClient::PrintPage>(move(payload))->take_response();
    }

    void async_print_page(JsonValue const& payload)
    {
        auto message_buffer = MUST(Messages::WebDriverClient::PrintPage::static_encode(move(payload)));
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_print_page(JsonValue payload)
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::PrintPage>(move(payload)))
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

    Web::WebDriver::Response ensure_top_level_browsing_context_is_open()
    {
        return m_connection.template send_sync<Messages::WebDriverClient::EnsureTopLevelBrowsingContextIsOpen>()->take_response();
    }

    void async_ensure_top_level_browsing_context_is_open()
    {
        auto message_buffer = MUST(Messages::WebDriverClient::EnsureTopLevelBrowsingContextIsOpen::static_encode());
        (void)m_connection.post_message(message_buffer);
    }

    IPC::IPCErrorOr<Web::WebDriver::Response> try_ensure_top_level_browsing_context_is_open()
    {
        if (auto result = m_connection.template send_sync_but_allow_failure<Messages::WebDriverClient::EnsureTopLevelBrowsingContextIsOpen>())
            return move(*result);
        m_connection.shutdown();
        return IPC::ErrorCode::PeerDisconnected;
    }

private:
    IPC::Connection<LocalEndpoint, PeerEndpoint>& m_connection;
};

template<typename LocalEndpoint, typename PeerEndpoint>
class WebDriverClientProxy;
class WebDriverClientStub;

class WebDriverClientEndpoint {
public:
    template<typename LocalEndpoint>
    using Proxy = WebDriverClientProxy<LocalEndpoint, WebDriverClientEndpoint>;
    using Stub = WebDriverClientStub;

    static u32 static_magic() { return 4284153835; }

    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::WebDriverClient::MessageID::CloseSession:
            return Messages::WebDriverClient::CloseSession::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::CloseSessionResponse:
            return Messages::WebDriverClient::CloseSessionResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SetPageLoadStrategy:
            return Messages::WebDriverClient::SetPageLoadStrategy::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SetUserPromptHandler:
            return Messages::WebDriverClient::SetUserPromptHandler::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SetStrictFileInteractability:
            return Messages::WebDriverClient::SetStrictFileInteractability::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SetIsWebdriverActive:
            return Messages::WebDriverClient::SetIsWebdriverActive::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetTimeouts:
            return Messages::WebDriverClient::GetTimeouts::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetTimeoutsResponse:
            return Messages::WebDriverClient::GetTimeoutsResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SetTimeouts:
            return Messages::WebDriverClient::SetTimeouts::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SetTimeoutsResponse:
            return Messages::WebDriverClient::SetTimeoutsResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::NavigateTo:
            return Messages::WebDriverClient::NavigateTo::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::NavigateToResponse:
            return Messages::WebDriverClient::NavigateToResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetCurrentUrl:
            return Messages::WebDriverClient::GetCurrentUrl::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetCurrentUrlResponse:
            return Messages::WebDriverClient::GetCurrentUrlResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::Back:
            return Messages::WebDriverClient::Back::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::BackResponse:
            return Messages::WebDriverClient::BackResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::Forward:
            return Messages::WebDriverClient::Forward::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ForwardResponse:
            return Messages::WebDriverClient::ForwardResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::Refresh:
            return Messages::WebDriverClient::Refresh::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::RefreshResponse:
            return Messages::WebDriverClient::RefreshResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetTitle:
            return Messages::WebDriverClient::GetTitle::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetTitleResponse:
            return Messages::WebDriverClient::GetTitleResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::CloseWindow:
            return Messages::WebDriverClient::CloseWindow::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::CloseWindowResponse:
            return Messages::WebDriverClient::CloseWindowResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SwitchToWindow:
            return Messages::WebDriverClient::SwitchToWindow::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SwitchToWindowResponse:
            return Messages::WebDriverClient::SwitchToWindowResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::NewWindow:
            return Messages::WebDriverClient::NewWindow::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::NewWindowResponse:
            return Messages::WebDriverClient::NewWindowResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SwitchToFrame:
            return Messages::WebDriverClient::SwitchToFrame::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SwitchToFrameResponse:
            return Messages::WebDriverClient::SwitchToFrameResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SwitchToParentFrame:
            return Messages::WebDriverClient::SwitchToParentFrame::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SwitchToParentFrameResponse:
            return Messages::WebDriverClient::SwitchToParentFrameResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetWindowRect:
            return Messages::WebDriverClient::GetWindowRect::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetWindowRectResponse:
            return Messages::WebDriverClient::GetWindowRectResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SetWindowRect:
            return Messages::WebDriverClient::SetWindowRect::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SetWindowRectResponse:
            return Messages::WebDriverClient::SetWindowRectResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::MaximizeWindow:
            return Messages::WebDriverClient::MaximizeWindow::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::MaximizeWindowResponse:
            return Messages::WebDriverClient::MaximizeWindowResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::MinimizeWindow:
            return Messages::WebDriverClient::MinimizeWindow::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::MinimizeWindowResponse:
            return Messages::WebDriverClient::MinimizeWindowResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FullscreenWindow:
            return Messages::WebDriverClient::FullscreenWindow::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FullscreenWindowResponse:
            return Messages::WebDriverClient::FullscreenWindowResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ConsumeUserActivation:
            return Messages::WebDriverClient::ConsumeUserActivation::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ConsumeUserActivationResponse:
            return Messages::WebDriverClient::ConsumeUserActivationResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElement:
            return Messages::WebDriverClient::FindElement::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementResponse:
            return Messages::WebDriverClient::FindElementResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElements:
            return Messages::WebDriverClient::FindElements::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementsResponse:
            return Messages::WebDriverClient::FindElementsResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementFromElement:
            return Messages::WebDriverClient::FindElementFromElement::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementFromElementResponse:
            return Messages::WebDriverClient::FindElementFromElementResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementsFromElement:
            return Messages::WebDriverClient::FindElementsFromElement::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementsFromElementResponse:
            return Messages::WebDriverClient::FindElementsFromElementResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementFromShadowRoot:
            return Messages::WebDriverClient::FindElementFromShadowRoot::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementFromShadowRootResponse:
            return Messages::WebDriverClient::FindElementFromShadowRootResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementsFromShadowRoot:
            return Messages::WebDriverClient::FindElementsFromShadowRoot::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::FindElementsFromShadowRootResponse:
            return Messages::WebDriverClient::FindElementsFromShadowRootResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetActiveElement:
            return Messages::WebDriverClient::GetActiveElement::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetActiveElementResponse:
            return Messages::WebDriverClient::GetActiveElementResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementShadowRoot:
            return Messages::WebDriverClient::GetElementShadowRoot::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementShadowRootResponse:
            return Messages::WebDriverClient::GetElementShadowRootResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::IsElementSelected:
            return Messages::WebDriverClient::IsElementSelected::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::IsElementSelectedResponse:
            return Messages::WebDriverClient::IsElementSelectedResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementAttribute:
            return Messages::WebDriverClient::GetElementAttribute::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementAttributeResponse:
            return Messages::WebDriverClient::GetElementAttributeResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementProperty:
            return Messages::WebDriverClient::GetElementProperty::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementPropertyResponse:
            return Messages::WebDriverClient::GetElementPropertyResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementCssValue:
            return Messages::WebDriverClient::GetElementCssValue::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementCssValueResponse:
            return Messages::WebDriverClient::GetElementCssValueResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementText:
            return Messages::WebDriverClient::GetElementText::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementTextResponse:
            return Messages::WebDriverClient::GetElementTextResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementTagName:
            return Messages::WebDriverClient::GetElementTagName::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementTagNameResponse:
            return Messages::WebDriverClient::GetElementTagNameResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementRect:
            return Messages::WebDriverClient::GetElementRect::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetElementRectResponse:
            return Messages::WebDriverClient::GetElementRectResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::IsElementEnabled:
            return Messages::WebDriverClient::IsElementEnabled::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::IsElementEnabledResponse:
            return Messages::WebDriverClient::IsElementEnabledResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetComputedRole:
            return Messages::WebDriverClient::GetComputedRole::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetComputedRoleResponse:
            return Messages::WebDriverClient::GetComputedRoleResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetComputedLabel:
            return Messages::WebDriverClient::GetComputedLabel::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetComputedLabelResponse:
            return Messages::WebDriverClient::GetComputedLabelResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ElementClick:
            return Messages::WebDriverClient::ElementClick::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ElementClickResponse:
            return Messages::WebDriverClient::ElementClickResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ElementClear:
            return Messages::WebDriverClient::ElementClear::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ElementClearResponse:
            return Messages::WebDriverClient::ElementClearResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ElementSendKeys:
            return Messages::WebDriverClient::ElementSendKeys::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ElementSendKeysResponse:
            return Messages::WebDriverClient::ElementSendKeysResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetSource:
            return Messages::WebDriverClient::GetSource::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetSourceResponse:
            return Messages::WebDriverClient::GetSourceResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ExecuteScript:
            return Messages::WebDriverClient::ExecuteScript::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ExecuteScriptResponse:
            return Messages::WebDriverClient::ExecuteScriptResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ExecuteAsyncScript:
            return Messages::WebDriverClient::ExecuteAsyncScript::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ExecuteAsyncScriptResponse:
            return Messages::WebDriverClient::ExecuteAsyncScriptResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetAllCookies:
            return Messages::WebDriverClient::GetAllCookies::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetAllCookiesResponse:
            return Messages::WebDriverClient::GetAllCookiesResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetNamedCookie:
            return Messages::WebDriverClient::GetNamedCookie::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetNamedCookieResponse:
            return Messages::WebDriverClient::GetNamedCookieResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::AddCookie:
            return Messages::WebDriverClient::AddCookie::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::AddCookieResponse:
            return Messages::WebDriverClient::AddCookieResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::DeleteCookie:
            return Messages::WebDriverClient::DeleteCookie::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::DeleteCookieResponse:
            return Messages::WebDriverClient::DeleteCookieResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::DeleteAllCookies:
            return Messages::WebDriverClient::DeleteAllCookies::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::DeleteAllCookiesResponse:
            return Messages::WebDriverClient::DeleteAllCookiesResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::PerformActions:
            return Messages::WebDriverClient::PerformActions::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::PerformActionsResponse:
            return Messages::WebDriverClient::PerformActionsResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ReleaseActions:
            return Messages::WebDriverClient::ReleaseActions::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::ReleaseActionsResponse:
            return Messages::WebDriverClient::ReleaseActionsResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::DismissAlert:
            return Messages::WebDriverClient::DismissAlert::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::DismissAlertResponse:
            return Messages::WebDriverClient::DismissAlertResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::AcceptAlert:
            return Messages::WebDriverClient::AcceptAlert::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::AcceptAlertResponse:
            return Messages::WebDriverClient::AcceptAlertResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetAlertText:
            return Messages::WebDriverClient::GetAlertText::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::GetAlertTextResponse:
            return Messages::WebDriverClient::GetAlertTextResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SendAlertText:
            return Messages::WebDriverClient::SendAlertText::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::SendAlertTextResponse:
            return Messages::WebDriverClient::SendAlertTextResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::TakeScreenshot:
            return Messages::WebDriverClient::TakeScreenshot::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::TakeScreenshotResponse:
            return Messages::WebDriverClient::TakeScreenshotResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::TakeElementScreenshot:
            return Messages::WebDriverClient::TakeElementScreenshot::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::TakeElementScreenshotResponse:
            return Messages::WebDriverClient::TakeElementScreenshotResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::PrintPage:
            return Messages::WebDriverClient::PrintPage::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::PrintPageResponse:
            return Messages::WebDriverClient::PrintPageResponse::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::EnsureTopLevelBrowsingContextIsOpen:
            return Messages::WebDriverClient::EnsureTopLevelBrowsingContextIsOpen::decode(stream, attachments);
        case (int)Messages::WebDriverClient::MessageID::EnsureTopLevelBrowsingContextIsOpenResponse:
            return Messages::WebDriverClient::EnsureTopLevelBrowsingContextIsOpenResponse::decode(stream, attachments);
        default:
            return Error::from_string_literal("Failed to decode WebDriverClient message");
        }

        VERIFY_NOT_REACHED();
    }
};

class WebDriverClientStub : public IPC::Stub {
public:
    WebDriverClientStub() { }
    virtual ~WebDriverClientStub() override { }

    virtual u32 magic() const override { return 4284153835; }
    virtual ByteString name() const override { return "WebDriverClient"; }

    virtual ErrorOr<OwnPtr<IPC::MessageBuffer>> handle(NonnullOwnPtr<IPC::Message> message) override
    {
        switch (message->message_id()) {
        case (int)Messages::WebDriverClient::MessageID::CloseSession:
            return handle_close_session();
        case (int)Messages::WebDriverClient::MessageID::SetPageLoadStrategy:
            return handle_set_page_load_strategy(*message);
        case (int)Messages::WebDriverClient::MessageID::SetUserPromptHandler:
            return handle_set_user_prompt_handler(*message);
        case (int)Messages::WebDriverClient::MessageID::SetStrictFileInteractability:
            return handle_set_strict_file_interactability(*message);
        case (int)Messages::WebDriverClient::MessageID::SetIsWebdriverActive:
            return handle_set_is_webdriver_active(*message);
        case (int)Messages::WebDriverClient::MessageID::GetTimeouts:
            return handle_get_timeouts();
        case (int)Messages::WebDriverClient::MessageID::SetTimeouts:
            return handle_set_timeouts(*message);
        case (int)Messages::WebDriverClient::MessageID::NavigateTo:
            return handle_navigate_to(*message);
        case (int)Messages::WebDriverClient::MessageID::GetCurrentUrl:
            return handle_get_current_url();
        case (int)Messages::WebDriverClient::MessageID::Back:
            return handle_back();
        case (int)Messages::WebDriverClient::MessageID::Forward:
            return handle_forward();
        case (int)Messages::WebDriverClient::MessageID::Refresh:
            return handle_refresh();
        case (int)Messages::WebDriverClient::MessageID::GetTitle:
            return handle_get_title();
        case (int)Messages::WebDriverClient::MessageID::CloseWindow:
            return handle_close_window();
        case (int)Messages::WebDriverClient::MessageID::SwitchToWindow:
            return handle_switch_to_window(*message);
        case (int)Messages::WebDriverClient::MessageID::NewWindow:
            return handle_new_window(*message);
        case (int)Messages::WebDriverClient::MessageID::SwitchToFrame:
            return handle_switch_to_frame(*message);
        case (int)Messages::WebDriverClient::MessageID::SwitchToParentFrame:
            return handle_switch_to_parent_frame(*message);
        case (int)Messages::WebDriverClient::MessageID::GetWindowRect:
            return handle_get_window_rect();
        case (int)Messages::WebDriverClient::MessageID::SetWindowRect:
            return handle_set_window_rect(*message);
        case (int)Messages::WebDriverClient::MessageID::MaximizeWindow:
            return handle_maximize_window();
        case (int)Messages::WebDriverClient::MessageID::MinimizeWindow:
            return handle_minimize_window();
        case (int)Messages::WebDriverClient::MessageID::FullscreenWindow:
            return handle_fullscreen_window();
        case (int)Messages::WebDriverClient::MessageID::ConsumeUserActivation:
            return handle_consume_user_activation();
        case (int)Messages::WebDriverClient::MessageID::FindElement:
            return handle_find_element(*message);
        case (int)Messages::WebDriverClient::MessageID::FindElements:
            return handle_find_elements(*message);
        case (int)Messages::WebDriverClient::MessageID::FindElementFromElement:
            return handle_find_element_from_element(*message);
        case (int)Messages::WebDriverClient::MessageID::FindElementsFromElement:
            return handle_find_elements_from_element(*message);
        case (int)Messages::WebDriverClient::MessageID::FindElementFromShadowRoot:
            return handle_find_element_from_shadow_root(*message);
        case (int)Messages::WebDriverClient::MessageID::FindElementsFromShadowRoot:
            return handle_find_elements_from_shadow_root(*message);
        case (int)Messages::WebDriverClient::MessageID::GetActiveElement:
            return handle_get_active_element();
        case (int)Messages::WebDriverClient::MessageID::GetElementShadowRoot:
            return handle_get_element_shadow_root(*message);
        case (int)Messages::WebDriverClient::MessageID::IsElementSelected:
            return handle_is_element_selected(*message);
        case (int)Messages::WebDriverClient::MessageID::GetElementAttribute:
            return handle_get_element_attribute(*message);
        case (int)Messages::WebDriverClient::MessageID::GetElementProperty:
            return handle_get_element_property(*message);
        case (int)Messages::WebDriverClient::MessageID::GetElementCssValue:
            return handle_get_element_css_value(*message);
        case (int)Messages::WebDriverClient::MessageID::GetElementText:
            return handle_get_element_text(*message);
        case (int)Messages::WebDriverClient::MessageID::GetElementTagName:
            return handle_get_element_tag_name(*message);
        case (int)Messages::WebDriverClient::MessageID::GetElementRect:
            return handle_get_element_rect(*message);
        case (int)Messages::WebDriverClient::MessageID::IsElementEnabled:
            return handle_is_element_enabled(*message);
        case (int)Messages::WebDriverClient::MessageID::GetComputedRole:
            return handle_get_computed_role(*message);
        case (int)Messages::WebDriverClient::MessageID::GetComputedLabel:
            return handle_get_computed_label(*message);
        case (int)Messages::WebDriverClient::MessageID::ElementClick:
            return handle_element_click(*message);
        case (int)Messages::WebDriverClient::MessageID::ElementClear:
            return handle_element_clear(*message);
        case (int)Messages::WebDriverClient::MessageID::ElementSendKeys:
            return handle_element_send_keys(*message);
        case (int)Messages::WebDriverClient::MessageID::GetSource:
            return handle_get_source();
        case (int)Messages::WebDriverClient::MessageID::ExecuteScript:
            return handle_execute_script(*message);
        case (int)Messages::WebDriverClient::MessageID::ExecuteAsyncScript:
            return handle_execute_async_script(*message);
        case (int)Messages::WebDriverClient::MessageID::GetAllCookies:
            return handle_get_all_cookies();
        case (int)Messages::WebDriverClient::MessageID::GetNamedCookie:
            return handle_get_named_cookie(*message);
        case (int)Messages::WebDriverClient::MessageID::AddCookie:
            return handle_add_cookie(*message);
        case (int)Messages::WebDriverClient::MessageID::DeleteCookie:
            return handle_delete_cookie(*message);
        case (int)Messages::WebDriverClient::MessageID::DeleteAllCookies:
            return handle_delete_all_cookies();
        case (int)Messages::WebDriverClient::MessageID::PerformActions:
            return handle_perform_actions(*message);
        case (int)Messages::WebDriverClient::MessageID::ReleaseActions:
            return handle_release_actions();
        case (int)Messages::WebDriverClient::MessageID::DismissAlert:
            return handle_dismiss_alert();
        case (int)Messages::WebDriverClient::MessageID::AcceptAlert:
            return handle_accept_alert();
        case (int)Messages::WebDriverClient::MessageID::GetAlertText:
            return handle_get_alert_text();
        case (int)Messages::WebDriverClient::MessageID::SendAlertText:
            return handle_send_alert_text(*message);
        case (int)Messages::WebDriverClient::MessageID::TakeScreenshot:
            return handle_take_screenshot();
        case (int)Messages::WebDriverClient::MessageID::TakeElementScreenshot:
            return handle_take_element_screenshot(*message);
        case (int)Messages::WebDriverClient::MessageID::PrintPage:
            return handle_print_page(*message);
        case (int)Messages::WebDriverClient::MessageID::EnsureTopLevelBrowsingContextIsOpen:
            return handle_ensure_top_level_browsing_context_is_open();
        default:
            return Error::from_string_literal("Unknown message ID for WebDriverClient endpoint");
        }
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_close_session()
    {
        close_session();
        auto response = Messages::WebDriverClient::CloseSessionResponse {};
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_page_load_strategy(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SetPageLoadStrategy&>(message);
        set_page_load_strategy(request.take_page_load_strategy());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_user_prompt_handler(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SetUserPromptHandler&>(message);
        set_user_prompt_handler(request.take_user_prompt_handler());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_strict_file_interactability(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SetStrictFileInteractability&>(message);
        set_strict_file_interactability(request.strict_file_interactability());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_is_webdriver_active(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SetIsWebdriverActive&>(message);
        set_is_webdriver_active(request.active());
        return nullptr;
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_timeouts()
    {
        auto response = get_timeouts();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_timeouts(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SetTimeouts&>(message);
        auto response = set_timeouts(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_navigate_to(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::NavigateTo&>(message);
        auto response = navigate_to(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_current_url()
    {
        auto response = get_current_url();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_back()
    {
        auto response = back();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_forward()
    {
        auto response = forward();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_refresh()
    {
        auto response = refresh();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_title()
    {
        auto response = get_title();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_close_window()
    {
        auto response = close_window();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_switch_to_window(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SwitchToWindow&>(message);
        auto response = switch_to_window(request.take_handle());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_new_window(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::NewWindow&>(message);
        auto response = new_window(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_switch_to_frame(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SwitchToFrame&>(message);
        auto response = switch_to_frame(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_switch_to_parent_frame(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SwitchToParentFrame&>(message);
        auto response = switch_to_parent_frame(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_window_rect()
    {
        auto response = get_window_rect();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_set_window_rect(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SetWindowRect&>(message);
        auto response = set_window_rect(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_maximize_window()
    {
        auto response = maximize_window();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_minimize_window()
    {
        auto response = minimize_window();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_fullscreen_window()
    {
        auto response = fullscreen_window();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_consume_user_activation()
    {
        auto response = consume_user_activation();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_element(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::FindElement&>(message);
        auto response = find_element(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_elements(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::FindElements&>(message);
        auto response = find_elements(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_element_from_element(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::FindElementFromElement&>(message);
        auto response = find_element_from_element(request.take_payload(), request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_elements_from_element(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::FindElementsFromElement&>(message);
        auto response = find_elements_from_element(request.take_payload(), request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_element_from_shadow_root(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::FindElementFromShadowRoot&>(message);
        auto response = find_element_from_shadow_root(request.take_payload(), request.take_shadow_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_find_elements_from_shadow_root(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::FindElementsFromShadowRoot&>(message);
        auto response = find_elements_from_shadow_root(request.take_payload(), request.take_shadow_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_active_element()
    {
        auto response = get_active_element();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_element_shadow_root(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetElementShadowRoot&>(message);
        auto response = get_element_shadow_root(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_is_element_selected(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::IsElementSelected&>(message);
        auto response = is_element_selected(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_element_attribute(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetElementAttribute&>(message);
        auto response = get_element_attribute(request.take_element_id(), request.take_name());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_element_property(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetElementProperty&>(message);
        auto response = get_element_property(request.take_element_id(), request.take_name());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_element_css_value(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetElementCssValue&>(message);
        auto response = get_element_css_value(request.take_element_id(), request.take_name());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_element_text(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetElementText&>(message);
        auto response = get_element_text(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_element_tag_name(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetElementTagName&>(message);
        auto response = get_element_tag_name(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_element_rect(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetElementRect&>(message);
        auto response = get_element_rect(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_is_element_enabled(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::IsElementEnabled&>(message);
        auto response = is_element_enabled(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_computed_role(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetComputedRole&>(message);
        auto response = get_computed_role(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_computed_label(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetComputedLabel&>(message);
        auto response = get_computed_label(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_element_click(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::ElementClick&>(message);
        auto response = element_click(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_element_clear(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::ElementClear&>(message);
        auto response = element_clear(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_element_send_keys(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::ElementSendKeys&>(message);
        auto response = element_send_keys(request.take_element_id(), request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_source()
    {
        auto response = get_source();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_execute_script(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::ExecuteScript&>(message);
        auto response = execute_script(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_execute_async_script(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::ExecuteAsyncScript&>(message);
        auto response = execute_async_script(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_all_cookies()
    {
        auto response = get_all_cookies();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_named_cookie(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::GetNamedCookie&>(message);
        auto response = get_named_cookie(request.take_name());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_add_cookie(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::AddCookie&>(message);
        auto response = add_cookie(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_delete_cookie(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::DeleteCookie&>(message);
        auto response = delete_cookie(request.take_name());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_delete_all_cookies()
    {
        auto response = delete_all_cookies();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_perform_actions(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::PerformActions&>(message);
        auto response = perform_actions(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_release_actions()
    {
        auto response = release_actions();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_dismiss_alert()
    {
        auto response = dismiss_alert();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_accept_alert()
    {
        auto response = accept_alert();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_get_alert_text()
    {
        auto response = get_alert_text();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_send_alert_text(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::SendAlertText&>(message);
        auto response = send_alert_text(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_take_screenshot()
    {
        auto response = take_screenshot();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_take_element_screenshot(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::TakeElementScreenshot&>(message);
        auto response = take_element_screenshot(request.take_element_id());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_print_page(IPC::Message& message)
    {
        auto& request = static_cast<Messages::WebDriverClient::PrintPage&>(message);
        auto response = print_page(request.take_payload());
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    NEVER_INLINE ErrorOr<OwnPtr<IPC::MessageBuffer>> handle_ensure_top_level_browsing_context_is_open()
    {
        auto response = ensure_top_level_browsing_context_is_open();
        return make<IPC::MessageBuffer>(TRY(response.encode()));
    }

    virtual void close_session() = 0;
    virtual void set_page_load_strategy(Web::WebDriver::PageLoadStrategy page_load_strategy) = 0;
    virtual void set_user_prompt_handler(Web::WebDriver::UserPromptHandler user_prompt_handler) = 0;
    virtual void set_strict_file_interactability(bool strict_file_interactability) = 0;
    virtual void set_is_webdriver_active(bool active) = 0;
    virtual Messages::WebDriverClient::GetTimeoutsResponse get_timeouts() = 0;
    virtual Messages::WebDriverClient::SetTimeoutsResponse set_timeouts(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::NavigateToResponse navigate_to(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::GetCurrentUrlResponse get_current_url() = 0;
    virtual Messages::WebDriverClient::BackResponse back() = 0;
    virtual Messages::WebDriverClient::ForwardResponse forward() = 0;
    virtual Messages::WebDriverClient::RefreshResponse refresh() = 0;
    virtual Messages::WebDriverClient::GetTitleResponse get_title() = 0;
    virtual Messages::WebDriverClient::CloseWindowResponse close_window() = 0;
    virtual Messages::WebDriverClient::SwitchToWindowResponse switch_to_window(String handle) = 0;
    virtual Messages::WebDriverClient::NewWindowResponse new_window(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::SwitchToFrameResponse switch_to_frame(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::SwitchToParentFrameResponse switch_to_parent_frame(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::GetWindowRectResponse get_window_rect() = 0;
    virtual Messages::WebDriverClient::SetWindowRectResponse set_window_rect(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::MaximizeWindowResponse maximize_window() = 0;
    virtual Messages::WebDriverClient::MinimizeWindowResponse minimize_window() = 0;
    virtual Messages::WebDriverClient::FullscreenWindowResponse fullscreen_window() = 0;
    virtual Messages::WebDriverClient::ConsumeUserActivationResponse consume_user_activation() = 0;
    virtual Messages::WebDriverClient::FindElementResponse find_element(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::FindElementsResponse find_elements(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::FindElementFromElementResponse find_element_from_element(JsonValue payload, String element_id) = 0;
    virtual Messages::WebDriverClient::FindElementsFromElementResponse find_elements_from_element(JsonValue payload, String element_id) = 0;
    virtual Messages::WebDriverClient::FindElementFromShadowRootResponse find_element_from_shadow_root(JsonValue payload, String shadow_id) = 0;
    virtual Messages::WebDriverClient::FindElementsFromShadowRootResponse find_elements_from_shadow_root(JsonValue payload, String shadow_id) = 0;
    virtual Messages::WebDriverClient::GetActiveElementResponse get_active_element() = 0;
    virtual Messages::WebDriverClient::GetElementShadowRootResponse get_element_shadow_root(String element_id) = 0;
    virtual Messages::WebDriverClient::IsElementSelectedResponse is_element_selected(String element_id) = 0;
    virtual Messages::WebDriverClient::GetElementAttributeResponse get_element_attribute(String element_id, String name) = 0;
    virtual Messages::WebDriverClient::GetElementPropertyResponse get_element_property(String element_id, String name) = 0;
    virtual Messages::WebDriverClient::GetElementCssValueResponse get_element_css_value(String element_id, String name) = 0;
    virtual Messages::WebDriverClient::GetElementTextResponse get_element_text(String element_id) = 0;
    virtual Messages::WebDriverClient::GetElementTagNameResponse get_element_tag_name(String element_id) = 0;
    virtual Messages::WebDriverClient::GetElementRectResponse get_element_rect(String element_id) = 0;
    virtual Messages::WebDriverClient::IsElementEnabledResponse is_element_enabled(String element_id) = 0;
    virtual Messages::WebDriverClient::GetComputedRoleResponse get_computed_role(String element_id) = 0;
    virtual Messages::WebDriverClient::GetComputedLabelResponse get_computed_label(String element_id) = 0;
    virtual Messages::WebDriverClient::ElementClickResponse element_click(String element_id) = 0;
    virtual Messages::WebDriverClient::ElementClearResponse element_clear(String element_id) = 0;
    virtual Messages::WebDriverClient::ElementSendKeysResponse element_send_keys(String element_id, JsonValue payload) = 0;
    virtual Messages::WebDriverClient::GetSourceResponse get_source() = 0;
    virtual Messages::WebDriverClient::ExecuteScriptResponse execute_script(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::ExecuteAsyncScriptResponse execute_async_script(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::GetAllCookiesResponse get_all_cookies() = 0;
    virtual Messages::WebDriverClient::GetNamedCookieResponse get_named_cookie(String name) = 0;
    virtual Messages::WebDriverClient::AddCookieResponse add_cookie(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::DeleteCookieResponse delete_cookie(String name) = 0;
    virtual Messages::WebDriverClient::DeleteAllCookiesResponse delete_all_cookies() = 0;
    virtual Messages::WebDriverClient::PerformActionsResponse perform_actions(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::ReleaseActionsResponse release_actions() = 0;
    virtual Messages::WebDriverClient::DismissAlertResponse dismiss_alert() = 0;
    virtual Messages::WebDriverClient::AcceptAlertResponse accept_alert() = 0;
    virtual Messages::WebDriverClient::GetAlertTextResponse get_alert_text() = 0;
    virtual Messages::WebDriverClient::SendAlertTextResponse send_alert_text(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::TakeScreenshotResponse take_screenshot() = 0;
    virtual Messages::WebDriverClient::TakeElementScreenshotResponse take_element_screenshot(String element_id) = 0;
    virtual Messages::WebDriverClient::PrintPageResponse print_page(JsonValue payload) = 0;
    virtual Messages::WebDriverClient::EnsureTopLevelBrowsingContextIsOpenResponse ensure_top_level_browsing_context_is_open() = 0;
};

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