browser-commander 0.18.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,
};

/// Initializer the driver sends when it creates a `Tracing`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingInitializer {}

/// Parameters of `Tracing.tracingStart` (Start tracing).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingTracingStartParams {
    #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "snapshotDom", default, skip_serializing_if = "Option::is_none")]
    pub snapshot_dom: Option<bool>,
    #[serde(rename = "snapshotAria", default, skip_serializing_if = "Option::is_none")]
    pub snapshot_aria: Option<bool>,
    #[serde(rename = "snapshotScreen", default, skip_serializing_if = "Option::is_none")]
    pub snapshot_screen: Option<bool>,
    #[serde(rename = "screencast", default, skip_serializing_if = "Option::is_none")]
    pub screencast: Option<bool>,
    #[serde(rename = "live", default, skip_serializing_if = "Option::is_none")]
    pub live: Option<bool>,
}

/// Parameters of `Tracing.tracingStartChunk` (Start tracing).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingTracingStartChunkParams {
    #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "title", default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

/// Result of `Tracing.tracingStartChunk` (Start tracing).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingTracingStartChunkResult {
    #[serde(rename = "traceName")]
    pub trace_name: String,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingTracingGroupParamsLocation {
    #[serde(rename = "file")]
    pub file: String,
    #[serde(rename = "line", default, skip_serializing_if = "Option::is_none")]
    pub line: Option<i64>,
    #[serde(rename = "column", default, skip_serializing_if = "Option::is_none")]
    pub column: Option<i64>,
}

/// Parameters of `Tracing.tracingGroup` (Trace "{name}").
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingTracingGroupParams {
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "location", default, skip_serializing_if = "Option::is_none")]
    pub location: Option<TracingTracingGroupParamsLocation>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TracingTracingStopChunkParamsMode {
    #[default]
    #[serde(rename = "archive")]
    Archive,
    #[serde(rename = "discard")]
    Discard,
    #[serde(rename = "entries")]
    Entries,
}

/// Parameters of `Tracing.tracingStopChunk` (Stop tracing).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingTracingStopChunkParams {
    #[serde(rename = "mode")]
    pub mode: TracingTracingStopChunkParamsMode,
}

/// Result of `Tracing.tracingStopChunk` (Stop tracing).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingTracingStopChunkResult {
    #[serde(rename = "artifact", default, skip_serializing_if = "Option::is_none")]
    pub artifact: Option<Ref<Artifact>>,
    #[serde(rename = "entries", default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<NameValue>>,
}

/// Parameters of `Tracing.harStart`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingHarStartParams {
    #[serde(rename = "page", default, skip_serializing_if = "Option::is_none")]
    pub page: Option<Ref<Page>>,
    #[serde(rename = "options")]
    pub options: RecordHarOptions,
}

/// Result of `Tracing.harStart`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingHarStartResult {
    #[serde(rename = "harId")]
    pub har_id: String,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TracingHarExportParamsMode {
    #[default]
    #[serde(rename = "archive")]
    Archive,
    #[serde(rename = "entries")]
    Entries,
}

/// Parameters of `Tracing.harExport`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingHarExportParams {
    #[serde(rename = "harId", default, skip_serializing_if = "Option::is_none")]
    pub har_id: Option<String>,
    #[serde(rename = "mode")]
    pub mode: TracingHarExportParamsMode,
}

/// Result of `Tracing.harExport`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TracingHarExportResult {
    #[serde(rename = "artifact", default, skip_serializing_if = "Option::is_none")]
    pub artifact: Option<Ref<Artifact>>,
    #[serde(rename = "entries", default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<NameValue>>,
}

/// Events a `Tracing` channel can emit.
#[derive(Debug, Clone, PartialEq)]
pub enum TracingEvent {
    /// 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 TracingEvent {
    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 `Tracing` interface (`tracing.yml`).
#[derive(Debug, Clone)]
pub struct Tracing {
    channel: Channel,
}

impl ChannelType for Tracing {
    const INTERFACE: &'static str = "Tracing";
    type Initializer = TracingInitializer;
    type Event = TracingEvent;

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

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

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

impl Tracing {
    /// `Tracing.tracingStart` ("Start tracing").
    pub async fn tracing_start(&self, params: TracingTracingStartParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("tracingStart", &params).await
    }

    /// `Tracing.tracingStartChunk` ("Start tracing").
    pub async fn tracing_start_chunk(&self, params: TracingTracingStartChunkParams) -> Result<TracingTracingStartChunkResult, ProtocolError> {
        self.channel.send("tracingStartChunk", &params).await
    }

    /// `Tracing.tracingGroup` ("Trace "{name}"").
    pub async fn tracing_group(&self, params: TracingTracingGroupParams) -> Result<(), ProtocolError> {
        self.channel.send_no_result("tracingGroup", &params).await
    }

    /// `Tracing.tracingGroupEnd` ("Group end").
    pub async fn tracing_group_end(&self) -> Result<(), ProtocolError> {
        self.channel.send_no_result("tracingGroupEnd", &serde_json::json!({})).await
    }

    /// `Tracing.tracingStopChunk` ("Stop tracing").
    pub async fn tracing_stop_chunk(&self, params: TracingTracingStopChunkParams) -> Result<TracingTracingStopChunkResult, ProtocolError> {
        self.channel.send("tracingStopChunk", &params).await
    }

    /// `Tracing.tracingStop` ("Stop tracing").
    pub async fn tracing_stop(&self) -> Result<(), ProtocolError> {
        self.channel.send_no_result("tracingStop", &serde_json::json!({})).await
    }

    /// `Tracing.harStart` (internal).
    pub async fn har_start(&self, params: TracingHarStartParams) -> Result<TracingHarStartResult, ProtocolError> {
        self.channel.send("harStart", &params).await
    }

    /// `Tracing.harExport` (internal).
    pub async fn har_export(&self, params: TracingHarExportParams) -> Result<TracingHarExportResult, ProtocolError> {
        self.channel.send("harExport", &params).await
    }
}