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, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsInitializerDeviceDescriptorsDescriptorViewport {
    #[serde(rename = "width")]
    pub width: i64,
    #[serde(rename = "height")]
    pub height: i64,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsInitializerDeviceDescriptorsDescriptorScreen {
    #[serde(rename = "width")]
    pub width: i64,
    #[serde(rename = "height")]
    pub height: i64,
}

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

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsInitializerDeviceDescriptorsDescriptor {
    #[serde(rename = "userAgent")]
    pub user_agent: String,
    #[serde(rename = "viewport")]
    pub viewport: LocalUtilsInitializerDeviceDescriptorsDescriptorViewport,
    #[serde(rename = "screen", default, skip_serializing_if = "Option::is_none")]
    pub screen: Option<LocalUtilsInitializerDeviceDescriptorsDescriptorScreen>,
    #[serde(rename = "deviceScaleFactor")]
    pub device_scale_factor: f64,
    #[serde(rename = "isMobile")]
    pub is_mobile: bool,
    #[serde(rename = "hasTouch")]
    pub has_touch: bool,
    #[serde(rename = "defaultBrowserType")]
    pub default_browser_type: LocalUtilsInitializerDeviceDescriptorsDescriptorDefaultBrowserType,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsInitializerDeviceDescriptors {
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "descriptor")]
    pub descriptor: LocalUtilsInitializerDeviceDescriptorsDescriptor,
}

/// Initializer the driver sends when it creates a `LocalUtils`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsInitializer {
    #[serde(rename = "deviceDescriptors")]
    pub device_descriptors: Vec<LocalUtilsInitializerDeviceDescriptors>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum LocalUtilsZipParamsMode {
    #[default]
    #[serde(rename = "write")]
    Write,
    #[serde(rename = "append")]
    Append,
}

/// Parameters of `LocalUtils.zip`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsZipParams {
    #[serde(rename = "zipFile")]
    pub zip_file: String,
    #[serde(rename = "entries")]
    pub entries: Vec<NameValue>,
    #[serde(rename = "stacksId", default, skip_serializing_if = "Option::is_none")]
    pub stacks_id: Option<String>,
    #[serde(rename = "mode")]
    pub mode: LocalUtilsZipParamsMode,
    #[serde(rename = "includeSources")]
    pub include_sources: bool,
    #[serde(rename = "additionalSources", default, skip_serializing_if = "Option::is_none")]
    pub additional_sources: Option<Vec<String>>,
}

/// Parameters of `LocalUtils.harOpen`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsHarOpenParams {
    #[serde(rename = "file")]
    pub file: String,
}

/// Result of `LocalUtils.harOpen`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsHarOpenResult {
    #[serde(rename = "harId", default, skip_serializing_if = "Option::is_none")]
    pub har_id: Option<String>,
    #[serde(rename = "error", default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// Parameters of `LocalUtils.harLookup`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsHarLookupParams {
    #[serde(rename = "harId")]
    pub har_id: String,
    #[serde(rename = "url")]
    pub url: String,
    #[serde(rename = "method")]
    pub method: String,
    #[serde(rename = "headers")]
    pub headers: Vec<NameValue>,
    #[serde(rename = "postData", default, skip_serializing_if = "Option::is_none")]
    pub post_data: Option<Binary>,
    #[serde(rename = "isNavigationRequest")]
    pub is_navigation_request: bool,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum LocalUtilsHarLookupResultAction {
    #[default]
    #[serde(rename = "error")]
    Error,
    #[serde(rename = "redirect")]
    Redirect,
    #[serde(rename = "fulfill")]
    Fulfill,
    #[serde(rename = "noentry")]
    Noentry,
}

/// Result of `LocalUtils.harLookup`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsHarLookupResult {
    #[serde(rename = "action")]
    pub action: LocalUtilsHarLookupResultAction,
    #[serde(rename = "message", default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(rename = "redirectURL", default, skip_serializing_if = "Option::is_none")]
    pub redirect_url: Option<String>,
    #[serde(rename = "status", default, skip_serializing_if = "Option::is_none")]
    pub status: Option<i64>,
    #[serde(rename = "headers", default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<Vec<NameValue>>,
    #[serde(rename = "body", default, skip_serializing_if = "Option::is_none")]
    pub body: Option<Binary>,
}

/// Parameters of `LocalUtils.harClose`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsHarCloseParams {
    #[serde(rename = "harId")]
    pub har_id: String,
}

/// Parameters of `LocalUtils.harUnzip`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsHarUnzipParams {
    #[serde(rename = "zipFile")]
    pub zip_file: String,
    #[serde(rename = "harFile")]
    pub har_file: String,
    #[serde(rename = "resourcesDir", default, skip_serializing_if = "Option::is_none")]
    pub resources_dir: Option<String>,
}

