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

osn_selenium/executors/sync/cdp/audits.py

@@ -0,0 +1,48 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.audits import (
+	UnifiedAuditsCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.audits import (
+	AbstractAuditsCDPExecutor
+)
+
+
+__all__ = ["AuditsCDPExecutor"]
+
+
+class AuditsCDPExecutor(UnifiedAuditsCDPExecutor, AbstractAuditsCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedAuditsCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def check_contrast(self, report_aaa: Optional[bool] = None) -> None:
+		return self._check_contrast_impl(report_aaa=report_aaa)
+	
+	def check_forms_issues(self) -> List[Dict[str, Any]]:
+		return self._check_forms_issues_impl()
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def get_encoded_response(
+			self,
+			request_id: str,
+			encoding: str,
+			quality: Optional[float] = None,
+			size_only: Optional[bool] = None
+	) -> Tuple[Optional[str], int, int]:
+		return self._get_encoded_response_impl(
+				request_id=request_id,
+				encoding=encoding,
+				quality=quality,
+				size_only=size_only
+		)

osn_selenium/executors/sync/cdp/autofill.py

@@ -0,0 +1,39 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.autofill import (
+	UnifiedAutofillCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.autofill import (
+	AbstractAutofillCDPExecutor
+)
+
+
+__all__ = ["AutofillCDPExecutor"]
+
+
+class AutofillCDPExecutor(UnifiedAutofillCDPExecutor, AbstractAutofillCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedAutofillCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def set_addresses(self, addresses: List[Dict[str, Any]]) -> None:
+		return self._set_addresses_impl(addresses=addresses)
+	
+	def trigger(
+			self,
+			field_id: int,
+			frame_id: Optional[str] = None,
+			card: Optional[Dict[str, Any]] = None,
+			address: Optional[Dict[str, Any]] = None
+	) -> None:
+		return self._trigger_impl(field_id=field_id, frame_id=frame_id, card=card, address=address)

osn_selenium/executors/sync/cdp/background_service.py

@@ -0,0 +1,30 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.background_service import (
+	UnifiedBackgroundServiceCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.background_service import (
+	AbstractBackgroundServiceCDPExecutor
+)
+
+
+__all__ = ["BackgroundServiceCDPExecutor"]
+
+
+class BackgroundServiceCDPExecutor(
+		UnifiedBackgroundServiceCDPExecutor,
+		AbstractBackgroundServiceCDPExecutor
+):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedBackgroundServiceCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def clear_events(self, service: str) -> None:
+		return self._clear_events_impl(service=service)
+	
+	def set_recording(self, should_record: bool, service: str) -> None:
+		return self._set_recording_impl(should_record=should_record, service=service)
+	
+	def start_observing(self, service: str) -> None:
+		return self._start_observing_impl(service=service)
+	
+	def stop_observing(self, service: str) -> None:
+		return self._stop_observing_impl(service=service)

osn_selenium/executors/sync/cdp/bluetooth_emulation.py

@@ -0,0 +1,101 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.bluetooth_emulation import (
+	UnifiedBluetoothEmulationCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.bluetooth_emulation import (
+	AbstractBluetoothEmulationCDPExecutor
+)
+
+
+__all__ = ["BluetoothEmulationCDPExecutor"]
+
+
+class BluetoothEmulationCDPExecutor(
+		UnifiedBluetoothEmulationCDPExecutor,
+		AbstractBluetoothEmulationCDPExecutor
+):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedBluetoothEmulationCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def add_characteristic(
+			self,
+			service_id: str,
+			characteristic_uuid: str,
+			properties: Dict[str, Any]
+	) -> str:
+		return self._add_characteristic_impl(
+				service_id=service_id,
+				characteristic_uuid=characteristic_uuid,
+				properties=properties
+		)
+	
+	def add_descriptor(self, characteristic_id: str, descriptor_uuid: str) -> str:
+		return self._add_descriptor_impl(characteristic_id=characteristic_id, descriptor_uuid=descriptor_uuid)
+	
+	def add_service(self, address: str, service_uuid: str) -> str:
+		return self._add_service_impl(address=address, service_uuid=service_uuid)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self, state: str, le_supported: bool) -> None:
+		return self._enable_impl(state=state, le_supported=le_supported)
+	
+	def remove_characteristic(self, characteristic_id: str) -> None:
+		return self._remove_characteristic_impl(characteristic_id=characteristic_id)
+	
+	def remove_descriptor(self, descriptor_id: str) -> None:
+		return self._remove_descriptor_impl(descriptor_id=descriptor_id)
+	
+	def remove_service(self, service_id: str) -> None:
+		return self._remove_service_impl(service_id=service_id)
+	
+	def set_simulated_central_state(self, state: str) -> None:
+		return self._set_simulated_central_state_impl(state=state)
+	
+	def simulate_advertisement(self, entry: Dict[str, Any]) -> None:
+		return self._simulate_advertisement_impl(entry=entry)
+	
+	def simulate_characteristic_operation_response(
+			self,
+			characteristic_id: str,
+			type_: str,
+			code: int,
+			data: Optional[str] = None
+	) -> None:
+		return self._simulate_characteristic_operation_response_impl(characteristic_id=characteristic_id, type_=type_, code=code, data=data)
+	
+	def simulate_descriptor_operation_response(
+			self,
+			descriptor_id: str,
+			type_: str,
+			code: int,
+			data: Optional[str] = None
+	) -> None:
+		return self._simulate_descriptor_operation_response_impl(descriptor_id=descriptor_id, type_=type_, code=code, data=data)
+	
+	def simulate_gatt_disconnection(self, address: str) -> None:
+		return self._simulate_gatt_disconnection_impl(address=address)
+	
+	def simulate_gatt_operation_response(self, address: str, type_: str, code: int) -> None:
+		return self._simulate_gatt_operation_response_impl(address=address, type_=type_, code=code)
+	
+	def simulate_preconnected_peripheral(
+			self,
+			address: str,
+			name: str,
+			manufacturer_data: List[Dict[str, Any]],
+			known_service_uuids: List[str]
+	) -> None:
+		return self._simulate_preconnected_peripheral_impl(
+				address=address,
+				name=name,
+				manufacturer_data=manufacturer_data,
+				known_service_uuids=known_service_uuids
+		)

osn_selenium/executors/sync/cdp/browser.py

@@ -0,0 +1,131 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.browser import (
+	UnifiedBrowserCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.browser import (
+	AbstractBrowserCDPExecutor
+)
+
+
+__all__ = ["BrowserCDPExecutor"]
+
+
+class BrowserCDPExecutor(UnifiedBrowserCDPExecutor, AbstractBrowserCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedBrowserCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def add_privacy_sandbox_coordinator_key_config(
+			self,
+			api: str,
+			coordinator_origin: str,
+			key_config: str,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return self._add_privacy_sandbox_coordinator_key_config_impl(
+				api=api,
+				coordinator_origin=coordinator_origin,
+				key_config=key_config,
+				browser_context_id=browser_context_id
+		)
+	
+	def add_privacy_sandbox_enrollment_override(self, url: str) -> None:
+		return self._add_privacy_sandbox_enrollment_override_impl(url=url)
+	
+	def cancel_download(self, guid: str, browser_context_id: Optional[str] = None) -> None:
+		return self._cancel_download_impl(guid=guid, browser_context_id=browser_context_id)
+	
+	def close(self) -> None:
+		return self._close_impl()
+	
+	def crash(self) -> None:
+		return self._crash_impl()
+	
+	def crash_gpu_process(self) -> None:
+		return self._crash_gpu_process_impl()
+	
+	def execute_browser_command(self, command_id: str) -> None:
+		return self._execute_browser_command_impl(command_id=command_id)
+	
+	def get_browser_command_line(self) -> List[str]:
+		return self._get_browser_command_line_impl()
+	
+	def get_histogram(self, name: str, delta: Optional[bool] = None) -> Dict[str, Any]:
+		return self._get_histogram_impl(name=name, delta=delta)
+	
+	def get_histograms(self, query: Optional[str] = None, delta: Optional[bool] = None) -> List[Dict[str, Any]]:
+		return self._get_histograms_impl(query=query, delta=delta)
+	
+	def get_version(self) -> Tuple[str, str, str, str, str]:
+		return self._get_version_impl()
+	
+	def get_window_bounds(self, window_id: int) -> Dict[str, Any]:
+		return self._get_window_bounds_impl(window_id=window_id)
+	
+	def get_window_for_target(self, target_id: Optional[str] = None) -> Tuple[int, Dict[str, Any]]:
+		return self._get_window_for_target_impl(target_id=target_id)
+	
+	def grant_permissions(
+			self,
+			permissions: List[str],
+			origin: Optional[str] = None,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return self._grant_permissions_impl(
+				permissions=permissions,
+				origin=origin,
+				browser_context_id=browser_context_id
+		)
+	
+	def reset_permissions(self, browser_context_id: Optional[str] = None) -> None:
+		return self._reset_permissions_impl(browser_context_id=browser_context_id)
+	
+	def set_contents_size(
+			self,
+			window_id: int,
+			width: Optional[int] = None,
+			height: Optional[int] = None
+	) -> None:
+		return self._set_contents_size_impl(window_id=window_id, width=width, height=height)
+	
+	def set_dock_tile(self, badge_label: Optional[str] = None, image: Optional[str] = None) -> None:
+		return self._set_dock_tile_impl(badge_label=badge_label, image=image)
+	
+	def set_download_behavior(
+			self,
+			behavior: str,
+			browser_context_id: Optional[str] = None,
+			download_path: Optional[str] = None,
+			events_enabled: Optional[bool] = None
+	) -> None:
+		return self._set_download_behavior_impl(
+				behavior=behavior,
+				browser_context_id=browser_context_id,
+				download_path=download_path,
+				events_enabled=events_enabled
+		)
+	
+	def set_permission(
+			self,
+			permission: Dict[str, Any],
+			setting: str,
+			origin: Optional[str] = None,
+			embedded_origin: Optional[str] = None,
+			browser_context_id: Optional[str] = None
+	) -> None:
+		return self._set_permission_impl(
+				permission=permission,
+				setting=setting,
+				origin=origin,
+				embedded_origin=embedded_origin,
+				browser_context_id=browser_context_id
+		)
+	
+	def set_window_bounds(self, window_id: int, bounds: Dict[str, Any]) -> None:
+		return self._set_window_bounds_impl(window_id=window_id, bounds=bounds)

osn_selenium/executors/sync/cdp/cache_storage.py

@@ -0,0 +1,66 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.cache_storage import (
+	UnifiedCacheStorageCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.cache_storage import (
+	AbstractCacheStorageCDPExecutor
+)
+
+
+__all__ = ["CacheStorageCDPExecutor"]
+
+
+class CacheStorageCDPExecutor(UnifiedCacheStorageCDPExecutor, AbstractCacheStorageCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedCacheStorageCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def delete_cache(self, cache_id: str) -> None:
+		return self._delete_cache_impl(cache_id=cache_id)
+	
+	def delete_entry(self, cache_id: str, request: str) -> None:
+		return self._delete_entry_impl(cache_id=cache_id, request=request)
+	
+	def request_cache_names(
+			self,
+			security_origin: Optional[str] = None,
+			storage_key: Optional[str] = None,
+			storage_bucket: Optional[Dict[str, Any]] = None
+	) -> List[Dict[str, Any]]:
+		return self._request_cache_names_impl(
+				security_origin=security_origin,
+				storage_key=storage_key,
+				storage_bucket=storage_bucket
+		)
+	
+	def request_cached_response(
+			self,
+			cache_id: str,
+			request_url: str,
+			request_headers: List[Dict[str, Any]]
+	) -> Dict[str, Any]:
+		return self._request_cached_response_impl(
+				cache_id=cache_id,
+				request_url=request_url,
+				request_headers=request_headers
+		)
+	
+	def request_entries(
+			self,
+			cache_id: str,
+			skip_count: Optional[int] = None,
+			page_size: Optional[int] = None,
+			path_filter: Optional[str] = None
+	) -> Tuple[List[Dict[str, Any]], float]:
+		return self._request_entries_impl(
+				cache_id=cache_id,
+				skip_count=skip_count,
+				page_size=page_size,
+				path_filter=path_filter
+		)

osn_selenium/executors/sync/cdp/cast.py

@@ -0,0 +1,38 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	Optional
+)
+from osn_selenium.executors.unified.cdp.cast import (
+	UnifiedCastCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.cast import (
+	AbstractCastCDPExecutor
+)
+
+
+__all__ = ["CastCDPExecutor"]
+
+
+class CastCDPExecutor(UnifiedCastCDPExecutor, AbstractCastCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedCastCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self, presentation_url: Optional[str] = None) -> None:
+		return self._enable_impl(presentation_url=presentation_url)
+	
+	def set_sink_to_use(self, sink_name: str) -> None:
+		return self._set_sink_to_use_impl(sink_name=sink_name)
+	
+	def start_desktop_mirroring(self, sink_name: str) -> None:
+		return self._start_desktop_mirroring_impl(sink_name=sink_name)
+	
+	def start_tab_mirroring(self, sink_name: str) -> None:
+		return self._start_tab_mirroring_impl(sink_name=sink_name)
+	
+	def stop_casting(self, sink_name: str) -> None:
+		return self._stop_casting_impl(sink_name=sink_name)

osn_selenium/executors/sync/cdp/console.py

@@ -0,0 +1,24 @@
+from typing import Any, Callable, Dict
+from osn_selenium.executors.unified.cdp.console import (
+	UnifiedConsoleCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.console import (
+	AbstractConsoleCDPExecutor
+)
+
+
+__all__ = ["ConsoleCDPExecutor"]
+
+
+class ConsoleCDPExecutor(UnifiedConsoleCDPExecutor, AbstractConsoleCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedConsoleCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def clear_messages(self) -> None:
+		return self._clear_messages_impl()
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()

osn_selenium/executors/sync/cdp/css.py

@@ -0,0 +1,187 @@
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	List,
+	Optional,
+	Tuple
+)
+from osn_selenium.executors.unified.cdp.css import (
+	UnifiedCssCDPExecutor
+)
+from osn_selenium.abstract.executors.cdp.css import (
+	AbstractCssCDPExecutor
+)
+
+
+__all__ = ["CssCDPExecutor"]
+
+
+class CssCDPExecutor(UnifiedCssCDPExecutor, AbstractCssCDPExecutor):
+	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
+		UnifiedCssCDPExecutor.__init__(self, execute_function=execute_function)
+	
+	def add_rule(
+			self,
+			style_sheet_id: str,
+			rule_text: str,
+			location: Dict[str, Any],
+			node_for_property_syntax_validation: Optional[int] = None
+	) -> Dict[str, Any]:
+		return self._add_rule_impl(
+				style_sheet_id=style_sheet_id,
+				rule_text=rule_text,
+				location=location,
+				node_for_property_syntax_validation=node_for_property_syntax_validation
+		)
+	
+	def collect_class_names(self, style_sheet_id: str) -> List[str]:
+		return self._collect_class_names_impl(style_sheet_id=style_sheet_id)
+	
+	def create_style_sheet(self, frame_id: str, force: Optional[bool] = None) -> str:
+		return self._create_style_sheet_impl(frame_id=frame_id, force=force)
+	
+	def disable(self) -> None:
+		return self._disable_impl()
+	
+	def enable(self) -> None:
+		return self._enable_impl()
+	
+	def force_pseudo_state(self, node_id: int, forced_pseudo_classes: List[str]) -> None:
+		return self._force_pseudo_state_impl(node_id=node_id, forced_pseudo_classes=forced_pseudo_classes)
+	
+	def force_starting_style(self, node_id: int, forced: bool) -> None:
+		return self._force_starting_style_impl(node_id=node_id, forced=forced)
+	
+	def get_animated_styles_for_node(self, node_id: int) -> Tuple[
+		Optional[List[Dict[str, Any]]],
+		Optional[Dict[str, Any]],
+		Optional[List[Dict[str, Any]]]
+	]:
+		return self._get_animated_styles_for_node_impl(node_id=node_id)
+	
+	def get_background_colors(self, node_id: int) -> Tuple[Optional[List[str]], Optional[str], Optional[str]]:
+		return self._get_background_colors_impl(node_id=node_id)
+	
+	def get_computed_style_for_node(self, node_id: int) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+		return self._get_computed_style_for_node_impl(node_id=node_id)
+	
+	def get_environment_variables(self) -> Any:
+		return self._get_environment_variables_impl()
+	
+	def get_inline_styles_for_node(self, node_id: int) -> Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
+		return self._get_inline_styles_for_node_impl(node_id=node_id)
+	
+	def get_layers_for_node(self, node_id: int) -> Dict[str, Any]:
+		return self._get_layers_for_node_impl(node_id=node_id)
+	
+	def get_location_for_selector(self, style_sheet_id: str, selector_text: str) -> List[Dict[str, Any]]:
+		return self._get_location_for_selector_impl(style_sheet_id=style_sheet_id, selector_text=selector_text)
+	
+	def get_longhand_properties(self, shorthand_name: str, value: str) -> List[Dict[str, Any]]:
+		return self._get_longhand_properties_impl(shorthand_name=shorthand_name, value=value)
+	
+	def get_matched_styles_for_node(self, node_id: int) -> Tuple[
+		Optional[Dict[str, Any]],
+		Optional[Dict[str, Any]],
+		Optional[List[Dict[str, Any]]],
+		Optional[List[Dict[str, Any]]],
+		Optional[List[Dict[str, Any]]],
+		Optional[List[Dict[str, Any]]],
+		Optional[List[Dict[str, Any]]],
+		Optional[List[Dict[str, Any]]],
+		Optional[int],
+		Optional[List[Dict[str, Any]]],
+		Optional[List[Dict[str, Any]]],
+		Optional[Dict[str, Any]],
+		Optional[int],
+		Optional[List[Dict[str, Any]]]
+	]:
+		return self._get_matched_styles_for_node_impl(node_id=node_id)
+	
+	def get_media_queries(self) -> List[Dict[str, Any]]:
+		return self._get_media_queries_impl()
+	
+	def get_platform_fonts_for_node(self, node_id: int) -> List[Dict[str, Any]]:
+		return self._get_platform_fonts_for_node_impl(node_id=node_id)
+	
+	def get_style_sheet_text(self, style_sheet_id: str) -> str:
+		return self._get_style_sheet_text_impl(style_sheet_id=style_sheet_id)
+	
+	def resolve_values(
+			self,
+			values: List[str],
+			node_id: int,
+			property_name: Optional[str] = None,
+			pseudo_type: Optional[str] = None,
+			pseudo_identifier: Optional[str] = None
+	) -> List[str]:
+		return self._resolve_values_impl(
+				values=values,
+				node_id=node_id,
+				property_name=property_name,
+				pseudo_type=pseudo_type,
+				pseudo_identifier=pseudo_identifier
+		)
+	
+	def set_container_query_text(self, style_sheet_id: str, range_: Dict[str, Any], text: str) -> Dict[str, Any]:
+		return self._set_container_query_text_impl(style_sheet_id=style_sheet_id, range_=range_, text=text)
+	
+	def set_effective_property_value_for_node(self, node_id: int, property_name: str, value: str) -> None:
+		return self._set_effective_property_value_for_node_impl(node_id=node_id, property_name=property_name, value=value)
+	
+	def set_keyframe_key(self, style_sheet_id: str, range_: Dict[str, Any], key_text: str) -> Dict[str, Any]:
+		return self._set_keyframe_key_impl(style_sheet_id=style_sheet_id, range_=range_, key_text=key_text)
+	
+	def set_local_fonts_enabled(self, enabled: bool) -> None:
+		return self._set_local_fonts_enabled_impl(enabled=enabled)
+	
+	def set_media_text(self, style_sheet_id: str, range_: Dict[str, Any], text: str) -> Dict[str, Any]:
+		return self._set_media_text_impl(style_sheet_id=style_sheet_id, range_=range_, text=text)
+	
+	def set_property_rule_property_name(self, style_sheet_id: str, range_: Dict[str, Any], property_name: str) -> Dict[str, Any]:
+		return self._set_property_rule_property_name_impl(
+				style_sheet_id=style_sheet_id,
+				range_=range_,
+				property_name=property_name
+		)
+	
+	def set_rule_selector(self, style_sheet_id: str, range_: Dict[str, Any], selector: str) -> Dict[str, Any]:
+		return self._set_rule_selector_impl(style_sheet_id=style_sheet_id, range_=range_, selector=selector)
+	
+	def set_scope_text(self, style_sheet_id: str, range_: Dict[str, Any], text: str) -> Dict[str, Any]:
+		return self._set_scope_text_impl(style_sheet_id=style_sheet_id, range_=range_, text=text)
+	
+	def set_style_sheet_text(self, style_sheet_id: str, text: str) -> Optional[str]:
+		return self._set_style_sheet_text_impl(style_sheet_id=style_sheet_id, text=text)
+	
+	def set_style_texts(
+			self,
+			edits: List[Dict[str, Any]],
+			node_for_property_syntax_validation: Optional[int] = None
+	) -> List[Dict[str, Any]]:
+		return self._set_style_texts_impl(
+				edits=edits,
+				node_for_property_syntax_validation=node_for_property_syntax_validation
+		)
+	
+	def set_supports_text(self, style_sheet_id: str, range_: Dict[str, Any], text: str) -> Dict[str, Any]:
+		return self._set_supports_text_impl(style_sheet_id=style_sheet_id, range_=range_, text=text)
+	
+	def start_rule_usage_tracking(self) -> None:
+		return self._start_rule_usage_tracking_impl()
+	
+	def stop_rule_usage_tracking(self) -> List[Dict[str, Any]]:
+		return self._stop_rule_usage_tracking_impl()
+	
+	def take_computed_style_updates(self) -> List[int]:
+		return self._take_computed_style_updates_impl()
+	
+	def take_coverage_delta(self) -> Tuple[List[Dict[str, Any]], float]:
+		return self._take_coverage_delta_impl()
+	
+	def track_computed_style_updates(self, properties_to_track: List[Dict[str, Any]]) -> None:
+		return self._track_computed_style_updates_impl(properties_to_track=properties_to_track)
+	
+	def track_computed_style_updates_for_node(self, node_id: Optional[int] = None) -> None:
+		return self._track_computed_style_updates_for_node_impl(node_id=node_id)