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

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BrowserInitializerBrowserName {
    #[default]
    #[serde(rename = "chromium")]
    Chromium,
    #[serde(rename = "firefox")]
    Firefox,
    #[serde(rename = "webkit")]
    Webkit,
}

/// Initializer the driver sends when it creates a `Browser`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserInitializer {
    #[serde(rename = "version")]
    pub version: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "browserName")]
    pub browser_name: BrowserInitializerBrowserName,
}

/// Parameters of `Browser.startServer` (Start server).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserStartServerParams {
    #[serde(rename = "title")]
    pub title: String,
    #[serde(rename = "workspaceDir", default, skip_serializing_if = "Option::is_none")]
    pub workspace_dir: Option<String>,
    #[serde(rename = "metadata", default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Value>,
    #[serde(rename = "host", default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(rename = "port", default, skip_serializing_if = "Option::is_none")]
    pub port: Option<i64>,
}

/// Result of `Browser.startServer` (Start server).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserStartServerResult {
    #[serde(rename = "endpoint")]
    pub endpoint: String,
}

/// Parameters of `Browser.close` (Close browser).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserCloseParams {
    #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// Result of `Browser.defaultUserAgentForTest`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserDefaultUserAgentForTestResult {
    #[serde(rename = "userAgent")]
    pub user_agent: String,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewContextParamsProxy {
    #[serde(rename = "server")]
    pub server: String,
    #[serde(rename = "bypass", default, skip_serializing_if = "Option::is_none")]
    pub bypass: Option<String>,
    #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(rename = "password", default, skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewContextParamsStorageState {
    #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
    pub cookies: Option<Vec<SetNetworkCookie>>,
    #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
    pub origins: Option<Vec<SetOriginStorage>>,
    #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
    pub credentials: Option<Vec<VirtualCredential>>,
}

/// Parameters of `Browser.newContext` (Create context).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewContextParams {
    /// Properties of the `ContextOptions` mixin.
    #[serde(flatten)]
    pub context_options: ContextOptions,
    #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
    pub proxy: Option<BrowserNewContextParamsProxy>,
    #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
    pub storage_state: Option<BrowserNewContextParamsStorageState>,
}

/// Result of `Browser.newContext` (Create context).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewContextResult {
    #[serde(rename = "context")]
    pub context: Ref<BrowserContext>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewContextForReuseParamsProxy {
    #[serde(rename = "server")]
    pub server: String,
    #[serde(rename = "bypass", default, skip_serializing_if = "Option::is_none")]
    pub bypass: Option<String>,
    #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(rename = "password", default, skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewContextForReuseParamsStorageState {
    #[serde(rename = "cookies", default, skip_serializing_if = "Option::is_none")]
    pub cookies: Option<Vec<SetNetworkCookie>>,
    #[serde(rename = "origins", default, skip_serializing_if = "Option::is_none")]
    pub origins: Option<Vec<SetOriginStorage>>,
    #[serde(rename = "credentials", default, skip_serializing_if = "Option::is_none")]
    pub credentials: Option<Vec<VirtualCredential>>,
}

/// Parameters of `Browser.newContextForReuse`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewContextForReuseParams {
    /// Properties of the `ContextOptions` mixin.
    #[serde(flatten)]
    pub context_options: ContextOptions,
    #[serde(rename = "proxy", default, skip_serializing_if = "Option::is_none")]
    pub proxy: Option<BrowserNewContextForReuseParamsProxy>,
    #[serde(rename = "storageState", default, skip_serializing_if = "Option::is_none")]
    pub storage_state: Option<BrowserNewContextForReuseParamsStorageState>,
}

/// Result of `Browser.newContextForReuse`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewContextForReuseResult {
    #[serde(rename = "context")]
    pub context: Ref<BrowserContext>,
}

/// Parameters of `Browser.disconnectFromReusedContext`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserDisconnectFromReusedContextParams {
    #[serde(rename = "reason")]
    pub reason: String,
}

