browser-commander 0.14.0

// @generated by scripts/generate-playwright-protocol.mjs from
// rust/protocol/playwright/*.yml. Do not edit by hand.

#![allow(clippy::all, missing_docs, unused_imports)]

use serde::{Deserialize, Serialize};

use super::*;
use crate::playwright::connection::{
    Binary, Channel, ChannelType, ObjectRef, ProtocolError, ProtocolEvent, Ref,
};

/// Parameters of `Frame.waitForFunction` (Wait for function).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrameWaitForFunctionParams {
    #[serde(rename = "expression")]
    pub expression: String,
    #[serde(rename = "isFunction", default, skip_serializing_if = "Option::is_none")]
    pub is_function: Option<bool>,
    #[serde(rename = "arg")]
    pub arg: SerializedArgument,
    #[serde(rename = "pollingInterval", default, skip_serializing_if = "Option::is_none")]
    pub polling_interval: Option<f64>,
    #[serde(rename = "selector", default, skip_serializing_if = "Option::is_none")]
    pub selector: Option<String>,
    #[serde(rename = "strict", default, skip_serializing_if = "Option::is_none")]
    pub strict: Option<bool>,
}

/// Result of `Frame.waitForFunction` (Wait for function).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrameWaitForFunctionResult {
    #[serde(rename = "handle", default, skip_serializing_if = "Option::is_none")]
    pub handle: Option<Ref<JSHandle>>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum FrameWaitForSelectorParamsState {
    #[default]
    #[serde(rename = "attached")]
    Attached,
    #[serde(rename = "detached")]
    Detached,
    #[serde(rename = "visible")]
    Visible,
    #[serde(rename = "hidden")]
    Hidden,
}

/// Parameters of `Frame.waitForSelector` (Wait for selector).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrameWaitForSelectorParams {
    #[serde(rename = "selector")]
    pub selector: String,
    #[serde(rename = "strict", default, skip_serializing_if = "Option::is_none")]
    pub strict: Option<bool>,
    #[serde(rename = "state", default, skip_serializing_if = "Option::is_none")]
    pub state: Option<FrameWaitForSelectorParamsState>,
    #[serde(rename = "omitReturnValue", default, skip_serializing_if = "Option::is_none")]
    pub omit_return_value: Option<bool>,
}

/// Result of `Frame.waitForSelector` (Wait for selector).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrameWaitForSelectorResult {
    #[serde(rename = "element", default, skip_serializing_if = "Option::is_none")]
    pub element: Option<Ref<ElementHandle>>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum FrameExpectParamsPseudo {
    #[default]
    #[serde(rename = "before")]
    Before,
    #[serde(rename = "after")]
    After,
}

/// Parameters of `Frame.expect` (Expect "{expression}").
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrameExpectParams {
    #[serde(rename = "selector", default, skip_serializing_if = "Option::is_none")]
    pub selector: Option<String>,
    #[serde(rename = "expression")]
    pub expression: String,
    #[serde(rename = "expressionArg", default, skip_serializing_if = "Option::is_none")]
    pub expression_arg: Option<serde_json::Value>,
    #[serde(rename = "pseudo", default, skip_serializing_if = "Option::is_none")]
    pub pseudo: Option<FrameExpectParamsPseudo>,
    #[serde(rename = "expectedText", default, skip_serializing_if = "Option::is_none")]
    pub expected_text: Option<Vec<ExpectedTextValue>>,
    #[serde(rename = "expectedNumber", default, skip_serializing_if = "Option::is_none")]
    pub expected_number: Option<f64>,
    #[serde(rename = "expectedValue", default, skip_serializing_if = "Option::is_none")]
    pub expected_value: Option<SerializedArgument>,
    #[serde(rename = "useInnerText", default, skip_serializing_if = "Option::is_none")]
    pub use_inner_text: Option<bool>,
    #[serde(rename = "isNot")]
    pub is_not: bool,
}