/// Parameters of `LocalUtils.connect`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsConnectParams {
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    #[serde(rename = "headers", default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<serde_json::Value>,
    #[serde(rename = "exposeNetwork", default, skip_serializing_if = "Option::is_none")]
    pub expose_network: Option<String>,
    #[serde(rename = "slowMo", default, skip_serializing_if = "Option::is_none")]
    pub slow_mo: Option<f64>,
    #[serde(rename = "socksProxyRedirectPortForTest", default, skip_serializing_if = "Option::is_none")]
    pub socks_proxy_redirect_port_for_test: Option<i64>,
}

/// Result of `LocalUtils.connect`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsConnectResult {
    #[serde(rename = "pipe")]
    pub pipe: Ref<JsonPipe>,
    #[serde(rename = "headers")]
    pub headers: Vec<NameValue>,
}

/// Parameters of `LocalUtils.tracingStarted`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsTracingStartedParams {
    #[serde(rename = "tracesDir", default, skip_serializing_if = "Option::is_none")]
    pub traces_dir: Option<String>,
    #[serde(rename = "traceName")]
    pub trace_name: String,
    #[serde(rename = "live", default, skip_serializing_if = "Option::is_none")]
    pub live: Option<bool>,
}

/// Result of `LocalUtils.tracingStarted`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsTracingStartedResult {
    #[serde(rename = "stacksId")]
    pub stacks_id: String,
}

/// Parameters of `LocalUtils.addStackToTracingNoReply`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsAddStackToTracingNoReplyParams {
    #[serde(rename = "callData")]
    pub call_data: ClientSideCallMetadata,
}

/// Parameters of `LocalUtils.traceDiscarded`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsTraceDiscardedParams {
    #[serde(rename = "stacksId")]
    pub stacks_id: String,
}

/// Parameters of `LocalUtils.globToRegex`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsGlobToRegexParams {
    #[serde(rename = "glob")]
    pub glob: String,
    #[serde(rename = "baseURL", default, skip_serializing_if = "Option::is_none")]
    pub base_url: Option<String>,
    #[serde(rename = "webSocketUrl", default, skip_serializing_if = "Option::is_none")]
    pub web_socket_url: Option<bool>,
}

/// Result of `LocalUtils.globToRegex`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocalUtilsGlobToRegexResult {
    #[serde(rename = "regex")]
    pub regex: String,
}

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

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

impl ChannelType for LocalUtils {
    const INTERFACE: &'static str = "LocalUtils";
    type Initializer = LocalUtilsInitializer;
    type Event = LocalUtilsEvent;

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

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

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

impl LocalUtils {
    /// `LocalUtils.zip` (internal).
    pub async fn zip(&self, params: LocalUtilsZipParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("zip", &params).await
    }

    /// `LocalUtils.harOpen` (internal).
    pub async fn har_open(&self, params: LocalUtilsHarOpenParams) -> Result<LocalUtilsHarOpenResult, ProtocolError> {
        self.channel.send("harOpen", &params).await
    }

    /// `LocalUtils.harLookup` (internal).
    pub async fn har_lookup(&self, params: LocalUtilsHarLookupParams) -> Result<LocalUtilsHarLookupResult, ProtocolError> {
        self.channel.send("harLookup", &params).await
    }

    /// `LocalUtils.harClose` (internal).
    pub async fn har_close(&self, params: LocalUtilsHarCloseParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("harClose", &params).await
    }

    /// `LocalUtils.harUnzip` (internal).
    pub async fn har_unzip(&self, params: LocalUtilsHarUnzipParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("harUnzip", &params).await
    }

    /// `LocalUtils.connect` (internal).
    pub async fn connect(&self, params: LocalUtilsConnectParams) -> Result<LocalUtilsConnectResult, ProtocolError> {
        self.channel.send("connect", &params).await
    }

    /// `LocalUtils.tracingStarted` (internal).
    pub async fn tracing_started(&self, params: LocalUtilsTracingStartedParams) -> Result<LocalUtilsTracingStartedResult, ProtocolError> {
        self.channel.send("tracingStarted", &params).await
    }

    /// `LocalUtils.addStackToTracingNoReply` (internal).
    pub async fn add_stack_to_tracing_no_reply(&self, params: LocalUtilsAddStackToTracingNoReplyParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("addStackToTracingNoReply", &params).await
    }

    /// `LocalUtils.traceDiscarded` (internal).
    pub async fn trace_discarded(&self, params: LocalUtilsTraceDiscardedParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("traceDiscarded", &params).await
    }

    /// `LocalUtils.globToRegex` (internal).
    pub async fn glob_to_regex(&self, params: LocalUtilsGlobToRegexParams) -> Result<LocalUtilsGlobToRegexResult, ProtocolError> {
        self.channel.send("globToRegex", &params).await
    }
}