browser_protocol/audits/
mod.rs

1//! Audits domain allows investigation of page violations and possible improvements.
2
3
4use serde::{Serialize, Deserialize};
5use serde_json::Value as JsonValue;
6use std::borrow::Cow;
7
8/// Information about a cookie that is affected by an inspector issue.
9
10#[derive(Debug, Clone, Serialize, Deserialize, Default)]
11#[serde(rename_all = "camelCase")]
12pub struct AffectedCookie<'a> {
13    /// The following three properties uniquely identify a cookie
14    name: Cow<'a, str>,
15    path: Cow<'a, str>,
16    domain: Cow<'a, str>,
17}
18
19impl<'a> AffectedCookie<'a> {
20    pub fn builder(name: impl Into<Cow<'a, str>>, path: impl Into<Cow<'a, str>>, domain: impl Into<Cow<'a, str>>) -> AffectedCookieBuilder<'a> {
21        AffectedCookieBuilder {
22            name: name.into(),
23            path: path.into(),
24            domain: domain.into(),
25        }
26    }
27    pub fn name(&self) -> &str { self.name.as_ref() }
28    pub fn path(&self) -> &str { self.path.as_ref() }
29    pub fn domain(&self) -> &str { self.domain.as_ref() }
30}
31
32
33pub struct AffectedCookieBuilder<'a> {
34    name: Cow<'a, str>,
35    path: Cow<'a, str>,
36    domain: Cow<'a, str>,
37}
38
39impl<'a> AffectedCookieBuilder<'a> {
40    pub fn build(self) -> AffectedCookie<'a> {
41        AffectedCookie {
42            name: self.name,
43            path: self.path,
44            domain: self.domain,
45        }
46    }
47}
48
49/// Information about a request that is affected by an inspector issue.
50
51#[derive(Debug, Clone, Serialize, Deserialize, Default)]
52#[serde(rename_all = "camelCase")]
53pub struct AffectedRequest<'a> {
54    /// The unique request id.
55    #[serde(skip_serializing_if = "Option::is_none")]
56    requestId: Option<crate::network::RequestId<'a>>,
57    url: Cow<'a, str>,
58}
59
60impl<'a> AffectedRequest<'a> {
61    pub fn builder(url: impl Into<Cow<'a, str>>) -> AffectedRequestBuilder<'a> {
62        AffectedRequestBuilder {
63            requestId: None,
64            url: url.into(),
65        }
66    }
67    pub fn requestId(&self) -> Option<&crate::network::RequestId<'a>> { self.requestId.as_ref() }
68    pub fn url(&self) -> &str { self.url.as_ref() }
69}
70
71
72pub struct AffectedRequestBuilder<'a> {
73    requestId: Option<crate::network::RequestId<'a>>,
74    url: Cow<'a, str>,
75}
76
77impl<'a> AffectedRequestBuilder<'a> {
78    /// The unique request id.
79    pub fn requestId(mut self, requestId: crate::network::RequestId<'a>) -> Self { self.requestId = Some(requestId); self }
80    pub fn build(self) -> AffectedRequest<'a> {
81        AffectedRequest {
82            requestId: self.requestId,
83            url: self.url,
84        }
85    }
86}
87
88/// Information about the frame affected by an inspector issue.
89
90#[derive(Debug, Clone, Serialize, Deserialize, Default)]
91#[serde(rename_all = "camelCase")]
92pub struct AffectedFrame<'a> {
93    frameId: crate::page::FrameId<'a>,
94}
95
96impl<'a> AffectedFrame<'a> {
97    pub fn builder(frameId: crate::page::FrameId<'a>) -> AffectedFrameBuilder<'a> {
98        AffectedFrameBuilder {
99            frameId: frameId,
100        }
101    }
102    pub fn frameId(&self) -> &crate::page::FrameId<'a> { &self.frameId }
103}
104
105
106pub struct AffectedFrameBuilder<'a> {
107    frameId: crate::page::FrameId<'a>,
108}
109
110impl<'a> AffectedFrameBuilder<'a> {
111    pub fn build(self) -> AffectedFrame<'a> {
112        AffectedFrame {
113            frameId: self.frameId,
114        }
115    }
116}
117
118
119#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
120pub enum CookieExclusionReason {
121    #[default]
122    #[serde(rename = "ExcludeSameSiteUnspecifiedTreatedAsLax")]
123    ExcludeSameSiteUnspecifiedTreatedAsLax,
124    #[serde(rename = "ExcludeSameSiteNoneInsecure")]
125    ExcludeSameSiteNoneInsecure,
126    #[serde(rename = "ExcludeSameSiteLax")]
127    ExcludeSameSiteLax,
128    #[serde(rename = "ExcludeSameSiteStrict")]
129    ExcludeSameSiteStrict,
130    #[serde(rename = "ExcludeDomainNonASCII")]
131    ExcludeDomainNonASCII,
132    #[serde(rename = "ExcludeThirdPartyCookieBlockedInFirstPartySet")]
133    ExcludeThirdPartyCookieBlockedInFirstPartySet,
134    #[serde(rename = "ExcludeThirdPartyPhaseout")]
135    ExcludeThirdPartyPhaseout,
136    #[serde(rename = "ExcludePortMismatch")]
137    ExcludePortMismatch,
138    #[serde(rename = "ExcludeSchemeMismatch")]
139    ExcludeSchemeMismatch,
140}
141
142
143#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
144pub enum CookieWarningReason {
145    #[default]
146    #[serde(rename = "WarnSameSiteUnspecifiedCrossSiteContext")]
147    WarnSameSiteUnspecifiedCrossSiteContext,
148    #[serde(rename = "WarnSameSiteNoneInsecure")]
149    WarnSameSiteNoneInsecure,
150    #[serde(rename = "WarnSameSiteUnspecifiedLaxAllowUnsafe")]
151    WarnSameSiteUnspecifiedLaxAllowUnsafe,
152    #[serde(rename = "WarnSameSiteStrictLaxDowngradeStrict")]
153    WarnSameSiteStrictLaxDowngradeStrict,
154    #[serde(rename = "WarnSameSiteStrictCrossDowngradeStrict")]
155    WarnSameSiteStrictCrossDowngradeStrict,
156    #[serde(rename = "WarnSameSiteStrictCrossDowngradeLax")]
157    WarnSameSiteStrictCrossDowngradeLax,
158    #[serde(rename = "WarnSameSiteLaxCrossDowngradeStrict")]
159    WarnSameSiteLaxCrossDowngradeStrict,
160    #[serde(rename = "WarnSameSiteLaxCrossDowngradeLax")]
161    WarnSameSiteLaxCrossDowngradeLax,
162    #[serde(rename = "WarnAttributeValueExceedsMaxSize")]
163    WarnAttributeValueExceedsMaxSize,
164    #[serde(rename = "WarnDomainNonASCII")]
165    WarnDomainNonASCII,
166    #[serde(rename = "WarnThirdPartyPhaseout")]
167    WarnThirdPartyPhaseout,
168    #[serde(rename = "WarnCrossSiteRedirectDowngradeChangesInclusion")]
169    WarnCrossSiteRedirectDowngradeChangesInclusion,
170    #[serde(rename = "WarnDeprecationTrialMetadata")]
171    WarnDeprecationTrialMetadata,
172    #[serde(rename = "WarnThirdPartyCookieHeuristic")]
173    WarnThirdPartyCookieHeuristic,
174}
175
176
177#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
178pub enum CookieOperation {
179    #[default]
180    #[serde(rename = "SetCookie")]
181    SetCookie,
182    #[serde(rename = "ReadCookie")]
183    ReadCookie,
184}
185
186/// Represents the category of insight that a cookie issue falls under.
187
188#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
189pub enum InsightType {
190    #[default]
191    #[serde(rename = "GitHubResource")]
192    GitHubResource,
193    #[serde(rename = "GracePeriod")]
194    GracePeriod,
195    #[serde(rename = "Heuristics")]
196    Heuristics,
197}
198
199/// Information about the suggested solution to a cookie issue.
200
201#[derive(Debug, Clone, Serialize, Deserialize, Default)]
202#[serde(rename_all = "camelCase")]
203pub struct CookieIssueInsight<'a> {
204    #[serde(rename = "type")]
205    type_: InsightType,
206    /// Link to table entry in third-party cookie migration readiness list.
207    #[serde(skip_serializing_if = "Option::is_none")]
208    tableEntryUrl: Option<Cow<'a, str>>,
209}
210
211impl<'a> CookieIssueInsight<'a> {
212    pub fn builder(type_: InsightType) -> CookieIssueInsightBuilder<'a> {
213        CookieIssueInsightBuilder {
214            type_: type_,
215            tableEntryUrl: None,
216        }
217    }
218    pub fn type_(&self) -> &InsightType { &self.type_ }
219    pub fn tableEntryUrl(&self) -> Option<&str> { self.tableEntryUrl.as_deref() }
220}
221
222
223pub struct CookieIssueInsightBuilder<'a> {
224    type_: InsightType,
225    tableEntryUrl: Option<Cow<'a, str>>,
226}
227
228impl<'a> CookieIssueInsightBuilder<'a> {
229    /// Link to table entry in third-party cookie migration readiness list.
230    pub fn tableEntryUrl(mut self, tableEntryUrl: impl Into<Cow<'a, str>>) -> Self { self.tableEntryUrl = Some(tableEntryUrl.into()); self }
231    pub fn build(self) -> CookieIssueInsight<'a> {
232        CookieIssueInsight {
233            type_: self.type_,
234            tableEntryUrl: self.tableEntryUrl,
235        }
236    }
237}
238
239/// This information is currently necessary, as the front-end has a difficult
240/// time finding a specific cookie. With this, we can convey specific error
241/// information without the cookie.
242
243#[derive(Debug, Clone, Serialize, Deserialize, Default)]
244#[serde(rename_all = "camelCase")]
245pub struct CookieIssueDetails<'a> {
246    /// If AffectedCookie is not set then rawCookieLine contains the raw
247    /// Set-Cookie header string. This hints at a problem where the
248    /// cookie line is syntactically or semantically malformed in a way
249    /// that no valid cookie could be created.
250    #[serde(skip_serializing_if = "Option::is_none")]
251    cookie: Option<AffectedCookie<'a>>,
252    #[serde(skip_serializing_if = "Option::is_none")]
253    rawCookieLine: Option<Cow<'a, str>>,
254    cookieWarningReasons: Vec<CookieWarningReason>,
255    cookieExclusionReasons: Vec<CookieExclusionReason>,
256    /// Optionally identifies the site-for-cookies and the cookie url, which
257    /// may be used by the front-end as additional context.
258    operation: CookieOperation,
259    #[serde(skip_serializing_if = "Option::is_none")]
260    siteForCookies: Option<Cow<'a, str>>,
261    #[serde(skip_serializing_if = "Option::is_none")]
262    cookieUrl: Option<Cow<'a, str>>,
263    #[serde(skip_serializing_if = "Option::is_none")]
264    request: Option<AffectedRequest<'a>>,
265    /// The recommended solution to the issue.
266    #[serde(skip_serializing_if = "Option::is_none")]
267    insight: Option<CookieIssueInsight<'a>>,
268}
269
270impl<'a> CookieIssueDetails<'a> {
271    pub fn builder(cookieWarningReasons: Vec<CookieWarningReason>, cookieExclusionReasons: Vec<CookieExclusionReason>, operation: CookieOperation) -> CookieIssueDetailsBuilder<'a> {
272        CookieIssueDetailsBuilder {
273            cookie: None,
274            rawCookieLine: None,
275            cookieWarningReasons: cookieWarningReasons,
276            cookieExclusionReasons: cookieExclusionReasons,
277            operation: operation,
278            siteForCookies: None,
279            cookieUrl: None,
280            request: None,
281            insight: None,
282        }
283    }
284    pub fn cookie(&self) -> Option<&AffectedCookie<'a>> { self.cookie.as_ref() }
285    pub fn rawCookieLine(&self) -> Option<&str> { self.rawCookieLine.as_deref() }
286    pub fn cookieWarningReasons(&self) -> &[CookieWarningReason] { &self.cookieWarningReasons }
287    pub fn cookieExclusionReasons(&self) -> &[CookieExclusionReason] { &self.cookieExclusionReasons }
288    pub fn operation(&self) -> &CookieOperation { &self.operation }
289    pub fn siteForCookies(&self) -> Option<&str> { self.siteForCookies.as_deref() }
290    pub fn cookieUrl(&self) -> Option<&str> { self.cookieUrl.as_deref() }
291    pub fn request(&self) -> Option<&AffectedRequest<'a>> { self.request.as_ref() }
292    pub fn insight(&self) -> Option<&CookieIssueInsight<'a>> { self.insight.as_ref() }
293}
294
295
296pub struct CookieIssueDetailsBuilder<'a> {
297    cookie: Option<AffectedCookie<'a>>,
298    rawCookieLine: Option<Cow<'a, str>>,
299    cookieWarningReasons: Vec<CookieWarningReason>,
300    cookieExclusionReasons: Vec<CookieExclusionReason>,
301    operation: CookieOperation,
302    siteForCookies: Option<Cow<'a, str>>,
303    cookieUrl: Option<Cow<'a, str>>,
304    request: Option<AffectedRequest<'a>>,
305    insight: Option<CookieIssueInsight<'a>>,
306}
307
308impl<'a> CookieIssueDetailsBuilder<'a> {
309    /// If AffectedCookie is not set then rawCookieLine contains the raw
310    /// Set-Cookie header string. This hints at a problem where the
311    /// cookie line is syntactically or semantically malformed in a way
312    /// that no valid cookie could be created.
313    pub fn cookie(mut self, cookie: AffectedCookie<'a>) -> Self { self.cookie = Some(cookie); self }
314    pub fn rawCookieLine(mut self, rawCookieLine: impl Into<Cow<'a, str>>) -> Self { self.rawCookieLine = Some(rawCookieLine.into()); self }
315    pub fn siteForCookies(mut self, siteForCookies: impl Into<Cow<'a, str>>) -> Self { self.siteForCookies = Some(siteForCookies.into()); self }
316    pub fn cookieUrl(mut self, cookieUrl: impl Into<Cow<'a, str>>) -> Self { self.cookieUrl = Some(cookieUrl.into()); self }
317    pub fn request(mut self, request: AffectedRequest<'a>) -> Self { self.request = Some(request); self }
318    /// The recommended solution to the issue.
319    pub fn insight(mut self, insight: CookieIssueInsight<'a>) -> Self { self.insight = Some(insight); self }
320    pub fn build(self) -> CookieIssueDetails<'a> {
321        CookieIssueDetails {
322            cookie: self.cookie,
323            rawCookieLine: self.rawCookieLine,
324            cookieWarningReasons: self.cookieWarningReasons,
325            cookieExclusionReasons: self.cookieExclusionReasons,
326            operation: self.operation,
327            siteForCookies: self.siteForCookies,
328            cookieUrl: self.cookieUrl,
329            request: self.request,
330            insight: self.insight,
331        }
332    }
333}
334
335
336#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
337pub enum PerformanceIssueType {
338    #[default]
339    #[serde(rename = "DocumentCookie")]
340    DocumentCookie,
341}
342
343/// Details for a performance issue.
344
345#[derive(Debug, Clone, Serialize, Deserialize, Default)]
346#[serde(rename_all = "camelCase")]
347pub struct PerformanceIssueDetails<'a> {
348    performanceIssueType: PerformanceIssueType,
349    #[serde(skip_serializing_if = "Option::is_none")]
350    sourceCodeLocation: Option<SourceCodeLocation<'a>>,
351}
352
353impl<'a> PerformanceIssueDetails<'a> {
354    pub fn builder(performanceIssueType: PerformanceIssueType) -> PerformanceIssueDetailsBuilder<'a> {
355        PerformanceIssueDetailsBuilder {
356            performanceIssueType: performanceIssueType,
357            sourceCodeLocation: None,
358        }
359    }
360    pub fn performanceIssueType(&self) -> &PerformanceIssueType { &self.performanceIssueType }
361    pub fn sourceCodeLocation(&self) -> Option<&SourceCodeLocation<'a>> { self.sourceCodeLocation.as_ref() }
362}
363
364
365pub struct PerformanceIssueDetailsBuilder<'a> {
366    performanceIssueType: PerformanceIssueType,
367    sourceCodeLocation: Option<SourceCodeLocation<'a>>,
368}
369
370impl<'a> PerformanceIssueDetailsBuilder<'a> {
371    pub fn sourceCodeLocation(mut self, sourceCodeLocation: SourceCodeLocation<'a>) -> Self { self.sourceCodeLocation = Some(sourceCodeLocation); self }
372    pub fn build(self) -> PerformanceIssueDetails<'a> {
373        PerformanceIssueDetails {
374            performanceIssueType: self.performanceIssueType,
375            sourceCodeLocation: self.sourceCodeLocation,
376        }
377    }
378}
379
380
381#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
382pub enum MixedContentResolutionStatus {
383    #[default]
384    #[serde(rename = "MixedContentBlocked")]
385    MixedContentBlocked,
386    #[serde(rename = "MixedContentAutomaticallyUpgraded")]
387    MixedContentAutomaticallyUpgraded,
388    #[serde(rename = "MixedContentWarning")]
389    MixedContentWarning,
390}
391
392
393#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
394pub enum MixedContentResourceType {
395    #[default]
396    #[serde(rename = "AttributionSrc")]
397    AttributionSrc,
398    #[serde(rename = "Audio")]
399    Audio,
400    #[serde(rename = "Beacon")]
401    Beacon,
402    #[serde(rename = "CSPReport")]
403    CSPReport,
404    #[serde(rename = "Download")]
405    Download,
406    #[serde(rename = "EventSource")]
407    EventSource,
408    #[serde(rename = "Favicon")]
409    Favicon,
410    #[serde(rename = "Font")]
411    Font,
412    #[serde(rename = "Form")]
413    Form,
414    #[serde(rename = "Frame")]
415    Frame,
416    #[serde(rename = "Image")]
417    Image,
418    #[serde(rename = "Import")]
419    Import,
420    #[serde(rename = "JSON")]
421    JSON,
422    #[serde(rename = "Manifest")]
423    Manifest,
424    #[serde(rename = "Ping")]
425    Ping,
426    #[serde(rename = "PluginData")]
427    PluginData,
428    #[serde(rename = "PluginResource")]
429    PluginResource,
430    #[serde(rename = "Prefetch")]
431    Prefetch,
432    #[serde(rename = "Resource")]
433    Resource,
434    #[serde(rename = "Script")]
435    Script,
436    #[serde(rename = "ServiceWorker")]
437    ServiceWorker,
438    #[serde(rename = "SharedWorker")]
439    SharedWorker,
440    #[serde(rename = "SpeculationRules")]
441    SpeculationRules,
442    #[serde(rename = "Stylesheet")]
443    Stylesheet,
444    #[serde(rename = "Track")]
445    Track,
446    #[serde(rename = "Video")]
447    Video,
448    #[serde(rename = "Worker")]
449    Worker,
450    #[serde(rename = "XMLHttpRequest")]
451    XMLHttpRequest,
452    #[serde(rename = "XSLT")]
453    XSLT,
454}
455
456
457#[derive(Debug, Clone, Serialize, Deserialize, Default)]
458#[serde(rename_all = "camelCase")]
459pub struct MixedContentIssueDetails<'a> {
460    /// The type of resource causing the mixed content issue (css, js, iframe,
461    /// form,...). Marked as optional because it is mapped to from
462    /// blink::mojom::RequestContextType, which will be replaced
463    /// by network::mojom::RequestDestination
464    #[serde(skip_serializing_if = "Option::is_none")]
465    resourceType: Option<MixedContentResourceType>,
466    /// The way the mixed content issue is being resolved.
467    resolutionStatus: MixedContentResolutionStatus,
468    /// The unsafe http url causing the mixed content issue.
469    insecureURL: Cow<'a, str>,
470    /// The url responsible for the call to an unsafe url.
471    mainResourceURL: Cow<'a, str>,
472    /// The mixed content request.
473    /// Does not always exist (e.g. for unsafe form submission urls).
474    #[serde(skip_serializing_if = "Option::is_none")]
475    request: Option<AffectedRequest<'a>>,
476    /// Optional because not every mixed content issue is necessarily linked to a frame.
477    #[serde(skip_serializing_if = "Option::is_none")]
478    frame: Option<AffectedFrame<'a>>,
479}
480
481impl<'a> MixedContentIssueDetails<'a> {
482    pub fn builder(resolutionStatus: MixedContentResolutionStatus, insecureURL: impl Into<Cow<'a, str>>, mainResourceURL: impl Into<Cow<'a, str>>) -> MixedContentIssueDetailsBuilder<'a> {
483        MixedContentIssueDetailsBuilder {
484            resourceType: None,
485            resolutionStatus: resolutionStatus,
486            insecureURL: insecureURL.into(),
487            mainResourceURL: mainResourceURL.into(),
488            request: None,
489            frame: None,
490        }
491    }
492    pub fn resourceType(&self) -> Option<&MixedContentResourceType> { self.resourceType.as_ref() }
493    pub fn resolutionStatus(&self) -> &MixedContentResolutionStatus { &self.resolutionStatus }
494    pub fn insecureURL(&self) -> &str { self.insecureURL.as_ref() }
495    pub fn mainResourceURL(&self) -> &str { self.mainResourceURL.as_ref() }
496    pub fn request(&self) -> Option<&AffectedRequest<'a>> { self.request.as_ref() }
497    pub fn frame(&self) -> Option<&AffectedFrame<'a>> { self.frame.as_ref() }
498}
499
500
501pub struct MixedContentIssueDetailsBuilder<'a> {
502    resourceType: Option<MixedContentResourceType>,
503    resolutionStatus: MixedContentResolutionStatus,
504    insecureURL: Cow<'a, str>,
505    mainResourceURL: Cow<'a, str>,
506    request: Option<AffectedRequest<'a>>,
507    frame: Option<AffectedFrame<'a>>,
508}
509
510impl<'a> MixedContentIssueDetailsBuilder<'a> {
511    /// The type of resource causing the mixed content issue (css, js, iframe,
512    /// form,...). Marked as optional because it is mapped to from
513    /// blink::mojom::RequestContextType, which will be replaced
514    /// by network::mojom::RequestDestination
515    pub fn resourceType(mut self, resourceType: MixedContentResourceType) -> Self { self.resourceType = Some(resourceType); self }
516    /// The mixed content request.
517    /// Does not always exist (e.g. for unsafe form submission urls).
518    pub fn request(mut self, request: AffectedRequest<'a>) -> Self { self.request = Some(request); self }
519    /// Optional because not every mixed content issue is necessarily linked to a frame.
520    pub fn frame(mut self, frame: AffectedFrame<'a>) -> Self { self.frame = Some(frame); self }
521    pub fn build(self) -> MixedContentIssueDetails<'a> {
522        MixedContentIssueDetails {
523            resourceType: self.resourceType,
524            resolutionStatus: self.resolutionStatus,
525            insecureURL: self.insecureURL,
526            mainResourceURL: self.mainResourceURL,
527            request: self.request,
528            frame: self.frame,
529        }
530    }
531}
532
533/// Enum indicating the reason a response has been blocked. These reasons are
534/// refinements of the net error BLOCKED_BY_RESPONSE.
535
536#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
537pub enum BlockedByResponseReason {
538    #[default]
539    #[serde(rename = "CoepFrameResourceNeedsCoepHeader")]
540    CoepFrameResourceNeedsCoepHeader,
541    #[serde(rename = "CoopSandboxedIFrameCannotNavigateToCoopPage")]
542    CoopSandboxedIFrameCannotNavigateToCoopPage,
543    #[serde(rename = "CorpNotSameOrigin")]
544    CorpNotSameOrigin,
545    #[serde(rename = "CorpNotSameOriginAfterDefaultedToSameOriginByCoep")]
546    CorpNotSameOriginAfterDefaultedToSameOriginByCoep,
547    #[serde(rename = "CorpNotSameOriginAfterDefaultedToSameOriginByDip")]
548    CorpNotSameOriginAfterDefaultedToSameOriginByDip,
549    #[serde(rename = "CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip")]
550    CorpNotSameOriginAfterDefaultedToSameOriginByCoepAndDip,
551    #[serde(rename = "CorpNotSameSite")]
552    CorpNotSameSite,
553    #[serde(rename = "SRIMessageSignatureMismatch")]
554    SRIMessageSignatureMismatch,
555}
556
557/// Details for a request that has been blocked with the BLOCKED_BY_RESPONSE
558/// code. Currently only used for COEP/COOP, but may be extended to include
559/// some CSP errors in the future.
560
561#[derive(Debug, Clone, Serialize, Deserialize, Default)]
562#[serde(rename_all = "camelCase")]
563pub struct BlockedByResponseIssueDetails<'a> {
564    request: AffectedRequest<'a>,
565    #[serde(skip_serializing_if = "Option::is_none")]
566    parentFrame: Option<AffectedFrame<'a>>,
567    #[serde(skip_serializing_if = "Option::is_none")]
568    blockedFrame: Option<AffectedFrame<'a>>,
569    reason: BlockedByResponseReason,
570}
571
572impl<'a> BlockedByResponseIssueDetails<'a> {
573    pub fn builder(request: AffectedRequest<'a>, reason: BlockedByResponseReason) -> BlockedByResponseIssueDetailsBuilder<'a> {
574        BlockedByResponseIssueDetailsBuilder {
575            request: request,
576            parentFrame: None,
577            blockedFrame: None,
578            reason: reason,
579        }
580    }
581    pub fn request(&self) -> &AffectedRequest<'a> { &self.request }
582    pub fn parentFrame(&self) -> Option<&AffectedFrame<'a>> { self.parentFrame.as_ref() }
583    pub fn blockedFrame(&self) -> Option<&AffectedFrame<'a>> { self.blockedFrame.as_ref() }
584    pub fn reason(&self) -> &BlockedByResponseReason { &self.reason }
585}
586
587
588pub struct BlockedByResponseIssueDetailsBuilder<'a> {
589    request: AffectedRequest<'a>,
590    parentFrame: Option<AffectedFrame<'a>>,
591    blockedFrame: Option<AffectedFrame<'a>>,
592    reason: BlockedByResponseReason,
593}
594
595impl<'a> BlockedByResponseIssueDetailsBuilder<'a> {
596    pub fn parentFrame(mut self, parentFrame: AffectedFrame<'a>) -> Self { self.parentFrame = Some(parentFrame); self }
597    pub fn blockedFrame(mut self, blockedFrame: AffectedFrame<'a>) -> Self { self.blockedFrame = Some(blockedFrame); self }
598    pub fn build(self) -> BlockedByResponseIssueDetails<'a> {
599        BlockedByResponseIssueDetails {
600            request: self.request,
601            parentFrame: self.parentFrame,
602            blockedFrame: self.blockedFrame,
603            reason: self.reason,
604        }
605    }
606}
607
608
609#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
610pub enum HeavyAdResolutionStatus {
611    #[default]
612    #[serde(rename = "HeavyAdBlocked")]
613    HeavyAdBlocked,
614    #[serde(rename = "HeavyAdWarning")]
615    HeavyAdWarning,
616}
617
618
619#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
620pub enum HeavyAdReason {
621    #[default]
622    #[serde(rename = "NetworkTotalLimit")]
623    NetworkTotalLimit,
624    #[serde(rename = "CpuTotalLimit")]
625    CpuTotalLimit,
626    #[serde(rename = "CpuPeakLimit")]
627    CpuPeakLimit,
628}
629
630
631#[derive(Debug, Clone, Serialize, Deserialize, Default)]
632#[serde(rename_all = "camelCase")]
633pub struct HeavyAdIssueDetails<'a> {
634    /// The resolution status, either blocking the content or warning.
635    resolution: HeavyAdResolutionStatus,
636    /// The reason the ad was blocked, total network or cpu or peak cpu.
637    reason: HeavyAdReason,
638    /// The frame that was blocked.
639    frame: AffectedFrame<'a>,
640}
641
642impl<'a> HeavyAdIssueDetails<'a> {
643    pub fn builder(resolution: HeavyAdResolutionStatus, reason: HeavyAdReason, frame: AffectedFrame<'a>) -> HeavyAdIssueDetailsBuilder<'a> {
644        HeavyAdIssueDetailsBuilder {
645            resolution: resolution,
646            reason: reason,
647            frame: frame,
648        }
649    }
650    pub fn resolution(&self) -> &HeavyAdResolutionStatus { &self.resolution }
651    pub fn reason(&self) -> &HeavyAdReason { &self.reason }
652    pub fn frame(&self) -> &AffectedFrame<'a> { &self.frame }
653}
654
655
656pub struct HeavyAdIssueDetailsBuilder<'a> {
657    resolution: HeavyAdResolutionStatus,
658    reason: HeavyAdReason,
659    frame: AffectedFrame<'a>,
660}
661
662impl<'a> HeavyAdIssueDetailsBuilder<'a> {
663    pub fn build(self) -> HeavyAdIssueDetails<'a> {
664        HeavyAdIssueDetails {
665            resolution: self.resolution,
666            reason: self.reason,
667            frame: self.frame,
668        }
669    }
670}
671
672
673#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
674pub enum ContentSecurityPolicyViolationType {
675    #[default]
676    #[serde(rename = "kInlineViolation")]
677    KInlineViolation,
678    #[serde(rename = "kEvalViolation")]
679    KEvalViolation,
680    #[serde(rename = "kURLViolation")]
681    KURLViolation,
682    #[serde(rename = "kSRIViolation")]
683    KSRIViolation,
684    #[serde(rename = "kTrustedTypesSinkViolation")]
685    KTrustedTypesSinkViolation,
686    #[serde(rename = "kTrustedTypesPolicyViolation")]
687    KTrustedTypesPolicyViolation,
688    #[serde(rename = "kWasmEvalViolation")]
689    KWasmEvalViolation,
690}
691
692
693#[derive(Debug, Clone, Serialize, Deserialize, Default)]
694#[serde(rename_all = "camelCase")]
695pub struct SourceCodeLocation<'a> {
696    #[serde(skip_serializing_if = "Option::is_none")]
697    scriptId: Option<crate::runtime::ScriptId<'a>>,
698    url: Cow<'a, str>,
699    lineNumber: i64,
700    columnNumber: i64,
701}
702
703impl<'a> SourceCodeLocation<'a> {
704    pub fn builder(url: impl Into<Cow<'a, str>>, lineNumber: i64, columnNumber: i64) -> SourceCodeLocationBuilder<'a> {
705        SourceCodeLocationBuilder {
706            scriptId: None,
707            url: url.into(),
708            lineNumber: lineNumber,
709            columnNumber: columnNumber,
710        }
711    }
712    pub fn scriptId(&self) -> Option<&crate::runtime::ScriptId<'a>> { self.scriptId.as_ref() }
713    pub fn url(&self) -> &str { self.url.as_ref() }
714    pub fn lineNumber(&self) -> i64 { self.lineNumber }
715    pub fn columnNumber(&self) -> i64 { self.columnNumber }
716}
717
718
719pub struct SourceCodeLocationBuilder<'a> {
720    scriptId: Option<crate::runtime::ScriptId<'a>>,
721    url: Cow<'a, str>,
722    lineNumber: i64,
723    columnNumber: i64,
724}
725
726impl<'a> SourceCodeLocationBuilder<'a> {
727    pub fn scriptId(mut self, scriptId: crate::runtime::ScriptId<'a>) -> Self { self.scriptId = Some(scriptId); self }
728    pub fn build(self) -> SourceCodeLocation<'a> {
729        SourceCodeLocation {
730            scriptId: self.scriptId,
731            url: self.url,
732            lineNumber: self.lineNumber,
733            columnNumber: self.columnNumber,
734        }
735    }
736}
737
738
739#[derive(Debug, Clone, Serialize, Deserialize, Default)]
740#[serde(rename_all = "camelCase")]
741pub struct ContentSecurityPolicyIssueDetails<'a> {
742    /// The url not included in allowed sources.
743    #[serde(skip_serializing_if = "Option::is_none")]
744    blockedURL: Option<Cow<'a, str>>,
745    /// Specific directive that is violated, causing the CSP issue.
746    violatedDirective: Cow<'a, str>,
747    isReportOnly: bool,
748    contentSecurityPolicyViolationType: ContentSecurityPolicyViolationType,
749    #[serde(skip_serializing_if = "Option::is_none")]
750    frameAncestor: Option<AffectedFrame<'a>>,
751    #[serde(skip_serializing_if = "Option::is_none")]
752    sourceCodeLocation: Option<SourceCodeLocation<'a>>,
753    #[serde(skip_serializing_if = "Option::is_none")]
754    violatingNodeId: Option<crate::dom::BackendNodeId>,
755}
756
757impl<'a> ContentSecurityPolicyIssueDetails<'a> {
758    pub fn builder(violatedDirective: impl Into<Cow<'a, str>>, isReportOnly: bool, contentSecurityPolicyViolationType: ContentSecurityPolicyViolationType) -> ContentSecurityPolicyIssueDetailsBuilder<'a> {
759        ContentSecurityPolicyIssueDetailsBuilder {
760            blockedURL: None,
761            violatedDirective: violatedDirective.into(),
762            isReportOnly: isReportOnly,
763            contentSecurityPolicyViolationType: contentSecurityPolicyViolationType,
764            frameAncestor: None,
765            sourceCodeLocation: None,
766            violatingNodeId: None,
767        }
768    }
769    pub fn blockedURL(&self) -> Option<&str> { self.blockedURL.as_deref() }
770    pub fn violatedDirective(&self) -> &str { self.violatedDirective.as_ref() }
771    pub fn isReportOnly(&self) -> bool { self.isReportOnly }
772    pub fn contentSecurityPolicyViolationType(&self) -> &ContentSecurityPolicyViolationType { &self.contentSecurityPolicyViolationType }
773    pub fn frameAncestor(&self) -> Option<&AffectedFrame<'a>> { self.frameAncestor.as_ref() }
774    pub fn sourceCodeLocation(&self) -> Option<&SourceCodeLocation<'a>> { self.sourceCodeLocation.as_ref() }
775    pub fn violatingNodeId(&self) -> Option<&crate::dom::BackendNodeId> { self.violatingNodeId.as_ref() }
776}
777
778
779pub struct ContentSecurityPolicyIssueDetailsBuilder<'a> {
780    blockedURL: Option<Cow<'a, str>>,
781    violatedDirective: Cow<'a, str>,
782    isReportOnly: bool,
783    contentSecurityPolicyViolationType: ContentSecurityPolicyViolationType,
784    frameAncestor: Option<AffectedFrame<'a>>,
785    sourceCodeLocation: Option<SourceCodeLocation<'a>>,
786    violatingNodeId: Option<crate::dom::BackendNodeId>,
787}
788
789impl<'a> ContentSecurityPolicyIssueDetailsBuilder<'a> {
790    /// The url not included in allowed sources.
791    pub fn blockedURL(mut self, blockedURL: impl Into<Cow<'a, str>>) -> Self { self.blockedURL = Some(blockedURL.into()); self }
792    pub fn frameAncestor(mut self, frameAncestor: AffectedFrame<'a>) -> Self { self.frameAncestor = Some(frameAncestor); self }
793    pub fn sourceCodeLocation(mut self, sourceCodeLocation: SourceCodeLocation<'a>) -> Self { self.sourceCodeLocation = Some(sourceCodeLocation); self }
794    pub fn violatingNodeId(mut self, violatingNodeId: crate::dom::BackendNodeId) -> Self { self.violatingNodeId = Some(violatingNodeId); self }
795    pub fn build(self) -> ContentSecurityPolicyIssueDetails<'a> {
796        ContentSecurityPolicyIssueDetails {
797            blockedURL: self.blockedURL,
798            violatedDirective: self.violatedDirective,
799            isReportOnly: self.isReportOnly,
800            contentSecurityPolicyViolationType: self.contentSecurityPolicyViolationType,
801            frameAncestor: self.frameAncestor,
802            sourceCodeLocation: self.sourceCodeLocation,
803            violatingNodeId: self.violatingNodeId,
804        }
805    }
806}
807
808
809#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
810pub enum SharedArrayBufferIssueType {
811    #[default]
812    #[serde(rename = "TransferIssue")]
813    TransferIssue,
814    #[serde(rename = "CreationIssue")]
815    CreationIssue,
816}
817
818/// Details for a issue arising from an SAB being instantiated in, or
819/// transferred to a context that is not cross-origin isolated.
820
821#[derive(Debug, Clone, Serialize, Deserialize, Default)]
822#[serde(rename_all = "camelCase")]
823pub struct SharedArrayBufferIssueDetails<'a> {
824    sourceCodeLocation: SourceCodeLocation<'a>,
825    isWarning: bool,
826    #[serde(rename = "type")]
827    type_: SharedArrayBufferIssueType,
828}
829
830impl<'a> SharedArrayBufferIssueDetails<'a> {
831    pub fn builder(sourceCodeLocation: SourceCodeLocation<'a>, isWarning: bool, type_: SharedArrayBufferIssueType) -> SharedArrayBufferIssueDetailsBuilder<'a> {
832        SharedArrayBufferIssueDetailsBuilder {
833            sourceCodeLocation: sourceCodeLocation,
834            isWarning: isWarning,
835            type_: type_,
836        }
837    }
838    pub fn sourceCodeLocation(&self) -> &SourceCodeLocation<'a> { &self.sourceCodeLocation }
839    pub fn isWarning(&self) -> bool { self.isWarning }
840    pub fn type_(&self) -> &SharedArrayBufferIssueType { &self.type_ }
841}
842
843
844pub struct SharedArrayBufferIssueDetailsBuilder<'a> {
845    sourceCodeLocation: SourceCodeLocation<'a>,
846    isWarning: bool,
847    type_: SharedArrayBufferIssueType,
848}
849
850impl<'a> SharedArrayBufferIssueDetailsBuilder<'a> {
851    pub fn build(self) -> SharedArrayBufferIssueDetails<'a> {
852        SharedArrayBufferIssueDetails {
853            sourceCodeLocation: self.sourceCodeLocation,
854            isWarning: self.isWarning,
855            type_: self.type_,
856        }
857    }
858}
859
860/// Details for a CORS related issue, e.g. a warning or error related to
861/// CORS RFC1918 enforcement.
862
863#[derive(Debug, Clone, Serialize, Deserialize, Default)]
864#[serde(rename_all = "camelCase")]
865pub struct CorsIssueDetails<'a> {
866    corsErrorStatus: crate::network::CorsErrorStatus<'a>,
867    isWarning: bool,
868    request: AffectedRequest<'a>,
869    #[serde(skip_serializing_if = "Option::is_none")]
870    location: Option<SourceCodeLocation<'a>>,
871    #[serde(skip_serializing_if = "Option::is_none")]
872    initiatorOrigin: Option<Cow<'a, str>>,
873    #[serde(skip_serializing_if = "Option::is_none")]
874    resourceIPAddressSpace: Option<crate::network::IPAddressSpace>,
875    #[serde(skip_serializing_if = "Option::is_none")]
876    clientSecurityState: Option<crate::network::ClientSecurityState>,
877}
878
879impl<'a> CorsIssueDetails<'a> {
880    pub fn builder(corsErrorStatus: crate::network::CorsErrorStatus<'a>, isWarning: bool, request: AffectedRequest<'a>) -> CorsIssueDetailsBuilder<'a> {
881        CorsIssueDetailsBuilder {
882            corsErrorStatus: corsErrorStatus,
883            isWarning: isWarning,
884            request: request,
885            location: None,
886            initiatorOrigin: None,
887            resourceIPAddressSpace: None,
888            clientSecurityState: None,
889        }
890    }
891    pub fn corsErrorStatus(&self) -> &crate::network::CorsErrorStatus<'a> { &self.corsErrorStatus }
892    pub fn isWarning(&self) -> bool { self.isWarning }
893    pub fn request(&self) -> &AffectedRequest<'a> { &self.request }
894    pub fn location(&self) -> Option<&SourceCodeLocation<'a>> { self.location.as_ref() }
895    pub fn initiatorOrigin(&self) -> Option<&str> { self.initiatorOrigin.as_deref() }
896    pub fn resourceIPAddressSpace(&self) -> Option<&crate::network::IPAddressSpace> { self.resourceIPAddressSpace.as_ref() }
897    pub fn clientSecurityState(&self) -> Option<&crate::network::ClientSecurityState> { self.clientSecurityState.as_ref() }
898}
899
900
901pub struct CorsIssueDetailsBuilder<'a> {
902    corsErrorStatus: crate::network::CorsErrorStatus<'a>,
903    isWarning: bool,
904    request: AffectedRequest<'a>,
905    location: Option<SourceCodeLocation<'a>>,
906    initiatorOrigin: Option<Cow<'a, str>>,
907    resourceIPAddressSpace: Option<crate::network::IPAddressSpace>,
908    clientSecurityState: Option<crate::network::ClientSecurityState>,
909}
910
911impl<'a> CorsIssueDetailsBuilder<'a> {
912    pub fn location(mut self, location: SourceCodeLocation<'a>) -> Self { self.location = Some(location); self }
913    pub fn initiatorOrigin(mut self, initiatorOrigin: impl Into<Cow<'a, str>>) -> Self { self.initiatorOrigin = Some(initiatorOrigin.into()); self }
914    pub fn resourceIPAddressSpace(mut self, resourceIPAddressSpace: crate::network::IPAddressSpace) -> Self { self.resourceIPAddressSpace = Some(resourceIPAddressSpace); self }
915    pub fn clientSecurityState(mut self, clientSecurityState: crate::network::ClientSecurityState) -> Self { self.clientSecurityState = Some(clientSecurityState); self }
916    pub fn build(self) -> CorsIssueDetails<'a> {
917        CorsIssueDetails {
918            corsErrorStatus: self.corsErrorStatus,
919            isWarning: self.isWarning,
920            request: self.request,
921            location: self.location,
922            initiatorOrigin: self.initiatorOrigin,
923            resourceIPAddressSpace: self.resourceIPAddressSpace,
924            clientSecurityState: self.clientSecurityState,
925        }
926    }
927}
928
929
930#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
931pub enum AttributionReportingIssueType {
932    #[default]
933    #[serde(rename = "PermissionPolicyDisabled")]
934    PermissionPolicyDisabled,
935    #[serde(rename = "UntrustworthyReportingOrigin")]
936    UntrustworthyReportingOrigin,
937    #[serde(rename = "InsecureContext")]
938    InsecureContext,
939    #[serde(rename = "InvalidHeader")]
940    InvalidHeader,
941    #[serde(rename = "InvalidRegisterTriggerHeader")]
942    InvalidRegisterTriggerHeader,
943    #[serde(rename = "SourceAndTriggerHeaders")]
944    SourceAndTriggerHeaders,
945    #[serde(rename = "SourceIgnored")]
946    SourceIgnored,
947    #[serde(rename = "TriggerIgnored")]
948    TriggerIgnored,
949    #[serde(rename = "OsSourceIgnored")]
950    OsSourceIgnored,
951    #[serde(rename = "OsTriggerIgnored")]
952    OsTriggerIgnored,
953    #[serde(rename = "InvalidRegisterOsSourceHeader")]
954    InvalidRegisterOsSourceHeader,
955    #[serde(rename = "InvalidRegisterOsTriggerHeader")]
956    InvalidRegisterOsTriggerHeader,
957    #[serde(rename = "WebAndOsHeaders")]
958    WebAndOsHeaders,
959    #[serde(rename = "NoWebOrOsSupport")]
960    NoWebOrOsSupport,
961    #[serde(rename = "NavigationRegistrationWithoutTransientUserActivation")]
962    NavigationRegistrationWithoutTransientUserActivation,
963    #[serde(rename = "InvalidInfoHeader")]
964    InvalidInfoHeader,
965    #[serde(rename = "NoRegisterSourceHeader")]
966    NoRegisterSourceHeader,
967    #[serde(rename = "NoRegisterTriggerHeader")]
968    NoRegisterTriggerHeader,
969    #[serde(rename = "NoRegisterOsSourceHeader")]
970    NoRegisterOsSourceHeader,
971    #[serde(rename = "NoRegisterOsTriggerHeader")]
972    NoRegisterOsTriggerHeader,
973    #[serde(rename = "NavigationRegistrationUniqueScopeAlreadySet")]
974    NavigationRegistrationUniqueScopeAlreadySet,
975}
976
977
978#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
979pub enum SharedDictionaryError {
980    #[default]
981    #[serde(rename = "UseErrorCrossOriginNoCorsRequest")]
982    UseErrorCrossOriginNoCorsRequest,
983    #[serde(rename = "UseErrorDictionaryLoadFailure")]
984    UseErrorDictionaryLoadFailure,
985    #[serde(rename = "UseErrorMatchingDictionaryNotUsed")]
986    UseErrorMatchingDictionaryNotUsed,
987    #[serde(rename = "UseErrorUnexpectedContentDictionaryHeader")]
988    UseErrorUnexpectedContentDictionaryHeader,
989    #[serde(rename = "WriteErrorCossOriginNoCorsRequest")]
990    WriteErrorCossOriginNoCorsRequest,
991    #[serde(rename = "WriteErrorDisallowedBySettings")]
992    WriteErrorDisallowedBySettings,
993    #[serde(rename = "WriteErrorExpiredResponse")]
994    WriteErrorExpiredResponse,
995    #[serde(rename = "WriteErrorFeatureDisabled")]
996    WriteErrorFeatureDisabled,
997    #[serde(rename = "WriteErrorInsufficientResources")]
998    WriteErrorInsufficientResources,
999    #[serde(rename = "WriteErrorInvalidMatchField")]
1000    WriteErrorInvalidMatchField,
1001    #[serde(rename = "WriteErrorInvalidStructuredHeader")]
1002    WriteErrorInvalidStructuredHeader,
1003    #[serde(rename = "WriteErrorInvalidTTLField")]
1004    WriteErrorInvalidTTLField,
1005    #[serde(rename = "WriteErrorNavigationRequest")]
1006    WriteErrorNavigationRequest,
1007    #[serde(rename = "WriteErrorNoMatchField")]
1008    WriteErrorNoMatchField,
1009    #[serde(rename = "WriteErrorNonIntegerTTLField")]
1010    WriteErrorNonIntegerTTLField,
1011    #[serde(rename = "WriteErrorNonListMatchDestField")]
1012    WriteErrorNonListMatchDestField,
1013    #[serde(rename = "WriteErrorNonSecureContext")]
1014    WriteErrorNonSecureContext,
1015    #[serde(rename = "WriteErrorNonStringIdField")]
1016    WriteErrorNonStringIdField,
1017    #[serde(rename = "WriteErrorNonStringInMatchDestList")]
1018    WriteErrorNonStringInMatchDestList,
1019    #[serde(rename = "WriteErrorNonStringMatchField")]
1020    WriteErrorNonStringMatchField,
1021    #[serde(rename = "WriteErrorNonTokenTypeField")]
1022    WriteErrorNonTokenTypeField,
1023    #[serde(rename = "WriteErrorRequestAborted")]
1024    WriteErrorRequestAborted,
1025    #[serde(rename = "WriteErrorShuttingDown")]
1026    WriteErrorShuttingDown,
1027    #[serde(rename = "WriteErrorTooLongIdField")]
1028    WriteErrorTooLongIdField,
1029    #[serde(rename = "WriteErrorUnsupportedType")]
1030    WriteErrorUnsupportedType,
1031}
1032
1033
1034#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1035pub enum SRIMessageSignatureError {
1036    #[default]
1037    #[serde(rename = "MissingSignatureHeader")]
1038    MissingSignatureHeader,
1039    #[serde(rename = "MissingSignatureInputHeader")]
1040    MissingSignatureInputHeader,
1041    #[serde(rename = "InvalidSignatureHeader")]
1042    InvalidSignatureHeader,
1043    #[serde(rename = "InvalidSignatureInputHeader")]
1044    InvalidSignatureInputHeader,
1045    #[serde(rename = "SignatureHeaderValueIsNotByteSequence")]
1046    SignatureHeaderValueIsNotByteSequence,
1047    #[serde(rename = "SignatureHeaderValueIsParameterized")]
1048    SignatureHeaderValueIsParameterized,
1049    #[serde(rename = "SignatureHeaderValueIsIncorrectLength")]
1050    SignatureHeaderValueIsIncorrectLength,
1051    #[serde(rename = "SignatureInputHeaderMissingLabel")]
1052    SignatureInputHeaderMissingLabel,
1053    #[serde(rename = "SignatureInputHeaderValueNotInnerList")]
1054    SignatureInputHeaderValueNotInnerList,
1055    #[serde(rename = "SignatureInputHeaderValueMissingComponents")]
1056    SignatureInputHeaderValueMissingComponents,
1057    #[serde(rename = "SignatureInputHeaderInvalidComponentType")]
1058    SignatureInputHeaderInvalidComponentType,
1059    #[serde(rename = "SignatureInputHeaderInvalidComponentName")]
1060    SignatureInputHeaderInvalidComponentName,
1061    #[serde(rename = "SignatureInputHeaderInvalidHeaderComponentParameter")]
1062    SignatureInputHeaderInvalidHeaderComponentParameter,
1063    #[serde(rename = "SignatureInputHeaderInvalidDerivedComponentParameter")]
1064    SignatureInputHeaderInvalidDerivedComponentParameter,
1065    #[serde(rename = "SignatureInputHeaderKeyIdLength")]
1066    SignatureInputHeaderKeyIdLength,
1067    #[serde(rename = "SignatureInputHeaderInvalidParameter")]
1068    SignatureInputHeaderInvalidParameter,
1069    #[serde(rename = "SignatureInputHeaderMissingRequiredParameters")]
1070    SignatureInputHeaderMissingRequiredParameters,
1071    #[serde(rename = "ValidationFailedSignatureExpired")]
1072    ValidationFailedSignatureExpired,
1073    #[serde(rename = "ValidationFailedInvalidLength")]
1074    ValidationFailedInvalidLength,
1075    #[serde(rename = "ValidationFailedSignatureMismatch")]
1076    ValidationFailedSignatureMismatch,
1077    #[serde(rename = "ValidationFailedIntegrityMismatch")]
1078    ValidationFailedIntegrityMismatch,
1079}
1080
1081
1082#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1083pub enum UnencodedDigestError {
1084    #[default]
1085    #[serde(rename = "MalformedDictionary")]
1086    MalformedDictionary,
1087    #[serde(rename = "UnknownAlgorithm")]
1088    UnknownAlgorithm,
1089    #[serde(rename = "IncorrectDigestType")]
1090    IncorrectDigestType,
1091    #[serde(rename = "IncorrectDigestLength")]
1092    IncorrectDigestLength,
1093}
1094
1095
1096#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1097pub enum ConnectionAllowlistError {
1098    #[default]
1099    #[serde(rename = "InvalidHeader")]
1100    InvalidHeader,
1101    #[serde(rename = "MoreThanOneList")]
1102    MoreThanOneList,
1103    #[serde(rename = "ItemNotInnerList")]
1104    ItemNotInnerList,
1105    #[serde(rename = "InvalidAllowlistItemType")]
1106    InvalidAllowlistItemType,
1107    #[serde(rename = "ReportingEndpointNotToken")]
1108    ReportingEndpointNotToken,
1109    #[serde(rename = "InvalidUrlPattern")]
1110    InvalidUrlPattern,
1111}
1112
1113/// Details for issues around "Attribution Reporting API" usage.
1114/// Explainer: https://github.com/WICG/attribution-reporting-api
1115
1116#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1117#[serde(rename_all = "camelCase")]
1118pub struct AttributionReportingIssueDetails<'a> {
1119    violationType: AttributionReportingIssueType,
1120    #[serde(skip_serializing_if = "Option::is_none")]
1121    request: Option<AffectedRequest<'a>>,
1122    #[serde(skip_serializing_if = "Option::is_none")]
1123    violatingNodeId: Option<crate::dom::BackendNodeId>,
1124    #[serde(skip_serializing_if = "Option::is_none")]
1125    invalidParameter: Option<Cow<'a, str>>,
1126}
1127
1128impl<'a> AttributionReportingIssueDetails<'a> {
1129    pub fn builder(violationType: AttributionReportingIssueType) -> AttributionReportingIssueDetailsBuilder<'a> {
1130        AttributionReportingIssueDetailsBuilder {
1131            violationType: violationType,
1132            request: None,
1133            violatingNodeId: None,
1134            invalidParameter: None,
1135        }
1136    }
1137    pub fn violationType(&self) -> &AttributionReportingIssueType { &self.violationType }
1138    pub fn request(&self) -> Option<&AffectedRequest<'a>> { self.request.as_ref() }
1139    pub fn violatingNodeId(&self) -> Option<&crate::dom::BackendNodeId> { self.violatingNodeId.as_ref() }
1140    pub fn invalidParameter(&self) -> Option<&str> { self.invalidParameter.as_deref() }
1141}
1142
1143
1144pub struct AttributionReportingIssueDetailsBuilder<'a> {
1145    violationType: AttributionReportingIssueType,
1146    request: Option<AffectedRequest<'a>>,
1147    violatingNodeId: Option<crate::dom::BackendNodeId>,
1148    invalidParameter: Option<Cow<'a, str>>,
1149}
1150
1151impl<'a> AttributionReportingIssueDetailsBuilder<'a> {
1152    pub fn request(mut self, request: AffectedRequest<'a>) -> Self { self.request = Some(request); self }
1153    pub fn violatingNodeId(mut self, violatingNodeId: crate::dom::BackendNodeId) -> Self { self.violatingNodeId = Some(violatingNodeId); self }
1154    pub fn invalidParameter(mut self, invalidParameter: impl Into<Cow<'a, str>>) -> Self { self.invalidParameter = Some(invalidParameter.into()); self }
1155    pub fn build(self) -> AttributionReportingIssueDetails<'a> {
1156        AttributionReportingIssueDetails {
1157            violationType: self.violationType,
1158            request: self.request,
1159            violatingNodeId: self.violatingNodeId,
1160            invalidParameter: self.invalidParameter,
1161        }
1162    }
1163}
1164
1165/// Details for issues about documents in Quirks Mode
1166/// or Limited Quirks Mode that affects page layouting.
1167
1168#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1169#[serde(rename_all = "camelCase")]
1170pub struct QuirksModeIssueDetails<'a> {
1171    /// If false, it means the document's mode is "quirks"
1172    /// instead of "limited-quirks".
1173    isLimitedQuirksMode: bool,
1174    documentNodeId: crate::dom::BackendNodeId,
1175    url: Cow<'a, str>,
1176    frameId: crate::page::FrameId<'a>,
1177    loaderId: crate::network::LoaderId<'a>,
1178}
1179
1180impl<'a> QuirksModeIssueDetails<'a> {
1181    pub fn builder(isLimitedQuirksMode: bool, documentNodeId: crate::dom::BackendNodeId, url: impl Into<Cow<'a, str>>, frameId: crate::page::FrameId<'a>, loaderId: crate::network::LoaderId<'a>) -> QuirksModeIssueDetailsBuilder<'a> {
1182        QuirksModeIssueDetailsBuilder {
1183            isLimitedQuirksMode: isLimitedQuirksMode,
1184            documentNodeId: documentNodeId,
1185            url: url.into(),
1186            frameId: frameId,
1187            loaderId: loaderId,
1188        }
1189    }
1190    pub fn isLimitedQuirksMode(&self) -> bool { self.isLimitedQuirksMode }
1191    pub fn documentNodeId(&self) -> &crate::dom::BackendNodeId { &self.documentNodeId }
1192    pub fn url(&self) -> &str { self.url.as_ref() }
1193    pub fn frameId(&self) -> &crate::page::FrameId<'a> { &self.frameId }
1194    pub fn loaderId(&self) -> &crate::network::LoaderId<'a> { &self.loaderId }
1195}
1196
1197
1198pub struct QuirksModeIssueDetailsBuilder<'a> {
1199    isLimitedQuirksMode: bool,
1200    documentNodeId: crate::dom::BackendNodeId,
1201    url: Cow<'a, str>,
1202    frameId: crate::page::FrameId<'a>,
1203    loaderId: crate::network::LoaderId<'a>,
1204}
1205
1206impl<'a> QuirksModeIssueDetailsBuilder<'a> {
1207    pub fn build(self) -> QuirksModeIssueDetails<'a> {
1208        QuirksModeIssueDetails {
1209            isLimitedQuirksMode: self.isLimitedQuirksMode,
1210            documentNodeId: self.documentNodeId,
1211            url: self.url,
1212            frameId: self.frameId,
1213            loaderId: self.loaderId,
1214        }
1215    }
1216}
1217
1218
1219#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1220#[serde(rename_all = "camelCase")]
1221pub struct NavigatorUserAgentIssueDetails<'a> {
1222    url: Cow<'a, str>,
1223    #[serde(skip_serializing_if = "Option::is_none")]
1224    location: Option<SourceCodeLocation<'a>>,
1225}
1226
1227impl<'a> NavigatorUserAgentIssueDetails<'a> {
1228    pub fn builder(url: impl Into<Cow<'a, str>>) -> NavigatorUserAgentIssueDetailsBuilder<'a> {
1229        NavigatorUserAgentIssueDetailsBuilder {
1230            url: url.into(),
1231            location: None,
1232        }
1233    }
1234    pub fn url(&self) -> &str { self.url.as_ref() }
1235    pub fn location(&self) -> Option<&SourceCodeLocation<'a>> { self.location.as_ref() }
1236}
1237
1238
1239pub struct NavigatorUserAgentIssueDetailsBuilder<'a> {
1240    url: Cow<'a, str>,
1241    location: Option<SourceCodeLocation<'a>>,
1242}
1243
1244impl<'a> NavigatorUserAgentIssueDetailsBuilder<'a> {
1245    pub fn location(mut self, location: SourceCodeLocation<'a>) -> Self { self.location = Some(location); self }
1246    pub fn build(self) -> NavigatorUserAgentIssueDetails<'a> {
1247        NavigatorUserAgentIssueDetails {
1248            url: self.url,
1249            location: self.location,
1250        }
1251    }
1252}
1253
1254
1255#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1256#[serde(rename_all = "camelCase")]
1257pub struct SharedDictionaryIssueDetails<'a> {
1258    sharedDictionaryError: SharedDictionaryError,
1259    request: AffectedRequest<'a>,
1260}
1261
1262impl<'a> SharedDictionaryIssueDetails<'a> {
1263    pub fn builder(sharedDictionaryError: SharedDictionaryError, request: AffectedRequest<'a>) -> SharedDictionaryIssueDetailsBuilder<'a> {
1264        SharedDictionaryIssueDetailsBuilder {
1265            sharedDictionaryError: sharedDictionaryError,
1266            request: request,
1267        }
1268    }
1269    pub fn sharedDictionaryError(&self) -> &SharedDictionaryError { &self.sharedDictionaryError }
1270    pub fn request(&self) -> &AffectedRequest<'a> { &self.request }
1271}
1272
1273
1274pub struct SharedDictionaryIssueDetailsBuilder<'a> {
1275    sharedDictionaryError: SharedDictionaryError,
1276    request: AffectedRequest<'a>,
1277}
1278
1279impl<'a> SharedDictionaryIssueDetailsBuilder<'a> {
1280    pub fn build(self) -> SharedDictionaryIssueDetails<'a> {
1281        SharedDictionaryIssueDetails {
1282            sharedDictionaryError: self.sharedDictionaryError,
1283            request: self.request,
1284        }
1285    }
1286}
1287
1288
1289#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1290#[serde(rename_all = "camelCase")]
1291pub struct SRIMessageSignatureIssueDetails<'a> {
1292    error: SRIMessageSignatureError,
1293    signatureBase: Cow<'a, str>,
1294    integrityAssertions: Vec<Cow<'a, str>>,
1295    request: AffectedRequest<'a>,
1296}
1297
1298impl<'a> SRIMessageSignatureIssueDetails<'a> {
1299    pub fn builder(error: SRIMessageSignatureError, signatureBase: impl Into<Cow<'a, str>>, integrityAssertions: Vec<Cow<'a, str>>, request: AffectedRequest<'a>) -> SRIMessageSignatureIssueDetailsBuilder<'a> {
1300        SRIMessageSignatureIssueDetailsBuilder {
1301            error: error,
1302            signatureBase: signatureBase.into(),
1303            integrityAssertions: integrityAssertions,
1304            request: request,
1305        }
1306    }
1307    pub fn error(&self) -> &SRIMessageSignatureError { &self.error }
1308    pub fn signatureBase(&self) -> &str { self.signatureBase.as_ref() }
1309    pub fn integrityAssertions(&self) -> &[Cow<'a, str>] { &self.integrityAssertions }
1310    pub fn request(&self) -> &AffectedRequest<'a> { &self.request }
1311}
1312
1313
1314pub struct SRIMessageSignatureIssueDetailsBuilder<'a> {
1315    error: SRIMessageSignatureError,
1316    signatureBase: Cow<'a, str>,
1317    integrityAssertions: Vec<Cow<'a, str>>,
1318    request: AffectedRequest<'a>,
1319}
1320
1321impl<'a> SRIMessageSignatureIssueDetailsBuilder<'a> {
1322    pub fn build(self) -> SRIMessageSignatureIssueDetails<'a> {
1323        SRIMessageSignatureIssueDetails {
1324            error: self.error,
1325            signatureBase: self.signatureBase,
1326            integrityAssertions: self.integrityAssertions,
1327            request: self.request,
1328        }
1329    }
1330}
1331
1332
1333#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1334#[serde(rename_all = "camelCase")]
1335pub struct UnencodedDigestIssueDetails<'a> {
1336    error: UnencodedDigestError,
1337    request: AffectedRequest<'a>,
1338}
1339
1340impl<'a> UnencodedDigestIssueDetails<'a> {
1341    pub fn builder(error: UnencodedDigestError, request: AffectedRequest<'a>) -> UnencodedDigestIssueDetailsBuilder<'a> {
1342        UnencodedDigestIssueDetailsBuilder {
1343            error: error,
1344            request: request,
1345        }
1346    }
1347    pub fn error(&self) -> &UnencodedDigestError { &self.error }
1348    pub fn request(&self) -> &AffectedRequest<'a> { &self.request }
1349}
1350
1351
1352pub struct UnencodedDigestIssueDetailsBuilder<'a> {
1353    error: UnencodedDigestError,
1354    request: AffectedRequest<'a>,
1355}
1356
1357impl<'a> UnencodedDigestIssueDetailsBuilder<'a> {
1358    pub fn build(self) -> UnencodedDigestIssueDetails<'a> {
1359        UnencodedDigestIssueDetails {
1360            error: self.error,
1361            request: self.request,
1362        }
1363    }
1364}
1365
1366
1367#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1368#[serde(rename_all = "camelCase")]
1369pub struct ConnectionAllowlistIssueDetails<'a> {
1370    error: ConnectionAllowlistError,
1371    request: AffectedRequest<'a>,
1372}
1373
1374impl<'a> ConnectionAllowlistIssueDetails<'a> {
1375    pub fn builder(error: ConnectionAllowlistError, request: AffectedRequest<'a>) -> ConnectionAllowlistIssueDetailsBuilder<'a> {
1376        ConnectionAllowlistIssueDetailsBuilder {
1377            error: error,
1378            request: request,
1379        }
1380    }
1381    pub fn error(&self) -> &ConnectionAllowlistError { &self.error }
1382    pub fn request(&self) -> &AffectedRequest<'a> { &self.request }
1383}
1384
1385
1386pub struct ConnectionAllowlistIssueDetailsBuilder<'a> {
1387    error: ConnectionAllowlistError,
1388    request: AffectedRequest<'a>,
1389}
1390
1391impl<'a> ConnectionAllowlistIssueDetailsBuilder<'a> {
1392    pub fn build(self) -> ConnectionAllowlistIssueDetails<'a> {
1393        ConnectionAllowlistIssueDetails {
1394            error: self.error,
1395            request: self.request,
1396        }
1397    }
1398}
1399
1400
1401#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1402pub enum GenericIssueErrorType {
1403    #[default]
1404    #[serde(rename = "FormLabelForNameError")]
1405    FormLabelForNameError,
1406    #[serde(rename = "FormDuplicateIdForInputError")]
1407    FormDuplicateIdForInputError,
1408    #[serde(rename = "FormInputWithNoLabelError")]
1409    FormInputWithNoLabelError,
1410    #[serde(rename = "FormAutocompleteAttributeEmptyError")]
1411    FormAutocompleteAttributeEmptyError,
1412    #[serde(rename = "FormEmptyIdAndNameAttributesForInputError")]
1413    FormEmptyIdAndNameAttributesForInputError,
1414    #[serde(rename = "FormAriaLabelledByToNonExistingIdError")]
1415    FormAriaLabelledByToNonExistingIdError,
1416    #[serde(rename = "FormInputAssignedAutocompleteValueToIdOrNameAttributeError")]
1417    FormInputAssignedAutocompleteValueToIdOrNameAttributeError,
1418    #[serde(rename = "FormLabelHasNeitherForNorNestedInputError")]
1419    FormLabelHasNeitherForNorNestedInputError,
1420    #[serde(rename = "FormLabelForMatchesNonExistingIdError")]
1421    FormLabelForMatchesNonExistingIdError,
1422    #[serde(rename = "FormInputHasWrongButWellIntendedAutocompleteValueError")]
1423    FormInputHasWrongButWellIntendedAutocompleteValueError,
1424    #[serde(rename = "ResponseWasBlockedByORB")]
1425    ResponseWasBlockedByORB,
1426    #[serde(rename = "NavigationEntryMarkedSkippable")]
1427    NavigationEntryMarkedSkippable,
1428    #[serde(rename = "AutofillAndManualTextPolicyControlledFeaturesInfo")]
1429    AutofillAndManualTextPolicyControlledFeaturesInfo,
1430    #[serde(rename = "AutofillPolicyControlledFeatureInfo")]
1431    AutofillPolicyControlledFeatureInfo,
1432    #[serde(rename = "ManualTextPolicyControlledFeatureInfo")]
1433    ManualTextPolicyControlledFeatureInfo,
1434    #[serde(rename = "FormModelContextParameterMissingTitleAndDescription")]
1435    FormModelContextParameterMissingTitleAndDescription,
1436    #[serde(rename = "FormModelContextMissingToolName")]
1437    FormModelContextMissingToolName,
1438    #[serde(rename = "FormModelContextMissingToolDescription")]
1439    FormModelContextMissingToolDescription,
1440    #[serde(rename = "FormModelContextRequiredParameterMissingName")]
1441    FormModelContextRequiredParameterMissingName,
1442    #[serde(rename = "FormModelContextParameterMissingName")]
1443    FormModelContextParameterMissingName,
1444}
1445
1446/// Depending on the concrete errorType, different properties are set.
1447
1448#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1449#[serde(rename_all = "camelCase")]
1450pub struct GenericIssueDetails<'a> {
1451    /// Issues with the same errorType are aggregated in the frontend.
1452    errorType: GenericIssueErrorType,
1453    #[serde(skip_serializing_if = "Option::is_none")]
1454    frameId: Option<crate::page::FrameId<'a>>,
1455    #[serde(skip_serializing_if = "Option::is_none")]
1456    violatingNodeId: Option<crate::dom::BackendNodeId>,
1457    #[serde(skip_serializing_if = "Option::is_none")]
1458    violatingNodeAttribute: Option<Cow<'a, str>>,
1459    #[serde(skip_serializing_if = "Option::is_none")]
1460    request: Option<AffectedRequest<'a>>,
1461}
1462
1463impl<'a> GenericIssueDetails<'a> {
1464    pub fn builder(errorType: GenericIssueErrorType) -> GenericIssueDetailsBuilder<'a> {
1465        GenericIssueDetailsBuilder {
1466            errorType: errorType,
1467            frameId: None,
1468            violatingNodeId: None,
1469            violatingNodeAttribute: None,
1470            request: None,
1471        }
1472    }
1473    pub fn errorType(&self) -> &GenericIssueErrorType { &self.errorType }
1474    pub fn frameId(&self) -> Option<&crate::page::FrameId<'a>> { self.frameId.as_ref() }
1475    pub fn violatingNodeId(&self) -> Option<&crate::dom::BackendNodeId> { self.violatingNodeId.as_ref() }
1476    pub fn violatingNodeAttribute(&self) -> Option<&str> { self.violatingNodeAttribute.as_deref() }
1477    pub fn request(&self) -> Option<&AffectedRequest<'a>> { self.request.as_ref() }
1478}
1479
1480
1481pub struct GenericIssueDetailsBuilder<'a> {
1482    errorType: GenericIssueErrorType,
1483    frameId: Option<crate::page::FrameId<'a>>,
1484    violatingNodeId: Option<crate::dom::BackendNodeId>,
1485    violatingNodeAttribute: Option<Cow<'a, str>>,
1486    request: Option<AffectedRequest<'a>>,
1487}
1488
1489impl<'a> GenericIssueDetailsBuilder<'a> {
1490    pub fn frameId(mut self, frameId: crate::page::FrameId<'a>) -> Self { self.frameId = Some(frameId); self }
1491    pub fn violatingNodeId(mut self, violatingNodeId: crate::dom::BackendNodeId) -> Self { self.violatingNodeId = Some(violatingNodeId); self }
1492    pub fn violatingNodeAttribute(mut self, violatingNodeAttribute: impl Into<Cow<'a, str>>) -> Self { self.violatingNodeAttribute = Some(violatingNodeAttribute.into()); self }
1493    pub fn request(mut self, request: AffectedRequest<'a>) -> Self { self.request = Some(request); self }
1494    pub fn build(self) -> GenericIssueDetails<'a> {
1495        GenericIssueDetails {
1496            errorType: self.errorType,
1497            frameId: self.frameId,
1498            violatingNodeId: self.violatingNodeId,
1499            violatingNodeAttribute: self.violatingNodeAttribute,
1500            request: self.request,
1501        }
1502    }
1503}
1504
1505/// This issue tracks information needed to print a deprecation message.
1506/// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/frame/third_party/blink/renderer/core/frame/deprecation/README.md
1507
1508#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1509#[serde(rename_all = "camelCase")]
1510pub struct DeprecationIssueDetails<'a> {
1511    #[serde(skip_serializing_if = "Option::is_none")]
1512    affectedFrame: Option<AffectedFrame<'a>>,
1513    sourceCodeLocation: SourceCodeLocation<'a>,
1514    /// One of the deprecation names from third_party/blink/renderer/core/frame/deprecation/deprecation.json5
1515    #[serde(rename = "type")]
1516    type_: Cow<'a, str>,
1517}
1518
1519impl<'a> DeprecationIssueDetails<'a> {
1520    pub fn builder(sourceCodeLocation: SourceCodeLocation<'a>, type_: impl Into<Cow<'a, str>>) -> DeprecationIssueDetailsBuilder<'a> {
1521        DeprecationIssueDetailsBuilder {
1522            affectedFrame: None,
1523            sourceCodeLocation: sourceCodeLocation,
1524            type_: type_.into(),
1525        }
1526    }
1527    pub fn affectedFrame(&self) -> Option<&AffectedFrame<'a>> { self.affectedFrame.as_ref() }
1528    pub fn sourceCodeLocation(&self) -> &SourceCodeLocation<'a> { &self.sourceCodeLocation }
1529    pub fn type_(&self) -> &str { self.type_.as_ref() }
1530}
1531
1532
1533pub struct DeprecationIssueDetailsBuilder<'a> {
1534    affectedFrame: Option<AffectedFrame<'a>>,
1535    sourceCodeLocation: SourceCodeLocation<'a>,
1536    type_: Cow<'a, str>,
1537}
1538
1539impl<'a> DeprecationIssueDetailsBuilder<'a> {
1540    pub fn affectedFrame(mut self, affectedFrame: AffectedFrame<'a>) -> Self { self.affectedFrame = Some(affectedFrame); self }
1541    pub fn build(self) -> DeprecationIssueDetails<'a> {
1542        DeprecationIssueDetails {
1543            affectedFrame: self.affectedFrame,
1544            sourceCodeLocation: self.sourceCodeLocation,
1545            type_: self.type_,
1546        }
1547    }
1548}
1549
1550/// This issue warns about sites in the redirect chain of a finished navigation
1551/// that may be flagged as trackers and have their state cleared if they don't
1552/// receive a user interaction. Note that in this context 'site' means eTLD+1.
1553/// For example, if the URL 'https://example.test:80/bounce' was in the
1554/// redirect chain, the site reported would be 'example.test'.
1555
1556#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1557#[serde(rename_all = "camelCase")]
1558pub struct BounceTrackingIssueDetails<'a> {
1559    trackingSites: Vec<Cow<'a, str>>,
1560}
1561
1562impl<'a> BounceTrackingIssueDetails<'a> {
1563    pub fn builder(trackingSites: Vec<Cow<'a, str>>) -> BounceTrackingIssueDetailsBuilder<'a> {
1564        BounceTrackingIssueDetailsBuilder {
1565            trackingSites: trackingSites,
1566        }
1567    }
1568    pub fn trackingSites(&self) -> &[Cow<'a, str>] { &self.trackingSites }
1569}
1570
1571
1572pub struct BounceTrackingIssueDetailsBuilder<'a> {
1573    trackingSites: Vec<Cow<'a, str>>,
1574}
1575
1576impl<'a> BounceTrackingIssueDetailsBuilder<'a> {
1577    pub fn build(self) -> BounceTrackingIssueDetails<'a> {
1578        BounceTrackingIssueDetails {
1579            trackingSites: self.trackingSites,
1580        }
1581    }
1582}
1583
1584/// This issue warns about third-party sites that are accessing cookies on the
1585/// current page, and have been permitted due to having a global metadata grant.
1586/// Note that in this context 'site' means eTLD+1. For example, if the URL
1587/// 'https://example.test:80/web_page' was accessing cookies, the site reported
1588/// would be 'example.test'.
1589
1590#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1591#[serde(rename_all = "camelCase")]
1592pub struct CookieDeprecationMetadataIssueDetails<'a> {
1593    allowedSites: Vec<Cow<'a, str>>,
1594    optOutPercentage: f64,
1595    isOptOutTopLevel: bool,
1596    operation: CookieOperation,
1597}
1598
1599impl<'a> CookieDeprecationMetadataIssueDetails<'a> {
1600    pub fn builder(allowedSites: Vec<Cow<'a, str>>, optOutPercentage: f64, isOptOutTopLevel: bool, operation: CookieOperation) -> CookieDeprecationMetadataIssueDetailsBuilder<'a> {
1601        CookieDeprecationMetadataIssueDetailsBuilder {
1602            allowedSites: allowedSites,
1603            optOutPercentage: optOutPercentage,
1604            isOptOutTopLevel: isOptOutTopLevel,
1605            operation: operation,
1606        }
1607    }
1608    pub fn allowedSites(&self) -> &[Cow<'a, str>] { &self.allowedSites }
1609    pub fn optOutPercentage(&self) -> f64 { self.optOutPercentage }
1610    pub fn isOptOutTopLevel(&self) -> bool { self.isOptOutTopLevel }
1611    pub fn operation(&self) -> &CookieOperation { &self.operation }
1612}
1613
1614
1615pub struct CookieDeprecationMetadataIssueDetailsBuilder<'a> {
1616    allowedSites: Vec<Cow<'a, str>>,
1617    optOutPercentage: f64,
1618    isOptOutTopLevel: bool,
1619    operation: CookieOperation,
1620}
1621
1622impl<'a> CookieDeprecationMetadataIssueDetailsBuilder<'a> {
1623    pub fn build(self) -> CookieDeprecationMetadataIssueDetails<'a> {
1624        CookieDeprecationMetadataIssueDetails {
1625            allowedSites: self.allowedSites,
1626            optOutPercentage: self.optOutPercentage,
1627            isOptOutTopLevel: self.isOptOutTopLevel,
1628            operation: self.operation,
1629        }
1630    }
1631}
1632
1633
1634#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1635pub enum ClientHintIssueReason {
1636    #[default]
1637    #[serde(rename = "MetaTagAllowListInvalidOrigin")]
1638    MetaTagAllowListInvalidOrigin,
1639    #[serde(rename = "MetaTagModifiedHTML")]
1640    MetaTagModifiedHTML,
1641}
1642
1643
1644#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1645#[serde(rename_all = "camelCase")]
1646pub struct FederatedAuthRequestIssueDetails {
1647    federatedAuthRequestIssueReason: FederatedAuthRequestIssueReason,
1648}
1649
1650impl FederatedAuthRequestIssueDetails {
1651    pub fn builder(federatedAuthRequestIssueReason: FederatedAuthRequestIssueReason) -> FederatedAuthRequestIssueDetailsBuilder {
1652        FederatedAuthRequestIssueDetailsBuilder {
1653            federatedAuthRequestIssueReason: federatedAuthRequestIssueReason,
1654        }
1655    }
1656    pub fn federatedAuthRequestIssueReason(&self) -> &FederatedAuthRequestIssueReason { &self.federatedAuthRequestIssueReason }
1657}
1658
1659
1660pub struct FederatedAuthRequestIssueDetailsBuilder {
1661    federatedAuthRequestIssueReason: FederatedAuthRequestIssueReason,
1662}
1663
1664impl FederatedAuthRequestIssueDetailsBuilder {
1665    pub fn build(self) -> FederatedAuthRequestIssueDetails {
1666        FederatedAuthRequestIssueDetails {
1667            federatedAuthRequestIssueReason: self.federatedAuthRequestIssueReason,
1668        }
1669    }
1670}
1671
1672/// Represents the failure reason when a federated authentication reason fails.
1673/// Should be updated alongside RequestIdTokenStatus in
1674/// third_party/blink/public/mojom/devtools/inspector_issue.mojom to include
1675/// all cases except for success.
1676
1677#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1678pub enum FederatedAuthRequestIssueReason {
1679    #[default]
1680    #[serde(rename = "ShouldEmbargo")]
1681    ShouldEmbargo,
1682    #[serde(rename = "TooManyRequests")]
1683    TooManyRequests,
1684    #[serde(rename = "WellKnownHttpNotFound")]
1685    WellKnownHttpNotFound,
1686    #[serde(rename = "WellKnownNoResponse")]
1687    WellKnownNoResponse,
1688    #[serde(rename = "WellKnownInvalidResponse")]
1689    WellKnownInvalidResponse,
1690    #[serde(rename = "WellKnownListEmpty")]
1691    WellKnownListEmpty,
1692    #[serde(rename = "WellKnownInvalidContentType")]
1693    WellKnownInvalidContentType,
1694    #[serde(rename = "ConfigNotInWellKnown")]
1695    ConfigNotInWellKnown,
1696    #[serde(rename = "WellKnownTooBig")]
1697    WellKnownTooBig,
1698    #[serde(rename = "ConfigHttpNotFound")]
1699    ConfigHttpNotFound,
1700    #[serde(rename = "ConfigNoResponse")]
1701    ConfigNoResponse,
1702    #[serde(rename = "ConfigInvalidResponse")]
1703    ConfigInvalidResponse,
1704    #[serde(rename = "ConfigInvalidContentType")]
1705    ConfigInvalidContentType,
1706    #[serde(rename = "IdpNotPotentiallyTrustworthy")]
1707    IdpNotPotentiallyTrustworthy,
1708    #[serde(rename = "DisabledInSettings")]
1709    DisabledInSettings,
1710    #[serde(rename = "DisabledInFlags")]
1711    DisabledInFlags,
1712    #[serde(rename = "ErrorFetchingSignin")]
1713    ErrorFetchingSignin,
1714    #[serde(rename = "InvalidSigninResponse")]
1715    InvalidSigninResponse,
1716    #[serde(rename = "AccountsHttpNotFound")]
1717    AccountsHttpNotFound,
1718    #[serde(rename = "AccountsNoResponse")]
1719    AccountsNoResponse,
1720    #[serde(rename = "AccountsInvalidResponse")]
1721    AccountsInvalidResponse,
1722    #[serde(rename = "AccountsListEmpty")]
1723    AccountsListEmpty,
1724    #[serde(rename = "AccountsInvalidContentType")]
1725    AccountsInvalidContentType,
1726    #[serde(rename = "IdTokenHttpNotFound")]
1727    IdTokenHttpNotFound,
1728    #[serde(rename = "IdTokenNoResponse")]
1729    IdTokenNoResponse,
1730    #[serde(rename = "IdTokenInvalidResponse")]
1731    IdTokenInvalidResponse,
1732    #[serde(rename = "IdTokenIdpErrorResponse")]
1733    IdTokenIdpErrorResponse,
1734    #[serde(rename = "IdTokenCrossSiteIdpErrorResponse")]
1735    IdTokenCrossSiteIdpErrorResponse,
1736    #[serde(rename = "IdTokenInvalidRequest")]
1737    IdTokenInvalidRequest,
1738    #[serde(rename = "IdTokenInvalidContentType")]
1739    IdTokenInvalidContentType,
1740    #[serde(rename = "ErrorIdToken")]
1741    ErrorIdToken,
1742    #[serde(rename = "Canceled")]
1743    Canceled,
1744    #[serde(rename = "RpPageNotVisible")]
1745    RpPageNotVisible,
1746    #[serde(rename = "SilentMediationFailure")]
1747    SilentMediationFailure,
1748    #[serde(rename = "NotSignedInWithIdp")]
1749    NotSignedInWithIdp,
1750    #[serde(rename = "MissingTransientUserActivation")]
1751    MissingTransientUserActivation,
1752    #[serde(rename = "ReplacedByActiveMode")]
1753    ReplacedByActiveMode,
1754    #[serde(rename = "RelyingPartyOriginIsOpaque")]
1755    RelyingPartyOriginIsOpaque,
1756    #[serde(rename = "TypeNotMatching")]
1757    TypeNotMatching,
1758    #[serde(rename = "UiDismissedNoEmbargo")]
1759    UiDismissedNoEmbargo,
1760    #[serde(rename = "CorsError")]
1761    CorsError,
1762    #[serde(rename = "SuppressedBySegmentationPlatform")]
1763    SuppressedBySegmentationPlatform,
1764}
1765
1766
1767#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1768#[serde(rename_all = "camelCase")]
1769pub struct FederatedAuthUserInfoRequestIssueDetails {
1770    federatedAuthUserInfoRequestIssueReason: FederatedAuthUserInfoRequestIssueReason,
1771}
1772
1773impl FederatedAuthUserInfoRequestIssueDetails {
1774    pub fn builder(federatedAuthUserInfoRequestIssueReason: FederatedAuthUserInfoRequestIssueReason) -> FederatedAuthUserInfoRequestIssueDetailsBuilder {
1775        FederatedAuthUserInfoRequestIssueDetailsBuilder {
1776            federatedAuthUserInfoRequestIssueReason: federatedAuthUserInfoRequestIssueReason,
1777        }
1778    }
1779    pub fn federatedAuthUserInfoRequestIssueReason(&self) -> &FederatedAuthUserInfoRequestIssueReason { &self.federatedAuthUserInfoRequestIssueReason }
1780}
1781
1782
1783pub struct FederatedAuthUserInfoRequestIssueDetailsBuilder {
1784    federatedAuthUserInfoRequestIssueReason: FederatedAuthUserInfoRequestIssueReason,
1785}
1786
1787impl FederatedAuthUserInfoRequestIssueDetailsBuilder {
1788    pub fn build(self) -> FederatedAuthUserInfoRequestIssueDetails {
1789        FederatedAuthUserInfoRequestIssueDetails {
1790            federatedAuthUserInfoRequestIssueReason: self.federatedAuthUserInfoRequestIssueReason,
1791        }
1792    }
1793}
1794
1795/// Represents the failure reason when a getUserInfo() call fails.
1796/// Should be updated alongside FederatedAuthUserInfoRequestResult in
1797/// third_party/blink/public/mojom/devtools/inspector_issue.mojom.
1798
1799#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1800pub enum FederatedAuthUserInfoRequestIssueReason {
1801    #[default]
1802    #[serde(rename = "NotSameOrigin")]
1803    NotSameOrigin,
1804    #[serde(rename = "NotIframe")]
1805    NotIframe,
1806    #[serde(rename = "NotPotentiallyTrustworthy")]
1807    NotPotentiallyTrustworthy,
1808    #[serde(rename = "NoApiPermission")]
1809    NoApiPermission,
1810    #[serde(rename = "NotSignedInWithIdp")]
1811    NotSignedInWithIdp,
1812    #[serde(rename = "NoAccountSharingPermission")]
1813    NoAccountSharingPermission,
1814    #[serde(rename = "InvalidConfigOrWellKnown")]
1815    InvalidConfigOrWellKnown,
1816    #[serde(rename = "InvalidAccountsResponse")]
1817    InvalidAccountsResponse,
1818    #[serde(rename = "NoReturningUserFromFetchedAccounts")]
1819    NoReturningUserFromFetchedAccounts,
1820}
1821
1822/// This issue tracks client hints related issues. It's used to deprecate old
1823/// features, encourage the use of new ones, and provide general guidance.
1824
1825#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1826#[serde(rename_all = "camelCase")]
1827pub struct ClientHintIssueDetails<'a> {
1828    sourceCodeLocation: SourceCodeLocation<'a>,
1829    clientHintIssueReason: ClientHintIssueReason,
1830}
1831
1832impl<'a> ClientHintIssueDetails<'a> {
1833    pub fn builder(sourceCodeLocation: SourceCodeLocation<'a>, clientHintIssueReason: ClientHintIssueReason) -> ClientHintIssueDetailsBuilder<'a> {
1834        ClientHintIssueDetailsBuilder {
1835            sourceCodeLocation: sourceCodeLocation,
1836            clientHintIssueReason: clientHintIssueReason,
1837        }
1838    }
1839    pub fn sourceCodeLocation(&self) -> &SourceCodeLocation<'a> { &self.sourceCodeLocation }
1840    pub fn clientHintIssueReason(&self) -> &ClientHintIssueReason { &self.clientHintIssueReason }
1841}
1842
1843
1844pub struct ClientHintIssueDetailsBuilder<'a> {
1845    sourceCodeLocation: SourceCodeLocation<'a>,
1846    clientHintIssueReason: ClientHintIssueReason,
1847}
1848
1849impl<'a> ClientHintIssueDetailsBuilder<'a> {
1850    pub fn build(self) -> ClientHintIssueDetails<'a> {
1851        ClientHintIssueDetails {
1852            sourceCodeLocation: self.sourceCodeLocation,
1853            clientHintIssueReason: self.clientHintIssueReason,
1854        }
1855    }
1856}
1857
1858
1859#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1860#[serde(rename_all = "camelCase")]
1861pub struct FailedRequestInfo<'a> {
1862    /// The URL that failed to load.
1863    url: Cow<'a, str>,
1864    /// The failure message for the failed request.
1865    failureMessage: Cow<'a, str>,
1866    #[serde(skip_serializing_if = "Option::is_none")]
1867    requestId: Option<crate::network::RequestId<'a>>,
1868}
1869
1870impl<'a> FailedRequestInfo<'a> {
1871    pub fn builder(url: impl Into<Cow<'a, str>>, failureMessage: impl Into<Cow<'a, str>>) -> FailedRequestInfoBuilder<'a> {
1872        FailedRequestInfoBuilder {
1873            url: url.into(),
1874            failureMessage: failureMessage.into(),
1875            requestId: None,
1876        }
1877    }
1878    pub fn url(&self) -> &str { self.url.as_ref() }
1879    pub fn failureMessage(&self) -> &str { self.failureMessage.as_ref() }
1880    pub fn requestId(&self) -> Option<&crate::network::RequestId<'a>> { self.requestId.as_ref() }
1881}
1882
1883
1884pub struct FailedRequestInfoBuilder<'a> {
1885    url: Cow<'a, str>,
1886    failureMessage: Cow<'a, str>,
1887    requestId: Option<crate::network::RequestId<'a>>,
1888}
1889
1890impl<'a> FailedRequestInfoBuilder<'a> {
1891    pub fn requestId(mut self, requestId: crate::network::RequestId<'a>) -> Self { self.requestId = Some(requestId); self }
1892    pub fn build(self) -> FailedRequestInfo<'a> {
1893        FailedRequestInfo {
1894            url: self.url,
1895            failureMessage: self.failureMessage,
1896            requestId: self.requestId,
1897        }
1898    }
1899}
1900
1901
1902#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1903pub enum PartitioningBlobURLInfo {
1904    #[default]
1905    #[serde(rename = "BlockedCrossPartitionFetching")]
1906    BlockedCrossPartitionFetching,
1907    #[serde(rename = "EnforceNoopenerForNavigation")]
1908    EnforceNoopenerForNavigation,
1909}
1910
1911
1912#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1913#[serde(rename_all = "camelCase")]
1914pub struct PartitioningBlobURLIssueDetails<'a> {
1915    /// The BlobURL that failed to load.
1916    url: Cow<'a, str>,
1917    /// Additional information about the Partitioning Blob URL issue.
1918    partitioningBlobURLInfo: PartitioningBlobURLInfo,
1919}
1920
1921impl<'a> PartitioningBlobURLIssueDetails<'a> {
1922    pub fn builder(url: impl Into<Cow<'a, str>>, partitioningBlobURLInfo: PartitioningBlobURLInfo) -> PartitioningBlobURLIssueDetailsBuilder<'a> {
1923        PartitioningBlobURLIssueDetailsBuilder {
1924            url: url.into(),
1925            partitioningBlobURLInfo: partitioningBlobURLInfo,
1926        }
1927    }
1928    pub fn url(&self) -> &str { self.url.as_ref() }
1929    pub fn partitioningBlobURLInfo(&self) -> &PartitioningBlobURLInfo { &self.partitioningBlobURLInfo }
1930}
1931
1932
1933pub struct PartitioningBlobURLIssueDetailsBuilder<'a> {
1934    url: Cow<'a, str>,
1935    partitioningBlobURLInfo: PartitioningBlobURLInfo,
1936}
1937
1938impl<'a> PartitioningBlobURLIssueDetailsBuilder<'a> {
1939    pub fn build(self) -> PartitioningBlobURLIssueDetails<'a> {
1940        PartitioningBlobURLIssueDetails {
1941            url: self.url,
1942            partitioningBlobURLInfo: self.partitioningBlobURLInfo,
1943        }
1944    }
1945}
1946
1947
1948#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
1949pub enum ElementAccessibilityIssueReason {
1950    #[default]
1951    #[serde(rename = "DisallowedSelectChild")]
1952    DisallowedSelectChild,
1953    #[serde(rename = "DisallowedOptGroupChild")]
1954    DisallowedOptGroupChild,
1955    #[serde(rename = "NonPhrasingContentOptionChild")]
1956    NonPhrasingContentOptionChild,
1957    #[serde(rename = "InteractiveContentOptionChild")]
1958    InteractiveContentOptionChild,
1959    #[serde(rename = "InteractiveContentLegendChild")]
1960    InteractiveContentLegendChild,
1961    #[serde(rename = "InteractiveContentSummaryDescendant")]
1962    InteractiveContentSummaryDescendant,
1963}
1964
1965/// This issue warns about errors in the select or summary element content model.
1966
1967#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1968#[serde(rename_all = "camelCase")]
1969pub struct ElementAccessibilityIssueDetails {
1970    nodeId: crate::dom::BackendNodeId,
1971    elementAccessibilityIssueReason: ElementAccessibilityIssueReason,
1972    hasDisallowedAttributes: bool,
1973}
1974
1975impl ElementAccessibilityIssueDetails {
1976    pub fn builder(nodeId: crate::dom::BackendNodeId, elementAccessibilityIssueReason: ElementAccessibilityIssueReason, hasDisallowedAttributes: bool) -> ElementAccessibilityIssueDetailsBuilder {
1977        ElementAccessibilityIssueDetailsBuilder {
1978            nodeId: nodeId,
1979            elementAccessibilityIssueReason: elementAccessibilityIssueReason,
1980            hasDisallowedAttributes: hasDisallowedAttributes,
1981        }
1982    }
1983    pub fn nodeId(&self) -> &crate::dom::BackendNodeId { &self.nodeId }
1984    pub fn elementAccessibilityIssueReason(&self) -> &ElementAccessibilityIssueReason { &self.elementAccessibilityIssueReason }
1985    pub fn hasDisallowedAttributes(&self) -> bool { self.hasDisallowedAttributes }
1986}
1987
1988
1989pub struct ElementAccessibilityIssueDetailsBuilder {
1990    nodeId: crate::dom::BackendNodeId,
1991    elementAccessibilityIssueReason: ElementAccessibilityIssueReason,
1992    hasDisallowedAttributes: bool,
1993}
1994
1995impl ElementAccessibilityIssueDetailsBuilder {
1996    pub fn build(self) -> ElementAccessibilityIssueDetails {
1997        ElementAccessibilityIssueDetails {
1998            nodeId: self.nodeId,
1999            elementAccessibilityIssueReason: self.elementAccessibilityIssueReason,
2000            hasDisallowedAttributes: self.hasDisallowedAttributes,
2001        }
2002    }
2003}
2004
2005
2006#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
2007pub enum StyleSheetLoadingIssueReason {
2008    #[default]
2009    #[serde(rename = "LateImportRule")]
2010    LateImportRule,
2011    #[serde(rename = "RequestFailed")]
2012    RequestFailed,
2013}
2014
2015/// This issue warns when a referenced stylesheet couldn't be loaded.
2016
2017#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2018#[serde(rename_all = "camelCase")]
2019pub struct StylesheetLoadingIssueDetails<'a> {
2020    /// Source code position that referenced the failing stylesheet.
2021    sourceCodeLocation: SourceCodeLocation<'a>,
2022    /// Reason why the stylesheet couldn't be loaded.
2023    styleSheetLoadingIssueReason: StyleSheetLoadingIssueReason,
2024    /// Contains additional info when the failure was due to a request.
2025    #[serde(skip_serializing_if = "Option::is_none")]
2026    failedRequestInfo: Option<FailedRequestInfo<'a>>,
2027}
2028
2029impl<'a> StylesheetLoadingIssueDetails<'a> {
2030    pub fn builder(sourceCodeLocation: SourceCodeLocation<'a>, styleSheetLoadingIssueReason: StyleSheetLoadingIssueReason) -> StylesheetLoadingIssueDetailsBuilder<'a> {
2031        StylesheetLoadingIssueDetailsBuilder {
2032            sourceCodeLocation: sourceCodeLocation,
2033            styleSheetLoadingIssueReason: styleSheetLoadingIssueReason,
2034            failedRequestInfo: None,
2035        }
2036    }
2037    pub fn sourceCodeLocation(&self) -> &SourceCodeLocation<'a> { &self.sourceCodeLocation }
2038    pub fn styleSheetLoadingIssueReason(&self) -> &StyleSheetLoadingIssueReason { &self.styleSheetLoadingIssueReason }
2039    pub fn failedRequestInfo(&self) -> Option<&FailedRequestInfo<'a>> { self.failedRequestInfo.as_ref() }
2040}
2041
2042
2043pub struct StylesheetLoadingIssueDetailsBuilder<'a> {
2044    sourceCodeLocation: SourceCodeLocation<'a>,
2045    styleSheetLoadingIssueReason: StyleSheetLoadingIssueReason,
2046    failedRequestInfo: Option<FailedRequestInfo<'a>>,
2047}
2048
2049impl<'a> StylesheetLoadingIssueDetailsBuilder<'a> {
2050    /// Contains additional info when the failure was due to a request.
2051    pub fn failedRequestInfo(mut self, failedRequestInfo: FailedRequestInfo<'a>) -> Self { self.failedRequestInfo = Some(failedRequestInfo); self }
2052    pub fn build(self) -> StylesheetLoadingIssueDetails<'a> {
2053        StylesheetLoadingIssueDetails {
2054            sourceCodeLocation: self.sourceCodeLocation,
2055            styleSheetLoadingIssueReason: self.styleSheetLoadingIssueReason,
2056            failedRequestInfo: self.failedRequestInfo,
2057        }
2058    }
2059}
2060
2061
2062#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
2063pub enum PropertyRuleIssueReason {
2064    #[default]
2065    #[serde(rename = "InvalidSyntax")]
2066    InvalidSyntax,
2067    #[serde(rename = "InvalidInitialValue")]
2068    InvalidInitialValue,
2069    #[serde(rename = "InvalidInherits")]
2070    InvalidInherits,
2071    #[serde(rename = "InvalidName")]
2072    InvalidName,
2073}
2074
2075/// This issue warns about errors in property rules that lead to property
2076/// registrations being ignored.
2077
2078#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2079#[serde(rename_all = "camelCase")]
2080pub struct PropertyRuleIssueDetails<'a> {
2081    /// Source code position of the property rule.
2082    sourceCodeLocation: SourceCodeLocation<'a>,
2083    /// Reason why the property rule was discarded.
2084    propertyRuleIssueReason: PropertyRuleIssueReason,
2085    /// The value of the property rule property that failed to parse
2086    #[serde(skip_serializing_if = "Option::is_none")]
2087    propertyValue: Option<Cow<'a, str>>,
2088}
2089
2090impl<'a> PropertyRuleIssueDetails<'a> {
2091    pub fn builder(sourceCodeLocation: SourceCodeLocation<'a>, propertyRuleIssueReason: PropertyRuleIssueReason) -> PropertyRuleIssueDetailsBuilder<'a> {
2092        PropertyRuleIssueDetailsBuilder {
2093            sourceCodeLocation: sourceCodeLocation,
2094            propertyRuleIssueReason: propertyRuleIssueReason,
2095            propertyValue: None,
2096        }
2097    }
2098    pub fn sourceCodeLocation(&self) -> &SourceCodeLocation<'a> { &self.sourceCodeLocation }
2099    pub fn propertyRuleIssueReason(&self) -> &PropertyRuleIssueReason { &self.propertyRuleIssueReason }
2100    pub fn propertyValue(&self) -> Option<&str> { self.propertyValue.as_deref() }
2101}
2102
2103
2104pub struct PropertyRuleIssueDetailsBuilder<'a> {
2105    sourceCodeLocation: SourceCodeLocation<'a>,
2106    propertyRuleIssueReason: PropertyRuleIssueReason,
2107    propertyValue: Option<Cow<'a, str>>,
2108}
2109
2110impl<'a> PropertyRuleIssueDetailsBuilder<'a> {
2111    /// The value of the property rule property that failed to parse
2112    pub fn propertyValue(mut self, propertyValue: impl Into<Cow<'a, str>>) -> Self { self.propertyValue = Some(propertyValue.into()); self }
2113    pub fn build(self) -> PropertyRuleIssueDetails<'a> {
2114        PropertyRuleIssueDetails {
2115            sourceCodeLocation: self.sourceCodeLocation,
2116            propertyRuleIssueReason: self.propertyRuleIssueReason,
2117            propertyValue: self.propertyValue,
2118        }
2119    }
2120}
2121
2122
2123#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
2124pub enum UserReidentificationIssueType {
2125    #[default]
2126    #[serde(rename = "BlockedFrameNavigation")]
2127    BlockedFrameNavigation,
2128    #[serde(rename = "BlockedSubresource")]
2129    BlockedSubresource,
2130    #[serde(rename = "NoisedCanvasReadback")]
2131    NoisedCanvasReadback,
2132}
2133
2134/// This issue warns about uses of APIs that may be considered misuse to
2135/// re-identify users.
2136
2137#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2138#[serde(rename_all = "camelCase")]
2139pub struct UserReidentificationIssueDetails<'a> {
2140    #[serde(rename = "type")]
2141    type_: UserReidentificationIssueType,
2142    /// Applies to BlockedFrameNavigation and BlockedSubresource issue types.
2143    #[serde(skip_serializing_if = "Option::is_none")]
2144    request: Option<AffectedRequest<'a>>,
2145    /// Applies to NoisedCanvasReadback issue type.
2146    #[serde(skip_serializing_if = "Option::is_none")]
2147    sourceCodeLocation: Option<SourceCodeLocation<'a>>,
2148}
2149
2150impl<'a> UserReidentificationIssueDetails<'a> {
2151    pub fn builder(type_: UserReidentificationIssueType) -> UserReidentificationIssueDetailsBuilder<'a> {
2152        UserReidentificationIssueDetailsBuilder {
2153            type_: type_,
2154            request: None,
2155            sourceCodeLocation: None,
2156        }
2157    }
2158    pub fn type_(&self) -> &UserReidentificationIssueType { &self.type_ }
2159    pub fn request(&self) -> Option<&AffectedRequest<'a>> { self.request.as_ref() }
2160    pub fn sourceCodeLocation(&self) -> Option<&SourceCodeLocation<'a>> { self.sourceCodeLocation.as_ref() }
2161}
2162
2163
2164pub struct UserReidentificationIssueDetailsBuilder<'a> {
2165    type_: UserReidentificationIssueType,
2166    request: Option<AffectedRequest<'a>>,
2167    sourceCodeLocation: Option<SourceCodeLocation<'a>>,
2168}
2169
2170impl<'a> UserReidentificationIssueDetailsBuilder<'a> {
2171    /// Applies to BlockedFrameNavigation and BlockedSubresource issue types.
2172    pub fn request(mut self, request: AffectedRequest<'a>) -> Self { self.request = Some(request); self }
2173    /// Applies to NoisedCanvasReadback issue type.
2174    pub fn sourceCodeLocation(mut self, sourceCodeLocation: SourceCodeLocation<'a>) -> Self { self.sourceCodeLocation = Some(sourceCodeLocation); self }
2175    pub fn build(self) -> UserReidentificationIssueDetails<'a> {
2176        UserReidentificationIssueDetails {
2177            type_: self.type_,
2178            request: self.request,
2179            sourceCodeLocation: self.sourceCodeLocation,
2180        }
2181    }
2182}
2183
2184
2185#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
2186pub enum PermissionElementIssueType {
2187    #[default]
2188    #[serde(rename = "InvalidType")]
2189    InvalidType,
2190    #[serde(rename = "FencedFrameDisallowed")]
2191    FencedFrameDisallowed,
2192    #[serde(rename = "CspFrameAncestorsMissing")]
2193    CspFrameAncestorsMissing,
2194    #[serde(rename = "PermissionsPolicyBlocked")]
2195    PermissionsPolicyBlocked,
2196    #[serde(rename = "PaddingRightUnsupported")]
2197    PaddingRightUnsupported,
2198    #[serde(rename = "PaddingBottomUnsupported")]
2199    PaddingBottomUnsupported,
2200    #[serde(rename = "InsetBoxShadowUnsupported")]
2201    InsetBoxShadowUnsupported,
2202    #[serde(rename = "RequestInProgress")]
2203    RequestInProgress,
2204    #[serde(rename = "UntrustedEvent")]
2205    UntrustedEvent,
2206    #[serde(rename = "RegistrationFailed")]
2207    RegistrationFailed,
2208    #[serde(rename = "TypeNotSupported")]
2209    TypeNotSupported,
2210    #[serde(rename = "InvalidTypeActivation")]
2211    InvalidTypeActivation,
2212    #[serde(rename = "SecurityChecksFailed")]
2213    SecurityChecksFailed,
2214    #[serde(rename = "ActivationDisabled")]
2215    ActivationDisabled,
2216    #[serde(rename = "GeolocationDeprecated")]
2217    GeolocationDeprecated,
2218    #[serde(rename = "InvalidDisplayStyle")]
2219    InvalidDisplayStyle,
2220    #[serde(rename = "NonOpaqueColor")]
2221    NonOpaqueColor,
2222    #[serde(rename = "LowContrast")]
2223    LowContrast,
2224    #[serde(rename = "FontSizeTooSmall")]
2225    FontSizeTooSmall,
2226    #[serde(rename = "FontSizeTooLarge")]
2227    FontSizeTooLarge,
2228    #[serde(rename = "InvalidSizeValue")]
2229    InvalidSizeValue,
2230}
2231
2232/// This issue warns about improper usage of the <permission> element.
2233
2234#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2235#[serde(rename_all = "camelCase")]
2236pub struct PermissionElementIssueDetails<'a> {
2237    issueType: PermissionElementIssueType,
2238    /// The value of the type attribute.
2239    #[serde(skip_serializing_if = "Option::is_none", rename = "type")]
2240    type_: Option<Cow<'a, str>>,
2241    /// The node ID of the <permission> element.
2242    #[serde(skip_serializing_if = "Option::is_none")]
2243    nodeId: Option<crate::dom::BackendNodeId>,
2244    /// True if the issue is a warning, false if it is an error.
2245    #[serde(skip_serializing_if = "Option::is_none")]
2246    isWarning: Option<bool>,
2247    /// Fields for message construction:
2248    /// Used for messages that reference a specific permission name
2249    #[serde(skip_serializing_if = "Option::is_none")]
2250    permissionName: Option<Cow<'a, str>>,
2251    /// Used for messages about occlusion
2252    #[serde(skip_serializing_if = "Option::is_none")]
2253    occluderNodeInfo: Option<Cow<'a, str>>,
2254    /// Used for messages about occluder's parent
2255    #[serde(skip_serializing_if = "Option::is_none")]
2256    occluderParentNodeInfo: Option<Cow<'a, str>>,
2257    /// Used for messages about activation disabled reason
2258    #[serde(skip_serializing_if = "Option::is_none")]
2259    disableReason: Option<Cow<'a, str>>,
2260}
2261
2262impl<'a> PermissionElementIssueDetails<'a> {
2263    pub fn builder(issueType: PermissionElementIssueType) -> PermissionElementIssueDetailsBuilder<'a> {
2264        PermissionElementIssueDetailsBuilder {
2265            issueType: issueType,
2266            type_: None,
2267            nodeId: None,
2268            isWarning: None,
2269            permissionName: None,
2270            occluderNodeInfo: None,
2271            occluderParentNodeInfo: None,
2272            disableReason: None,
2273        }
2274    }
2275    pub fn issueType(&self) -> &PermissionElementIssueType { &self.issueType }
2276    pub fn type_(&self) -> Option<&str> { self.type_.as_deref() }
2277    pub fn nodeId(&self) -> Option<&crate::dom::BackendNodeId> { self.nodeId.as_ref() }
2278    pub fn isWarning(&self) -> Option<bool> { self.isWarning }
2279    pub fn permissionName(&self) -> Option<&str> { self.permissionName.as_deref() }
2280    pub fn occluderNodeInfo(&self) -> Option<&str> { self.occluderNodeInfo.as_deref() }
2281    pub fn occluderParentNodeInfo(&self) -> Option<&str> { self.occluderParentNodeInfo.as_deref() }
2282    pub fn disableReason(&self) -> Option<&str> { self.disableReason.as_deref() }
2283}
2284
2285
2286pub struct PermissionElementIssueDetailsBuilder<'a> {
2287    issueType: PermissionElementIssueType,
2288    type_: Option<Cow<'a, str>>,
2289    nodeId: Option<crate::dom::BackendNodeId>,
2290    isWarning: Option<bool>,
2291    permissionName: Option<Cow<'a, str>>,
2292    occluderNodeInfo: Option<Cow<'a, str>>,
2293    occluderParentNodeInfo: Option<Cow<'a, str>>,
2294    disableReason: Option<Cow<'a, str>>,
2295}
2296
2297impl<'a> PermissionElementIssueDetailsBuilder<'a> {
2298    /// The value of the type attribute.
2299    pub fn type_(mut self, type_: impl Into<Cow<'a, str>>) -> Self { self.type_ = Some(type_.into()); self }
2300    /// The node ID of the <permission> element.
2301    pub fn nodeId(mut self, nodeId: crate::dom::BackendNodeId) -> Self { self.nodeId = Some(nodeId); self }
2302    /// True if the issue is a warning, false if it is an error.
2303    pub fn isWarning(mut self, isWarning: bool) -> Self { self.isWarning = Some(isWarning); self }
2304    /// Fields for message construction:
2305    /// Used for messages that reference a specific permission name
2306    pub fn permissionName(mut self, permissionName: impl Into<Cow<'a, str>>) -> Self { self.permissionName = Some(permissionName.into()); self }
2307    /// Used for messages about occlusion
2308    pub fn occluderNodeInfo(mut self, occluderNodeInfo: impl Into<Cow<'a, str>>) -> Self { self.occluderNodeInfo = Some(occluderNodeInfo.into()); self }
2309    /// Used for messages about occluder's parent
2310    pub fn occluderParentNodeInfo(mut self, occluderParentNodeInfo: impl Into<Cow<'a, str>>) -> Self { self.occluderParentNodeInfo = Some(occluderParentNodeInfo.into()); self }
2311    /// Used for messages about activation disabled reason
2312    pub fn disableReason(mut self, disableReason: impl Into<Cow<'a, str>>) -> Self { self.disableReason = Some(disableReason.into()); self }
2313    pub fn build(self) -> PermissionElementIssueDetails<'a> {
2314        PermissionElementIssueDetails {
2315            issueType: self.issueType,
2316            type_: self.type_,
2317            nodeId: self.nodeId,
2318            isWarning: self.isWarning,
2319            permissionName: self.permissionName,
2320            occluderNodeInfo: self.occluderNodeInfo,
2321            occluderParentNodeInfo: self.occluderParentNodeInfo,
2322            disableReason: self.disableReason,
2323        }
2324    }
2325}
2326
2327/// The issue warns about blocked calls to privacy sensitive APIs via the
2328/// Selective Permissions Intervention.
2329
2330#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2331#[serde(rename_all = "camelCase")]
2332pub struct SelectivePermissionsInterventionIssueDetails<'a> {
2333    /// Which API was intervened on.
2334    apiName: Cow<'a, str>,
2335    /// Why the ad script using the API is considered an ad.
2336    adAncestry: crate::network::AdAncestry<'a>,
2337    /// The stack trace at the time of the intervention.
2338    #[serde(skip_serializing_if = "Option::is_none")]
2339    stackTrace: Option<crate::runtime::StackTrace>,
2340}
2341
2342impl<'a> SelectivePermissionsInterventionIssueDetails<'a> {
2343    pub fn builder(apiName: impl Into<Cow<'a, str>>, adAncestry: crate::network::AdAncestry<'a>) -> SelectivePermissionsInterventionIssueDetailsBuilder<'a> {
2344        SelectivePermissionsInterventionIssueDetailsBuilder {
2345            apiName: apiName.into(),
2346            adAncestry: adAncestry,
2347            stackTrace: None,
2348        }
2349    }
2350    pub fn apiName(&self) -> &str { self.apiName.as_ref() }
2351    pub fn adAncestry(&self) -> &crate::network::AdAncestry<'a> { &self.adAncestry }
2352    pub fn stackTrace(&self) -> Option<&crate::runtime::StackTrace> { self.stackTrace.as_ref() }
2353}
2354
2355
2356pub struct SelectivePermissionsInterventionIssueDetailsBuilder<'a> {
2357    apiName: Cow<'a, str>,
2358    adAncestry: crate::network::AdAncestry<'a>,
2359    stackTrace: Option<crate::runtime::StackTrace>,
2360}
2361
2362impl<'a> SelectivePermissionsInterventionIssueDetailsBuilder<'a> {
2363    /// The stack trace at the time of the intervention.
2364    pub fn stackTrace(mut self, stackTrace: crate::runtime::StackTrace) -> Self { self.stackTrace = Some(stackTrace); self }
2365    pub fn build(self) -> SelectivePermissionsInterventionIssueDetails<'a> {
2366        SelectivePermissionsInterventionIssueDetails {
2367            apiName: self.apiName,
2368            adAncestry: self.adAncestry,
2369            stackTrace: self.stackTrace,
2370        }
2371    }
2372}
2373
2374/// A unique identifier for the type of issue. Each type may use one of the
2375/// optional fields in InspectorIssueDetails to convey more specific
2376/// information about the kind of issue.
2377
2378#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
2379pub enum InspectorIssueCode {
2380    #[default]
2381    #[serde(rename = "CookieIssue")]
2382    CookieIssue,
2383    #[serde(rename = "MixedContentIssue")]
2384    MixedContentIssue,
2385    #[serde(rename = "BlockedByResponseIssue")]
2386    BlockedByResponseIssue,
2387    #[serde(rename = "HeavyAdIssue")]
2388    HeavyAdIssue,
2389    #[serde(rename = "ContentSecurityPolicyIssue")]
2390    ContentSecurityPolicyIssue,
2391    #[serde(rename = "SharedArrayBufferIssue")]
2392    SharedArrayBufferIssue,
2393    #[serde(rename = "CorsIssue")]
2394    CorsIssue,
2395    #[serde(rename = "AttributionReportingIssue")]
2396    AttributionReportingIssue,
2397    #[serde(rename = "QuirksModeIssue")]
2398    QuirksModeIssue,
2399    #[serde(rename = "PartitioningBlobURLIssue")]
2400    PartitioningBlobURLIssue,
2401    #[serde(rename = "NavigatorUserAgentIssue")]
2402    NavigatorUserAgentIssue,
2403    #[serde(rename = "GenericIssue")]
2404    GenericIssue,
2405    #[serde(rename = "DeprecationIssue")]
2406    DeprecationIssue,
2407    #[serde(rename = "ClientHintIssue")]
2408    ClientHintIssue,
2409    #[serde(rename = "FederatedAuthRequestIssue")]
2410    FederatedAuthRequestIssue,
2411    #[serde(rename = "BounceTrackingIssue")]
2412    BounceTrackingIssue,
2413    #[serde(rename = "CookieDeprecationMetadataIssue")]
2414    CookieDeprecationMetadataIssue,
2415    #[serde(rename = "StylesheetLoadingIssue")]
2416    StylesheetLoadingIssue,
2417    #[serde(rename = "FederatedAuthUserInfoRequestIssue")]
2418    FederatedAuthUserInfoRequestIssue,
2419    #[serde(rename = "PropertyRuleIssue")]
2420    PropertyRuleIssue,
2421    #[serde(rename = "SharedDictionaryIssue")]
2422    SharedDictionaryIssue,
2423    #[serde(rename = "ElementAccessibilityIssue")]
2424    ElementAccessibilityIssue,
2425    #[serde(rename = "SRIMessageSignatureIssue")]
2426    SRIMessageSignatureIssue,
2427    #[serde(rename = "UnencodedDigestIssue")]
2428    UnencodedDigestIssue,
2429    #[serde(rename = "ConnectionAllowlistIssue")]
2430    ConnectionAllowlistIssue,
2431    #[serde(rename = "UserReidentificationIssue")]
2432    UserReidentificationIssue,
2433    #[serde(rename = "PermissionElementIssue")]
2434    PermissionElementIssue,
2435    #[serde(rename = "PerformanceIssue")]
2436    PerformanceIssue,
2437    #[serde(rename = "SelectivePermissionsInterventionIssue")]
2438    SelectivePermissionsInterventionIssue,
2439}
2440
2441/// This struct holds a list of optional fields with additional information
2442/// specific to the kind of issue. When adding a new issue code, please also
2443/// add a new optional field to this type.
2444
2445#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2446#[serde(rename_all = "camelCase")]
2447pub struct InspectorIssueDetails<'a> {
2448    #[serde(skip_serializing_if = "Option::is_none")]
2449    cookieIssueDetails: Option<CookieIssueDetails<'a>>,
2450    #[serde(skip_serializing_if = "Option::is_none")]
2451    mixedContentIssueDetails: Option<MixedContentIssueDetails<'a>>,
2452    #[serde(skip_serializing_if = "Option::is_none")]
2453    blockedByResponseIssueDetails: Option<BlockedByResponseIssueDetails<'a>>,
2454    #[serde(skip_serializing_if = "Option::is_none")]
2455    heavyAdIssueDetails: Option<HeavyAdIssueDetails<'a>>,
2456    #[serde(skip_serializing_if = "Option::is_none")]
2457    contentSecurityPolicyIssueDetails: Option<ContentSecurityPolicyIssueDetails<'a>>,
2458    #[serde(skip_serializing_if = "Option::is_none")]
2459    sharedArrayBufferIssueDetails: Option<SharedArrayBufferIssueDetails<'a>>,
2460    #[serde(skip_serializing_if = "Option::is_none")]
2461    corsIssueDetails: Option<CorsIssueDetails<'a>>,
2462    #[serde(skip_serializing_if = "Option::is_none")]
2463    attributionReportingIssueDetails: Option<AttributionReportingIssueDetails<'a>>,
2464    #[serde(skip_serializing_if = "Option::is_none")]
2465    quirksModeIssueDetails: Option<QuirksModeIssueDetails<'a>>,
2466    #[serde(skip_serializing_if = "Option::is_none")]
2467    partitioningBlobURLIssueDetails: Option<PartitioningBlobURLIssueDetails<'a>>,
2468    #[serde(skip_serializing_if = "Option::is_none")]
2469    navigatorUserAgentIssueDetails: Option<NavigatorUserAgentIssueDetails<'a>>,
2470    #[serde(skip_serializing_if = "Option::is_none")]
2471    genericIssueDetails: Option<GenericIssueDetails<'a>>,
2472    #[serde(skip_serializing_if = "Option::is_none")]
2473    deprecationIssueDetails: Option<DeprecationIssueDetails<'a>>,
2474    #[serde(skip_serializing_if = "Option::is_none")]
2475    clientHintIssueDetails: Option<ClientHintIssueDetails<'a>>,
2476    #[serde(skip_serializing_if = "Option::is_none")]
2477    federatedAuthRequestIssueDetails: Option<FederatedAuthRequestIssueDetails>,
2478    #[serde(skip_serializing_if = "Option::is_none")]
2479    bounceTrackingIssueDetails: Option<BounceTrackingIssueDetails<'a>>,
2480    #[serde(skip_serializing_if = "Option::is_none")]
2481    cookieDeprecationMetadataIssueDetails: Option<CookieDeprecationMetadataIssueDetails<'a>>,
2482    #[serde(skip_serializing_if = "Option::is_none")]
2483    stylesheetLoadingIssueDetails: Option<StylesheetLoadingIssueDetails<'a>>,
2484    #[serde(skip_serializing_if = "Option::is_none")]
2485    propertyRuleIssueDetails: Option<PropertyRuleIssueDetails<'a>>,
2486    #[serde(skip_serializing_if = "Option::is_none")]
2487    federatedAuthUserInfoRequestIssueDetails: Option<FederatedAuthUserInfoRequestIssueDetails>,
2488    #[serde(skip_serializing_if = "Option::is_none")]
2489    sharedDictionaryIssueDetails: Option<SharedDictionaryIssueDetails<'a>>,
2490    #[serde(skip_serializing_if = "Option::is_none")]
2491    elementAccessibilityIssueDetails: Option<ElementAccessibilityIssueDetails>,
2492    #[serde(skip_serializing_if = "Option::is_none")]
2493    sriMessageSignatureIssueDetails: Option<SRIMessageSignatureIssueDetails<'a>>,
2494    #[serde(skip_serializing_if = "Option::is_none")]
2495    unencodedDigestIssueDetails: Option<UnencodedDigestIssueDetails<'a>>,
2496    #[serde(skip_serializing_if = "Option::is_none")]
2497    connectionAllowlistIssueDetails: Option<ConnectionAllowlistIssueDetails<'a>>,
2498    #[serde(skip_serializing_if = "Option::is_none")]
2499    userReidentificationIssueDetails: Option<UserReidentificationIssueDetails<'a>>,
2500    #[serde(skip_serializing_if = "Option::is_none")]
2501    permissionElementIssueDetails: Option<PermissionElementIssueDetails<'a>>,
2502    #[serde(skip_serializing_if = "Option::is_none")]
2503    performanceIssueDetails: Option<PerformanceIssueDetails<'a>>,
2504    #[serde(skip_serializing_if = "Option::is_none")]
2505    selectivePermissionsInterventionIssueDetails: Option<SelectivePermissionsInterventionIssueDetails<'a>>,
2506}
2507
2508impl<'a> InspectorIssueDetails<'a> {
2509    pub fn builder() -> InspectorIssueDetailsBuilder<'a> {
2510        InspectorIssueDetailsBuilder {
2511            cookieIssueDetails: None,
2512            mixedContentIssueDetails: None,
2513            blockedByResponseIssueDetails: None,
2514            heavyAdIssueDetails: None,
2515            contentSecurityPolicyIssueDetails: None,
2516            sharedArrayBufferIssueDetails: None,
2517            corsIssueDetails: None,
2518            attributionReportingIssueDetails: None,
2519            quirksModeIssueDetails: None,
2520            partitioningBlobURLIssueDetails: None,
2521            navigatorUserAgentIssueDetails: None,
2522            genericIssueDetails: None,
2523            deprecationIssueDetails: None,
2524            clientHintIssueDetails: None,
2525            federatedAuthRequestIssueDetails: None,
2526            bounceTrackingIssueDetails: None,
2527            cookieDeprecationMetadataIssueDetails: None,
2528            stylesheetLoadingIssueDetails: None,
2529            propertyRuleIssueDetails: None,
2530            federatedAuthUserInfoRequestIssueDetails: None,
2531            sharedDictionaryIssueDetails: None,
2532            elementAccessibilityIssueDetails: None,
2533            sriMessageSignatureIssueDetails: None,
2534            unencodedDigestIssueDetails: None,
2535            connectionAllowlistIssueDetails: None,
2536            userReidentificationIssueDetails: None,
2537            permissionElementIssueDetails: None,
2538            performanceIssueDetails: None,
2539            selectivePermissionsInterventionIssueDetails: None,
2540        }
2541    }
2542    pub fn cookieIssueDetails(&self) -> Option<&CookieIssueDetails<'a>> { self.cookieIssueDetails.as_ref() }
2543    pub fn mixedContentIssueDetails(&self) -> Option<&MixedContentIssueDetails<'a>> { self.mixedContentIssueDetails.as_ref() }
2544    pub fn blockedByResponseIssueDetails(&self) -> Option<&BlockedByResponseIssueDetails<'a>> { self.blockedByResponseIssueDetails.as_ref() }
2545    pub fn heavyAdIssueDetails(&self) -> Option<&HeavyAdIssueDetails<'a>> { self.heavyAdIssueDetails.as_ref() }
2546    pub fn contentSecurityPolicyIssueDetails(&self) -> Option<&ContentSecurityPolicyIssueDetails<'a>> { self.contentSecurityPolicyIssueDetails.as_ref() }
2547    pub fn sharedArrayBufferIssueDetails(&self) -> Option<&SharedArrayBufferIssueDetails<'a>> { self.sharedArrayBufferIssueDetails.as_ref() }
2548    pub fn corsIssueDetails(&self) -> Option<&CorsIssueDetails<'a>> { self.corsIssueDetails.as_ref() }
2549    pub fn attributionReportingIssueDetails(&self) -> Option<&AttributionReportingIssueDetails<'a>> { self.attributionReportingIssueDetails.as_ref() }
2550    pub fn quirksModeIssueDetails(&self) -> Option<&QuirksModeIssueDetails<'a>> { self.quirksModeIssueDetails.as_ref() }
2551    pub fn partitioningBlobURLIssueDetails(&self) -> Option<&PartitioningBlobURLIssueDetails<'a>> { self.partitioningBlobURLIssueDetails.as_ref() }
2552    pub fn navigatorUserAgentIssueDetails(&self) -> Option<&NavigatorUserAgentIssueDetails<'a>> { self.navigatorUserAgentIssueDetails.as_ref() }
2553    pub fn genericIssueDetails(&self) -> Option<&GenericIssueDetails<'a>> { self.genericIssueDetails.as_ref() }
2554    pub fn deprecationIssueDetails(&self) -> Option<&DeprecationIssueDetails<'a>> { self.deprecationIssueDetails.as_ref() }
2555    pub fn clientHintIssueDetails(&self) -> Option<&ClientHintIssueDetails<'a>> { self.clientHintIssueDetails.as_ref() }
2556    pub fn federatedAuthRequestIssueDetails(&self) -> Option<&FederatedAuthRequestIssueDetails> { self.federatedAuthRequestIssueDetails.as_ref() }
2557    pub fn bounceTrackingIssueDetails(&self) -> Option<&BounceTrackingIssueDetails<'a>> { self.bounceTrackingIssueDetails.as_ref() }
2558    pub fn cookieDeprecationMetadataIssueDetails(&self) -> Option<&CookieDeprecationMetadataIssueDetails<'a>> { self.cookieDeprecationMetadataIssueDetails.as_ref() }
2559    pub fn stylesheetLoadingIssueDetails(&self) -> Option<&StylesheetLoadingIssueDetails<'a>> { self.stylesheetLoadingIssueDetails.as_ref() }
2560    pub fn propertyRuleIssueDetails(&self) -> Option<&PropertyRuleIssueDetails<'a>> { self.propertyRuleIssueDetails.as_ref() }
2561    pub fn federatedAuthUserInfoRequestIssueDetails(&self) -> Option<&FederatedAuthUserInfoRequestIssueDetails> { self.federatedAuthUserInfoRequestIssueDetails.as_ref() }
2562    pub fn sharedDictionaryIssueDetails(&self) -> Option<&SharedDictionaryIssueDetails<'a>> { self.sharedDictionaryIssueDetails.as_ref() }
2563    pub fn elementAccessibilityIssueDetails(&self) -> Option<&ElementAccessibilityIssueDetails> { self.elementAccessibilityIssueDetails.as_ref() }
2564    pub fn sriMessageSignatureIssueDetails(&self) -> Option<&SRIMessageSignatureIssueDetails<'a>> { self.sriMessageSignatureIssueDetails.as_ref() }
2565    pub fn unencodedDigestIssueDetails(&self) -> Option<&UnencodedDigestIssueDetails<'a>> { self.unencodedDigestIssueDetails.as_ref() }
2566    pub fn connectionAllowlistIssueDetails(&self) -> Option<&ConnectionAllowlistIssueDetails<'a>> { self.connectionAllowlistIssueDetails.as_ref() }
2567    pub fn userReidentificationIssueDetails(&self) -> Option<&UserReidentificationIssueDetails<'a>> { self.userReidentificationIssueDetails.as_ref() }
2568    pub fn permissionElementIssueDetails(&self) -> Option<&PermissionElementIssueDetails<'a>> { self.permissionElementIssueDetails.as_ref() }
2569    pub fn performanceIssueDetails(&self) -> Option<&PerformanceIssueDetails<'a>> { self.performanceIssueDetails.as_ref() }
2570    pub fn selectivePermissionsInterventionIssueDetails(&self) -> Option<&SelectivePermissionsInterventionIssueDetails<'a>> { self.selectivePermissionsInterventionIssueDetails.as_ref() }
2571}
2572
2573#[derive(Default)]
2574pub struct InspectorIssueDetailsBuilder<'a> {
2575    cookieIssueDetails: Option<CookieIssueDetails<'a>>,
2576    mixedContentIssueDetails: Option<MixedContentIssueDetails<'a>>,
2577    blockedByResponseIssueDetails: Option<BlockedByResponseIssueDetails<'a>>,
2578    heavyAdIssueDetails: Option<HeavyAdIssueDetails<'a>>,
2579    contentSecurityPolicyIssueDetails: Option<ContentSecurityPolicyIssueDetails<'a>>,
2580    sharedArrayBufferIssueDetails: Option<SharedArrayBufferIssueDetails<'a>>,
2581    corsIssueDetails: Option<CorsIssueDetails<'a>>,
2582    attributionReportingIssueDetails: Option<AttributionReportingIssueDetails<'a>>,
2583    quirksModeIssueDetails: Option<QuirksModeIssueDetails<'a>>,
2584    partitioningBlobURLIssueDetails: Option<PartitioningBlobURLIssueDetails<'a>>,
2585    navigatorUserAgentIssueDetails: Option<NavigatorUserAgentIssueDetails<'a>>,
2586    genericIssueDetails: Option<GenericIssueDetails<'a>>,
2587    deprecationIssueDetails: Option<DeprecationIssueDetails<'a>>,
2588    clientHintIssueDetails: Option<ClientHintIssueDetails<'a>>,
2589    federatedAuthRequestIssueDetails: Option<FederatedAuthRequestIssueDetails>,
2590    bounceTrackingIssueDetails: Option<BounceTrackingIssueDetails<'a>>,
2591    cookieDeprecationMetadataIssueDetails: Option<CookieDeprecationMetadataIssueDetails<'a>>,
2592    stylesheetLoadingIssueDetails: Option<StylesheetLoadingIssueDetails<'a>>,
2593    propertyRuleIssueDetails: Option<PropertyRuleIssueDetails<'a>>,
2594    federatedAuthUserInfoRequestIssueDetails: Option<FederatedAuthUserInfoRequestIssueDetails>,
2595    sharedDictionaryIssueDetails: Option<SharedDictionaryIssueDetails<'a>>,
2596    elementAccessibilityIssueDetails: Option<ElementAccessibilityIssueDetails>,
2597    sriMessageSignatureIssueDetails: Option<SRIMessageSignatureIssueDetails<'a>>,
2598    unencodedDigestIssueDetails: Option<UnencodedDigestIssueDetails<'a>>,
2599    connectionAllowlistIssueDetails: Option<ConnectionAllowlistIssueDetails<'a>>,
2600    userReidentificationIssueDetails: Option<UserReidentificationIssueDetails<'a>>,
2601    permissionElementIssueDetails: Option<PermissionElementIssueDetails<'a>>,
2602    performanceIssueDetails: Option<PerformanceIssueDetails<'a>>,
2603    selectivePermissionsInterventionIssueDetails: Option<SelectivePermissionsInterventionIssueDetails<'a>>,
2604}
2605
2606impl<'a> InspectorIssueDetailsBuilder<'a> {
2607    pub fn cookieIssueDetails(mut self, cookieIssueDetails: CookieIssueDetails<'a>) -> Self { self.cookieIssueDetails = Some(cookieIssueDetails); self }
2608    pub fn mixedContentIssueDetails(mut self, mixedContentIssueDetails: MixedContentIssueDetails<'a>) -> Self { self.mixedContentIssueDetails = Some(mixedContentIssueDetails); self }
2609    pub fn blockedByResponseIssueDetails(mut self, blockedByResponseIssueDetails: BlockedByResponseIssueDetails<'a>) -> Self { self.blockedByResponseIssueDetails = Some(blockedByResponseIssueDetails); self }
2610    pub fn heavyAdIssueDetails(mut self, heavyAdIssueDetails: HeavyAdIssueDetails<'a>) -> Self { self.heavyAdIssueDetails = Some(heavyAdIssueDetails); self }
2611    pub fn contentSecurityPolicyIssueDetails(mut self, contentSecurityPolicyIssueDetails: ContentSecurityPolicyIssueDetails<'a>) -> Self { self.contentSecurityPolicyIssueDetails = Some(contentSecurityPolicyIssueDetails); self }
2612    pub fn sharedArrayBufferIssueDetails(mut self, sharedArrayBufferIssueDetails: SharedArrayBufferIssueDetails<'a>) -> Self { self.sharedArrayBufferIssueDetails = Some(sharedArrayBufferIssueDetails); self }
2613    pub fn corsIssueDetails(mut self, corsIssueDetails: CorsIssueDetails<'a>) -> Self { self.corsIssueDetails = Some(corsIssueDetails); self }
2614    pub fn attributionReportingIssueDetails(mut self, attributionReportingIssueDetails: AttributionReportingIssueDetails<'a>) -> Self { self.attributionReportingIssueDetails = Some(attributionReportingIssueDetails); self }
2615    pub fn quirksModeIssueDetails(mut self, quirksModeIssueDetails: QuirksModeIssueDetails<'a>) -> Self { self.quirksModeIssueDetails = Some(quirksModeIssueDetails); self }
2616    pub fn partitioningBlobURLIssueDetails(mut self, partitioningBlobURLIssueDetails: PartitioningBlobURLIssueDetails<'a>) -> Self { self.partitioningBlobURLIssueDetails = Some(partitioningBlobURLIssueDetails); self }
2617    pub fn navigatorUserAgentIssueDetails(mut self, navigatorUserAgentIssueDetails: NavigatorUserAgentIssueDetails<'a>) -> Self { self.navigatorUserAgentIssueDetails = Some(navigatorUserAgentIssueDetails); self }
2618    pub fn genericIssueDetails(mut self, genericIssueDetails: GenericIssueDetails<'a>) -> Self { self.genericIssueDetails = Some(genericIssueDetails); self }
2619    pub fn deprecationIssueDetails(mut self, deprecationIssueDetails: DeprecationIssueDetails<'a>) -> Self { self.deprecationIssueDetails = Some(deprecationIssueDetails); self }
2620    pub fn clientHintIssueDetails(mut self, clientHintIssueDetails: ClientHintIssueDetails<'a>) -> Self { self.clientHintIssueDetails = Some(clientHintIssueDetails); self }
2621    pub fn federatedAuthRequestIssueDetails(mut self, federatedAuthRequestIssueDetails: FederatedAuthRequestIssueDetails) -> Self { self.federatedAuthRequestIssueDetails = Some(federatedAuthRequestIssueDetails); self }
2622    pub fn bounceTrackingIssueDetails(mut self, bounceTrackingIssueDetails: BounceTrackingIssueDetails<'a>) -> Self { self.bounceTrackingIssueDetails = Some(bounceTrackingIssueDetails); self }
2623    pub fn cookieDeprecationMetadataIssueDetails(mut self, cookieDeprecationMetadataIssueDetails: CookieDeprecationMetadataIssueDetails<'a>) -> Self { self.cookieDeprecationMetadataIssueDetails = Some(cookieDeprecationMetadataIssueDetails); self }
2624    pub fn stylesheetLoadingIssueDetails(mut self, stylesheetLoadingIssueDetails: StylesheetLoadingIssueDetails<'a>) -> Self { self.stylesheetLoadingIssueDetails = Some(stylesheetLoadingIssueDetails); self }
2625    pub fn propertyRuleIssueDetails(mut self, propertyRuleIssueDetails: PropertyRuleIssueDetails<'a>) -> Self { self.propertyRuleIssueDetails = Some(propertyRuleIssueDetails); self }
2626    pub fn federatedAuthUserInfoRequestIssueDetails(mut self, federatedAuthUserInfoRequestIssueDetails: FederatedAuthUserInfoRequestIssueDetails) -> Self { self.federatedAuthUserInfoRequestIssueDetails = Some(federatedAuthUserInfoRequestIssueDetails); self }
2627    pub fn sharedDictionaryIssueDetails(mut self, sharedDictionaryIssueDetails: SharedDictionaryIssueDetails<'a>) -> Self { self.sharedDictionaryIssueDetails = Some(sharedDictionaryIssueDetails); self }
2628    pub fn elementAccessibilityIssueDetails(mut self, elementAccessibilityIssueDetails: ElementAccessibilityIssueDetails) -> Self { self.elementAccessibilityIssueDetails = Some(elementAccessibilityIssueDetails); self }
2629    pub fn sriMessageSignatureIssueDetails(mut self, sriMessageSignatureIssueDetails: SRIMessageSignatureIssueDetails<'a>) -> Self { self.sriMessageSignatureIssueDetails = Some(sriMessageSignatureIssueDetails); self }
2630    pub fn unencodedDigestIssueDetails(mut self, unencodedDigestIssueDetails: UnencodedDigestIssueDetails<'a>) -> Self { self.unencodedDigestIssueDetails = Some(unencodedDigestIssueDetails); self }
2631    pub fn connectionAllowlistIssueDetails(mut self, connectionAllowlistIssueDetails: ConnectionAllowlistIssueDetails<'a>) -> Self { self.connectionAllowlistIssueDetails = Some(connectionAllowlistIssueDetails); self }
2632    pub fn userReidentificationIssueDetails(mut self, userReidentificationIssueDetails: UserReidentificationIssueDetails<'a>) -> Self { self.userReidentificationIssueDetails = Some(userReidentificationIssueDetails); self }
2633    pub fn permissionElementIssueDetails(mut self, permissionElementIssueDetails: PermissionElementIssueDetails<'a>) -> Self { self.permissionElementIssueDetails = Some(permissionElementIssueDetails); self }
2634    pub fn performanceIssueDetails(mut self, performanceIssueDetails: PerformanceIssueDetails<'a>) -> Self { self.performanceIssueDetails = Some(performanceIssueDetails); self }
2635    pub fn selectivePermissionsInterventionIssueDetails(mut self, selectivePermissionsInterventionIssueDetails: SelectivePermissionsInterventionIssueDetails<'a>) -> Self { self.selectivePermissionsInterventionIssueDetails = Some(selectivePermissionsInterventionIssueDetails); self }
2636    pub fn build(self) -> InspectorIssueDetails<'a> {
2637        InspectorIssueDetails {
2638            cookieIssueDetails: self.cookieIssueDetails,
2639            mixedContentIssueDetails: self.mixedContentIssueDetails,
2640            blockedByResponseIssueDetails: self.blockedByResponseIssueDetails,
2641            heavyAdIssueDetails: self.heavyAdIssueDetails,
2642            contentSecurityPolicyIssueDetails: self.contentSecurityPolicyIssueDetails,
2643            sharedArrayBufferIssueDetails: self.sharedArrayBufferIssueDetails,
2644            corsIssueDetails: self.corsIssueDetails,
2645            attributionReportingIssueDetails: self.attributionReportingIssueDetails,
2646            quirksModeIssueDetails: self.quirksModeIssueDetails,
2647            partitioningBlobURLIssueDetails: self.partitioningBlobURLIssueDetails,
2648            navigatorUserAgentIssueDetails: self.navigatorUserAgentIssueDetails,
2649            genericIssueDetails: self.genericIssueDetails,
2650            deprecationIssueDetails: self.deprecationIssueDetails,
2651            clientHintIssueDetails: self.clientHintIssueDetails,
2652            federatedAuthRequestIssueDetails: self.federatedAuthRequestIssueDetails,
2653            bounceTrackingIssueDetails: self.bounceTrackingIssueDetails,
2654            cookieDeprecationMetadataIssueDetails: self.cookieDeprecationMetadataIssueDetails,
2655            stylesheetLoadingIssueDetails: self.stylesheetLoadingIssueDetails,
2656            propertyRuleIssueDetails: self.propertyRuleIssueDetails,
2657            federatedAuthUserInfoRequestIssueDetails: self.federatedAuthUserInfoRequestIssueDetails,
2658            sharedDictionaryIssueDetails: self.sharedDictionaryIssueDetails,
2659            elementAccessibilityIssueDetails: self.elementAccessibilityIssueDetails,
2660            sriMessageSignatureIssueDetails: self.sriMessageSignatureIssueDetails,
2661            unencodedDigestIssueDetails: self.unencodedDigestIssueDetails,
2662            connectionAllowlistIssueDetails: self.connectionAllowlistIssueDetails,
2663            userReidentificationIssueDetails: self.userReidentificationIssueDetails,
2664            permissionElementIssueDetails: self.permissionElementIssueDetails,
2665            performanceIssueDetails: self.performanceIssueDetails,
2666            selectivePermissionsInterventionIssueDetails: self.selectivePermissionsInterventionIssueDetails,
2667        }
2668    }
2669}
2670
2671/// A unique id for a DevTools inspector issue. Allows other entities (e.g.
2672/// exceptions, CDP message, console messages, etc.) to reference an issue.
2673
2674pub type IssueId<'a> = Cow<'a, str>;
2675
2676/// An inspector issue reported from the back-end.
2677
2678#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2679#[serde(rename_all = "camelCase")]
2680pub struct InspectorIssue<'a> {
2681    code: InspectorIssueCode,
2682    details: InspectorIssueDetails<'a>,
2683    /// A unique id for this issue. May be omitted if no other entity (e.g.
2684    /// exception, CDP message, etc.) is referencing this issue.
2685    #[serde(skip_serializing_if = "Option::is_none")]
2686    issueId: Option<IssueId<'a>>,
2687}
2688
2689impl<'a> InspectorIssue<'a> {
2690    pub fn builder(code: InspectorIssueCode, details: InspectorIssueDetails<'a>) -> InspectorIssueBuilder<'a> {
2691        InspectorIssueBuilder {
2692            code: code,
2693            details: details,
2694            issueId: None,
2695        }
2696    }
2697    pub fn code(&self) -> &InspectorIssueCode { &self.code }
2698    pub fn details(&self) -> &InspectorIssueDetails<'a> { &self.details }
2699    pub fn issueId(&self) -> Option<&IssueId<'a>> { self.issueId.as_ref() }
2700}
2701
2702
2703pub struct InspectorIssueBuilder<'a> {
2704    code: InspectorIssueCode,
2705    details: InspectorIssueDetails<'a>,
2706    issueId: Option<IssueId<'a>>,
2707}
2708
2709impl<'a> InspectorIssueBuilder<'a> {
2710    /// A unique id for this issue. May be omitted if no other entity (e.g.
2711    /// exception, CDP message, etc.) is referencing this issue.
2712    pub fn issueId(mut self, issueId: IssueId<'a>) -> Self { self.issueId = Some(issueId); self }
2713    pub fn build(self) -> InspectorIssue<'a> {
2714        InspectorIssue {
2715            code: self.code,
2716            details: self.details,
2717            issueId: self.issueId,
2718        }
2719    }
2720}
2721
2722/// Returns the response body and size if it were re-encoded with the specified settings. Only
2723/// applies to images.
2724
2725#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2726#[serde(rename_all = "camelCase")]
2727pub struct GetEncodedResponseParams<'a> {
2728    /// Identifier of the network request to get content for.
2729    requestId: crate::network::RequestId<'a>,
2730    /// The encoding to use.
2731    encoding: Cow<'a, str>,
2732    /// The quality of the encoding (0-1). (defaults to 1)
2733    #[serde(skip_serializing_if = "Option::is_none")]
2734    quality: Option<f64>,
2735    /// Whether to only return the size information (defaults to false).
2736    #[serde(skip_serializing_if = "Option::is_none")]
2737    sizeOnly: Option<bool>,
2738}
2739
2740impl<'a> GetEncodedResponseParams<'a> {
2741    pub fn builder(requestId: crate::network::RequestId<'a>, encoding: impl Into<Cow<'a, str>>) -> GetEncodedResponseParamsBuilder<'a> {
2742        GetEncodedResponseParamsBuilder {
2743            requestId: requestId,
2744            encoding: encoding.into(),
2745            quality: None,
2746            sizeOnly: None,
2747        }
2748    }
2749    pub fn requestId(&self) -> &crate::network::RequestId<'a> { &self.requestId }
2750    pub fn encoding(&self) -> &str { self.encoding.as_ref() }
2751    pub fn quality(&self) -> Option<f64> { self.quality }
2752    pub fn sizeOnly(&self) -> Option<bool> { self.sizeOnly }
2753}
2754
2755
2756pub struct GetEncodedResponseParamsBuilder<'a> {
2757    requestId: crate::network::RequestId<'a>,
2758    encoding: Cow<'a, str>,
2759    quality: Option<f64>,
2760    sizeOnly: Option<bool>,
2761}
2762
2763impl<'a> GetEncodedResponseParamsBuilder<'a> {
2764    /// The quality of the encoding (0-1). (defaults to 1)
2765    pub fn quality(mut self, quality: f64) -> Self { self.quality = Some(quality); self }
2766    /// Whether to only return the size information (defaults to false).
2767    pub fn sizeOnly(mut self, sizeOnly: bool) -> Self { self.sizeOnly = Some(sizeOnly); self }
2768    pub fn build(self) -> GetEncodedResponseParams<'a> {
2769        GetEncodedResponseParams {
2770            requestId: self.requestId,
2771            encoding: self.encoding,
2772            quality: self.quality,
2773            sizeOnly: self.sizeOnly,
2774        }
2775    }
2776}
2777
2778/// Returns the response body and size if it were re-encoded with the specified settings. Only
2779/// applies to images.
2780
2781#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2782#[serde(rename_all = "camelCase")]
2783pub struct GetEncodedResponseReturns<'a> {
2784    /// The encoded body as a base64 string. Omitted if sizeOnly is true. (Encoded as a base64 string when passed over JSON)
2785    #[serde(skip_serializing_if = "Option::is_none")]
2786    body: Option<Cow<'a, str>>,
2787    /// Size before re-encoding.
2788    originalSize: u64,
2789    /// Size after re-encoding.
2790    encodedSize: u64,
2791}
2792
2793impl<'a> GetEncodedResponseReturns<'a> {
2794    pub fn builder(originalSize: u64, encodedSize: u64) -> GetEncodedResponseReturnsBuilder<'a> {
2795        GetEncodedResponseReturnsBuilder {
2796            body: None,
2797            originalSize: originalSize,
2798            encodedSize: encodedSize,
2799        }
2800    }
2801    pub fn body(&self) -> Option<&str> { self.body.as_deref() }
2802    pub fn originalSize(&self) -> u64 { self.originalSize }
2803    pub fn encodedSize(&self) -> u64 { self.encodedSize }
2804}
2805
2806
2807pub struct GetEncodedResponseReturnsBuilder<'a> {
2808    body: Option<Cow<'a, str>>,
2809    originalSize: u64,
2810    encodedSize: u64,
2811}
2812
2813impl<'a> GetEncodedResponseReturnsBuilder<'a> {
2814    /// The encoded body as a base64 string. Omitted if sizeOnly is true. (Encoded as a base64 string when passed over JSON)
2815    pub fn body(mut self, body: impl Into<Cow<'a, str>>) -> Self { self.body = Some(body.into()); self }
2816    pub fn build(self) -> GetEncodedResponseReturns<'a> {
2817        GetEncodedResponseReturns {
2818            body: self.body,
2819            originalSize: self.originalSize,
2820            encodedSize: self.encodedSize,
2821        }
2822    }
2823}
2824
2825impl<'a> GetEncodedResponseParams<'a> { pub const METHOD: &'static str = "Audits.getEncodedResponse"; }
2826
2827impl<'a> crate::CdpCommand<'a> for GetEncodedResponseParams<'a> {
2828    const METHOD: &'static str = "Audits.getEncodedResponse";
2829    type Response = GetEncodedResponseReturns<'a>;
2830}
2831
2832#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2833pub struct DisableParams {}
2834
2835impl DisableParams { pub const METHOD: &'static str = "Audits.disable"; }
2836
2837impl<'a> crate::CdpCommand<'a> for DisableParams {
2838    const METHOD: &'static str = "Audits.disable";
2839    type Response = crate::EmptyReturns;
2840}
2841
2842#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2843pub struct EnableParams {}
2844
2845impl EnableParams { pub const METHOD: &'static str = "Audits.enable"; }
2846
2847impl<'a> crate::CdpCommand<'a> for EnableParams {
2848    const METHOD: &'static str = "Audits.enable";
2849    type Response = crate::EmptyReturns;
2850}
2851
2852/// Runs the form issues check for the target page. Found issues are reported
2853/// using Audits.issueAdded event.
2854
2855#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2856#[serde(rename_all = "camelCase")]
2857pub struct CheckFormsIssuesReturns<'a> {
2858    formIssues: Vec<GenericIssueDetails<'a>>,
2859}
2860
2861impl<'a> CheckFormsIssuesReturns<'a> {
2862    pub fn builder(formIssues: Vec<GenericIssueDetails<'a>>) -> CheckFormsIssuesReturnsBuilder<'a> {
2863        CheckFormsIssuesReturnsBuilder {
2864            formIssues: formIssues,
2865        }
2866    }
2867    pub fn formIssues(&self) -> &[GenericIssueDetails<'a>] { &self.formIssues }
2868}
2869
2870
2871pub struct CheckFormsIssuesReturnsBuilder<'a> {
2872    formIssues: Vec<GenericIssueDetails<'a>>,
2873}
2874
2875impl<'a> CheckFormsIssuesReturnsBuilder<'a> {
2876    pub fn build(self) -> CheckFormsIssuesReturns<'a> {
2877        CheckFormsIssuesReturns {
2878            formIssues: self.formIssues,
2879        }
2880    }
2881}
2882
2883#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2884pub struct CheckFormsIssuesParams {}
2885
2886impl CheckFormsIssuesParams { pub const METHOD: &'static str = "Audits.checkFormsIssues"; }
2887
2888impl<'a> crate::CdpCommand<'a> for CheckFormsIssuesParams {
2889    const METHOD: &'static str = "Audits.checkFormsIssues";
2890    type Response = CheckFormsIssuesReturns<'a>;
2891}
browser_protocol/audits/mod.rs

browser_protocol/audits/
mod.rs