/// Payload of the `Frame.loadstate` event.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrameLoadstateEventParams {
    #[serde(rename = "add", default, skip_serializing_if = "Option::is_none")]
    pub add: Option<LifecycleEvent>,
    #[serde(rename = "remove", default, skip_serializing_if = "Option::is_none")]
    pub remove: Option<LifecycleEvent>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrameNavigatedEventParamsNewDocument {
    #[serde(rename = "request", default, skip_serializing_if = "Option::is_none")]
    pub request: Option<Ref<Request>>,
}

/// Payload of the `Frame.navigated` event.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FrameNavigatedEventParams {
    #[serde(rename = "url")]
    pub url: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "newDocument", default, skip_serializing_if = "Option::is_none")]
    pub new_document: Option<FrameNavigatedEventParamsNewDocument>,
    #[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// Events a `Frame` channel can emit.
#[derive(Debug, Clone, PartialEq)]
pub enum FrameEvent {
    /// `Frame.loadstate`
    Loadstate(FrameLoadstateEventParams),
    /// `Frame.navigated`
    Navigated(FrameNavigatedEventParams),
    /// An event this binding does not know (a newer driver).
    Unknown {
        /// Event name.
        method: String,
        /// Raw event parameters.
        params: serde_json::Value,
    },
}

impl ProtocolEvent for FrameEvent {
    fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
        match method {
            "loadstate" => Ok(Self::Loadstate(serde_json::from_value(params)?)),
            "navigated" => Ok(Self::Navigated(serde_json::from_value(params)?)),
            _ => Ok(Self::Unknown { method: method.to_string(), params }),
        }
    }
}

/// Channel for the `Frame` interface (`frame.yml`).
#[derive(Debug, Clone)]
pub struct Frame {
    channel: Channel,
}

impl ChannelType for Frame {
    const INTERFACE: &'static str = "Frame";
    type Initializer = FrameInitializer;
    type Event = FrameEvent;

    fn accepts(interface: &str) -> bool {
        matches!(interface, "Frame")
    }

    fn from_channel(channel: Channel) -> Self {
        Self { channel }
    }

    fn channel(&self) -> &Channel {
        &self.channel
    }
}

impl Frame {
    /// `Frame.evalOnSelector` ("Evaluate").
    pub async fn eval_on_selector(&self, params: FrameEvalOnSelectorParams) -> Result<FrameEvalOnSelectorResult, ProtocolError> {
        self.channel.send("evalOnSelector", &params).await
    }

    /// `Frame.evalOnSelectorAll` ("Evaluate").
    pub async fn eval_on_selector_all(&self, params: FrameEvalOnSelectorAllParams) -> Result<FrameEvalOnSelectorAllResult, ProtocolError> {
        self.channel.send("evalOnSelectorAll", &params).await
    }

    /// `Frame.addScriptTag` ("Add script tag").
    pub async fn add_script_tag(&self, params: FrameAddScriptTagParams) -> Result<FrameAddScriptTagResult, ProtocolError> {
        self.channel.send("addScriptTag", &params).await
    }

    /// `Frame.addStyleTag` ("Add style tag").
    pub async fn add_style_tag(&self, params: FrameAddStyleTagParams) -> Result<FrameAddStyleTagResult, ProtocolError> {
        self.channel.send("addStyleTag", &params).await
    }

    /// `Frame.ariaSnapshot` ("Aria snapshot").
    pub async fn aria_snapshot(&self, params: FrameAriaSnapshotParams) -> Result<FrameAriaSnapshotResult, ProtocolError> {
        self.channel.send("ariaSnapshot", &params).await
    }

    /// `Frame.blur` ("Blur").
    pub async fn blur(&self, params: FrameBlurParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("blur", &params).await
    }

    /// `Frame.check` ("Check").
    pub async fn check(&self, params: FrameCheckParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("check", &params).await
    }

    /// `Frame.click` ("Click").
    pub async fn click(&self, params: FrameClickParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("click", &params).await
    }

    /// `Frame.content` ("Get content").
    pub async fn content(&self) -> Result<FrameContentResult, ProtocolError> {
        self.channel.send("content", &serde_json::json!({})).await
    }

    /// `Frame.dragAndDrop` ("Drag and drop").
    pub async fn drag_and_drop(&self, params: FrameDragAndDropParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("dragAndDrop", &params).await
    }

