rustenium_cdp_definitions/browser_protocol/emulation/
command_builders.rs

1use super::commands::*;
2#[derive(Debug, Clone, Default)]
3pub struct ClearDeviceMetricsOverrideBuilder;
4impl ClearDeviceMetricsOverrideBuilder {
5    pub fn new() -> Self {
6        Self
7    }
8    pub fn build(self) -> ClearDeviceMetricsOverride {
9        ClearDeviceMetricsOverride {
10            method: ClearDeviceMetricsOverrideMethod::ClearDeviceMetricsOverride,
11            params: ClearDeviceMetricsOverrideParams {},
12        }
13    }
14}
15impl ClearDeviceMetricsOverride {
16    pub fn builder() -> ClearDeviceMetricsOverrideBuilder {
17        ClearDeviceMetricsOverrideBuilder
18    }
19}
20#[derive(Debug, Clone, Default)]
21pub struct ClearGeolocationOverrideBuilder;
22impl ClearGeolocationOverrideBuilder {
23    pub fn new() -> Self {
24        Self
25    }
26    pub fn build(self) -> ClearGeolocationOverride {
27        ClearGeolocationOverride {
28            method: ClearGeolocationOverrideMethod::ClearGeolocationOverride,
29            params: ClearGeolocationOverrideParams {},
30        }
31    }
32}
33impl ClearGeolocationOverride {
34    pub fn builder() -> ClearGeolocationOverrideBuilder {
35        ClearGeolocationOverrideBuilder
36    }
37}
38#[derive(Debug, Clone, Default)]
39pub struct ResetPageScaleFactorBuilder;
40impl ResetPageScaleFactorBuilder {
41    pub fn new() -> Self {
42        Self
43    }
44    pub fn build(self) -> ResetPageScaleFactor {
45        ResetPageScaleFactor {
46            method: ResetPageScaleFactorMethod::ResetPageScaleFactor,
47            params: ResetPageScaleFactorParams {},
48        }
49    }
50}
51impl ResetPageScaleFactor {
52    pub fn builder() -> ResetPageScaleFactorBuilder {
53        ResetPageScaleFactorBuilder
54    }
55}
56impl SetFocusEmulationEnabled {
57    pub fn builder() -> SetFocusEmulationEnabledBuilder {
58        <SetFocusEmulationEnabledBuilder as Default>::default()
59    }
60}
61#[derive(Default, Clone)]
62pub struct SetFocusEmulationEnabledBuilder {
63    enabled: Option<bool>,
64}
65impl SetFocusEmulationEnabledBuilder {
66    pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
67        self.enabled = Some(enabled.into());
68        self
69    }
70    pub fn build(self) -> Result<SetFocusEmulationEnabled, String> {
71        Ok(SetFocusEmulationEnabled {
72            method: SetFocusEmulationEnabledMethod::SetFocusEmulationEnabled,
73            params: SetFocusEmulationEnabledParams {
74                enabled: self
75                    .enabled
76                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(enabled)))?,
77            },
78        })
79    }
80}
81impl SetAutoDarkModeOverride {
82    pub fn builder() -> SetAutoDarkModeOverrideBuilder {
83        <SetAutoDarkModeOverrideBuilder as Default>::default()
84    }
85}
86#[derive(Default, Clone)]
87pub struct SetAutoDarkModeOverrideBuilder {
88    enabled: Option<bool>,
89}
90impl SetAutoDarkModeOverrideBuilder {
91    pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
92        self.enabled = Some(enabled.into());
93        self
94    }
95    pub fn build(self) -> SetAutoDarkModeOverride {
96        SetAutoDarkModeOverride {
97            method: SetAutoDarkModeOverrideMethod::SetAutoDarkModeOverride,
98            params: SetAutoDarkModeOverrideParams {
99                enabled: self.enabled,
100            },
101        }
102    }
103}
104impl SetCpuThrottlingRate {
105    pub fn builder() -> SetCpuThrottlingRateBuilder {
106        <SetCpuThrottlingRateBuilder as Default>::default()
107    }
108}
109#[derive(Default, Clone)]
110pub struct SetCpuThrottlingRateBuilder {
111    rate: Option<f64>,
112}
113impl SetCpuThrottlingRateBuilder {
114    pub fn rate(mut self, rate: impl Into<f64>) -> Self {
115        self.rate = Some(rate.into());
116        self
117    }
118    pub fn build(self) -> Result<SetCpuThrottlingRate, String> {
119        Ok(SetCpuThrottlingRate {
120            method: SetCpuThrottlingRateMethod::SetCpuThrottlingRate,
121            params: SetCpuThrottlingRateParams {
122                rate: self
123                    .rate
124                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(rate)))?,
125            },
126        })
127    }
128}
129impl SetDefaultBackgroundColorOverride {
130    pub fn builder() -> SetDefaultBackgroundColorOverrideBuilder {
131        <SetDefaultBackgroundColorOverrideBuilder as Default>::default()
132    }
133}
134#[derive(Default, Clone)]
135pub struct SetDefaultBackgroundColorOverrideBuilder {
136    color: Option<crate::browser_protocol::dom::types::Rgba>,
137}
138impl SetDefaultBackgroundColorOverrideBuilder {
139    pub fn color(mut self, color: impl Into<crate::browser_protocol::dom::types::Rgba>) -> Self {
140        self.color = Some(color.into());
141        self
142    }
143    pub fn build(self) -> SetDefaultBackgroundColorOverride {
144        SetDefaultBackgroundColorOverride {
145            method: SetDefaultBackgroundColorOverrideMethod::SetDefaultBackgroundColorOverride,
146            params: SetDefaultBackgroundColorOverrideParams { color: self.color },
147        }
148    }
149}
150impl SetSafeAreaInsetsOverride {
151    pub fn builder() -> SetSafeAreaInsetsOverrideBuilder {
152        <SetSafeAreaInsetsOverrideBuilder as Default>::default()
153    }
154}
155#[derive(Default, Clone)]
156pub struct SetSafeAreaInsetsOverrideBuilder {
157    insets: Option<super::types::SafeAreaInsets>,
158}
159impl SetSafeAreaInsetsOverrideBuilder {
160    pub fn insets(mut self, insets: impl Into<super::types::SafeAreaInsets>) -> Self {
161        self.insets = Some(insets.into());
162        self
163    }
164    pub fn build(self) -> Result<SetSafeAreaInsetsOverride, String> {
165        Ok(SetSafeAreaInsetsOverride {
166            method: SetSafeAreaInsetsOverrideMethod::SetSafeAreaInsetsOverride,
167            params: SetSafeAreaInsetsOverrideParams {
168                insets: self
169                    .insets
170                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(insets)))?,
171            },
172        })
173    }
174}
175impl SetDeviceMetricsOverride {
176    pub fn builder() -> SetDeviceMetricsOverrideBuilder {
177        <SetDeviceMetricsOverrideBuilder as Default>::default()
178    }
179}
180#[derive(Default, Clone)]
181pub struct SetDeviceMetricsOverrideBuilder {
182    width: Option<i64>,
183    height: Option<i64>,
184    device_scale_factor: Option<f64>,
185    mobile: Option<bool>,
186    scale: Option<f64>,
187    screen_width: Option<i64>,
188    screen_height: Option<i64>,
189    position_x: Option<i64>,
190    position_y: Option<i64>,
191    dont_set_visible_size: Option<bool>,
192    screen_orientation: Option<super::types::ScreenOrientation>,
193    viewport: Option<crate::browser_protocol::page::types::Viewport>,
194    scrollbar_type: Option<SetDeviceMetricsOverrideScrollbarType>,
195}
196impl SetDeviceMetricsOverrideBuilder {
197    pub fn width(mut self, width: impl Into<i64>) -> Self {
198        self.width = Some(width.into());
199        self
200    }
201    pub fn height(mut self, height: impl Into<i64>) -> Self {
202        self.height = Some(height.into());
203        self
204    }
205    pub fn device_scale_factor(mut self, device_scale_factor: impl Into<f64>) -> Self {
206        self.device_scale_factor = Some(device_scale_factor.into());
207        self
208    }
209    pub fn mobile(mut self, mobile: impl Into<bool>) -> Self {
210        self.mobile = Some(mobile.into());
211        self
212    }
213    pub fn scale(mut self, scale: impl Into<f64>) -> Self {
214        self.scale = Some(scale.into());
215        self
216    }
217    pub fn screen_width(mut self, screen_width: impl Into<i64>) -> Self {
218        self.screen_width = Some(screen_width.into());
219        self
220    }
221    pub fn screen_height(mut self, screen_height: impl Into<i64>) -> Self {
222        self.screen_height = Some(screen_height.into());
223        self
224    }
225    pub fn position_x(mut self, position_x: impl Into<i64>) -> Self {
226        self.position_x = Some(position_x.into());
227        self
228    }
229    pub fn position_y(mut self, position_y: impl Into<i64>) -> Self {
230        self.position_y = Some(position_y.into());
231        self
232    }
233    pub fn dont_set_visible_size(mut self, dont_set_visible_size: impl Into<bool>) -> Self {
234        self.dont_set_visible_size = Some(dont_set_visible_size.into());
235        self
236    }
237    pub fn screen_orientation(
238        mut self,
239        screen_orientation: impl Into<super::types::ScreenOrientation>,
240    ) -> Self {
241        self.screen_orientation = Some(screen_orientation.into());
242        self
243    }
244    pub fn viewport(
245        mut self,
246        viewport: impl Into<crate::browser_protocol::page::types::Viewport>,
247    ) -> Self {
248        self.viewport = Some(viewport.into());
249        self
250    }
251    pub fn scrollbar_type(
252        mut self,
253        scrollbar_type: impl Into<SetDeviceMetricsOverrideScrollbarType>,
254    ) -> Self {
255        self.scrollbar_type = Some(scrollbar_type.into());
256        self
257    }
258    pub fn build(self) -> Result<SetDeviceMetricsOverride, String> {
259        Ok(SetDeviceMetricsOverride {
260            method: SetDeviceMetricsOverrideMethod::SetDeviceMetricsOverride,
261            params: SetDeviceMetricsOverrideParams {
262                width: self
263                    .width
264                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(width)))?,
265                height: self
266                    .height
267                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(height)))?,
268                device_scale_factor: self.device_scale_factor.ok_or_else(|| {
269                    format!(
270                        "Field `{}` is mandatory.",
271                        std::stringify!(device_scale_factor)
272                    )
273                })?,
274                mobile: self
275                    .mobile
276                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(mobile)))?,
277                scale: self.scale,
278                screen_width: self.screen_width,
279                screen_height: self.screen_height,
280                position_x: self.position_x,
281                position_y: self.position_y,
282                dont_set_visible_size: self.dont_set_visible_size,
283                screen_orientation: self.screen_orientation,
284                viewport: self.viewport,
285                scrollbar_type: self.scrollbar_type,
286            },
287        })
288    }
289}
290impl SetDevicePostureOverride {
291    pub fn builder() -> SetDevicePostureOverrideBuilder {
292        <SetDevicePostureOverrideBuilder as Default>::default()
293    }
294}
295#[derive(Default, Clone)]
296pub struct SetDevicePostureOverrideBuilder {
297    posture: Option<super::types::DevicePosture>,
298}
299impl SetDevicePostureOverrideBuilder {
300    pub fn posture(mut self, posture: impl Into<super::types::DevicePosture>) -> Self {
301        self.posture = Some(posture.into());
302        self
303    }
304    pub fn build(self) -> Result<SetDevicePostureOverride, String> {
305        Ok(SetDevicePostureOverride {
306            method: SetDevicePostureOverrideMethod::SetDevicePostureOverride,
307            params: SetDevicePostureOverrideParams {
308                posture: self
309                    .posture
310                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(posture)))?,
311            },
312        })
313    }
314}
315#[derive(Debug, Clone, Default)]
316pub struct ClearDevicePostureOverrideBuilder;
317impl ClearDevicePostureOverrideBuilder {
318    pub fn new() -> Self {
319        Self
320    }
321    pub fn build(self) -> ClearDevicePostureOverride {
322        ClearDevicePostureOverride {
323            method: ClearDevicePostureOverrideMethod::ClearDevicePostureOverride,
324            params: ClearDevicePostureOverrideParams {},
325        }
326    }
327}
328impl ClearDevicePostureOverride {
329    pub fn builder() -> ClearDevicePostureOverrideBuilder {
330        ClearDevicePostureOverrideBuilder
331    }
332}
333impl SetDisplayFeaturesOverride {
334    pub fn builder() -> SetDisplayFeaturesOverrideBuilder {
335        <SetDisplayFeaturesOverrideBuilder as Default>::default()
336    }
337}
338#[derive(Default, Clone)]
339pub struct SetDisplayFeaturesOverrideBuilder {
340    features: Option<Vec<super::types::DisplayFeature>>,
341}
342impl SetDisplayFeaturesOverrideBuilder {
343    pub fn feature(mut self, feature: impl Into<super::types::DisplayFeature>) -> Self {
344        let v = self.features.get_or_insert(Vec::new());
345        v.push(feature.into());
346        self
347    }
348    pub fn features<I, S>(mut self, features: I) -> Self
349    where
350        I: IntoIterator<Item = S>,
351        S: Into<super::types::DisplayFeature>,
352    {
353        let v = self.features.get_or_insert(Vec::new());
354        for val in features {
355            v.push(val.into());
356        }
357        self
358    }
359    pub fn build(self) -> Result<SetDisplayFeaturesOverride, String> {
360        Ok(SetDisplayFeaturesOverride {
361            method: SetDisplayFeaturesOverrideMethod::SetDisplayFeaturesOverride,
362            params: SetDisplayFeaturesOverrideParams {
363                features: self.features.ok_or_else(|| {
364                    format!("Field `{}` is mandatory.", std::stringify!(features))
365                })?,
366            },
367        })
368    }
369}
370#[derive(Debug, Clone, Default)]
371pub struct ClearDisplayFeaturesOverrideBuilder;
372impl ClearDisplayFeaturesOverrideBuilder {
373    pub fn new() -> Self {
374        Self
375    }
376    pub fn build(self) -> ClearDisplayFeaturesOverride {
377        ClearDisplayFeaturesOverride {
378            method: ClearDisplayFeaturesOverrideMethod::ClearDisplayFeaturesOverride,
379            params: ClearDisplayFeaturesOverrideParams {},
380        }
381    }
382}
383impl ClearDisplayFeaturesOverride {
384    pub fn builder() -> ClearDisplayFeaturesOverrideBuilder {
385        ClearDisplayFeaturesOverrideBuilder
386    }
387}
388impl SetScrollbarsHidden {
389    pub fn builder() -> SetScrollbarsHiddenBuilder {
390        <SetScrollbarsHiddenBuilder as Default>::default()
391    }
392}
393#[derive(Default, Clone)]
394pub struct SetScrollbarsHiddenBuilder {
395    hidden: Option<bool>,
396}
397impl SetScrollbarsHiddenBuilder {
398    pub fn hidden(mut self, hidden: impl Into<bool>) -> Self {
399        self.hidden = Some(hidden.into());
400        self
401    }
402    pub fn build(self) -> Result<SetScrollbarsHidden, String> {
403        Ok(SetScrollbarsHidden {
404            method: SetScrollbarsHiddenMethod::SetScrollbarsHidden,
405            params: SetScrollbarsHiddenParams {
406                hidden: self
407                    .hidden
408                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(hidden)))?,
409            },
410        })
411    }
412}
413impl SetDocumentCookieDisabled {
414    pub fn builder() -> SetDocumentCookieDisabledBuilder {
415        <SetDocumentCookieDisabledBuilder as Default>::default()
416    }
417}
418#[derive(Default, Clone)]
419pub struct SetDocumentCookieDisabledBuilder {
420    disabled: Option<bool>,
421}
422impl SetDocumentCookieDisabledBuilder {
423    pub fn disabled(mut self, disabled: impl Into<bool>) -> Self {
424        self.disabled = Some(disabled.into());
425        self
426    }
427    pub fn build(self) -> Result<SetDocumentCookieDisabled, String> {
428        Ok(SetDocumentCookieDisabled {
429            method: SetDocumentCookieDisabledMethod::SetDocumentCookieDisabled,
430            params: SetDocumentCookieDisabledParams {
431                disabled: self.disabled.ok_or_else(|| {
432                    format!("Field `{}` is mandatory.", std::stringify!(disabled))
433                })?,
434            },
435        })
436    }
437}
438impl SetEmitTouchEventsForMouse {
439    pub fn builder() -> SetEmitTouchEventsForMouseBuilder {
440        <SetEmitTouchEventsForMouseBuilder as Default>::default()
441    }
442}
443#[derive(Default, Clone)]
444pub struct SetEmitTouchEventsForMouseBuilder {
445    enabled: Option<bool>,
446    configuration: Option<SetEmitTouchEventsForMouseConfiguration>,
447}
448impl SetEmitTouchEventsForMouseBuilder {
449    pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
450        self.enabled = Some(enabled.into());
451        self
452    }
453    pub fn configuration(
454        mut self,
455        configuration: impl Into<SetEmitTouchEventsForMouseConfiguration>,
456    ) -> Self {
457        self.configuration = Some(configuration.into());
458        self
459    }
460    pub fn build(self) -> Result<SetEmitTouchEventsForMouse, String> {
461        Ok(SetEmitTouchEventsForMouse {
462            method: SetEmitTouchEventsForMouseMethod::SetEmitTouchEventsForMouse,
463            params: SetEmitTouchEventsForMouseParams {
464                enabled: self
465                    .enabled
466                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(enabled)))?,
467                configuration: self.configuration,
468            },
469        })
470    }
471}
472impl SetEmulatedMedia {
473    pub fn builder() -> SetEmulatedMediaBuilder {
474        <SetEmulatedMediaBuilder as Default>::default()
475    }
476}
477#[derive(Default, Clone)]
478pub struct SetEmulatedMediaBuilder {
479    media: Option<String>,
480    features: Option<Vec<super::types::MediaFeature>>,
481}
482impl SetEmulatedMediaBuilder {
483    pub fn media(mut self, media: impl Into<String>) -> Self {
484        self.media = Some(media.into());
485        self
486    }
487    pub fn feature(mut self, feature: impl Into<super::types::MediaFeature>) -> Self {
488        let v = self.features.get_or_insert(Vec::new());
489        v.push(feature.into());
490        self
491    }
492    pub fn features<I, S>(mut self, features: I) -> Self
493    where
494        I: IntoIterator<Item = S>,
495        S: Into<super::types::MediaFeature>,
496    {
497        let v = self.features.get_or_insert(Vec::new());
498        for val in features {
499            v.push(val.into());
500        }
501        self
502    }
503    pub fn build(self) -> SetEmulatedMedia {
504        SetEmulatedMedia {
505            method: SetEmulatedMediaMethod::SetEmulatedMedia,
506            params: SetEmulatedMediaParams {
507                media: self.media,
508                features: self.features,
509            },
510        }
511    }
512}
513impl SetEmulatedVisionDeficiency {
514    pub fn builder() -> SetEmulatedVisionDeficiencyBuilder {
515        <SetEmulatedVisionDeficiencyBuilder as Default>::default()
516    }
517}
518#[derive(Default, Clone)]
519pub struct SetEmulatedVisionDeficiencyBuilder {
520    r#type: Option<SetEmulatedVisionDeficiencyType>,
521}
522impl SetEmulatedVisionDeficiencyBuilder {
523    pub fn r#type(mut self, r#type: impl Into<SetEmulatedVisionDeficiencyType>) -> Self {
524        self.r#type = Some(r#type.into());
525        self
526    }
527    pub fn build(self) -> Result<SetEmulatedVisionDeficiency, String> {
528        Ok(SetEmulatedVisionDeficiency {
529            method: SetEmulatedVisionDeficiencyMethod::SetEmulatedVisionDeficiency,
530            params: SetEmulatedVisionDeficiencyParams {
531                r#type: self
532                    .r#type
533                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r#type)))?,
534            },
535        })
536    }
537}
538impl SetEmulatedOsTextScale {
539    pub fn builder() -> SetEmulatedOsTextScaleBuilder {
540        <SetEmulatedOsTextScaleBuilder as Default>::default()
541    }
542}
543#[derive(Default, Clone)]
544pub struct SetEmulatedOsTextScaleBuilder {
545    scale: Option<f64>,
546}
547impl SetEmulatedOsTextScaleBuilder {
548    pub fn scale(mut self, scale: impl Into<f64>) -> Self {
549        self.scale = Some(scale.into());
550        self
551    }
552    pub fn build(self) -> SetEmulatedOsTextScale {
553        SetEmulatedOsTextScale {
554            method: SetEmulatedOsTextScaleMethod::SetEmulatedOsTextScale,
555            params: SetEmulatedOsTextScaleParams { scale: self.scale },
556        }
557    }
558}
559impl SetGeolocationOverride {
560    pub fn builder() -> SetGeolocationOverrideBuilder {
561        <SetGeolocationOverrideBuilder as Default>::default()
562    }
563}
564#[derive(Default, Clone)]
565pub struct SetGeolocationOverrideBuilder {
566    latitude: Option<f64>,
567    longitude: Option<f64>,
568    accuracy: Option<f64>,
569    altitude: Option<f64>,
570    altitude_accuracy: Option<f64>,
571    heading: Option<f64>,
572    speed: Option<f64>,
573}
574impl SetGeolocationOverrideBuilder {
575    pub fn latitude(mut self, latitude: impl Into<f64>) -> Self {
576        self.latitude = Some(latitude.into());
577        self
578    }
579    pub fn longitude(mut self, longitude: impl Into<f64>) -> Self {
580        self.longitude = Some(longitude.into());
581        self
582    }
583    pub fn accuracy(mut self, accuracy: impl Into<f64>) -> Self {
584        self.accuracy = Some(accuracy.into());
585        self
586    }
587    pub fn altitude(mut self, altitude: impl Into<f64>) -> Self {
588        self.altitude = Some(altitude.into());
589        self
590    }
591    pub fn altitude_accuracy(mut self, altitude_accuracy: impl Into<f64>) -> Self {
592        self.altitude_accuracy = Some(altitude_accuracy.into());
593        self
594    }
595    pub fn heading(mut self, heading: impl Into<f64>) -> Self {
596        self.heading = Some(heading.into());
597        self
598    }
599    pub fn speed(mut self, speed: impl Into<f64>) -> Self {
600        self.speed = Some(speed.into());
601        self
602    }
603    pub fn build(self) -> SetGeolocationOverride {
604        SetGeolocationOverride {
605            method: SetGeolocationOverrideMethod::SetGeolocationOverride,
606            params: SetGeolocationOverrideParams {
607                latitude: self.latitude,
608                longitude: self.longitude,
609                accuracy: self.accuracy,
610                altitude: self.altitude,
611                altitude_accuracy: self.altitude_accuracy,
612                heading: self.heading,
613                speed: self.speed,
614            },
615        }
616    }
617}
618impl GetOverriddenSensorInformation {
619    pub fn builder() -> GetOverriddenSensorInformationBuilder {
620        <GetOverriddenSensorInformationBuilder as Default>::default()
621    }
622}
623#[derive(Default, Clone)]
624pub struct GetOverriddenSensorInformationBuilder {
625    r#type: Option<super::types::SensorType>,
626}
627impl GetOverriddenSensorInformationBuilder {
628    pub fn r#type(mut self, r#type: impl Into<super::types::SensorType>) -> Self {
629        self.r#type = Some(r#type.into());
630        self
631    }
632    pub fn build(self) -> Result<GetOverriddenSensorInformation, String> {
633        Ok(GetOverriddenSensorInformation {
634            method: GetOverriddenSensorInformationMethod::GetOverriddenSensorInformation,
635            params: GetOverriddenSensorInformationParams {
636                r#type: self
637                    .r#type
638                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r#type)))?,
639            },
640        })
641    }
642}
643impl SetSensorOverrideEnabled {
644    pub fn builder() -> SetSensorOverrideEnabledBuilder {
645        <SetSensorOverrideEnabledBuilder as Default>::default()
646    }
647}
648#[derive(Default, Clone)]
649pub struct SetSensorOverrideEnabledBuilder {
650    enabled: Option<bool>,
651    r#type: Option<super::types::SensorType>,
652    metadata: Option<super::types::SensorMetadata>,
653}
654impl SetSensorOverrideEnabledBuilder {
655    pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
656        self.enabled = Some(enabled.into());
657        self
658    }
659    pub fn r#type(mut self, r#type: impl Into<super::types::SensorType>) -> Self {
660        self.r#type = Some(r#type.into());
661        self
662    }
663    pub fn metadata(mut self, metadata: impl Into<super::types::SensorMetadata>) -> Self {
664        self.metadata = Some(metadata.into());
665        self
666    }
667    pub fn build(self) -> Result<SetSensorOverrideEnabled, String> {
668        Ok(SetSensorOverrideEnabled {
669            method: SetSensorOverrideEnabledMethod::SetSensorOverrideEnabled,
670            params: SetSensorOverrideEnabledParams {
671                enabled: self
672                    .enabled
673                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(enabled)))?,
674                r#type: self
675                    .r#type
676                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r#type)))?,
677                metadata: self.metadata,
678            },
679        })
680    }
681}
682impl SetSensorOverrideReadings {
683    pub fn builder() -> SetSensorOverrideReadingsBuilder {
684        <SetSensorOverrideReadingsBuilder as Default>::default()
685    }
686}
687#[derive(Default, Clone)]
688pub struct SetSensorOverrideReadingsBuilder {
689    r#type: Option<super::types::SensorType>,
690    reading: Option<super::types::SensorReading>,
691}
692impl SetSensorOverrideReadingsBuilder {
693    pub fn r#type(mut self, r#type: impl Into<super::types::SensorType>) -> Self {
694        self.r#type = Some(r#type.into());
695        self
696    }
697    pub fn reading(mut self, reading: impl Into<super::types::SensorReading>) -> Self {
698        self.reading = Some(reading.into());
699        self
700    }
701    pub fn build(self) -> Result<SetSensorOverrideReadings, String> {
702        Ok(SetSensorOverrideReadings {
703            method: SetSensorOverrideReadingsMethod::SetSensorOverrideReadings,
704            params: SetSensorOverrideReadingsParams {
705                r#type: self
706                    .r#type
707                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r#type)))?,
708                reading: self
709                    .reading
710                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(reading)))?,
711            },
712        })
713    }
714}
715impl SetPressureSourceOverrideEnabled {
716    pub fn builder() -> SetPressureSourceOverrideEnabledBuilder {
717        <SetPressureSourceOverrideEnabledBuilder as Default>::default()
718    }
719}
720#[derive(Default, Clone)]
721pub struct SetPressureSourceOverrideEnabledBuilder {
722    enabled: Option<bool>,
723    source: Option<super::types::PressureSource>,
724    metadata: Option<super::types::PressureMetadata>,
725}
726impl SetPressureSourceOverrideEnabledBuilder {
727    pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
728        self.enabled = Some(enabled.into());
729        self
730    }
731    pub fn source(mut self, source: impl Into<super::types::PressureSource>) -> Self {
732        self.source = Some(source.into());
733        self
734    }
735    pub fn metadata(mut self, metadata: impl Into<super::types::PressureMetadata>) -> Self {
736        self.metadata = Some(metadata.into());
737        self
738    }
739    pub fn build(self) -> Result<SetPressureSourceOverrideEnabled, String> {
740        Ok(SetPressureSourceOverrideEnabled {
741            method: SetPressureSourceOverrideEnabledMethod::SetPressureSourceOverrideEnabled,
742            params: SetPressureSourceOverrideEnabledParams {
743                enabled: self
744                    .enabled
745                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(enabled)))?,
746                source: self
747                    .source
748                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(source)))?,
749                metadata: self.metadata,
750            },
751        })
752    }
753}
754impl SetPressureStateOverride {
755    pub fn builder() -> SetPressureStateOverrideBuilder {
756        <SetPressureStateOverrideBuilder as Default>::default()
757    }
758}
759#[derive(Default, Clone)]
760pub struct SetPressureStateOverrideBuilder {
761    source: Option<super::types::PressureSource>,
762    state: Option<super::types::PressureState>,
763}
764impl SetPressureStateOverrideBuilder {
765    pub fn source(mut self, source: impl Into<super::types::PressureSource>) -> Self {
766        self.source = Some(source.into());
767        self
768    }
769    pub fn state(mut self, state: impl Into<super::types::PressureState>) -> Self {
770        self.state = Some(state.into());
771        self
772    }
773    pub fn build(self) -> Result<SetPressureStateOverride, String> {
774        Ok(SetPressureStateOverride {
775            method: SetPressureStateOverrideMethod::SetPressureStateOverride,
776            params: SetPressureStateOverrideParams {
777                source: self
778                    .source
779                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(source)))?,
780                state: self
781                    .state
782                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(state)))?,
783            },
784        })
785    }
786}
787impl SetPressureDataOverride {
788    pub fn builder() -> SetPressureDataOverrideBuilder {
789        <SetPressureDataOverrideBuilder as Default>::default()
790    }
791}
792#[derive(Default, Clone)]
793pub struct SetPressureDataOverrideBuilder {
794    source: Option<super::types::PressureSource>,
795    state: Option<super::types::PressureState>,
796    own_contribution_estimate: Option<f64>,
797}
798impl SetPressureDataOverrideBuilder {
799    pub fn source(mut self, source: impl Into<super::types::PressureSource>) -> Self {
800        self.source = Some(source.into());
801        self
802    }
803    pub fn state(mut self, state: impl Into<super::types::PressureState>) -> Self {
804        self.state = Some(state.into());
805        self
806    }
807    pub fn own_contribution_estimate(mut self, own_contribution_estimate: impl Into<f64>) -> Self {
808        self.own_contribution_estimate = Some(own_contribution_estimate.into());
809        self
810    }
811    pub fn build(self) -> Result<SetPressureDataOverride, String> {
812        Ok(SetPressureDataOverride {
813            method: SetPressureDataOverrideMethod::SetPressureDataOverride,
814            params: SetPressureDataOverrideParams {
815                source: self
816                    .source
817                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(source)))?,
818                state: self
819                    .state
820                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(state)))?,
821                own_contribution_estimate: self.own_contribution_estimate,
822            },
823        })
824    }
825}
826impl SetIdleOverride {
827    pub fn builder() -> SetIdleOverrideBuilder {
828        <SetIdleOverrideBuilder as Default>::default()
829    }
830}
831#[derive(Default, Clone)]
832pub struct SetIdleOverrideBuilder {
833    is_user_active: Option<bool>,
834    is_screen_unlocked: Option<bool>,
835}
836impl SetIdleOverrideBuilder {
837    pub fn is_user_active(mut self, is_user_active: impl Into<bool>) -> Self {
838        self.is_user_active = Some(is_user_active.into());
839        self
840    }
841    pub fn is_screen_unlocked(mut self, is_screen_unlocked: impl Into<bool>) -> Self {
842        self.is_screen_unlocked = Some(is_screen_unlocked.into());
843        self
844    }
845    pub fn build(self) -> Result<SetIdleOverride, String> {
846        Ok(SetIdleOverride {
847            method: SetIdleOverrideMethod::SetIdleOverride,
848            params: SetIdleOverrideParams {
849                is_user_active: self.is_user_active.ok_or_else(|| {
850                    format!("Field `{}` is mandatory.", std::stringify!(is_user_active))
851                })?,
852                is_screen_unlocked: self.is_screen_unlocked.ok_or_else(|| {
853                    format!(
854                        "Field `{}` is mandatory.",
855                        std::stringify!(is_screen_unlocked)
856                    )
857                })?,
858            },
859        })
860    }
861}
862#[derive(Debug, Clone, Default)]
863pub struct ClearIdleOverrideBuilder;
864impl ClearIdleOverrideBuilder {
865    pub fn new() -> Self {
866        Self
867    }
868    pub fn build(self) -> ClearIdleOverride {
869        ClearIdleOverride {
870            method: ClearIdleOverrideMethod::ClearIdleOverride,
871            params: ClearIdleOverrideParams {},
872        }
873    }
874}
875impl ClearIdleOverride {
876    pub fn builder() -> ClearIdleOverrideBuilder {
877        ClearIdleOverrideBuilder
878    }
879}
880impl SetPageScaleFactor {
881    pub fn builder() -> SetPageScaleFactorBuilder {
882        <SetPageScaleFactorBuilder as Default>::default()
883    }
884}
885#[derive(Default, Clone)]
886pub struct SetPageScaleFactorBuilder {
887    page_scale_factor: Option<f64>,
888}
889impl SetPageScaleFactorBuilder {
890    pub fn page_scale_factor(mut self, page_scale_factor: impl Into<f64>) -> Self {
891        self.page_scale_factor = Some(page_scale_factor.into());
892        self
893    }
894    pub fn build(self) -> Result<SetPageScaleFactor, String> {
895        Ok(SetPageScaleFactor {
896            method: SetPageScaleFactorMethod::SetPageScaleFactor,
897            params: SetPageScaleFactorParams {
898                page_scale_factor: self.page_scale_factor.ok_or_else(|| {
899                    format!(
900                        "Field `{}` is mandatory.",
901                        std::stringify!(page_scale_factor)
902                    )
903                })?,
904            },
905        })
906    }
907}
908impl SetScriptExecutionDisabled {
909    pub fn builder() -> SetScriptExecutionDisabledBuilder {
910        <SetScriptExecutionDisabledBuilder as Default>::default()
911    }
912}
913#[derive(Default, Clone)]
914pub struct SetScriptExecutionDisabledBuilder {
915    value: Option<bool>,
916}
917impl SetScriptExecutionDisabledBuilder {
918    pub fn value(mut self, value: impl Into<bool>) -> Self {
919        self.value = Some(value.into());
920        self
921    }
922    pub fn build(self) -> Result<SetScriptExecutionDisabled, String> {
923        Ok(SetScriptExecutionDisabled {
924            method: SetScriptExecutionDisabledMethod::SetScriptExecutionDisabled,
925            params: SetScriptExecutionDisabledParams {
926                value: self
927                    .value
928                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(value)))?,
929            },
930        })
931    }
932}
933impl SetTouchEmulationEnabled {
934    pub fn builder() -> SetTouchEmulationEnabledBuilder {
935        <SetTouchEmulationEnabledBuilder as Default>::default()
936    }
937}
938#[derive(Default, Clone)]
939pub struct SetTouchEmulationEnabledBuilder {
940    enabled: Option<bool>,
941    max_touch_points: Option<i64>,
942}
943impl SetTouchEmulationEnabledBuilder {
944    pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
945        self.enabled = Some(enabled.into());
946        self
947    }
948    pub fn max_touch_points(mut self, max_touch_points: impl Into<i64>) -> Self {
949        self.max_touch_points = Some(max_touch_points.into());
950        self
951    }
952    pub fn build(self) -> Result<SetTouchEmulationEnabled, String> {
953        Ok(SetTouchEmulationEnabled {
954            method: SetTouchEmulationEnabledMethod::SetTouchEmulationEnabled,
955            params: SetTouchEmulationEnabledParams {
956                enabled: self
957                    .enabled
958                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(enabled)))?,
959                max_touch_points: self.max_touch_points,
960            },
961        })
962    }
963}
964impl SetVirtualTimePolicy {
965    pub fn builder() -> SetVirtualTimePolicyBuilder {
966        <SetVirtualTimePolicyBuilder as Default>::default()
967    }
968}
969#[derive(Default, Clone)]
970pub struct SetVirtualTimePolicyBuilder {
971    policy: Option<super::types::VirtualTimePolicy>,
972    budget: Option<f64>,
973    max_virtual_time_task_starvation_count: Option<i64>,
974    initial_virtual_time: Option<crate::browser_protocol::network::types::TimeSinceEpoch>,
975}
976impl SetVirtualTimePolicyBuilder {
977    pub fn policy(mut self, policy: impl Into<super::types::VirtualTimePolicy>) -> Self {
978        self.policy = Some(policy.into());
979        self
980    }
981    pub fn budget(mut self, budget: impl Into<f64>) -> Self {
982        self.budget = Some(budget.into());
983        self
984    }
985    pub fn max_virtual_time_task_starvation_count(
986        mut self,
987        max_virtual_time_task_starvation_count: impl Into<i64>,
988    ) -> Self {
989        self.max_virtual_time_task_starvation_count =
990            Some(max_virtual_time_task_starvation_count.into());
991        self
992    }
993    pub fn initial_virtual_time(
994        mut self,
995        initial_virtual_time: impl Into<crate::browser_protocol::network::types::TimeSinceEpoch>,
996    ) -> Self {
997        self.initial_virtual_time = Some(initial_virtual_time.into());
998        self
999    }
1000    pub fn build(self) -> Result<SetVirtualTimePolicy, String> {
1001        Ok(SetVirtualTimePolicy {
1002            method: SetVirtualTimePolicyMethod::SetVirtualTimePolicy,
1003            params: SetVirtualTimePolicyParams {
1004                policy: self
1005                    .policy
1006                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(policy)))?,
1007                budget: self.budget,
1008                max_virtual_time_task_starvation_count: self.max_virtual_time_task_starvation_count,
1009                initial_virtual_time: self.initial_virtual_time,
1010            },
1011        })
1012    }
1013}
1014impl SetLocaleOverride {
1015    pub fn builder() -> SetLocaleOverrideBuilder {
1016        <SetLocaleOverrideBuilder as Default>::default()
1017    }
1018}
1019#[derive(Default, Clone)]
1020pub struct SetLocaleOverrideBuilder {
1021    locale: Option<String>,
1022}
1023impl SetLocaleOverrideBuilder {
1024    pub fn locale(mut self, locale: impl Into<String>) -> Self {
1025        self.locale = Some(locale.into());
1026        self
1027    }
1028    pub fn build(self) -> SetLocaleOverride {
1029        SetLocaleOverride {
1030            method: SetLocaleOverrideMethod::SetLocaleOverride,
1031            params: SetLocaleOverrideParams {
1032                locale: self.locale,
1033            },
1034        }
1035    }
1036}
1037impl SetTimezoneOverride {
1038    pub fn builder() -> SetTimezoneOverrideBuilder {
1039        <SetTimezoneOverrideBuilder as Default>::default()
1040    }
1041}
1042#[derive(Default, Clone)]
1043pub struct SetTimezoneOverrideBuilder {
1044    timezone_id: Option<String>,
1045}
1046impl SetTimezoneOverrideBuilder {
1047    pub fn timezone_id(mut self, timezone_id: impl Into<String>) -> Self {
1048        self.timezone_id = Some(timezone_id.into());
1049        self
1050    }
1051    pub fn build(self) -> Result<SetTimezoneOverride, String> {
1052        Ok(SetTimezoneOverride {
1053            method: SetTimezoneOverrideMethod::SetTimezoneOverride,
1054            params: SetTimezoneOverrideParams {
1055                timezone_id: self.timezone_id.ok_or_else(|| {
1056                    format!("Field `{}` is mandatory.", std::stringify!(timezone_id))
1057                })?,
1058            },
1059        })
1060    }
1061}
1062impl SetDisabledImageTypes {
1063    pub fn builder() -> SetDisabledImageTypesBuilder {
1064        <SetDisabledImageTypesBuilder as Default>::default()
1065    }
1066}
1067#[derive(Default, Clone)]
1068pub struct SetDisabledImageTypesBuilder {
1069    image_types: Option<Vec<super::types::DisabledImageType>>,
1070}
1071impl SetDisabledImageTypesBuilder {
1072    pub fn image_type(mut self, image_type: impl Into<super::types::DisabledImageType>) -> Self {
1073        let v = self.image_types.get_or_insert(Vec::new());
1074        v.push(image_type.into());
1075        self
1076    }
1077    pub fn image_types<I, S>(mut self, image_types: I) -> Self
1078    where
1079        I: IntoIterator<Item = S>,
1080        S: Into<super::types::DisabledImageType>,
1081    {
1082        let v = self.image_types.get_or_insert(Vec::new());
1083        for val in image_types {
1084            v.push(val.into());
1085        }
1086        self
1087    }
1088    pub fn build(self) -> Result<SetDisabledImageTypes, String> {
1089        Ok(SetDisabledImageTypes {
1090            method: SetDisabledImageTypesMethod::SetDisabledImageTypes,
1091            params: SetDisabledImageTypesParams {
1092                image_types: self.image_types.ok_or_else(|| {
1093                    format!("Field `{}` is mandatory.", std::stringify!(image_types))
1094                })?,
1095            },
1096        })
1097    }
1098}
1099impl SetDataSaverOverride {
1100    pub fn builder() -> SetDataSaverOverrideBuilder {
1101        <SetDataSaverOverrideBuilder as Default>::default()
1102    }
1103}
1104#[derive(Default, Clone)]
1105pub struct SetDataSaverOverrideBuilder {
1106    data_saver_enabled: Option<bool>,
1107}
1108impl SetDataSaverOverrideBuilder {
1109    pub fn data_saver_enabled(mut self, data_saver_enabled: impl Into<bool>) -> Self {
1110        self.data_saver_enabled = Some(data_saver_enabled.into());
1111        self
1112    }
1113    pub fn build(self) -> SetDataSaverOverride {
1114        SetDataSaverOverride {
1115            method: SetDataSaverOverrideMethod::SetDataSaverOverride,
1116            params: SetDataSaverOverrideParams {
1117                data_saver_enabled: self.data_saver_enabled,
1118            },
1119        }
1120    }
1121}
1122impl SetHardwareConcurrencyOverride {
1123    pub fn builder() -> SetHardwareConcurrencyOverrideBuilder {
1124        <SetHardwareConcurrencyOverrideBuilder as Default>::default()
1125    }
1126}
1127#[derive(Default, Clone)]
1128pub struct SetHardwareConcurrencyOverrideBuilder {
1129    hardware_concurrency: Option<i64>,
1130}
1131impl SetHardwareConcurrencyOverrideBuilder {
1132    pub fn hardware_concurrency(mut self, hardware_concurrency: impl Into<i64>) -> Self {
1133        self.hardware_concurrency = Some(hardware_concurrency.into());
1134        self
1135    }
1136    pub fn build(self) -> Result<SetHardwareConcurrencyOverride, String> {
1137        Ok(SetHardwareConcurrencyOverride {
1138            method: SetHardwareConcurrencyOverrideMethod::SetHardwareConcurrencyOverride,
1139            params: SetHardwareConcurrencyOverrideParams {
1140                hardware_concurrency: self.hardware_concurrency.ok_or_else(|| {
1141                    format!(
1142                        "Field `{}` is mandatory.",
1143                        std::stringify!(hardware_concurrency)
1144                    )
1145                })?,
1146            },
1147        })
1148    }
1149}
1150impl SetUserAgentOverride {
1151    pub fn builder() -> SetUserAgentOverrideBuilder {
1152        <SetUserAgentOverrideBuilder as Default>::default()
1153    }
1154}
1155#[derive(Default, Clone)]
1156pub struct SetUserAgentOverrideBuilder {
1157    user_agent: Option<String>,
1158    accept_language: Option<String>,
1159    platform: Option<String>,
1160    user_agent_metadata: Option<super::types::UserAgentMetadata>,
1161}
1162impl SetUserAgentOverrideBuilder {
1163    pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
1164        self.user_agent = Some(user_agent.into());
1165        self
1166    }
1167    pub fn accept_language(mut self, accept_language: impl Into<String>) -> Self {
1168        self.accept_language = Some(accept_language.into());
1169        self
1170    }
1171    pub fn platform(mut self, platform: impl Into<String>) -> Self {
1172        self.platform = Some(platform.into());
1173        self
1174    }
1175    pub fn user_agent_metadata(
1176        mut self,
1177        user_agent_metadata: impl Into<super::types::UserAgentMetadata>,
1178    ) -> Self {
1179        self.user_agent_metadata = Some(user_agent_metadata.into());
1180        self
1181    }
1182    pub fn build(self) -> Result<SetUserAgentOverride, String> {
1183        Ok(SetUserAgentOverride {
1184            method: SetUserAgentOverrideMethod::SetUserAgentOverride,
1185            params: SetUserAgentOverrideParams {
1186                user_agent: self.user_agent.ok_or_else(|| {
1187                    format!("Field `{}` is mandatory.", std::stringify!(user_agent))
1188                })?,
1189                accept_language: self.accept_language,
1190                platform: self.platform,
1191                user_agent_metadata: self.user_agent_metadata,
1192            },
1193        })
1194    }
1195}
1196impl SetAutomationOverride {
1197    pub fn builder() -> SetAutomationOverrideBuilder {
1198        <SetAutomationOverrideBuilder as Default>::default()
1199    }
1200}
1201#[derive(Default, Clone)]
1202pub struct SetAutomationOverrideBuilder {
1203    enabled: Option<bool>,
1204}
1205impl SetAutomationOverrideBuilder {
1206    pub fn enabled(mut self, enabled: impl Into<bool>) -> Self {
1207        self.enabled = Some(enabled.into());
1208        self
1209    }
1210    pub fn build(self) -> Result<SetAutomationOverride, String> {
1211        Ok(SetAutomationOverride {
1212            method: SetAutomationOverrideMethod::SetAutomationOverride,
1213            params: SetAutomationOverrideParams {
1214                enabled: self
1215                    .enabled
1216                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(enabled)))?,
1217            },
1218        })
1219    }
1220}
1221impl SetSmallViewportHeightDifferenceOverride {
1222    pub fn builder() -> SetSmallViewportHeightDifferenceOverrideBuilder {
1223        <SetSmallViewportHeightDifferenceOverrideBuilder as Default>::default()
1224    }
1225}
1226#[derive(Default, Clone)]
1227pub struct SetSmallViewportHeightDifferenceOverrideBuilder {
1228    difference: Option<i64>,
1229}
1230impl SetSmallViewportHeightDifferenceOverrideBuilder {
1231    pub fn difference(mut self, difference: impl Into<i64>) -> Self {
1232        self.difference = Some(difference.into());
1233        self
1234    }
1235    pub fn build(self) -> Result<SetSmallViewportHeightDifferenceOverride, String> {
1236        Ok (SetSmallViewportHeightDifferenceOverride { method : SetSmallViewportHeightDifferenceOverrideMethod :: SetSmallViewportHeightDifferenceOverride , params : SetSmallViewportHeightDifferenceOverrideParams { difference : self . difference . ok_or_else (|| format ! ("Field `{}` is mandatory." , std :: stringify ! (difference))) ? , } , })
1237    }
1238}
1239#[derive(Debug, Clone, Default)]
1240pub struct GetScreenInfosBuilder;
1241impl GetScreenInfosBuilder {
1242    pub fn new() -> Self {
1243        Self
1244    }
1245    pub fn build(self) -> GetScreenInfos {
1246        GetScreenInfos {
1247            method: GetScreenInfosMethod::GetScreenInfos,
1248            params: GetScreenInfosParams {},
1249        }
1250    }
1251}
1252impl GetScreenInfos {
1253    pub fn builder() -> GetScreenInfosBuilder {
1254        GetScreenInfosBuilder
1255    }
1256}
1257impl AddScreen {
1258    pub fn builder() -> AddScreenBuilder {
1259        <AddScreenBuilder as Default>::default()
1260    }
1261}
1262#[derive(Default, Clone)]
1263pub struct AddScreenBuilder {
1264    left: Option<i64>,
1265    top: Option<i64>,
1266    width: Option<i64>,
1267    height: Option<i64>,
1268    work_area_insets: Option<super::types::WorkAreaInsets>,
1269    device_pixel_ratio: Option<f64>,
1270    rotation: Option<i64>,
1271    color_depth: Option<i64>,
1272    label: Option<String>,
1273    is_internal: Option<bool>,
1274}
1275impl AddScreenBuilder {
1276    pub fn left(mut self, left: impl Into<i64>) -> Self {
1277        self.left = Some(left.into());
1278        self
1279    }
1280    pub fn top(mut self, top: impl Into<i64>) -> Self {
1281        self.top = Some(top.into());
1282        self
1283    }
1284    pub fn width(mut self, width: impl Into<i64>) -> Self {
1285        self.width = Some(width.into());
1286        self
1287    }
1288    pub fn height(mut self, height: impl Into<i64>) -> Self {
1289        self.height = Some(height.into());
1290        self
1291    }
1292    pub fn work_area_insets(
1293        mut self,
1294        work_area_insets: impl Into<super::types::WorkAreaInsets>,
1295    ) -> Self {
1296        self.work_area_insets = Some(work_area_insets.into());
1297        self
1298    }
1299    pub fn device_pixel_ratio(mut self, device_pixel_ratio: impl Into<f64>) -> Self {
1300        self.device_pixel_ratio = Some(device_pixel_ratio.into());
1301        self
1302    }
1303    pub fn rotation(mut self, rotation: impl Into<i64>) -> Self {
1304        self.rotation = Some(rotation.into());
1305        self
1306    }
1307    pub fn color_depth(mut self, color_depth: impl Into<i64>) -> Self {
1308        self.color_depth = Some(color_depth.into());
1309        self
1310    }
1311    pub fn label(mut self, label: impl Into<String>) -> Self {
1312        self.label = Some(label.into());
1313        self
1314    }
1315    pub fn is_internal(mut self, is_internal: impl Into<bool>) -> Self {
1316        self.is_internal = Some(is_internal.into());
1317        self
1318    }
1319    pub fn build(self) -> Result<AddScreen, String> {
1320        Ok(AddScreen {
1321            method: AddScreenMethod::AddScreen,
1322            params: AddScreenParams {
1323                left: self
1324                    .left
1325                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(left)))?,
1326                top: self
1327                    .top
1328                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(top)))?,
1329                width: self
1330                    .width
1331                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(width)))?,
1332                height: self
1333                    .height
1334                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(height)))?,
1335                work_area_insets: self.work_area_insets,
1336                device_pixel_ratio: self.device_pixel_ratio,
1337                rotation: self.rotation,
1338                color_depth: self.color_depth,
1339                label: self.label,
1340                is_internal: self.is_internal,
1341            },
1342        })
1343    }
1344}
1345impl RemoveScreen {
1346    pub fn builder() -> RemoveScreenBuilder {
1347        <RemoveScreenBuilder as Default>::default()
1348    }
1349}
1350#[derive(Default, Clone)]
1351pub struct RemoveScreenBuilder {
1352    screen_id: Option<super::types::ScreenId>,
1353}
1354impl RemoveScreenBuilder {
1355    pub fn screen_id(mut self, screen_id: impl Into<super::types::ScreenId>) -> Self {
1356        self.screen_id = Some(screen_id.into());
1357        self
1358    }
1359    pub fn build(self) -> Result<RemoveScreen, String> {
1360        Ok(RemoveScreen {
1361            method: RemoveScreenMethod::RemoveScreen,
1362            params: RemoveScreenParams {
1363                screen_id: self.screen_id.ok_or_else(|| {
1364                    format!("Field `{}` is mandatory.", std::stringify!(screen_id))
1365                })?,
1366            },
1367        })
1368    }
1369}
rustenium_cdp_definitions/browser_protocol/emulation/command_builders.rs

rustenium_cdp_definitions/browser_protocol/emulation/
command_builders.rs
