rustenium_bidi_definitions/emulation/
types.rs

1use serde::{Deserialize, Serialize};
2#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
3pub enum ForcedColorsModeTheme {
4    #[serde(rename = "light")]
5    Light,
6    #[serde(rename = "dark")]
7    Dark,
8}
9#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, serde_valid :: Validate)]
10pub struct GeolocationCoordinates {
11    #[serde(rename = "latitude")]
12    pub latitude: f64,
13    #[serde(rename = "longitude")]
14    pub longitude: f64,
15    #[serde(rename = "accuracy")]
16    #[serde(skip_serializing_if = "Option::is_none")]
17    #[serde(default = "default_geolocation_coordinates_accuracy")]
18    #[validate(minimum = 0f64)]
19    pub accuracy: Option<f64>,
20    #[serde(rename = "altitude")]
21    #[serde(skip_serializing_if = "Option::is_none")]
22    #[serde(default)]
23    pub altitude: Option<f64>,
24    #[serde(rename = "altitudeAccuracy")]
25    #[serde(skip_serializing_if = "Option::is_none")]
26    #[serde(default)]
27    #[validate(minimum = 0f64)]
28    pub altitude_accuracy: Option<f64>,
29    #[serde(rename = "heading")]
30    #[serde(skip_serializing_if = "Option::is_none")]
31    #[serde(default)]
32    pub heading: Option<f64>,
33    #[serde(rename = "speed")]
34    #[serde(skip_serializing_if = "Option::is_none")]
35    #[serde(default)]
36    #[validate(minimum = 0f64)]
37    pub speed: Option<f64>,
38}
39fn default_geolocation_coordinates_accuracy() -> Option<f64> {
40    Some(1f64)
41}
42impl GeolocationCoordinates {
43    pub fn new(latitude: impl Into<f64>, longitude: impl Into<f64>) -> Self {
44        Self {
45            latitude: latitude.into(),
46            longitude: longitude.into(),
47            accuracy: None,
48            altitude: None,
49            altitude_accuracy: None,
50            heading: None,
51            speed: None,
52        }
53    }
54}
55impl GeolocationCoordinates {
56    pub const IDENTIFIER: &'static str = "emulation.GeolocationCoordinates";
57    pub const DOMAIN_DIRECTION: &'static str = "remote";
58    pub fn identifier(&self) -> &'static str {
59        Self::IDENTIFIER
60    }
61}
62#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
63pub struct GeolocationPositionError {
64    #[serde(rename = "type")]
65    pub r#type: GeolocationPositionErrorType,
66}
67#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
68pub enum GeolocationPositionErrorType {
69    #[serde(rename = "positionUnavailable")]
70    PositionUnavailable,
71}
72impl GeolocationPositionError {
73    pub fn new(r#type: impl Into<GeolocationPositionErrorType>) -> Self {
74        Self {
75            r#type: r#type.into(),
76        }
77    }
78}
79impl GeolocationPositionError {
80    pub const IDENTIFIER: &'static str = "emulation.GeolocationPositionError";
81    pub const DOMAIN_DIRECTION: &'static str = "remote";
82    pub fn identifier(&self) -> &'static str {
83        Self::IDENTIFIER
84    }
85}
86#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
87pub struct NetworkConditions(NetworkConditionsOffline);
88impl NetworkConditions {
89    pub fn new(val: impl Into<NetworkConditionsOffline>) -> Self {
90        NetworkConditions(val.into())
91    }
92    pub fn inner(&self) -> &NetworkConditionsOffline {
93        &self.0
94    }
95}
96impl NetworkConditions {
97    pub const IDENTIFIER: &'static str = "emulation.NetworkConditions";
98    pub const DOMAIN_DIRECTION: &'static str = "remote";
99    pub fn identifier(&self) -> &'static str {
100        Self::IDENTIFIER
101    }
102}
103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
104pub struct NetworkConditionsOffline {
105    #[serde(rename = "type")]
106    pub r#type: NetworkConditionsOfflineType,
107}
108#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
109pub enum NetworkConditionsOfflineType {
110    #[serde(rename = "offline")]
111    Offline,
112}
113impl NetworkConditionsOffline {
114    pub fn new(r#type: impl Into<NetworkConditionsOfflineType>) -> Self {
115        Self {
116            r#type: r#type.into(),
117        }
118    }
119}
120impl NetworkConditionsOffline {
121    pub const IDENTIFIER: &'static str = "emulation.NetworkConditionsOffline";
122    pub const DOMAIN_DIRECTION: &'static str = "remote";
123    pub fn identifier(&self) -> &'static str {
124        Self::IDENTIFIER
125    }
126}
127#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
128pub enum ScreenOrientationNatural {
129    #[serde(rename = "portrait")]
130    Portrait,
131    #[serde(rename = "landscape")]
132    Landscape,
133}
134#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
135pub enum ScreenOrientationType {
136    #[serde(rename = "portrait-primary")]
137    PortraitPrimary,
138    #[serde(rename = "portrait-secondary")]
139    PortraitSecondary,
140    #[serde(rename = "landscape-primary")]
141    LandscapePrimary,
142    #[serde(rename = "landscape-secondary")]
143    LandscapeSecondary,
144}
145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
146pub struct ScreenOrientation {
147    #[serde(rename = "natural")]
148    pub natural: ScreenOrientationNatural,
149    #[serde(rename = "type")]
150    pub r#type: ScreenOrientationType,
151}
152impl ScreenOrientation {
153    pub fn new(
154        natural: impl Into<ScreenOrientationNatural>,
155        r#type: impl Into<ScreenOrientationType>,
156    ) -> Self {
157        Self {
158            natural: natural.into(),
159            r#type: r#type.into(),
160        }
161    }
162}
163impl ScreenOrientation {
164    pub const IDENTIFIER: &'static str = "emulation.ScreenOrientation";
165    pub const DOMAIN_DIRECTION: &'static str = "remote";
166    pub fn identifier(&self) -> &'static str {
167        Self::IDENTIFIER
168    }
169}
rustenium_bidi_definitions/emulation/types.rs

rustenium_bidi_definitions/emulation/
types.rs