    /// `Frame.drop` ("Drop files or data onto an element").
    pub async fn drop(&self, params: FrameDropParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("drop", &params).await
    }

    /// `Frame.dblclick` ("Double click").
    pub async fn dblclick(&self, params: FrameDblclickParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("dblclick", &params).await
    }

    /// `Frame.dispatchEvent` ("Dispatch "{type}"").
    pub async fn dispatch_event(&self, params: FrameDispatchEventParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("dispatchEvent", &params).await
    }

    /// `Frame.evaluateExpression` ("Evaluate").
    pub async fn evaluate_expression(&self, params: FrameEvaluateExpressionParams) -> Result<FrameEvaluateExpressionResult, ProtocolError> {
        self.channel.send("evaluateExpression", &params).await
    }

    /// `Frame.evaluateExpressionHandle` ("Evaluate").
    pub async fn evaluate_expression_handle(&self, params: FrameEvaluateExpressionHandleParams) -> Result<FrameEvaluateExpressionHandleResult, ProtocolError> {
        self.channel.send("evaluateExpressionHandle", &params).await
    }

    /// `Frame.fill` ("Fill "{value}"").
    pub async fn fill(&self, params: FrameFillParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("fill", &params).await
    }

    /// `Frame.focus` ("Focus").
    pub async fn focus(&self, params: FrameFocusParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("focus", &params).await
    }

    /// `Frame.frameElement` ("Get frame element").
    pub async fn frame_element(&self) -> Result<FrameFrameElementResult, ProtocolError> {
        self.channel.send("frameElement", &serde_json::json!({})).await
    }

    /// `Frame.resolveSelector` (internal).
    pub async fn resolve_selector(&self, params: FrameResolveSelectorParams) -> Result<FrameResolveSelectorResult, ProtocolError> {
        self.channel.send("resolveSelector", &params).await
    }

    /// `Frame.highlight` (internal).
    pub async fn highlight(&self, params: FrameHighlightParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("highlight", &params).await
    }

    /// `Frame.hideHighlight` (internal).
    pub async fn hide_highlight(&self, params: FrameHideHighlightParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("hideHighlight", &params).await
    }

    /// `Frame.getAttribute` ("Get attribute "{name}"").
    pub async fn get_attribute(&self, params: FrameGetAttributeParams) -> Result<FrameGetAttributeResult, ProtocolError> {
        self.channel.send("getAttribute", &params).await
    }

    /// `Frame.goto` ("Navigate to "{url}"").
    pub async fn goto(&self, params: FrameGotoParams) -> Result<FrameGotoResult, ProtocolError> {
        self.channel.send("goto", &params).await
    }

    /// `Frame.hover` ("Hover").
    pub async fn hover(&self, params: FrameHoverParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("hover", &params).await
    }

    /// `Frame.innerHTML` ("Get HTML").
    pub async fn inner_html(&self, params: FrameInnerHTMLParams) -> Result<FrameInnerHTMLResult, ProtocolError> {
        self.channel.send("innerHTML", &params).await
    }

    /// `Frame.innerText` ("Get inner text").
    pub async fn inner_text(&self, params: FrameInnerTextParams) -> Result<FrameInnerTextResult, ProtocolError> {
        self.channel.send("innerText", &params).await
    }

    /// `Frame.inputValue` ("Get input value").
    pub async fn input_value(&self, params: FrameInputValueParams) -> Result<FrameInputValueResult, ProtocolError> {
        self.channel.send("inputValue", &params).await
    }

    /// `Frame.isChecked` ("Is checked").
    pub async fn is_checked(&self, params: FrameIsCheckedParams) -> Result<FrameIsCheckedResult, ProtocolError> {
        self.channel.send("isChecked", &params).await
    }

    /// `Frame.isDisabled` ("Is disabled").
    pub async fn is_disabled(&self, params: FrameIsDisabledParams) -> Result<FrameIsDisabledResult, ProtocolError> {
        self.channel.send("isDisabled", &params).await
    }