/// Result of `Browser.newBrowserCDPSession` (Create CDP session).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserNewBrowserCDPSessionResult {
    #[serde(rename = "session")]
    pub session: Ref<CDPSession>,
}

/// Parameters of `Browser.startTracing` (Start browser tracing).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserStartTracingParams {
    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
    pub page: Option<Ref<Page>>,
    #[serde(rename = "screenshots", default, skip_serializing_if = "Option::is_none")]
    pub screenshots: Option<bool>,
    #[serde(rename = "categories", default, skip_serializing_if = "Option::is_none")]
    pub categories: Option<Vec<String>>,
}

/// Result of `Browser.stopTracing` (Stop browser tracing).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserStopTracingResult {
    #[serde(rename = "artifact")]
    pub artifact: Ref<Artifact>,
}

/// Payload of the `Browser.context` event.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BrowserContextEventParams {
    #[serde(rename = "context")]
    pub context: Ref<BrowserContext>,
}

/// Events a `Browser` channel can emit.
#[derive(Debug, Clone, PartialEq)]
pub enum BrowserEvent {
    /// `Browser.context`
    Context(BrowserContextEventParams),
    /// `Browser.close`
    Close,
    /// 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 BrowserEvent {
    fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
        match method {
            "context" => Ok(Self::Context(serde_json::from_value(params)?)),
            "close" => Ok(Self::Close),
            _ => Ok(Self::Unknown { method: method.to_string(), params }),
        }
    }
}

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

impl ChannelType for Browser {
    const INTERFACE: &'static str = "Browser";
    type Initializer = BrowserInitializer;
    type Event = BrowserEvent;

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

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

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

impl Browser {
    /// `Browser.startServer` ("Start server").
    pub async fn start_server(&self, params: BrowserStartServerParams) -> Result<BrowserStartServerResult, ProtocolError> {
        self.channel.send("startServer", &params).await
    }

    /// `Browser.stopServer` ("Stop server").
    pub async fn stop_server(&self) -> Result<(), ProtocolError> {
        self.channel.send_no_result("stopServer", &serde_json::json!({})).await
    }

    /// `Browser.close` ("Close browser").
    pub async fn close(&self, params: BrowserCloseParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("close", &params).await
    }

    /// `Browser.killForTests` (internal).
    pub async fn kill_for_tests(&self) -> Result<(), ProtocolError> {
        self.channel.send_no_result("killForTests", &serde_json::json!({})).await
    }

    /// `Browser.defaultUserAgentForTest` (internal).
    pub async fn default_user_agent_for_test(&self) -> Result<BrowserDefaultUserAgentForTestResult, ProtocolError> {
        self.channel.send("defaultUserAgentForTest", &serde_json::json!({})).await
    }

    /// `Browser.newContext` ("Create context").
    pub async fn new_context(&self, params: BrowserNewContextParams) -> Result<BrowserNewContextResult, ProtocolError> {
        self.channel.send("newContext", &params).await
    }

    /// `Browser.newContextForReuse` (internal).
    pub async fn new_context_for_reuse(&self, params: BrowserNewContextForReuseParams) -> Result<BrowserNewContextForReuseResult, ProtocolError> {
        self.channel.send("newContextForReuse", &params).await
    }

    /// `Browser.disconnectFromReusedContext` (internal).
    pub async fn disconnect_from_reused_context(&self, params: BrowserDisconnectFromReusedContextParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("disconnectFromReusedContext", &params).await
    }

    /// `Browser.newBrowserCDPSession` ("Create CDP session").
    pub async fn new_browser_cdp_session(&self) -> Result<BrowserNewBrowserCDPSessionResult, ProtocolError> {
        self.channel.send("newBrowserCDPSession", &serde_json::json!({})).await
    }

    /// `Browser.startTracing` ("Start browser tracing").
    pub async fn start_tracing(&self, params: BrowserStartTracingParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("startTracing", &params).await
    }

    /// `Browser.stopTracing` ("Stop browser tracing").
    pub async fn stop_tracing(&self) -> Result<BrowserStopTracingResult, ProtocolError> {
        self.channel.send("stopTracing", &serde_json::json!({})).await
    }
}