osn-selenium 0.0.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

osn_selenium/executors/unified/cdp/debugger.py

@@ -0,0 +1,243 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedDebuggerCDPExecutor"]
+
+
+class UnifiedDebuggerCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _continue_to_location_impl(self, location: Dict[str, Any], target_call_frames: Optional[str] = None) -> None:
+		return self._execute_function(
+				"Debugger.continueToLocation",
+				{"location": location, "target_call_frames": target_call_frames}
+		)
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("Debugger.disable", {})
+	
+	def _disassemble_wasm_module_impl(self, script_id: str) -> Tuple[Optional[str], int, List[int], Dict[str, Any]]:
+		return self._execute_function("Debugger.disassembleWasmModule", {"script_id": script_id})
+	
+	def _enable_impl(self, max_scripts_cache_size: Optional[float] = None) -> str:
+		return self._execute_function("Debugger.enable", {"max_scripts_cache_size": max_scripts_cache_size})
+	
+	def _evaluate_on_call_frame_impl(
+			self,
+			call_frame_id: str,
+			expression: str,
+			object_group: Optional[str] = None,
+			include_command_line_api: Optional[bool] = None,
+			silent: Optional[bool] = None,
+			return_by_value: Optional[bool] = None,
+			generate_preview: Optional[bool] = None,
+			throw_on_side_effect: Optional[bool] = None,
+			timeout: Optional[float] = None
+	) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
+		return self._execute_function(
+				"Debugger.evaluateOnCallFrame",
+				{
+					"call_frame_id": call_frame_id,
+					"expression": expression,
+					"object_group": object_group,
+					"include_command_line_api": include_command_line_api,
+					"silent": silent,
+					"return_by_value": return_by_value,
+					"generate_preview": generate_preview,
+					"throw_on_side_effect": throw_on_side_effect,
+					"timeout": timeout
+				}
+		)
+	
+	def _get_possible_breakpoints_impl(
+			self,
+			start: Dict[str, Any],
+			end: Optional[Dict[str, Any]] = None,
+			restrict_to_function: Optional[bool] = None
+	) -> List[Dict[str, Any]]:
+		return self._execute_function(
+				"Debugger.getPossibleBreakpoints",
+				{
+					"start": start,
+					"end": end,
+					"restrict_to_function": restrict_to_function
+				}
+		)
+	
+	def _get_script_source_impl(self, script_id: str) -> Tuple[str, Optional[str]]:
+		return self._execute_function("Debugger.getScriptSource", {"script_id": script_id})
+	
+	def _get_stack_trace_impl(self, stack_trace_id: Dict[str, Any]) -> Dict[str, Any]:
+		return self._execute_function("Debugger.getStackTrace", {"stack_trace_id": stack_trace_id})
+	
+	def _get_wasm_bytecode_impl(self, script_id: str) -> str:
+		return self._execute_function("Debugger.getWasmBytecode", {"script_id": script_id})
+	
+	def _next_wasm_disassembly_chunk_impl(self, stream_id: str) -> Dict[str, Any]:
+		return self._execute_function("Debugger.nextWasmDisassemblyChunk", {"stream_id": stream_id})
+	
+	def _pause_impl(self) -> None:
+		return self._execute_function("Debugger.pause", {})
+	
+	def _pause_on_async_call_impl(self, parent_stack_trace_id: Dict[str, Any]) -> None:
+		return self._execute_function(
+				"Debugger.pauseOnAsyncCall",
+				{"parent_stack_trace_id": parent_stack_trace_id}
+		)
+	
+	def _remove_breakpoint_impl(self, breakpoint_id: str) -> None:
+		return self._execute_function("Debugger.removeBreakpoint", {"breakpoint_id": breakpoint_id})
+	
+	def _restart_frame_impl(self, call_frame_id: str, mode: Optional[str] = None) -> Tuple[List[Dict[str, Any]], Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
+		return self._execute_function("Debugger.restartFrame", {"call_frame_id": call_frame_id, "mode": mode})
+	
+	def _resume_impl(self, terminate_on_resume: Optional[bool] = None) -> None:
+		return self._execute_function("Debugger.resume", {"terminate_on_resume": terminate_on_resume})
+	
+	def _search_in_content_impl(
+			self,
+			script_id: str,
+			query: str,
+			case_sensitive: Optional[bool] = None,
+			is_regex: Optional[bool] = None
+	) -> List[Dict[str, Any]]:
+		return self._execute_function(
+				"Debugger.searchInContent",
+				{
+					"script_id": script_id,
+					"query": query,
+					"case_sensitive": case_sensitive,
+					"is_regex": is_regex
+				}
+		)
+	
+	def _set_async_call_stack_depth_impl(self, max_depth: int) -> None:
+		return self._execute_function("Debugger.setAsyncCallStackDepth", {"max_depth": max_depth})
+	
+	def _set_blackbox_execution_contexts_impl(self, unique_ids: List[str]) -> None:
+		return self._execute_function("Debugger.setBlackboxExecutionContexts", {"unique_ids": unique_ids})
+	
+	def _set_blackbox_patterns_impl(self, patterns: List[str], skip_anonymous: Optional[bool] = None) -> None:
+		return self._execute_function(
+				"Debugger.setBlackboxPatterns",
+				{"patterns": patterns, "skip_anonymous": skip_anonymous}
+		)
+	
+	def _set_blackboxed_ranges_impl(self, script_id: str, positions: List[Dict[str, Any]]) -> None:
+		return self._execute_function(
+				"Debugger.setBlackboxedRanges",
+				{"script_id": script_id, "positions": positions}
+		)
+	
+	def _set_breakpoint_by_url_impl(
+			self,
+			line_number: int,
+			url: Optional[str] = None,
+			url_regex: Optional[str] = None,
+			script_hash: Optional[str] = None,
+			column_number: Optional[int] = None,
+			condition: Optional[str] = None
+	) -> Tuple[str, List[Dict[str, Any]]]:
+		return self._execute_function(
+				"Debugger.setBreakpointByUrl",
+				{
+					"line_number": line_number,
+					"url": url,
+					"url_regex": url_regex,
+					"script_hash": script_hash,
+					"column_number": column_number,
+					"condition": condition
+				}
+		)
+	
+	def _set_breakpoint_impl(self, location: Dict[str, Any], condition: Optional[str] = None) -> Tuple[str, Dict[str, Any]]:
+		return self._execute_function("Debugger.setBreakpoint", {"location": location, "condition": condition})
+	
+	def _set_breakpoint_on_function_call_impl(self, object_id: str, condition: Optional[str] = None) -> str:
+		return self._execute_function(
+				"Debugger.setBreakpointOnFunctionCall",
+				{"object_id": object_id, "condition": condition}
+		)
+	
+	def _set_breakpoints_active_impl(self, active: bool) -> None:
+		return self._execute_function("Debugger.setBreakpointsActive", {"active": active})
+	
+	def _set_instrumentation_breakpoint_impl(self, instrumentation: str) -> str:
+		return self._execute_function(
+				"Debugger.setInstrumentationBreakpoint",
+				{"instrumentation": instrumentation}
+		)
+	
+	def _set_pause_on_exceptions_impl(self, state: str) -> None:
+		return self._execute_function("Debugger.setPauseOnExceptions", {"state": state})
+	
+	def _set_return_value_impl(self, new_value: Dict[str, Any]) -> None:
+		return self._execute_function("Debugger.setReturnValue", {"new_value": new_value})
+	
+	def _set_script_source_impl(
+			self,
+			script_id: str,
+			script_source: str,
+			dry_run: Optional[bool] = None,
+			allow_top_frame_editing: Optional[bool] = None
+	) -> Tuple[
+		Optional[List[Dict[str, Any]]],
+		Optional[bool],
+		Optional[Dict[str, Any]],
+		Optional[Dict[str, Any]],
+		str,
+		Optional[Dict[str, Any]]
+	]:
+		return self._execute_function(
+				"Debugger.setScriptSource",
+				{
+					"script_id": script_id,
+					"script_source": script_source,
+					"dry_run": dry_run,
+					"allow_top_frame_editing": allow_top_frame_editing
+				}
+		)
+	
+	def _set_skip_all_pauses_impl(self, skip: bool) -> None:
+		return self._execute_function("Debugger.setSkipAllPauses", {"skip": skip})
+	
+	def _set_variable_value_impl(
+			self,
+			scope_number: int,
+			variable_name: str,
+			new_value: Dict[str, Any],
+			call_frame_id: str
+	) -> None:
+		return self._execute_function(
+				"Debugger.setVariableValue",
+				{
+					"scope_number": scope_number,
+					"variable_name": variable_name,
+					"new_value": new_value,
+					"call_frame_id": call_frame_id
+				}
+		)
+	
+	def _step_into_impl(
+			self,
+			break_on_async_call: Optional[bool] = None,
+			skip_list: Optional[List[Dict[str, Any]]] = None
+	) -> None:
+		return self._execute_function(
+				"Debugger.stepInto",
+				{"break_on_async_call": break_on_async_call, "skip_list": skip_list}
+		)
+	
+	def _step_out_impl(self) -> None:
+		return self._execute_function("Debugger.stepOut", {})
+	
+	def _step_over_impl(self, skip_list: Optional[List[Dict[str, Any]]] = None) -> None:
+		return self._execute_function("Debugger.stepOver", {"skip_list": skip_list})

osn_selenium/executors/unified/cdp/device_access.py

@@ -0,0 +1,21 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedDeviceAccessCDPExecutor"]
+
+
+class UnifiedDeviceAccessCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _cancel_prompt_impl(self, id_: str) -> None:
+		return self._execute_function("DeviceAccess.cancelPrompt", {"id_": id_})
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("DeviceAccess.disable", {})
+	
+	def _enable_impl(self) -> None:
+		return self._execute_function("DeviceAccess.enable", {})
+	
+	def _select_prompt_impl(self, id_: str, device_id: str) -> None:
+		return self._execute_function("DeviceAccess.selectPrompt", {"id_": id_, "device_id": device_id})

osn_selenium/executors/unified/cdp/device_orientation.py

@@ -0,0 +1,18 @@
+from typing import Any, Callable, Dict
+
+
+__all__ = ["UnifiedDeviceOrientationCDPExecutor"]
+
+
+class UnifiedDeviceOrientationCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _clear_device_orientation_override_impl(self) -> None:
+		return self._execute_function("DeviceOrientation.clearDeviceOrientationOverride", {})
+	
+	def _set_device_orientation_override_impl(self, alpha: float, beta: float, gamma: float) -> None:
+		return self._execute_function(
+				"DeviceOrientation.setDeviceOrientationOverride",
+				{"alpha": alpha, "beta": beta, "gamma": gamma}
+		)

osn_selenium/executors/unified/cdp/dom.py

@@ -0,0 +1,380 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+
+
+__all__ = ["UnifiedDomCDPExecutor"]
+
+
+class UnifiedDomCDPExecutor:
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		self._execute_function = execute_function
+	
+	def _collect_class_names_from_subtree_impl(self, node_id: int) -> List[str]:
+		return self._execute_function("DOM.collectClassNamesFromSubtree", {"node_id": node_id})
+	
+	def _copy_to_impl(
+			self,
+			node_id: int,
+			target_node_id: int,
+			insert_before_node_id: Optional[int] = None
+	) -> int:
+		return self._execute_function(
+				"DOM.copyTo",
+				{
+					"node_id": node_id,
+					"target_node_id": target_node_id,
+					"insert_before_node_id": insert_before_node_id
+				}
+		)
+	
+	def _describe_node_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			depth: Optional[int] = None,
+			pierce: Optional[bool] = None
+	) -> Dict[str, Any]:
+		return self._execute_function(
+				"DOM.describeNode",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id,
+					"depth": depth,
+					"pierce": pierce
+				}
+		)
+	
+	def _disable_impl(self) -> None:
+		return self._execute_function("DOM.disable", {})
+	
+	def _discard_search_results_impl(self, search_id: str) -> None:
+		return self._execute_function("DOM.discardSearchResults", {"search_id": search_id})
+	
+	def _enable_impl(self, include_whitespace: Optional[str] = None) -> None:
+		return self._execute_function("DOM.enable", {"include_whitespace": include_whitespace})
+	
+	def _focus_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"DOM.focus",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id
+				}
+		)
+	
+	def _force_show_popover_impl(self, node_id: int, enable: bool) -> List[int]:
+		return self._execute_function("DOM.forceShowPopover", {"node_id": node_id, "enable": enable})
+	
+	def _get_anchor_element_impl(self, node_id: int, anchor_specifier: Optional[str] = None) -> int:
+		return self._execute_function(
+				"DOM.getAnchorElement",
+				{"node_id": node_id, "anchor_specifier": anchor_specifier}
+		)
+	
+	def _get_attributes_impl(self, node_id: int) -> List[str]:
+		return self._execute_function("DOM.getAttributes", {"node_id": node_id})
+	
+	def _get_box_model_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> Dict[str, Any]:
+		return self._execute_function(
+				"DOM.getBoxModel",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id
+				}
+		)
+	
+	def _get_container_for_node_impl(
+			self,
+			node_id: int,
+			container_name: Optional[str] = None,
+			physical_axes: Optional[str] = None,
+			logical_axes: Optional[str] = None,
+			queries_scroll_state: Optional[bool] = None,
+			queries_anchored: Optional[bool] = None
+	) -> Optional[int]:
+		return self._execute_function(
+				"DOM.getContainerForNode",
+				{
+					"node_id": node_id,
+					"container_name": container_name,
+					"physical_axes": physical_axes,
+					"logical_axes": logical_axes,
+					"queries_scroll_state": queries_scroll_state,
+					"queries_anchored": queries_anchored
+				}
+		)
+	
+	def _get_content_quads_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> List[List[float]]:
+		return self._execute_function(
+				"DOM.getContentQuads",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id
+				}
+		)
+	
+	def _get_detached_dom_nodes_impl(self) -> List[Dict[str, Any]]:
+		return self._execute_function("DOM.getDetachedDomNodes", {})
+	
+	def _get_document_impl(self, depth: Optional[int] = None, pierce: Optional[bool] = None) -> Dict[str, Any]:
+		return self._execute_function("DOM.getDocument", {"depth": depth, "pierce": pierce})
+	
+	def _get_element_by_relation_impl(self, node_id: int, relation: str) -> int:
+		return self._execute_function("DOM.getElementByRelation", {"node_id": node_id, "relation": relation})
+	
+	def _get_file_info_impl(self, object_id: str) -> str:
+		return self._execute_function("DOM.getFileInfo", {"object_id": object_id})
+	
+	def _get_flattened_document_impl(self, depth: Optional[int] = None, pierce: Optional[bool] = None) -> List[Dict[str, Any]]:
+		return self._execute_function("DOM.getFlattenedDocument", {"depth": depth, "pierce": pierce})
+	
+	def _get_frame_owner_impl(self, frame_id: str) -> Tuple[int, Optional[int]]:
+		return self._execute_function("DOM.getFrameOwner", {"frame_id": frame_id})
+	
+	def _get_node_for_location_impl(
+			self,
+			x: int,
+			y: int,
+			include_user_agent_shadow_dom: Optional[bool] = None,
+			ignore_pointer_events_none: Optional[bool] = None
+	) -> Tuple[int, str, Optional[int]]:
+		return self._execute_function(
+				"DOM.getNodeForLocation",
+				{
+					"x": x,
+					"y": y,
+					"include_user_agent_shadow_dom": include_user_agent_shadow_dom,
+					"ignore_pointer_events_none": ignore_pointer_events_none
+				}
+		)
+	
+	def _get_node_stack_traces_impl(self, node_id: int) -> Optional[Dict[str, Any]]:
+		return self._execute_function("DOM.getNodeStackTraces", {"node_id": node_id})
+	
+	def _get_nodes_for_subtree_by_style_impl(
+			self,
+			node_id: int,
+			computed_styles: List[Dict[str, Any]],
+			pierce: Optional[bool] = None
+	) -> List[int]:
+		return self._execute_function(
+				"DOM.getNodesForSubtreeByStyle",
+				{
+					"node_id": node_id,
+					"computed_styles": computed_styles,
+					"pierce": pierce
+				}
+		)
+	
+	def _get_outer_html_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			include_shadow_dom: Optional[bool] = None
+	) -> str:
+		return self._execute_function(
+				"DOM.getOuterHTML",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id,
+					"include_shadow_dom": include_shadow_dom
+				}
+		)
+	
+	def _get_querying_descendants_for_container_impl(self, node_id: int) -> List[int]:
+		return self._execute_function("DOM.getQueryingDescendantsForContainer", {"node_id": node_id})
+	
+	def _get_relayout_boundary_impl(self, node_id: int) -> int:
+		return self._execute_function("DOM.getRelayoutBoundary", {"node_id": node_id})
+	
+	def _get_search_results_impl(self, search_id: str, from_index: int, to_index: int) -> List[int]:
+		return self._execute_function(
+				"DOM.getSearchResults",
+				{"search_id": search_id, "from_index": from_index, "to_index": to_index}
+		)
+	
+	def _get_top_layer_elements_impl(self) -> List[int]:
+		return self._execute_function("DOM.getTopLayerElements", {})
+	
+	def _hide_highlight_impl(self) -> None:
+		return self._execute_function("DOM.hideHighlight", {})
+	
+	def _highlight_node_impl(self) -> None:
+		return self._execute_function("DOM.highlightNode", {})
+	
+	def _highlight_rect_impl(self) -> None:
+		return self._execute_function("DOM.highlightRect", {})
+	
+	def _mark_undoable_state_impl(self) -> None:
+		return self._execute_function("DOM.markUndoableState", {})
+	
+	def _move_to_impl(
+			self,
+			node_id: int,
+			target_node_id: int,
+			insert_before_node_id: Optional[int] = None
+	) -> int:
+		return self._execute_function(
+				"DOM.moveTo",
+				{
+					"node_id": node_id,
+					"target_node_id": target_node_id,
+					"insert_before_node_id": insert_before_node_id
+				}
+		)
+	
+	def _perform_search_impl(self, query: str, include_user_agent_shadow_dom: Optional[bool] = None) -> Tuple[str, int]:
+		return self._execute_function(
+				"DOM.performSearch",
+				{
+					"query": query,
+					"include_user_agent_shadow_dom": include_user_agent_shadow_dom
+				}
+		)
+	
+	def _push_node_by_path_to_frontend_impl(self, path: str) -> int:
+		return self._execute_function("DOM.pushNodeByPathToFrontend", {"path": path})
+	
+	def _push_nodes_by_backend_ids_to_frontend_impl(self, backend_node_ids: List[int]) -> List[int]:
+		return self._execute_function(
+				"DOM.pushNodesByBackendIdsToFrontend",
+				{"backend_node_ids": backend_node_ids}
+		)
+	
+	def _query_selector_all_impl(self, node_id: int, selector: str) -> List[int]:
+		return self._execute_function("DOM.querySelectorAll", {"node_id": node_id, "selector": selector})
+	
+	def _query_selector_impl(self, node_id: int, selector: str) -> int:
+		return self._execute_function("DOM.querySelector", {"node_id": node_id, "selector": selector})
+	
+	def _redo_impl(self) -> None:
+		return self._execute_function("DOM.redo", {})
+	
+	def _remove_attribute_impl(self, node_id: int, name: str) -> None:
+		return self._execute_function("DOM.removeAttribute", {"node_id": node_id, "name": name})
+	
+	def _remove_node_impl(self, node_id: int) -> None:
+		return self._execute_function("DOM.removeNode", {"node_id": node_id})
+	
+	def _request_child_nodes_impl(
+			self,
+			node_id: int,
+			depth: Optional[int] = None,
+			pierce: Optional[bool] = None
+	) -> None:
+		return self._execute_function(
+				"DOM.requestChildNodes",
+				{"node_id": node_id, "depth": depth, "pierce": pierce}
+		)
+	
+	def _request_node_impl(self, object_id: str) -> int:
+		return self._execute_function("DOM.requestNode", {"object_id": object_id})
+	
+	def _resolve_node_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_group: Optional[str] = None,
+			execution_context_id: Optional[int] = None
+	) -> Dict[str, Any]:
+		return self._execute_function(
+				"DOM.resolveNode",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_group": object_group,
+					"execution_context_id": execution_context_id
+				}
+		)
+	
+	def _scroll_into_view_if_needed_impl(
+			self,
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None,
+			rect: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._execute_function(
+				"DOM.scrollIntoViewIfNeeded",
+				{
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id,
+					"rect": rect
+				}
+		)
+	
+	def _set_attribute_value_impl(self, node_id: int, name: str, value: str) -> None:
+		return self._execute_function(
+				"DOM.setAttributeValue",
+				{"node_id": node_id, "name": name, "value": value}
+		)
+	
+	def _set_attributes_as_text_impl(self, node_id: int, text: str, name: Optional[str] = None) -> None:
+		return self._execute_function(
+				"DOM.setAttributesAsText",
+				{"node_id": node_id, "text": text, "name": name}
+		)
+	
+	def _set_file_input_files_impl(
+			self,
+			files: List[str],
+			node_id: Optional[int] = None,
+			backend_node_id: Optional[int] = None,
+			object_id: Optional[str] = None
+	) -> None:
+		return self._execute_function(
+				"DOM.setFileInputFiles",
+				{
+					"files": files,
+					"node_id": node_id,
+					"backend_node_id": backend_node_id,
+					"object_id": object_id
+				}
+		)
+	
+	def _set_inspected_node_impl(self, node_id: int) -> None:
+		return self._execute_function("DOM.setInspectedNode", {"node_id": node_id})
+	
+	def _set_node_name_impl(self, node_id: int, name: str) -> int:
+		return self._execute_function("DOM.setNodeName", {"node_id": node_id, "name": name})
+	
+	def _set_node_stack_traces_enabled_impl(self, enable: bool) -> None:
+		return self._execute_function("DOM.setNodeStackTracesEnabled", {"enable": enable})
+	
+	def _set_node_value_impl(self, node_id: int, value: str) -> None:
+		return self._execute_function("DOM.setNodeValue", {"node_id": node_id, "value": value})
+	
+	def _set_outer_html_impl(self, node_id: int, outer_html: str) -> None:
+		return self._execute_function("DOM.setOuterHTML", {"node_id": node_id, "outer_html": outer_html})
+	
+	def _undo_impl(self) -> None:
+		return self._execute_function("DOM.undo", {})