use std::collections::BTreeMap;
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use crate::model::{
CausalEvent, ImageImportResponse, Recording, RecordingDetail, RecordingStopOutput,
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecipeRecordingStartOperation {
pub name: String,
#[serde(default)]
pub replace: bool,
#[serde(default)]
pub global: bool,
#[serde(default)]
pub cwd: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for RecipeRecordingStartOperation {
const METHOD: &'static str = "recording.start";
type Response = Recording;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecipeRecordingGetOperation {
pub id: String,
}
impl DaemonOperation for RecipeRecordingGetOperation {
const METHOD: &'static str = "recording.get";
type Response = RecordingDetail;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RecipeRecordingStopOperation {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub suggest: bool,
#[serde(default)]
pub skip: Vec<String>,
#[serde(default)]
pub ttl_ms: Option<u64>,
#[serde(default)]
pub replace: bool,
#[serde(default)]
pub global: bool,
#[serde(default)]
pub cwd: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for RecipeRecordingStopOperation {
const METHOD: &'static str = "recording.stop";
type Response = RecordingStopOutput;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImageImportOperation {
pub source: String,
pub idempotency_key: String,
}
impl DaemonOperation for ImageImportOperation {
const METHOD: &'static str = "execution.image.import";
type Response = ImageImportResponse;
}
use crate::debugger::{
AppleAttachResolution, AppleAttachResult, AppleDeviceApp, AppleDeviceTarget, BrowserCookie,
BrowserCoverageSnapshot, BrowserDomNode, BrowserInteraction, BrowserMetric, BrowserMockRule,
BrowserNavigation, BrowserNetworkBody, BrowserNetworkRequest, BrowserPageEvent,
BrowserScreenshot, BrowserStorageEntry, BrowserStyle, BrowserWebSocketFrame, DapInstruction,
DapMemory, DapModule, DapRegister, DapSessionState, DapSignal, DapThread, DapWatchpoint,
DebuggerAfter, DebuggerBreakpoint, DebuggerBrowserState, DebuggerCapture, DebuggerConsoleEntry,
DebuggerEvaluation, DebuggerEvent, DebuggerEvidenceTrace, DebuggerEvidenceTraceView,
DebuggerExceptionEntry, DebuggerFlow, DebuggerFlowRun, DebuggerFlowView, DebuggerFrame,
DebuggerHealth, DebuggerListener, DebuggerMark, DebuggerProperty, DebuggerPrototype,
DebuggerRecording, DebuggerRecordingStart, DebuggerReplay, DebuggerRunResult, DebuggerScope,
DebuggerScript, DebuggerSelection, DebuggerSessionRecord, DebuggerSessionView, DebuggerSource,
DebuggerTap, DebuggerTapHit, DebuggerTarget, DebuggerTimeline, DebuggerTraceCursor,
DebuggerTraceEntry, DebuggerTraceExport, DebuggerTraceGc, DebuggerTraceImport,
DebuggerTraceReplayResult, DebuggerVariable, DebuggerWatch, DebuggerWatchHit, DebuggerWhy,
ExtensionAttachResult, ExtensionCdpResult, ExtensionDoctor, ExtensionEvaluation,
ExtensionEvent, ExtensionHostInstallation, ExtensionObserveResult, ExtensionSnapshotResult,
ExtensionStatusView, ExtensionTab, LegacyDebuggerIndexStatus, LegacyDebuggerMigration,
LegacyDebuggerQuery, RrExecutionResult, RrProcessStatus, RrTrace,
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerLegacyImportOperation {
pub source: String,
#[serde(default)]
pub index: Option<String>,
#[serde(default)]
pub artifacts: Vec<String>,
pub replace: bool,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerLegacyImportOperation {
const METHOD: &'static str = "debugger.legacy.import";
type Response = LegacyDebuggerMigration;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerLegacyQueryOperation {
#[serde(default)]
pub index: Option<String>,
pub sql: String,
pub limit: usize,
}
impl DaemonOperation for DebuggerLegacyQueryOperation {
const METHOD: &'static str = "debugger.legacy.query";
type Response = LegacyDebuggerQuery;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerLegacyStatusOperation {
#[serde(default)]
pub index: Option<String>,
}
impl DaemonOperation for DebuggerLegacyStatusOperation {
const METHOD: &'static str = "debugger.legacy.status";
type Response = LegacyDebuggerIndexStatus;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionBridgeOperation {}
impl DaemonOperation for DebuggerExtensionBridgeOperation {
const METHOD: &'static str = "debugger.extension.bridge";
type Response = ExtensionStatusView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionInstallHostOperation {
pub browser: String,
pub extension_id: String,
pub host_name: String,
#[serde(default)]
pub host_path: Option<String>,
#[serde(default)]
pub home: Option<String>,
#[serde(default)]
pub user_data_dir: Option<String>,
pub dry_run: bool,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerExtensionInstallHostOperation {
const METHOD: &'static str = "debugger.extension.install_host";
type Response = ExtensionHostInstallation;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionDoctorOperation {
pub browser: String,
pub host_name: String,
#[serde(default)]
pub host_path: Option<String>,
#[serde(default)]
pub home: Option<String>,
#[serde(default)]
pub user_data_dir: Option<String>,
}
impl DaemonOperation for DebuggerExtensionDoctorOperation {
const METHOD: &'static str = "debugger.extension.doctor";
type Response = ExtensionDoctor;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionStatusOperation {}
impl DaemonOperation for DebuggerExtensionStatusOperation {
const METHOD: &'static str = "debugger.extension.status";
type Response = ExtensionStatusView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionTabsOperation {}
impl DaemonOperation for DebuggerExtensionTabsOperation {
const METHOD: &'static str = "debugger.extension.tabs";
type Response = Vec<ExtensionTab>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionAttachOperation {
pub tab_id: u64,
pub idempotency_key: String,
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerExtensionAttachOperation {
const METHOD: &'static str = "debugger.extension.attach";
type Response = ExtensionAttachResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionDetachOperation {
#[serde(default)]
pub tab_id: Option<u64>,
pub idempotency_key: String,
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerExtensionDetachOperation {
const METHOD: &'static str = "debugger.extension.detach";
type Response = ExtensionAttachResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionEvaluateOperation {
#[serde(default)]
pub tab_id: Option<u64>,
pub expression: String,
pub world: String,
pub idempotency_key: String,
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerExtensionEvaluateOperation {
const METHOD: &'static str = "debugger.extension.evaluate";
type Response = ExtensionEvaluation;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionCdpOperation {
#[serde(default)]
pub tab_id: Option<u64>,
pub method: String,
#[serde(default)]
pub params: Value,
pub idempotency_key: String,
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerExtensionCdpOperation {
const METHOD: &'static str = "debugger.extension.cdp";
type Response = ExtensionCdpResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionSnapshotOperation {
#[serde(default)]
pub tab_id: Option<u64>,
pub dom: bool,
pub state: bool,
pub storage: bool,
pub react: bool,
pub idempotency_key: String,
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerExtensionSnapshotOperation {
const METHOD: &'static str = "debugger.extension.snapshot";
type Response = ExtensionSnapshotResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionObserveOperation {
#[serde(default)]
pub tab_id: Option<u64>,
pub kinds: Vec<String>,
pub idempotency_key: String,
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerExtensionObserveOperation {
const METHOD: &'static str = "debugger.extension.observe";
type Response = ExtensionObserveResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionUnobserveOperation {
#[serde(default)]
pub tab_id: Option<u64>,
pub idempotency_key: String,
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerExtensionUnobserveOperation {
const METHOD: &'static str = "debugger.extension.unobserve";
type Response = ExtensionObserveResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExtensionEventsOperation {
#[serde(default)]
pub after: u64,
pub limit: usize,
}
impl DaemonOperation for DebuggerExtensionEventsOperation {
const METHOD: &'static str = "debugger.extension.events";
type Response = Vec<ExtensionEvent>;
}
pub trait DaemonOperation: Serialize {
const METHOD: &'static str;
type Response: DeserializeOwned;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerStatusOperation {
pub id: String,
}
impl DaemonOperation for DebuggerStatusOperation {
const METHOD: &'static str = "debugger.status";
type Response = DebuggerSessionView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerListOperation {}
impl DaemonOperation for DebuggerListOperation {
const METHOD: &'static str = "debugger.list";
type Response = Vec<DebuggerSessionRecord>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerSelectedOperation {}
impl DaemonOperation for DebuggerSelectedOperation {
const METHOD: &'static str = "debugger.selected";
type Response = Option<DebuggerSelection>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerSelectOperation {
pub id: String,
pub idempotency_key: String,
#[serde(default = "default_debugger_timeout_ms")]
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerSelectOperation {
const METHOD: &'static str = "debugger.select";
type Response = DebuggerSelection;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerPauseOperation {
pub id: String,
pub idempotency_key: String,
#[serde(default = "default_debugger_timeout_ms")]
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerPauseOperation {
const METHOD: &'static str = "debugger.pause";
type Response = DebuggerSessionView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerResumeOperation {
pub id: String,
pub idempotency_key: String,
#[serde(default = "default_debugger_timeout_ms")]
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerResumeOperation {
const METHOD: &'static str = "debugger.resume";
type Response = DebuggerSessionView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerContinueOperation {
pub id: String,
pub idempotency_key: String,
#[serde(default = "default_debugger_timeout_ms")]
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerContinueOperation {
const METHOD: &'static str = "debugger.continue";
type Response = DebuggerSessionView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerCloseOperation {
pub id: String,
pub idempotency_key: String,
#[serde(default = "default_debugger_timeout_ms")]
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerCloseOperation {
const METHOD: &'static str = "debugger.close";
type Response = DebuggerSessionView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerReconnectOperation {
pub id: String,
pub idempotency_key: String,
#[serde(default = "default_debugger_timeout_ms")]
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerReconnectOperation {
const METHOD: &'static str = "debugger.reconnect";
type Response = DebuggerSessionView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerRestartOperation {
pub id: String,
pub idempotency_key: String,
#[serde(default = "default_debugger_timeout_ms")]
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerRestartOperation {
const METHOD: &'static str = "debugger.restart";
type Response = DebuggerRunResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerStepOperation {
pub id: String,
pub kind: String,
pub idempotency_key: String,
#[serde(default = "default_debugger_timeout_ms")]
pub timeout_ms: u64,
}
impl DaemonOperation for DebuggerStepOperation {
const METHOD: &'static str = "debugger.step";
type Response = DebuggerSessionView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerRunOperation {
pub id: String,
pub host: String,
pub port: u16,
pub argv: Vec<String>,
#[serde(default)]
pub cwd: Option<String>,
#[serde(default)]
pub env: BTreeMap<String, String>,
pub timeout_ms: u64,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerRunOperation {
const METHOD: &'static str = "debugger.run";
type Response = DebuggerRunResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerOpenOperation {
pub id: String,
pub host: String,
pub port: u16,
#[serde(default)]
pub target_id: Option<String>,
#[serde(default)]
pub execution_id: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerOpenOperation {
const METHOD: &'static str = "debugger.open";
type Response = DebuggerSessionView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBreakpointSetOperation {
pub id: String,
pub file: String,
pub line: u64,
#[serde(default)]
pub condition: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBreakpointSetOperation {
const METHOD: &'static str = "debugger.breakpoint.set";
type Response = DebuggerBreakpoint;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBreakpointListOperation {
pub id: String,
}
impl DaemonOperation for DebuggerBreakpointListOperation {
const METHOD: &'static str = "debugger.breakpoint.list";
type Response = Vec<DebuggerBreakpoint>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBreakpointDeleteOperation {
pub id: String,
pub breakpoint_id: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBreakpointDeleteOperation {
const METHOD: &'static str = "debugger.breakpoint.delete";
type Response = DebuggerBreakpoint;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvaluateOperation {
pub id: String,
pub expression: String,
#[serde(default)]
pub frame: usize,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerEvaluateOperation {
const METHOD: &'static str = "debugger.evaluate";
type Response = DebuggerEvaluation;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerFlowRecordOperation {
pub id: String,
pub name: String,
#[serde(default)]
pub url: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerFlowRecordOperation {
const METHOD: &'static str = "debugger.flow.record";
type Response = DebuggerFlow;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerFlowStopOperation {
pub id: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerFlowStopOperation {
const METHOD: &'static str = "debugger.flow.stop";
type Response = DebuggerFlow;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerFlowRunOperation {
pub id: String,
pub name: String,
#[serde(default = "default_flow_step_timeout_ms")]
pub step_timeout_ms: u64,
pub idempotency_key: String,
}
fn default_flow_step_timeout_ms() -> u64 {
5_000
}
impl DaemonOperation for DebuggerFlowRunOperation {
const METHOD: &'static str = "debugger.flow.run";
type Response = DebuggerFlowRun;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerFlowListOperation {}
impl DaemonOperation for DebuggerFlowListOperation {
const METHOD: &'static str = "debugger.flow.list";
type Response = Vec<DebuggerFlow>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerFlowShowOperation {
pub id: String,
pub name: String,
}
impl DaemonOperation for DebuggerFlowShowOperation {
const METHOD: &'static str = "debugger.flow.show";
type Response = DebuggerFlowView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceStartOperation {
pub id: String,
pub name: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerEvidenceTraceStartOperation {
const METHOD: &'static str = "debugger.evidence_trace.start";
type Response = DebuggerEvidenceTrace;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceStopOperation {
pub id: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerEvidenceTraceStopOperation {
const METHOD: &'static str = "debugger.evidence_trace.stop";
type Response = DebuggerEvidenceTrace;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceListOperation {}
impl DaemonOperation for DebuggerEvidenceTraceListOperation {
const METHOD: &'static str = "debugger.evidence_trace.list";
type Response = Vec<DebuggerEvidenceTrace>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceShowOperation {
pub trace_id: String,
}
impl DaemonOperation for DebuggerEvidenceTraceShowOperation {
const METHOD: &'static str = "debugger.evidence_trace.show";
type Response = DebuggerEvidenceTraceView;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceUseOperation {
pub trace_id: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerEvidenceTraceUseOperation {
const METHOD: &'static str = "debugger.evidence_trace.use";
type Response = DebuggerEvidenceTrace;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceReplayOperation {
pub trace_id: String,
#[serde(default)]
pub at: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerEvidenceTraceReplayOperation {
const METHOD: &'static str = "debugger.evidence_trace.replay";
type Response = DebuggerTraceReplayResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceExportOperation {
pub trace_id: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerEvidenceTraceExportOperation {
const METHOD: &'static str = "debugger.evidence_trace.export";
type Response = DebuggerTraceExport;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceImportOperation {
pub path: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerEvidenceTraceImportOperation {
const METHOD: &'static str = "debugger.evidence_trace.import";
type Response = DebuggerTraceImport;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceGcOperation {
#[serde(default = "default_evidence_trace_keep")]
pub keep: usize,
pub idempotency_key: String,
}
fn default_evidence_trace_keep() -> usize {
10
}
impl DaemonOperation for DebuggerEvidenceTraceGcOperation {
const METHOD: &'static str = "debugger.evidence_trace.gc";
type Response = DebuggerTraceGc;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceCursorOperation {
#[serde(default)]
pub trace_id: Option<String>,
}
impl DaemonOperation for DebuggerEvidenceTraceCursorOperation {
const METHOD: &'static str = "debugger.evidence_trace.cursor";
type Response = Option<DebuggerTraceCursor>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceMoveOperation {
pub direction: String,
#[serde(default = "default_evidence_trace_count")]
pub count: usize,
#[serde(default)]
pub kind: Option<String>,
pub idempotency_key: String,
}
fn default_evidence_trace_count() -> usize {
1
}
impl DaemonOperation for DebuggerEvidenceTraceMoveOperation {
const METHOD: &'static str = "debugger.evidence_trace.move";
type Response = DebuggerTraceCursor;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEvidenceTraceJumpOperation {
pub direction: String,
#[serde(default = "default_evidence_trace_count")]
pub count: usize,
#[serde(default)]
pub kind: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerEvidenceTraceJumpOperation {
const METHOD: &'static str = "debugger.evidence_trace.jump";
type Response = DebuggerTraceCursor;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserStateOperation {
pub id: String,
}
impl DaemonOperation for DebuggerBrowserStateOperation {
const METHOD: &'static str = "debugger.browser.state";
type Response = DebuggerBrowserState;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserDomOperation {
pub id: String,
pub selector: String,
}
impl DaemonOperation for DebuggerBrowserDomOperation {
const METHOD: &'static str = "debugger.browser.dom";
type Response = Vec<BrowserDomNode>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserStylesOperation {
pub id: String,
pub selector: String,
}
impl DaemonOperation for DebuggerBrowserStylesOperation {
const METHOD: &'static str = "debugger.browser.styles";
type Response = Vec<BrowserStyle>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserCookiesOperation {
pub id: String,
}
impl DaemonOperation for DebuggerBrowserCookiesOperation {
const METHOD: &'static str = "debugger.browser.cookies";
type Response = Vec<BrowserCookie>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserStorageOperation {
pub id: String,
pub kind: String,
}
impl DaemonOperation for DebuggerBrowserStorageOperation {
const METHOD: &'static str = "debugger.browser.storage";
type Response = Vec<BrowserStorageEntry>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserPerformanceOperation {
pub id: String,
}
impl DaemonOperation for DebuggerBrowserPerformanceOperation {
const METHOD: &'static str = "debugger.browser.performance";
type Response = Vec<BrowserMetric>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserNetworkOperation {
pub id: String,
}
impl DaemonOperation for DebuggerBrowserNetworkOperation {
const METHOD: &'static str = "debugger.browser.network";
type Response = Vec<BrowserNetworkRequest>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserNetworkBodyOperation {
pub id: String,
pub request_id: String,
}
impl DaemonOperation for DebuggerBrowserNetworkBodyOperation {
const METHOD: &'static str = "debugger.browser.network_body";
type Response = BrowserNetworkBody;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserWebSocketsOperation {
pub id: String,
}
impl DaemonOperation for DebuggerBrowserWebSocketsOperation {
const METHOD: &'static str = "debugger.browser.websockets";
type Response = Vec<BrowserWebSocketFrame>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserPageEventsOperation {
pub id: String,
}
impl DaemonOperation for DebuggerBrowserPageEventsOperation {
const METHOD: &'static str = "debugger.browser.page_events";
type Response = Vec<BrowserPageEvent>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserNavigateOperation {
pub id: String,
pub action: String,
#[serde(default)]
pub target: Option<String>,
#[serde(default = "default_browser_timeout_ms")]
pub timeout_ms: u64,
pub idempotency_key: String,
}
fn default_browser_timeout_ms() -> u64 {
30_000
}
impl DaemonOperation for DebuggerBrowserNavigateOperation {
const METHOD: &'static str = "debugger.browser.navigate";
type Response = BrowserNavigation;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserScreenshotOperation {
pub id: String,
#[serde(default)]
pub selector: Option<String>,
#[serde(default)]
pub state: Option<String>,
#[serde(default)]
pub full_page: bool,
#[serde(default)]
pub width: Option<u64>,
#[serde(default)]
pub height: Option<u64>,
#[serde(default)]
pub inline: bool,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBrowserScreenshotOperation {
const METHOD: &'static str = "debugger.browser.screenshot";
type Response = BrowserScreenshot;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserClickOperation {
pub id: String,
pub selector: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBrowserClickOperation {
const METHOD: &'static str = "debugger.browser.click";
type Response = BrowserInteraction;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserTypeOperation {
pub id: String,
pub selector: String,
pub value: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBrowserTypeOperation {
const METHOD: &'static str = "debugger.browser.type";
type Response = BrowserInteraction;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserSelectOperation {
pub id: String,
pub selector: String,
pub value: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBrowserSelectOperation {
const METHOD: &'static str = "debugger.browser.select";
type Response = BrowserInteraction;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserMockOperation {
pub id: String,
pub pattern: String,
pub body: String,
#[serde(default = "default_browser_mock_status")]
pub status: u16,
#[serde(default)]
pub headers: Vec<(String, String)>,
pub idempotency_key: String,
}
fn default_browser_mock_status() -> u16 {
200
}
impl DaemonOperation for DebuggerBrowserMockOperation {
const METHOD: &'static str = "debugger.browser.mock";
type Response = BrowserMockRule;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserUnmockOperation {
pub id: String,
#[serde(default)]
pub pattern: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBrowserUnmockOperation {
const METHOD: &'static str = "debugger.browser.unmock";
type Response = Vec<BrowserMockRule>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserEmulateOperation {
pub id: String,
pub preset: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBrowserEmulateOperation {
const METHOD: &'static str = "debugger.browser.emulate";
type Response = String;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserThrottleOperation {
pub id: String,
pub preset: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBrowserThrottleOperation {
const METHOD: &'static str = "debugger.browser.throttle";
type Response = String;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerBrowserCoverageOperation {
pub id: String,
pub preset: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerBrowserCoverageOperation {
const METHOD: &'static str = "debugger.browser.coverage";
type Response = BrowserCoverageSnapshot;
}
macro_rules! recording_operation {
($name:ident, $method:literal, $response:ty, { $($field:ident : $ty:ty),* $(,)? }) => {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct $name { $(pub $field: $ty),* }
impl DaemonOperation for $name {
const METHOD: &'static str = $method;
type Response = $response;
}
};
}
recording_operation!(DebuggerRecordingStartOperation, "debugger.recording.start", DebuggerRecordingStart, { id: String, max_frames: usize, max_bytes: u64, idempotency_key: String });
recording_operation!(DebuggerRecordingStatusOperation, "debugger.recording.status", Option<DebuggerRecording>, { id: String });
recording_operation!(
DebuggerRecordingListOperation,
"debugger.recording.list",
Vec<DebuggerRecording>,
{}
);
recording_operation!(DebuggerRecordingCaptureOperation, "debugger.recording.capture", DebuggerCapture, { id: String, reason: String, idempotency_key: String });
recording_operation!(DebuggerRecordingShootOperation, "debugger.recording.shoot", DebuggerCapture, { id: String, reason: String, idempotency_key: String });
recording_operation!(DebuggerRecordingMarkOperation, "debugger.recording.mark", DebuggerMark, { id: String, name: String, idempotency_key: String });
recording_operation!(DebuggerRecordingCorrelateOperation, "debugger.recording.correlate", CausalEvent, { id: String, kind: String, reference: String, path: Option<String>, at: Option<u64>, idempotency_key: String });
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerRecordingAfterOperation {
pub id: String,
#[serde(default)]
pub anchor: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerRecordingAfterOperation {
const METHOD: &'static str = "debugger.recording.after";
type Response = DebuggerAfter;
}
recording_operation!(DebuggerRecordingAfterGetOperation, "debugger.recording.after_get", Option<DebuggerAfter>, { id: String });
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerRecordingTimelineOperation {
pub id: String,
#[serde(default = "default_recording_timeline_limit")]
pub limit: usize,
pub idempotency_key: String,
}
fn default_recording_timeline_limit() -> usize {
100
}
impl DaemonOperation for DebuggerRecordingTimelineOperation {
const METHOD: &'static str = "debugger.recording.timeline";
type Response = DebuggerTimeline;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerRecordingWhyOperation {
pub id: String,
#[serde(default)]
pub substring: Option<String>,
#[serde(default = "default_recording_why_window")]
pub window_ms: u64,
}
fn default_recording_why_window() -> u64 {
5 * 60 * 1_000
}
impl DaemonOperation for DebuggerRecordingWhyOperation {
const METHOD: &'static str = "debugger.recording.why";
type Response = DebuggerWhy;
}
recording_operation!(DebuggerRecordingStopOperation, "debugger.recording.stop", DebuggerRecording, { id: String, idempotency_key: String });
recording_operation!(DebuggerRecordingReplayOperation, "debugger.recording.replay", DebuggerReplay, { id: String, capture_id: String, timeout_ms: u64, idempotency_key: String });
recording_operation!(DebuggerRecordingCapturesOperation, "debugger.recording.captures", Vec<DebuggerCapture>, { recording_id: String });
recording_operation!(DebuggerRecordingMarksOperation, "debugger.recording.marks", Vec<DebuggerMark>, { recording_id: String });
recording_operation!(DebuggerRecordingAftersOperation, "debugger.recording.afters", Vec<DebuggerAfter>, { recording_id: String });
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerTargetsOperation {
pub host: String,
pub port: u16,
}
impl DaemonOperation for DebuggerTargetsOperation {
const METHOD: &'static str = "debugger.targets";
type Response = Vec<DebuggerTarget>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerEventsOperation {
pub id: String,
#[serde(default)]
pub after: u64,
#[serde(default = "default_debugger_event_limit")]
pub limit: usize,
}
impl DaemonOperation for DebuggerEventsOperation {
const METHOD: &'static str = "debugger.events";
type Response = Vec<DebuggerEvent>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerStackOperation {
pub id: String,
}
impl DaemonOperation for DebuggerStackOperation {
const METHOD: &'static str = "debugger.stack";
type Response = Vec<DebuggerFrame>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerHealthOperation {
pub id: String,
}
impl DaemonOperation for DebuggerHealthOperation {
const METHOD: &'static str = "debugger.health";
type Response = DebuggerHealth;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerTraceOperation {
pub id: String,
#[serde(default)]
pub after: u64,
#[serde(default = "default_debugger_event_limit")]
pub limit: usize,
}
impl DaemonOperation for DebuggerTraceOperation {
const METHOD: &'static str = "debugger.trace";
type Response = Vec<DebuggerTraceEntry>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerScopesOperation {
pub id: String,
pub frame: usize,
}
impl DaemonOperation for DebuggerScopesOperation {
const METHOD: &'static str = "debugger.scopes";
type Response = Vec<DebuggerScope>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerVariablesOperation {
pub id: String,
pub frame: usize,
}
impl DaemonOperation for DebuggerVariablesOperation {
const METHOD: &'static str = "debugger.variables";
type Response = Vec<DebuggerVariable>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerPropertiesOperation {
pub id: String,
pub object_id: String,
}
impl DaemonOperation for DebuggerPropertiesOperation {
const METHOD: &'static str = "debugger.properties";
type Response = Vec<DebuggerProperty>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerPrototypesOperation {
pub id: String,
pub object_id: String,
#[serde(default = "default_debugger_prototype_limit")]
pub limit: usize,
}
impl DaemonOperation for DebuggerPrototypesOperation {
const METHOD: &'static str = "debugger.prototypes";
type Response = Vec<DebuggerPrototype>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerListenersOperation {
pub id: String,
pub object_id: String,
}
impl DaemonOperation for DebuggerListenersOperation {
const METHOD: &'static str = "debugger.listeners";
type Response = Vec<DebuggerListener>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerThisOperation {
pub id: String,
pub frame: usize,
}
impl DaemonOperation for DebuggerThisOperation {
const METHOD: &'static str = "debugger.this";
type Response = Vec<DebuggerProperty>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerSourceOperation {
pub id: String,
#[serde(default)]
pub script_id: Option<String>,
#[serde(default)]
pub file: Option<String>,
#[serde(default)]
pub from_line: Option<u64>,
#[serde(default)]
pub to_line: Option<u64>,
}
impl DaemonOperation for DebuggerSourceOperation {
const METHOD: &'static str = "debugger.source";
type Response = DebuggerSource;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerScriptsOperation {
pub id: String,
}
impl DaemonOperation for DebuggerScriptsOperation {
const METHOD: &'static str = "debugger.scripts";
type Response = Vec<DebuggerScript>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerConsoleOperation {
pub id: String,
}
impl DaemonOperation for DebuggerConsoleOperation {
const METHOD: &'static str = "debugger.console";
type Response = Vec<DebuggerConsoleEntry>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerExceptionsOperation {
pub id: String,
}
impl DaemonOperation for DebuggerExceptionsOperation {
const METHOD: &'static str = "debugger.exceptions";
type Response = Vec<DebuggerExceptionEntry>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppleDevicesOperation {
pub platform: String,
}
impl DaemonOperation for AppleDevicesOperation {
const METHOD: &'static str = "debugger.apple.devices";
type Response = Vec<AppleDeviceTarget>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppleAppsOperation {
pub device_id: String,
}
impl DaemonOperation for AppleAppsOperation {
const METHOD: &'static str = "debugger.apple.apps";
type Response = Vec<AppleDeviceApp>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppleResolveOperation {
pub id: String,
pub bundle_id: String,
pub platform: String,
#[serde(default)]
pub device: Option<String>,
#[serde(default)]
pub pid: Option<u32>,
#[serde(default)]
pub launch: bool,
pub attach_strategy: String,
pub attach_timeout_ms: u64,
pub idempotency_key: String,
}
impl DaemonOperation for AppleResolveOperation {
const METHOD: &'static str = "debugger.apple.resolve";
type Response = AppleAttachResolution;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AppleAttachOperation {
pub id: String,
pub bundle_id: String,
pub platform: String,
#[serde(default)]
pub device: Option<String>,
#[serde(default)]
pub pid: Option<u32>,
#[serde(default)]
pub launch: bool,
pub attach_strategy: String,
pub adapter_argv: Vec<String>,
#[serde(default)]
pub cwd: Option<String>,
#[serde(default)]
pub env: BTreeMap<String, String>,
pub timeout_ms: u64,
pub idempotency_key: String,
}
impl DaemonOperation for AppleAttachOperation {
const METHOD: &'static str = "debugger.apple.attach";
type Response = AppleAttachResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DapLaunchOperation {
pub id: String,
pub adapter_argv: Vec<String>,
pub program: String,
#[serde(default)]
pub args: Vec<String>,
#[serde(default)]
pub cwd: Option<String>,
#[serde(default)]
pub env: BTreeMap<String, String>,
pub timeout_ms: u64,
pub idempotency_key: String,
}
impl DaemonOperation for DapLaunchOperation {
const METHOD: &'static str = "debugger.dap.launch";
type Response = DebuggerRunResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DapAttachOperation {
pub id: String,
pub adapter_argv: Vec<String>,
pub pid: u32,
#[serde(default)]
pub wait_for: bool,
#[serde(default)]
pub attach_commands: Vec<String>,
#[serde(default)]
pub started_stopped: bool,
#[serde(default)]
pub cwd: Option<String>,
#[serde(default)]
pub env: BTreeMap<String, String>,
pub timeout_ms: u64,
pub idempotency_key: String,
}
impl DaemonOperation for DapAttachOperation {
const METHOD: &'static str = "debugger.dap.attach";
type Response = DebuggerRunResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DapRequestOperation {
pub id: String,
pub command: String,
#[serde(default)]
pub arguments: Value,
pub timeout_ms: u64,
pub idempotency_key: String,
}
impl DaemonOperation for DapRequestOperation {
const METHOD: &'static str = "debugger.dap.request";
type Response = Value;
}
macro_rules! dap_session_operation {
($name:ident, $method:literal, $response:ty) => {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct $name {
pub id: String,
}
impl DaemonOperation for $name {
const METHOD: &'static str = $method;
type Response = $response;
}
};
}
dap_session_operation!(DapStateOperation, "debugger.dap.state", DapSessionState);
dap_session_operation!(DapThreadsOperation, "debugger.dap.threads", Vec<DapThread>);
dap_session_operation!(DapModulesOperation, "debugger.dap.modules", Vec<DapModule>);
dap_session_operation!(
DapRegistersOperation,
"debugger.dap.registers",
Vec<DapRegister>
);
dap_session_operation!(DapSignalsOperation, "debugger.dap.signals", Vec<DapSignal>);
dap_session_operation!(
DapWatchpointsOperation,
"debugger.dap.watchpoints",
Vec<DapWatchpoint>
);
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DapMemoryOperation {
pub id: String,
pub address: String,
pub count: u64,
}
impl DaemonOperation for DapMemoryOperation {
const METHOD: &'static str = "debugger.dap.memory";
type Response = DapMemory;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DapDisassembleOperation {
pub id: String,
pub address: String,
pub count: u64,
}
impl DaemonOperation for DapDisassembleOperation {
const METHOD: &'static str = "debugger.dap.disassemble";
type Response = Vec<DapInstruction>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RrRecordOperation {
pub name: String,
pub command: Vec<String>,
pub rr_executable: String,
#[serde(default)]
pub backend: crate::debugger::RrBackend,
#[serde(default)]
pub cwd: Option<String>,
#[serde(default)]
pub env: BTreeMap<String, String>,
pub idempotency_key: String,
}
impl DaemonOperation for RrRecordOperation {
const METHOD: &'static str = "debugger.rr.record";
type Response = RrExecutionResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RrReplayOperation {
pub trace_id: String,
pub rr_executable: String,
#[serde(default)]
pub backend: crate::debugger::RrBackend,
#[serde(default)]
pub event: Option<u64>,
#[serde(default)]
pub pid: Option<u32>,
#[serde(default)]
pub end: bool,
pub idempotency_key: String,
}
impl DaemonOperation for RrReplayOperation {
const METHOD: &'static str = "debugger.rr.replay";
type Response = RrExecutionResult;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RrProcessStatusOperation {
pub trace_id: String,
pub rr_executable: String,
#[serde(default)]
pub backend: crate::debugger::RrBackend,
pub idempotency_key: String,
}
impl DaemonOperation for RrProcessStatusOperation {
const METHOD: &'static str = "debugger.rr.ps";
type Response = RrProcessStatus;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RrImportOperation {
pub path: String,
#[serde(default)]
pub name: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for RrImportOperation {
const METHOD: &'static str = "debugger.rr.import";
type Response = RrTrace;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RrListOperation {}
impl DaemonOperation for RrListOperation {
const METHOD: &'static str = "debugger.rr.list";
type Response = Vec<RrTrace>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RrShowOperation {
pub trace_id: String,
}
impl DaemonOperation for RrShowOperation {
const METHOD: &'static str = "debugger.rr.show";
type Response = RrTrace;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerTapAddOperation {
pub id: String,
pub file: String,
pub line: u64,
pub expression: String,
#[serde(default)]
pub url_regex: Option<String>,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerTapAddOperation {
const METHOD: &'static str = "debugger.tap.add";
type Response = DebuggerTap;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerTapListOperation {
pub id: String,
}
impl DaemonOperation for DebuggerTapListOperation {
const METHOD: &'static str = "debugger.tap.list";
type Response = Vec<DebuggerTap>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerTapHitsOperation {
pub id: String,
pub tap_id: String,
#[serde(default = "default_debugger_event_limit")]
pub limit: usize,
}
impl DaemonOperation for DebuggerTapHitsOperation {
const METHOD: &'static str = "debugger.tap.hits";
type Response = Vec<DebuggerTapHit>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerTapRemoveOperation {
pub id: String,
pub tap_id: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerTapRemoveOperation {
const METHOD: &'static str = "debugger.tap.remove";
type Response = DebuggerTap;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerWatchAddOperation {
pub id: String,
pub target: String,
#[serde(default)]
pub expression: Option<String>,
#[serde(default = "default_debugger_watch_access")]
pub access: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerWatchAddOperation {
const METHOD: &'static str = "debugger.watch.add";
type Response = DebuggerWatch;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerWatchListOperation {
pub id: String,
}
impl DaemonOperation for DebuggerWatchListOperation {
const METHOD: &'static str = "debugger.watch.list";
type Response = Vec<DebuggerWatch>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerWatchHitsOperation {
pub id: String,
pub watch_id: String,
#[serde(default = "default_debugger_event_limit")]
pub limit: usize,
}
impl DaemonOperation for DebuggerWatchHitsOperation {
const METHOD: &'static str = "debugger.watch.hits";
type Response = Vec<DebuggerWatchHit>;
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebuggerWatchRemoveOperation {
pub id: String,
pub watch_id: String,
pub idempotency_key: String,
}
impl DaemonOperation for DebuggerWatchRemoveOperation {
const METHOD: &'static str = "debugger.watch.remove";
type Response = DebuggerWatch;
}
fn default_debugger_event_limit() -> usize {
100
}
fn default_debugger_timeout_ms() -> u64 {
30_000
}
fn default_debugger_prototype_limit() -> usize {
8
}
fn default_debugger_watch_access() -> String {
"write".to_string()
}