    /// `Frame.isEnabled` ("Is enabled").
    pub async fn is_enabled(&self, params: FrameIsEnabledParams) -> Result<FrameIsEnabledResult, ProtocolError> {
        self.channel.send("isEnabled", &params).await
    }

    /// `Frame.isHidden` ("Is hidden").
    pub async fn is_hidden(&self, params: FrameIsHiddenParams) -> Result<FrameIsHiddenResult, ProtocolError> {
        self.channel.send("isHidden", &params).await
    }

    /// `Frame.isVisible` ("Is visible").
    pub async fn is_visible(&self, params: FrameIsVisibleParams) -> Result<FrameIsVisibleResult, ProtocolError> {
        self.channel.send("isVisible", &params).await
    }

    /// `Frame.isEditable` ("Is editable").
    pub async fn is_editable(&self, params: FrameIsEditableParams) -> Result<FrameIsEditableResult, ProtocolError> {
        self.channel.send("isEditable", &params).await
    }

    /// `Frame.press` ("Press "{key}"").
    pub async fn press(&self, params: FramePressParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("press", &params).await
    }

    /// `Frame.querySelector` ("Query selector").
    pub async fn query_selector(&self, params: FrameQuerySelectorParams) -> Result<FrameQuerySelectorResult, ProtocolError> {
        self.channel.send("querySelector", &params).await
    }

    /// `Frame.querySelectorAll` ("Query selector all").
    pub async fn query_selector_all(&self, params: FrameQuerySelectorAllParams) -> Result<FrameQuerySelectorAllResult, ProtocolError> {
        self.channel.send("querySelectorAll", &params).await
    }

    /// `Frame.queryCount` ("Query count").
    pub async fn query_count(&self, params: FrameQueryCountParams) -> Result<FrameQueryCountResult, ProtocolError> {
        self.channel.send("queryCount", &params).await
    }

    /// `Frame.selectOption` ("Select option").
    pub async fn select_option(&self, params: FrameSelectOptionParams) -> Result<FrameSelectOptionResult, ProtocolError> {
        self.channel.send("selectOption", &params).await
    }

    /// `Frame.setContent` ("Set content").
    pub async fn set_content(&self, params: FrameSetContentParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("setContent", &params).await
    }

    /// `Frame.setInputFiles` ("Set input files").
    pub async fn set_input_files(&self, params: FrameSetInputFilesParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("setInputFiles", &params).await
    }

    /// `Frame.tap` ("Tap").
    pub async fn tap(&self, params: FrameTapParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("tap", &params).await
    }

    /// `Frame.textContent` ("Get text content").
    pub async fn text_content(&self, params: FrameTextContentParams) -> Result<FrameTextContentResult, ProtocolError> {
        self.channel.send("textContent", &params).await
    }

    /// `Frame.title` ("Get page title").
    pub async fn title(&self) -> Result<FrameTitleResult, ProtocolError> {
        self.channel.send("title", &serde_json::json!({})).await
    }

    /// `Frame.type` ("Type "{text}"").
    pub async fn r#type(&self, params: FrameTypeParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("type", &params).await
    }

    /// `Frame.uncheck` ("Uncheck").
    pub async fn uncheck(&self, params: FrameUncheckParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("uncheck", &params).await
    }

    /// `Frame.waitForTimeout` ("Wait for timeout").
    pub async fn wait_for_timeout(&self, params: FrameWaitForTimeoutParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("waitForTimeout", &params).await
    }

    /// `Frame.waitForFunction` ("Wait for function").
    pub async fn wait_for_function(&self, params: FrameWaitForFunctionParams) -> Result<FrameWaitForFunctionResult, ProtocolError> {
        self.channel.send("waitForFunction", &params).await
    }

    /// `Frame.waitForSelector` ("Wait for selector").
    pub async fn wait_for_selector(&self, params: FrameWaitForSelectorParams) -> Result<FrameWaitForSelectorResult, ProtocolError> {
        self.channel.send("waitForSelector", &params).await
    }

    /// `Frame.expect` ("Expect "{expression}"").
    pub async fn expect(&self, params: FrameExpectParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("expect", &params).await
    }
}