1use serde::{Deserialize, Serialize};
2#[doc = "Add handler to promise with given promise object id.\n[awaitPromise](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-awaitPromise)"]
3#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4pub struct AwaitPromiseParams {
5 #[doc = "Identifier of the promise."]
6 #[serde(rename = "promiseObjectId")]
7 pub promise_object_id: super::types::RemoteObjectId,
8 #[doc = "Whether the result is expected to be a JSON object that should be sent by value."]
9 #[serde(rename = "returnByValue")]
10 #[serde(skip_serializing_if = "Option::is_none")]
11 #[serde(default)]
12 pub return_by_value: Option<bool>,
13 #[doc = "Whether preview should be generated for the result."]
14 #[serde(rename = "generatePreview")]
15 #[serde(skip_serializing_if = "Option::is_none")]
16 #[serde(default)]
17 pub generate_preview: Option<bool>,
18}
19impl AwaitPromiseParams {
20 pub fn new(promise_object_id: impl Into<super::types::RemoteObjectId>) -> Self {
21 Self {
22 promise_object_id: promise_object_id.into(),
23 return_by_value: None,
24 generate_preview: None,
25 }
26 }
27}
28#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
29pub enum AwaitPromiseMethod {
30 #[serde(rename = "Runtime.awaitPromise")]
31 AwaitPromise,
32}
33#[doc = "Add handler to promise with given promise object id.\n[awaitPromise](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-awaitPromise)"]
34#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
35pub struct AwaitPromise {
36 pub method: AwaitPromiseMethod,
37 pub params: AwaitPromiseParams,
38}
39impl AwaitPromise {
40 pub const IDENTIFIER: &'static str = "Runtime.awaitPromise";
41 pub fn identifier(&self) -> &'static str {
42 Self::IDENTIFIER
43 }
44}
45impl crate::CommandResult for AwaitPromise {
46 type Result = super::results::AwaitPromiseResult;
47}
48#[doc = "Calls function with given declaration on the given object. Object group of the result is\ninherited from the target object.\n[callFunctionOn](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-callFunctionOn)"]
49#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
50pub struct CallFunctionOnParams {
51 #[doc = "Declaration of the function to call."]
52 #[serde(rename = "functionDeclaration")]
53 pub function_declaration: String,
54 #[doc = "Identifier of the object to call function on. Either objectId or executionContextId should\nbe specified."]
55 #[serde(rename = "objectId")]
56 #[serde(skip_serializing_if = "Option::is_none")]
57 #[serde(default)]
58 pub object_id: Option<super::types::RemoteObjectId>,
59 #[doc = "Call arguments. All call arguments must belong to the same JavaScript world as the target\nobject."]
60 #[serde(rename = "arguments")]
61 #[serde(skip_serializing_if = "Option::is_none")]
62 #[serde(default)]
63 pub arguments: Option<Vec<super::types::CallArgument>>,
64 #[doc = "In silent mode exceptions thrown during evaluation are not reported and do not pause\nexecution. Overrides `setPauseOnException` state."]
65 #[serde(rename = "silent")]
66 #[serde(skip_serializing_if = "Option::is_none")]
67 #[serde(default)]
68 pub silent: Option<bool>,
69 #[doc = "Whether the result is expected to be a JSON object which should be sent by value.\nCan be overriden by `serializationOptions`."]
70 #[serde(rename = "returnByValue")]
71 #[serde(skip_serializing_if = "Option::is_none")]
72 #[serde(default)]
73 pub return_by_value: Option<bool>,
74 #[doc = "Whether preview should be generated for the result."]
75 #[serde(rename = "generatePreview")]
76 #[serde(skip_serializing_if = "Option::is_none")]
77 #[serde(default)]
78 pub generate_preview: Option<bool>,
79 #[doc = "Whether execution should be treated as initiated by user in the UI."]
80 #[serde(rename = "userGesture")]
81 #[serde(skip_serializing_if = "Option::is_none")]
82 #[serde(default)]
83 pub user_gesture: Option<bool>,
84 #[doc = "Whether execution should `await` for resulting value and return once awaited promise is\nresolved."]
85 #[serde(rename = "awaitPromise")]
86 #[serde(skip_serializing_if = "Option::is_none")]
87 #[serde(default)]
88 pub await_promise: Option<bool>,
89 #[doc = "Specifies execution context which global object will be used to call function on. Either\nexecutionContextId or objectId should be specified."]
90 #[serde(rename = "executionContextId")]
91 #[serde(skip_serializing_if = "Option::is_none")]
92 #[serde(default)]
93 pub execution_context_id: Option<super::types::ExecutionContextId>,
94 #[doc = "Symbolic group name that can be used to release multiple objects. If objectGroup is not\nspecified and objectId is, objectGroup will be inherited from object."]
95 #[serde(rename = "objectGroup")]
96 #[serde(skip_serializing_if = "Option::is_none")]
97 #[serde(default)]
98 pub object_group: Option<String>,
99 #[doc = "Whether to throw an exception if side effect cannot be ruled out during evaluation."]
100 #[serde(rename = "throwOnSideEffect")]
101 #[serde(skip_serializing_if = "Option::is_none")]
102 #[serde(default)]
103 pub throw_on_side_effect: Option<bool>,
104 #[doc = "An alternative way to specify the execution context to call function on.\nCompared to contextId that may be reused across processes, this is guaranteed to be\nsystem-unique, so it can be used to prevent accidental function call\nin context different than intended (e.g. as a result of navigation across process\nboundaries).\nThis is mutually exclusive with `executionContextId`."]
105 #[serde(rename = "uniqueContextId")]
106 #[serde(skip_serializing_if = "Option::is_none")]
107 #[serde(default)]
108 pub unique_context_id: Option<String>,
109 #[doc = "Specifies the result serialization. If provided, overrides\n`generatePreview` and `returnByValue`."]
110 #[serde(rename = "serializationOptions")]
111 #[serde(skip_serializing_if = "Option::is_none")]
112 #[serde(default)]
113 pub serialization_options: Option<super::types::SerializationOptions>,
114}
115impl CallFunctionOnParams {
116 pub fn new(function_declaration: impl Into<String>) -> Self {
117 Self {
118 function_declaration: function_declaration.into(),
119 object_id: None,
120 arguments: None,
121 silent: None,
122 return_by_value: None,
123 generate_preview: None,
124 user_gesture: None,
125 await_promise: None,
126 execution_context_id: None,
127 object_group: None,
128 throw_on_side_effect: None,
129 unique_context_id: None,
130 serialization_options: None,
131 }
132 }
133}
134impl<T: Into<String>> From<T> for CallFunctionOnParams {
135 fn from(url: T) -> Self {
136 CallFunctionOnParams::new(url)
137 }
138}
139#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
140pub enum CallFunctionOnMethod {
141 #[serde(rename = "Runtime.callFunctionOn")]
142 CallFunctionOn,
143}
144#[doc = "Calls function with given declaration on the given object. Object group of the result is\ninherited from the target object.\n[callFunctionOn](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-callFunctionOn)"]
145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
146pub struct CallFunctionOn {
147 pub method: CallFunctionOnMethod,
148 pub params: CallFunctionOnParams,
149}
150impl CallFunctionOn {
151 pub const IDENTIFIER: &'static str = "Runtime.callFunctionOn";
152 pub fn identifier(&self) -> &'static str {
153 Self::IDENTIFIER
154 }
155}
156impl crate::CommandResult for CallFunctionOn {
157 type Result = super::results::CallFunctionOnResult;
158}
159#[doc = "Compiles expression.\n[compileScript](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-compileScript)"]
160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
161pub struct CompileScriptParams {
162 #[doc = "Expression to compile."]
163 #[serde(rename = "expression")]
164 pub expression: String,
165 #[doc = "Source url to be set for the script."]
166 #[serde(rename = "sourceURL")]
167 pub source_url: String,
168 #[doc = "Specifies whether the compiled script should be persisted."]
169 #[serde(rename = "persistScript")]
170 pub persist_script: bool,
171 #[doc = "Specifies in which execution context to perform script run. If the parameter is omitted the\nevaluation will be performed in the context of the inspected page."]
172 #[serde(rename = "executionContextId")]
173 #[serde(skip_serializing_if = "Option::is_none")]
174 #[serde(default)]
175 pub execution_context_id: Option<super::types::ExecutionContextId>,
176}
177impl CompileScriptParams {
178 pub fn new(
179 expression: impl Into<String>,
180 source_url: impl Into<String>,
181 persist_script: impl Into<bool>,
182 ) -> Self {
183 Self {
184 expression: expression.into(),
185 source_url: source_url.into(),
186 persist_script: persist_script.into(),
187 execution_context_id: None,
188 }
189 }
190}
191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
192pub enum CompileScriptMethod {
193 #[serde(rename = "Runtime.compileScript")]
194 CompileScript,
195}
196#[doc = "Compiles expression.\n[compileScript](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-compileScript)"]
197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
198pub struct CompileScript {
199 pub method: CompileScriptMethod,
200 pub params: CompileScriptParams,
201}
202impl CompileScript {
203 pub const IDENTIFIER: &'static str = "Runtime.compileScript";
204 pub fn identifier(&self) -> &'static str {
205 Self::IDENTIFIER
206 }
207}
208impl crate::CommandResult for CompileScript {
209 type Result = super::results::CompileScriptResult;
210}
211#[doc = "Disables reporting of execution contexts creation.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-disable)"]
212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
213pub struct DisableParams {}
214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
215pub enum DisableMethod {
216 #[serde(rename = "Runtime.disable")]
217 Disable,
218}
219#[doc = "Disables reporting of execution contexts creation.\n[disable](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-disable)"]
220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
221pub struct Disable {
222 pub method: DisableMethod,
223 pub params: DisableParams,
224}
225impl Disable {
226 pub const IDENTIFIER: &'static str = "Runtime.disable";
227 pub fn identifier(&self) -> &'static str {
228 Self::IDENTIFIER
229 }
230}
231impl crate::CommandResult for Disable {
232 type Result = super::results::DisableResult;
233}
234#[doc = "Discards collected exceptions and console API calls.\n[discardConsoleEntries](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-discardConsoleEntries)"]
235#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
236pub struct DiscardConsoleEntriesParams {}
237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
238pub enum DiscardConsoleEntriesMethod {
239 #[serde(rename = "Runtime.discardConsoleEntries")]
240 DiscardConsoleEntries,
241}
242#[doc = "Discards collected exceptions and console API calls.\n[discardConsoleEntries](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-discardConsoleEntries)"]
243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
244pub struct DiscardConsoleEntries {
245 pub method: DiscardConsoleEntriesMethod,
246 pub params: DiscardConsoleEntriesParams,
247}
248impl DiscardConsoleEntries {
249 pub const IDENTIFIER: &'static str = "Runtime.discardConsoleEntries";
250 pub fn identifier(&self) -> &'static str {
251 Self::IDENTIFIER
252 }
253}
254impl crate::CommandResult for DiscardConsoleEntries {
255 type Result = super::results::DiscardConsoleEntriesResult;
256}
257#[doc = "Enables reporting of execution contexts creation by means of `executionContextCreated` event.\nWhen the reporting gets enabled the event will be sent immediately for each existing execution\ncontext.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-enable)"]
258#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
259pub struct EnableParams {}
260#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
261pub enum EnableMethod {
262 #[serde(rename = "Runtime.enable")]
263 Enable,
264}
265#[doc = "Enables reporting of execution contexts creation by means of `executionContextCreated` event.\nWhen the reporting gets enabled the event will be sent immediately for each existing execution\ncontext.\n[enable](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-enable)"]
266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
267pub struct Enable {
268 pub method: EnableMethod,
269 pub params: EnableParams,
270}
271impl Enable {
272 pub const IDENTIFIER: &'static str = "Runtime.enable";
273 pub fn identifier(&self) -> &'static str {
274 Self::IDENTIFIER
275 }
276}
277impl crate::CommandResult for Enable {
278 type Result = super::results::EnableResult;
279}
280#[doc = "Evaluates expression on global object.\n[evaluate](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-evaluate)"]
281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
282pub struct EvaluateParams {
283 #[doc = "Expression to evaluate."]
284 #[serde(rename = "expression")]
285 pub expression: String,
286 #[doc = "Symbolic group name that can be used to release multiple objects."]
287 #[serde(rename = "objectGroup")]
288 #[serde(skip_serializing_if = "Option::is_none")]
289 #[serde(default)]
290 pub object_group: Option<String>,
291 #[doc = "Determines whether Command Line API should be available during the evaluation."]
292 #[serde(rename = "includeCommandLineAPI")]
293 #[serde(skip_serializing_if = "Option::is_none")]
294 #[serde(default)]
295 pub include_command_line_api: Option<bool>,
296 #[doc = "In silent mode exceptions thrown during evaluation are not reported and do not pause\nexecution. Overrides `setPauseOnException` state."]
297 #[serde(rename = "silent")]
298 #[serde(skip_serializing_if = "Option::is_none")]
299 #[serde(default)]
300 pub silent: Option<bool>,
301 #[doc = "Specifies in which execution context to perform evaluation. If the parameter is omitted the\nevaluation will be performed in the context of the inspected page.\nThis is mutually exclusive with `uniqueContextId`, which offers an\nalternative way to identify the execution context that is more reliable\nin a multi-process environment."]
302 #[serde(rename = "contextId")]
303 #[serde(skip_serializing_if = "Option::is_none")]
304 #[serde(default)]
305 pub context_id: Option<super::types::ExecutionContextId>,
306 #[doc = "Whether the result is expected to be a JSON object that should be sent by value."]
307 #[serde(rename = "returnByValue")]
308 #[serde(skip_serializing_if = "Option::is_none")]
309 #[serde(default)]
310 pub return_by_value: Option<bool>,
311 #[doc = "Whether preview should be generated for the result."]
312 #[serde(rename = "generatePreview")]
313 #[serde(skip_serializing_if = "Option::is_none")]
314 #[serde(default)]
315 pub generate_preview: Option<bool>,
316 #[doc = "Whether execution should be treated as initiated by user in the UI."]
317 #[serde(rename = "userGesture")]
318 #[serde(skip_serializing_if = "Option::is_none")]
319 #[serde(default)]
320 pub user_gesture: Option<bool>,
321 #[doc = "Whether execution should `await` for resulting value and return once awaited promise is\nresolved."]
322 #[serde(rename = "awaitPromise")]
323 #[serde(skip_serializing_if = "Option::is_none")]
324 #[serde(default)]
325 pub await_promise: Option<bool>,
326 #[doc = "Whether to throw an exception if side effect cannot be ruled out during evaluation.\nThis implies `disableBreaks` below."]
327 #[serde(rename = "throwOnSideEffect")]
328 #[serde(skip_serializing_if = "Option::is_none")]
329 #[serde(default)]
330 pub throw_on_side_effect: Option<bool>,
331 #[doc = "Terminate execution after timing out (number of milliseconds)."]
332 #[serde(rename = "timeout")]
333 #[serde(skip_serializing_if = "Option::is_none")]
334 #[serde(default)]
335 pub timeout: Option<super::types::TimeDelta>,
336 #[doc = "Disable breakpoints during execution."]
337 #[serde(rename = "disableBreaks")]
338 #[serde(skip_serializing_if = "Option::is_none")]
339 #[serde(default)]
340 pub disable_breaks: Option<bool>,
341 #[doc = "Setting this flag to true enables `let` re-declaration and top-level `await`.\nNote that `let` variables can only be re-declared if they originate from\n`replMode` themselves."]
342 #[serde(rename = "replMode")]
343 #[serde(skip_serializing_if = "Option::is_none")]
344 #[serde(default)]
345 pub repl_mode: Option<bool>,
346 #[doc = "The Content Security Policy (CSP) for the target might block 'unsafe-eval'\nwhich includes eval(), Function(), setTimeout() and setInterval()\nwhen called with non-callable arguments. This flag bypasses CSP for this\nevaluation and allows unsafe-eval. Defaults to true."]
347 #[serde(rename = "allowUnsafeEvalBlockedByCSP")]
348 #[serde(skip_serializing_if = "Option::is_none")]
349 #[serde(default)]
350 pub allow_unsafe_eval_blocked_by_csp: Option<bool>,
351 #[doc = "An alternative way to specify the execution context to evaluate in.\nCompared to contextId that may be reused across processes, this is guaranteed to be\nsystem-unique, so it can be used to prevent accidental evaluation of the expression\nin context different than intended (e.g. as a result of navigation across process\nboundaries).\nThis is mutually exclusive with `contextId`."]
352 #[serde(rename = "uniqueContextId")]
353 #[serde(skip_serializing_if = "Option::is_none")]
354 #[serde(default)]
355 pub unique_context_id: Option<String>,
356 #[doc = "Specifies the result serialization. If provided, overrides\n`generatePreview` and `returnByValue`."]
357 #[serde(rename = "serializationOptions")]
358 #[serde(skip_serializing_if = "Option::is_none")]
359 #[serde(default)]
360 pub serialization_options: Option<super::types::SerializationOptions>,
361}
362impl EvaluateParams {
363 pub fn new(expression: impl Into<String>) -> Self {
364 Self {
365 expression: expression.into(),
366 object_group: None,
367 include_command_line_api: None,
368 silent: None,
369 context_id: None,
370 return_by_value: None,
371 generate_preview: None,
372 user_gesture: None,
373 await_promise: None,
374 throw_on_side_effect: None,
375 timeout: None,
376 disable_breaks: None,
377 repl_mode: None,
378 allow_unsafe_eval_blocked_by_csp: None,
379 unique_context_id: None,
380 serialization_options: None,
381 }
382 }
383}
384impl<T: Into<String>> From<T> for EvaluateParams {
385 fn from(url: T) -> Self {
386 EvaluateParams::new(url)
387 }
388}
389#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
390pub enum EvaluateMethod {
391 #[serde(rename = "Runtime.evaluate")]
392 Evaluate,
393}
394#[doc = "Evaluates expression on global object.\n[evaluate](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-evaluate)"]
395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
396pub struct Evaluate {
397 pub method: EvaluateMethod,
398 pub params: EvaluateParams,
399}
400impl Evaluate {
401 pub const IDENTIFIER: &'static str = "Runtime.evaluate";
402 pub fn identifier(&self) -> &'static str {
403 Self::IDENTIFIER
404 }
405}
406impl crate::CommandResult for Evaluate {
407 type Result = super::results::EvaluateResult;
408}
409#[doc = "Returns the isolate id.\n[getIsolateId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getIsolateId)"]
410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
411pub struct GetIsolateIdParams {}
412#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
413pub enum GetIsolateIdMethod {
414 #[serde(rename = "Runtime.getIsolateId")]
415 GetIsolateId,
416}
417#[doc = "Returns the isolate id.\n[getIsolateId](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getIsolateId)"]
418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
419pub struct GetIsolateId {
420 pub method: GetIsolateIdMethod,
421 pub params: GetIsolateIdParams,
422}
423impl GetIsolateId {
424 pub const IDENTIFIER: &'static str = "Runtime.getIsolateId";
425 pub fn identifier(&self) -> &'static str {
426 Self::IDENTIFIER
427 }
428}
429impl crate::CommandResult for GetIsolateId {
430 type Result = super::results::GetIsolateIdResult;
431}
432#[doc = "Returns the JavaScript heap usage.\nIt is the total usage of the corresponding isolate not scoped to a particular Runtime.\n[getHeapUsage](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getHeapUsage)"]
433#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
434pub struct GetHeapUsageParams {}
435#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
436pub enum GetHeapUsageMethod {
437 #[serde(rename = "Runtime.getHeapUsage")]
438 GetHeapUsage,
439}
440#[doc = "Returns the JavaScript heap usage.\nIt is the total usage of the corresponding isolate not scoped to a particular Runtime.\n[getHeapUsage](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getHeapUsage)"]
441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
442pub struct GetHeapUsage {
443 pub method: GetHeapUsageMethod,
444 pub params: GetHeapUsageParams,
445}
446impl GetHeapUsage {
447 pub const IDENTIFIER: &'static str = "Runtime.getHeapUsage";
448 pub fn identifier(&self) -> &'static str {
449 Self::IDENTIFIER
450 }
451}
452impl crate::CommandResult for GetHeapUsage {
453 type Result = super::results::GetHeapUsageResult;
454}
455#[doc = "Returns properties of a given object. Object group of the result is inherited from the target\nobject.\n[getProperties](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getProperties)"]
456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
457pub struct GetPropertiesParams {
458 #[doc = "Identifier of the object to return properties for."]
459 #[serde(rename = "objectId")]
460 pub object_id: super::types::RemoteObjectId,
461 #[doc = "If true, returns properties belonging only to the element itself, not to its prototype\nchain."]
462 #[serde(rename = "ownProperties")]
463 #[serde(skip_serializing_if = "Option::is_none")]
464 #[serde(default)]
465 pub own_properties: Option<bool>,
466 #[doc = "If true, returns accessor properties (with getter/setter) only; internal properties are not\nreturned either."]
467 #[serde(rename = "accessorPropertiesOnly")]
468 #[serde(skip_serializing_if = "Option::is_none")]
469 #[serde(default)]
470 pub accessor_properties_only: Option<bool>,
471 #[doc = "Whether preview should be generated for the results."]
472 #[serde(rename = "generatePreview")]
473 #[serde(skip_serializing_if = "Option::is_none")]
474 #[serde(default)]
475 pub generate_preview: Option<bool>,
476 #[doc = "If true, returns non-indexed properties only."]
477 #[serde(rename = "nonIndexedPropertiesOnly")]
478 #[serde(skip_serializing_if = "Option::is_none")]
479 #[serde(default)]
480 pub non_indexed_properties_only: Option<bool>,
481}
482impl GetPropertiesParams {
483 pub fn new(object_id: impl Into<super::types::RemoteObjectId>) -> Self {
484 Self {
485 object_id: object_id.into(),
486 own_properties: None,
487 accessor_properties_only: None,
488 generate_preview: None,
489 non_indexed_properties_only: None,
490 }
491 }
492}
493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
494pub enum GetPropertiesMethod {
495 #[serde(rename = "Runtime.getProperties")]
496 GetProperties,
497}
498#[doc = "Returns properties of a given object. Object group of the result is inherited from the target\nobject.\n[getProperties](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getProperties)"]
499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
500pub struct GetProperties {
501 pub method: GetPropertiesMethod,
502 pub params: GetPropertiesParams,
503}
504impl GetProperties {
505 pub const IDENTIFIER: &'static str = "Runtime.getProperties";
506 pub fn identifier(&self) -> &'static str {
507 Self::IDENTIFIER
508 }
509}
510impl crate::CommandResult for GetProperties {
511 type Result = super::results::GetPropertiesResult;
512}
513#[doc = "Returns all let, const and class variables from global scope.\n[globalLexicalScopeNames](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-globalLexicalScopeNames)"]
514#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
515pub struct GlobalLexicalScopeNamesParams {
516 #[doc = "Specifies in which execution context to lookup global scope variables."]
517 #[serde(rename = "executionContextId")]
518 #[serde(skip_serializing_if = "Option::is_none")]
519 #[serde(default)]
520 pub execution_context_id: Option<super::types::ExecutionContextId>,
521}
522#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
523pub enum GlobalLexicalScopeNamesMethod {
524 #[serde(rename = "Runtime.globalLexicalScopeNames")]
525 GlobalLexicalScopeNames,
526}
527#[doc = "Returns all let, const and class variables from global scope.\n[globalLexicalScopeNames](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-globalLexicalScopeNames)"]
528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
529pub struct GlobalLexicalScopeNames {
530 pub method: GlobalLexicalScopeNamesMethod,
531 pub params: GlobalLexicalScopeNamesParams,
532}
533impl GlobalLexicalScopeNames {
534 pub const IDENTIFIER: &'static str = "Runtime.globalLexicalScopeNames";
535 pub fn identifier(&self) -> &'static str {
536 Self::IDENTIFIER
537 }
538}
539impl crate::CommandResult for GlobalLexicalScopeNames {
540 type Result = super::results::GlobalLexicalScopeNamesResult;
541}
542#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
543pub struct QueryObjectsParams {
544 #[doc = "Identifier of the prototype to return objects for."]
545 #[serde(rename = "prototypeObjectId")]
546 pub prototype_object_id: super::types::RemoteObjectId,
547 #[doc = "Symbolic group name that can be used to release the results."]
548 #[serde(rename = "objectGroup")]
549 #[serde(skip_serializing_if = "Option::is_none")]
550 #[serde(default)]
551 pub object_group: Option<String>,
552}
553impl QueryObjectsParams {
554 pub fn new(prototype_object_id: impl Into<super::types::RemoteObjectId>) -> Self {
555 Self {
556 prototype_object_id: prototype_object_id.into(),
557 object_group: None,
558 }
559 }
560}
561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
562pub enum QueryObjectsMethod {
563 #[serde(rename = "Runtime.queryObjects")]
564 QueryObjects,
565}
566#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
567pub struct QueryObjects {
568 pub method: QueryObjectsMethod,
569 pub params: QueryObjectsParams,
570}
571impl QueryObjects {
572 pub const IDENTIFIER: &'static str = "Runtime.queryObjects";
573 pub fn identifier(&self) -> &'static str {
574 Self::IDENTIFIER
575 }
576}
577impl crate::CommandResult for QueryObjects {
578 type Result = super::results::QueryObjectsResult;
579}
580#[doc = "Releases remote object with given id.\n[releaseObject](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-releaseObject)"]
581#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
582pub struct ReleaseObjectParams {
583 #[doc = "Identifier of the object to release."]
584 #[serde(rename = "objectId")]
585 pub object_id: super::types::RemoteObjectId,
586}
587impl ReleaseObjectParams {
588 pub fn new(object_id: impl Into<super::types::RemoteObjectId>) -> Self {
589 Self {
590 object_id: object_id.into(),
591 }
592 }
593}
594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
595pub enum ReleaseObjectMethod {
596 #[serde(rename = "Runtime.releaseObject")]
597 ReleaseObject,
598}
599#[doc = "Releases remote object with given id.\n[releaseObject](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-releaseObject)"]
600#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
601pub struct ReleaseObject {
602 pub method: ReleaseObjectMethod,
603 pub params: ReleaseObjectParams,
604}
605impl ReleaseObject {
606 pub const IDENTIFIER: &'static str = "Runtime.releaseObject";
607 pub fn identifier(&self) -> &'static str {
608 Self::IDENTIFIER
609 }
610}
611impl crate::CommandResult for ReleaseObject {
612 type Result = super::results::ReleaseObjectResult;
613}
614#[doc = "Releases all remote objects that belong to a given group.\n[releaseObjectGroup](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-releaseObjectGroup)"]
615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
616pub struct ReleaseObjectGroupParams {
617 #[doc = "Symbolic object group name."]
618 #[serde(rename = "objectGroup")]
619 pub object_group: String,
620}
621impl ReleaseObjectGroupParams {
622 pub fn new(object_group: impl Into<String>) -> Self {
623 Self {
624 object_group: object_group.into(),
625 }
626 }
627}
628impl<T: Into<String>> From<T> for ReleaseObjectGroupParams {
629 fn from(url: T) -> Self {
630 ReleaseObjectGroupParams::new(url)
631 }
632}
633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
634pub enum ReleaseObjectGroupMethod {
635 #[serde(rename = "Runtime.releaseObjectGroup")]
636 ReleaseObjectGroup,
637}
638#[doc = "Releases all remote objects that belong to a given group.\n[releaseObjectGroup](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-releaseObjectGroup)"]
639#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
640pub struct ReleaseObjectGroup {
641 pub method: ReleaseObjectGroupMethod,
642 pub params: ReleaseObjectGroupParams,
643}
644impl ReleaseObjectGroup {
645 pub const IDENTIFIER: &'static str = "Runtime.releaseObjectGroup";
646 pub fn identifier(&self) -> &'static str {
647 Self::IDENTIFIER
648 }
649}
650impl crate::CommandResult for ReleaseObjectGroup {
651 type Result = super::results::ReleaseObjectGroupResult;
652}
653#[doc = "Tells inspected instance to run if it was waiting for debugger to attach.\n[runIfWaitingForDebugger](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-runIfWaitingForDebugger)"]
654#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
655pub struct RunIfWaitingForDebuggerParams {}
656#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
657pub enum RunIfWaitingForDebuggerMethod {
658 #[serde(rename = "Runtime.runIfWaitingForDebugger")]
659 RunIfWaitingForDebugger,
660}
661#[doc = "Tells inspected instance to run if it was waiting for debugger to attach.\n[runIfWaitingForDebugger](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-runIfWaitingForDebugger)"]
662#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
663pub struct RunIfWaitingForDebugger {
664 pub method: RunIfWaitingForDebuggerMethod,
665 pub params: RunIfWaitingForDebuggerParams,
666}
667impl RunIfWaitingForDebugger {
668 pub const IDENTIFIER: &'static str = "Runtime.runIfWaitingForDebugger";
669 pub fn identifier(&self) -> &'static str {
670 Self::IDENTIFIER
671 }
672}
673impl crate::CommandResult for RunIfWaitingForDebugger {
674 type Result = super::results::RunIfWaitingForDebuggerResult;
675}
676#[doc = "Runs script with given id in a given context.\n[runScript](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-runScript)"]
677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
678pub struct RunScriptParams {
679 #[doc = "Id of the script to run."]
680 #[serde(rename = "scriptId")]
681 pub script_id: super::types::ScriptId,
682 #[doc = "Specifies in which execution context to perform script run. If the parameter is omitted the\nevaluation will be performed in the context of the inspected page."]
683 #[serde(rename = "executionContextId")]
684 #[serde(skip_serializing_if = "Option::is_none")]
685 #[serde(default)]
686 pub execution_context_id: Option<super::types::ExecutionContextId>,
687 #[doc = "Symbolic group name that can be used to release multiple objects."]
688 #[serde(rename = "objectGroup")]
689 #[serde(skip_serializing_if = "Option::is_none")]
690 #[serde(default)]
691 pub object_group: Option<String>,
692 #[doc = "In silent mode exceptions thrown during evaluation are not reported and do not pause\nexecution. Overrides `setPauseOnException` state."]
693 #[serde(rename = "silent")]
694 #[serde(skip_serializing_if = "Option::is_none")]
695 #[serde(default)]
696 pub silent: Option<bool>,
697 #[doc = "Determines whether Command Line API should be available during the evaluation."]
698 #[serde(rename = "includeCommandLineAPI")]
699 #[serde(skip_serializing_if = "Option::is_none")]
700 #[serde(default)]
701 pub include_command_line_api: Option<bool>,
702 #[doc = "Whether the result is expected to be a JSON object which should be sent by value."]
703 #[serde(rename = "returnByValue")]
704 #[serde(skip_serializing_if = "Option::is_none")]
705 #[serde(default)]
706 pub return_by_value: Option<bool>,
707 #[doc = "Whether preview should be generated for the result."]
708 #[serde(rename = "generatePreview")]
709 #[serde(skip_serializing_if = "Option::is_none")]
710 #[serde(default)]
711 pub generate_preview: Option<bool>,
712 #[doc = "Whether execution should `await` for resulting value and return once awaited promise is\nresolved."]
713 #[serde(rename = "awaitPromise")]
714 #[serde(skip_serializing_if = "Option::is_none")]
715 #[serde(default)]
716 pub await_promise: Option<bool>,
717}
718impl RunScriptParams {
719 pub fn new(script_id: impl Into<super::types::ScriptId>) -> Self {
720 Self {
721 script_id: script_id.into(),
722 execution_context_id: None,
723 object_group: None,
724 silent: None,
725 include_command_line_api: None,
726 return_by_value: None,
727 generate_preview: None,
728 await_promise: None,
729 }
730 }
731}
732#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
733pub enum RunScriptMethod {
734 #[serde(rename = "Runtime.runScript")]
735 RunScript,
736}
737#[doc = "Runs script with given id in a given context.\n[runScript](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-runScript)"]
738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
739pub struct RunScript {
740 pub method: RunScriptMethod,
741 pub params: RunScriptParams,
742}
743impl RunScript {
744 pub const IDENTIFIER: &'static str = "Runtime.runScript";
745 pub fn identifier(&self) -> &'static str {
746 Self::IDENTIFIER
747 }
748}
749impl crate::CommandResult for RunScript {
750 type Result = super::results::RunScriptResult;
751}
752#[doc = "Enables or disables async call stacks tracking.\n[setAsyncCallStackDepth](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-setAsyncCallStackDepth)"]
753#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
754pub struct SetAsyncCallStackDepthParams {
755 #[doc = "Maximum depth of async call stacks. Setting to `0` will effectively disable collecting async\ncall stacks (default)."]
756 #[serde(rename = "maxDepth")]
757 pub max_depth: i64,
758}
759impl SetAsyncCallStackDepthParams {
760 pub fn new(max_depth: impl Into<i64>) -> Self {
761 Self {
762 max_depth: max_depth.into(),
763 }
764 }
765}
766#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
767pub enum SetAsyncCallStackDepthMethod {
768 #[serde(rename = "Runtime.setAsyncCallStackDepth")]
769 SetAsyncCallStackDepth,
770}
771#[doc = "Enables or disables async call stacks tracking.\n[setAsyncCallStackDepth](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-setAsyncCallStackDepth)"]
772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
773pub struct SetAsyncCallStackDepth {
774 pub method: SetAsyncCallStackDepthMethod,
775 pub params: SetAsyncCallStackDepthParams,
776}
777impl SetAsyncCallStackDepth {
778 pub const IDENTIFIER: &'static str = "Runtime.setAsyncCallStackDepth";
779 pub fn identifier(&self) -> &'static str {
780 Self::IDENTIFIER
781 }
782}
783impl crate::CommandResult for SetAsyncCallStackDepth {
784 type Result = super::results::SetAsyncCallStackDepthResult;
785}
786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
787pub struct SetCustomObjectFormatterEnabledParams {
788 #[serde(rename = "enabled")]
789 pub enabled: bool,
790}
791impl SetCustomObjectFormatterEnabledParams {
792 pub fn new(enabled: impl Into<bool>) -> Self {
793 Self {
794 enabled: enabled.into(),
795 }
796 }
797}
798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
799pub enum SetCustomObjectFormatterEnabledMethod {
800 #[serde(rename = "Runtime.setCustomObjectFormatterEnabled")]
801 SetCustomObjectFormatterEnabled,
802}
803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
804pub struct SetCustomObjectFormatterEnabled {
805 pub method: SetCustomObjectFormatterEnabledMethod,
806 pub params: SetCustomObjectFormatterEnabledParams,
807}
808impl SetCustomObjectFormatterEnabled {
809 pub const IDENTIFIER: &'static str = "Runtime.setCustomObjectFormatterEnabled";
810 pub fn identifier(&self) -> &'static str {
811 Self::IDENTIFIER
812 }
813}
814impl crate::CommandResult for SetCustomObjectFormatterEnabled {
815 type Result = super::results::SetCustomObjectFormatterEnabledResult;
816}
817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
818pub struct SetMaxCallStackSizeToCaptureParams {
819 #[serde(rename = "size")]
820 pub size: i64,
821}
822impl SetMaxCallStackSizeToCaptureParams {
823 pub fn new(size: impl Into<i64>) -> Self {
824 Self { size: size.into() }
825 }
826}
827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
828pub enum SetMaxCallStackSizeToCaptureMethod {
829 #[serde(rename = "Runtime.setMaxCallStackSizeToCapture")]
830 SetMaxCallStackSizeToCapture,
831}
832#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
833pub struct SetMaxCallStackSizeToCapture {
834 pub method: SetMaxCallStackSizeToCaptureMethod,
835 pub params: SetMaxCallStackSizeToCaptureParams,
836}
837impl SetMaxCallStackSizeToCapture {
838 pub const IDENTIFIER: &'static str = "Runtime.setMaxCallStackSizeToCapture";
839 pub fn identifier(&self) -> &'static str {
840 Self::IDENTIFIER
841 }
842}
843impl crate::CommandResult for SetMaxCallStackSizeToCapture {
844 type Result = super::results::SetMaxCallStackSizeToCaptureResult;
845}
846#[doc = "Terminate current or next JavaScript execution.\nWill cancel the termination when the outer-most script execution ends.\n[terminateExecution](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-terminateExecution)"]
847#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
848pub struct TerminateExecutionParams {}
849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
850pub enum TerminateExecutionMethod {
851 #[serde(rename = "Runtime.terminateExecution")]
852 TerminateExecution,
853}
854#[doc = "Terminate current or next JavaScript execution.\nWill cancel the termination when the outer-most script execution ends.\n[terminateExecution](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-terminateExecution)"]
855#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
856pub struct TerminateExecution {
857 pub method: TerminateExecutionMethod,
858 pub params: TerminateExecutionParams,
859}
860impl TerminateExecution {
861 pub const IDENTIFIER: &'static str = "Runtime.terminateExecution";
862 pub fn identifier(&self) -> &'static str {
863 Self::IDENTIFIER
864 }
865}
866impl crate::CommandResult for TerminateExecution {
867 type Result = super::results::TerminateExecutionResult;
868}
869#[doc = "If executionContextId is empty, adds binding with the given name on the\nglobal objects of all inspected contexts, including those created later,\nbindings survive reloads.\nBinding function takes exactly one argument, this argument should be string,\nin case of any other input, function throws an exception.\nEach binding function call produces Runtime.bindingCalled notification.\n[addBinding](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-addBinding)"]
870#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
871pub struct AddBindingParams {
872 #[serde(rename = "name")]
873 pub name: String,
874 #[doc = "If specified, the binding is exposed to the executionContext with\nmatching name, even for contexts created after the binding is added.\nSee also `ExecutionContext.name` and `worldName` parameter to\n`Page.addScriptToEvaluateOnNewDocument`.\nThis parameter is mutually exclusive with `executionContextId`."]
875 #[serde(rename = "executionContextName")]
876 #[serde(skip_serializing_if = "Option::is_none")]
877 #[serde(default)]
878 pub execution_context_name: Option<String>,
879}
880impl AddBindingParams {
881 pub fn new(name: impl Into<String>) -> Self {
882 Self {
883 name: name.into(),
884 execution_context_name: None,
885 }
886 }
887}
888impl<T: Into<String>> From<T> for AddBindingParams {
889 fn from(url: T) -> Self {
890 AddBindingParams::new(url)
891 }
892}
893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
894pub enum AddBindingMethod {
895 #[serde(rename = "Runtime.addBinding")]
896 AddBinding,
897}
898#[doc = "If executionContextId is empty, adds binding with the given name on the\nglobal objects of all inspected contexts, including those created later,\nbindings survive reloads.\nBinding function takes exactly one argument, this argument should be string,\nin case of any other input, function throws an exception.\nEach binding function call produces Runtime.bindingCalled notification.\n[addBinding](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-addBinding)"]
899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
900pub struct AddBinding {
901 pub method: AddBindingMethod,
902 pub params: AddBindingParams,
903}
904impl AddBinding {
905 pub const IDENTIFIER: &'static str = "Runtime.addBinding";
906 pub fn identifier(&self) -> &'static str {
907 Self::IDENTIFIER
908 }
909}
910impl crate::CommandResult for AddBinding {
911 type Result = super::results::AddBindingResult;
912}
913#[doc = "This method does not remove binding function from global object but\nunsubscribes current runtime agent from Runtime.bindingCalled notifications.\n[removeBinding](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-removeBinding)"]
914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
915pub struct RemoveBindingParams {
916 #[serde(rename = "name")]
917 pub name: String,
918}
919impl RemoveBindingParams {
920 pub fn new(name: impl Into<String>) -> Self {
921 Self { name: name.into() }
922 }
923}
924impl<T: Into<String>> From<T> for RemoveBindingParams {
925 fn from(url: T) -> Self {
926 RemoveBindingParams::new(url)
927 }
928}
929#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
930pub enum RemoveBindingMethod {
931 #[serde(rename = "Runtime.removeBinding")]
932 RemoveBinding,
933}
934#[doc = "This method does not remove binding function from global object but\nunsubscribes current runtime agent from Runtime.bindingCalled notifications.\n[removeBinding](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-removeBinding)"]
935#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
936pub struct RemoveBinding {
937 pub method: RemoveBindingMethod,
938 pub params: RemoveBindingParams,
939}
940impl RemoveBinding {
941 pub const IDENTIFIER: &'static str = "Runtime.removeBinding";
942 pub fn identifier(&self) -> &'static str {
943 Self::IDENTIFIER
944 }
945}
946impl crate::CommandResult for RemoveBinding {
947 type Result = super::results::RemoveBindingResult;
948}
949#[doc = "This method tries to lookup and populate exception details for a\nJavaScript Error object.\nNote that the stackTrace portion of the resulting exceptionDetails will\nonly be populated if the Runtime domain was enabled at the time when the\nError was thrown.\n[getExceptionDetails](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getExceptionDetails)"]
950#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
951pub struct GetExceptionDetailsParams {
952 #[doc = "The error object for which to resolve the exception details."]
953 #[serde(rename = "errorObjectId")]
954 pub error_object_id: super::types::RemoteObjectId,
955}
956impl GetExceptionDetailsParams {
957 pub fn new(error_object_id: impl Into<super::types::RemoteObjectId>) -> Self {
958 Self {
959 error_object_id: error_object_id.into(),
960 }
961 }
962}
963#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
964pub enum GetExceptionDetailsMethod {
965 #[serde(rename = "Runtime.getExceptionDetails")]
966 GetExceptionDetails,
967}
968#[doc = "This method tries to lookup and populate exception details for a\nJavaScript Error object.\nNote that the stackTrace portion of the resulting exceptionDetails will\nonly be populated if the Runtime domain was enabled at the time when the\nError was thrown.\n[getExceptionDetails](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-getExceptionDetails)"]
969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
970pub struct GetExceptionDetails {
971 pub method: GetExceptionDetailsMethod,
972 pub params: GetExceptionDetailsParams,
973}
974impl GetExceptionDetails {
975 pub const IDENTIFIER: &'static str = "Runtime.getExceptionDetails";
976 pub fn identifier(&self) -> &'static str {
977 Self::IDENTIFIER
978 }
979}
980impl crate::CommandResult for GetExceptionDetails {
981 type Result = super::results::GetExceptionDetailsResult;
982}
983group_enum ! (RuntimeCommands { AwaitPromise (AwaitPromise) , CallFunctionOn (CallFunctionOn) , CompileScript (CompileScript) , Disable (Disable) , DiscardConsoleEntries (DiscardConsoleEntries) , Enable (Enable) , Evaluate (Evaluate) , GetIsolateId (GetIsolateId) , GetHeapUsage (GetHeapUsage) , GetProperties (GetProperties) , GlobalLexicalScopeNames (GlobalLexicalScopeNames) , QueryObjects (QueryObjects) , ReleaseObject (ReleaseObject) , ReleaseObjectGroup (ReleaseObjectGroup) , RunIfWaitingForDebugger (RunIfWaitingForDebugger) , RunScript (RunScript) , SetAsyncCallStackDepth (SetAsyncCallStackDepth) , SetCustomObjectFormatterEnabled (SetCustomObjectFormatterEnabled) , SetMaxCallStackSizeToCapture (SetMaxCallStackSizeToCapture) , TerminateExecution (TerminateExecution) , AddBinding (AddBinding) , RemoveBinding (RemoveBinding) , GetExceptionDetails (GetExceptionDetails) } + identifiable);