js-protocol 0.1.4

Generated Rust types and commands for the Chrome DevTools Protocol (js-protocol)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! This domain is deprecated - use Runtime or Log instead.


use serde::{Serialize, Deserialize};
use serde_json::Value as JsonValue;
use std::borrow::Cow;

/// Console message.

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct ConsoleMessage<'a> {
    /// Message source.
    source: Cow<'a, str>,
    /// Message severity.
    level: Cow<'a, str>,
    /// Message text.
    text: Cow<'a, str>,
    /// URL of the message origin.
    #[serde(skip_serializing_if = "Option::is_none")]
    url: Option<Cow<'a, str>>,
    /// Line number in the resource that generated this message (1-based).
    #[serde(skip_serializing_if = "Option::is_none")]
    line: Option<i64>,
    /// Column number in the resource that generated this message (1-based).
    #[serde(skip_serializing_if = "Option::is_none")]
    column: Option<i64>,
}

impl<'a> ConsoleMessage<'a> {
    /// Creates a builder for this type with the required parameters:
    /// * `source`: Message source.
    /// * `level`: Message severity.
    /// * `text`: Message text.
    pub fn builder(source: impl Into<Cow<'a, str>>, level: impl Into<Cow<'a, str>>, text: impl Into<Cow<'a, str>>) -> ConsoleMessageBuilder<'a> {
        ConsoleMessageBuilder {
            source: source.into(),
            level: level.into(),
            text: text.into(),
            url: None,
            line: None,
            column: None,
        }
    }
    /// Message source.
    pub fn source(&self) -> &str { self.source.as_ref() }
    /// Message severity.
    pub fn level(&self) -> &str { self.level.as_ref() }
    /// Message text.
    pub fn text(&self) -> &str { self.text.as_ref() }
    /// URL of the message origin.
    pub fn url(&self) -> Option<&str> { self.url.as_deref() }
    /// Line number in the resource that generated this message (1-based).
    pub fn line(&self) -> Option<i64> { self.line }
    /// Column number in the resource that generated this message (1-based).
    pub fn column(&self) -> Option<i64> { self.column }
}


pub struct ConsoleMessageBuilder<'a> {
    source: Cow<'a, str>,
    level: Cow<'a, str>,
    text: Cow<'a, str>,
    url: Option<Cow<'a, str>>,
    line: Option<i64>,
    column: Option<i64>,
}

impl<'a> ConsoleMessageBuilder<'a> {
    /// URL of the message origin.
    pub fn url(mut self, url: impl Into<Cow<'a, str>>) -> Self { self.url = Some(url.into()); self }
    /// Line number in the resource that generated this message (1-based).
    pub fn line(mut self, line: i64) -> Self { self.line = Some(line); self }
    /// Column number in the resource that generated this message (1-based).
    pub fn column(mut self, column: i64) -> Self { self.column = Some(column); self }
    pub fn build(self) -> ConsoleMessage<'a> {
        ConsoleMessage {
            source: self.source,
            level: self.level,
            text: self.text,
            url: self.url,
            line: self.line,
            column: self.column,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ClearMessagesParams {}

impl ClearMessagesParams { pub const METHOD: &'static str = "Console.clearMessages"; }

impl<'a> crate::CdpCommand<'a> for ClearMessagesParams {
    const METHOD: &'static str = "Console.clearMessages";
    type Response = crate::EmptyReturns;
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct DisableParams {}

impl DisableParams { pub const METHOD: &'static str = "Console.disable"; }

impl<'a> crate::CdpCommand<'a> for DisableParams {
    const METHOD: &'static str = "Console.disable";
    type Response = crate::EmptyReturns;
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct EnableParams {}

impl EnableParams { pub const METHOD: &'static str = "Console.enable"; }

impl<'a> crate::CdpCommand<'a> for EnableParams {
    const METHOD: &'static str = "Console.enable";
    type Response = crate::EmptyReturns;
}