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

osn_selenium/{webdrivers/Blink/flags.py → flags/blink.py}

@@ -1,28 +1,32 @@
 import pathlib
-from typing import (
-	Any,
-	Optional,
-	TypedDict,
-	Union
+from typing import Dict, List, Optional
+from osn_selenium._functions import validate_path
+from osn_selenium._typehints import PATH_TYPEHINT
+from osn_selenium.flags.base import BrowserFlagsManager
+from osn_selenium.exceptions.flags import FlagNotDefinedError
+from osn_selenium.flags._functions import (
+	build_first_start_argument
 )
-from osn_selenium.webdrivers.BaseDriver.flags import (
-	BrowserArguments,
-	BrowserAttributes,
-	BrowserExperimentalOptions,
-	BrowserFlagsManager
+from osn_selenium.exceptions.logic import (
+	AbstractImplementationError
 )
-from osn_selenium.webdrivers.types import (
-	AutoplayPolicyType,
+from osn_selenium.flags._typehints import (
+	BLINK_WEBDRIVER_OPTION_TYPEHINT
+)
+from osn_selenium.flags.models.base import (
 	FlagDefinition,
 	FlagNotDefined,
-	FlagType,
-	LogLevelType,
-	UseGLType,
-	_blink_webdriver_option_type
+	FlagType
+)
+from osn_selenium.flags.models.blink import (
+	BlinkArguments,
+	BlinkAttributes,
+	BlinkExperimentalOptions,
+	BlinkFeatures,
+	BlinkFlags
 )
-from osn_selenium.webdrivers._functions import (
+from osn_selenium.flags._validators import (
 	bool_adding_validation_function,
-	build_first_start_argument,
 	int_adding_validation_function,
 	optional_bool_adding_validation_function,
 	path_adding_validation_function,
@@ -30,236 +34,7 @@ from osn_selenium.webdrivers._functions import (
 )
 
 
-class BlinkExperimentalOptions(BrowserExperimentalOptions, total=False):
-	"""
-	Typed dictionary for experimental options specific to Blink-based browsers.
-
-	Attributes:
-		debugger_address (Optional[str]): The address (IP:port) of the remote debugger.
-	"""
-	
-	debugger_address: Optional[str]
-
-
-class BlinkFeatures(TypedDict, total=False):
-	"""
-	Typed dictionary for Blink-specific feature flags.
-
-	These flags control experimental or internal features within the Blink rendering engine.
-
-	Attributes:
-		calculate_native_win_occlusion (Optional[bool]): Controls native window occlusion calculation.
-		accept_ch_frame (Optional[bool]): Enables/disables Accept-CH frame.
-		avoid_unload_check_sync (Optional[bool]): Avoids synchronous unload checks.
-		bfcache_feature (Optional[bool]): Controls the Back-Forward Cache feature.
-		heavy_ad_mitigations (Optional[bool]): Enables/disables heavy ad mitigations.
-		isolate_origins (Optional[bool]): Controls origin isolation.
-		lazy_frame_loading (Optional[bool]): Enables/disables lazy frame loading.
-		script_streaming (Optional[bool]): Controls script streaming.
-		global_media_controls (Optional[bool]): Enables/disables global media controls.
-		improved_cookie_controls (Optional[bool]): Enables/disables improved cookie controls.
-		privacy_sandbox_settings4 (Optional[bool]): Controls Privacy Sandbox settings (version 4).
-		media_router (Optional[bool]): Enables/disables media router.
-		autofill_server_comm (Optional[bool]): Controls autofill server communication.
-		cert_transparency_updater (Optional[bool]): Controls certificate transparency updater.
-		optimization_hints (Optional[bool]): Enables/disables optimization hints.
-		dial_media_route_provider (Optional[bool]): Controls DIAL media route provider.
-		paint_holding (Optional[bool]): Enables/disables paint holding.
-		destroy_profile_on_browser_close (Optional[bool]): Destroys user profile on browser close.
-		site_per_process (Optional[bool]): Enforces site isolation (site-per-process model).
-		automation_controlled (Optional[bool]): Indicates if the browser is controlled by automation.
-	"""
-	
-	calculate_native_win_occlusion: Optional[bool]
-	accept_ch_frame: Optional[bool]
-	avoid_unload_check_sync: Optional[bool]
-	bfcache_feature: Optional[bool]
-	heavy_ad_mitigations: Optional[bool]
-	isolate_origins: Optional[bool]
-	lazy_frame_loading: Optional[bool]
-	script_streaming: Optional[bool]
-	global_media_controls: Optional[bool]
-	improved_cookie_controls: Optional[bool]
-	privacy_sandbox_settings4: Optional[bool]
-	media_router: Optional[bool]
-	autofill_server_comm: Optional[bool]
-	cert_transparency_updater: Optional[bool]
-	optimization_hints: Optional[bool]
-	dial_media_route_provider: Optional[bool]
-	paint_holding: Optional[bool]
-	destroy_profile_on_browser_close: Optional[bool]
-	site_per_process: Optional[bool]
-	automation_controlled: Optional[bool]
-
-
-class BlinkAttributes(BrowserAttributes, total=False):
-	"""
-	Typed dictionary for WebDriver attributes specific to Blink-based browsers.
-
-	Attributes:
-		enable_bidi (Optional[bool]): Enables/disables BiDi (Bidirectional) protocol mapper.
-	"""
-	
-	pass
-
-
-class BlinkArguments(BrowserArguments, total=False):
-	"""
-	Typed dictionary for command-line arguments specific to Blink-based browsers.
-
-	Attributes:
-		se_downloads_enabled (bool): Enables/disables Selenium downloads.
-		headless_mode (bool): Runs the browser in headless mode (without a UI).
-		mute_audio (bool): Mutes audio output from the browser.
-		no_first_run (bool): Prevents the browser from showing the "first run" experience.
-		disable_background_timer_throttling (bool): Disables throttling of background timers.
-		disable_backgrounding_occluded_windows (bool): Prevents backgrounding of occluded windows.
-		disable_hang_monitor (bool): Disables the browser's hang monitor.
-		disable_ipc_flooding_protection (bool): Disables IPC flooding protection.
-		disable_renderer_backgrounding (bool): Prevents renderer processes from being backgrounded.
-		disable_back_forward_cache (bool): Disables the Back-Forward Cache.
-		disable_notifications (bool): Disables web notifications.
-		disable_popup_blocking (bool): Disables the built-in popup blocker.
-		disable_prompt_on_repost (bool): Disables the prompt when reposting form data.
-		disable_sync (bool): Disables browser synchronization features.
-		disable_background_networking (bool): Disables background network activity.
-		disable_breakpad (bool): Disables the crash reporter.
-		disable_component_update (bool): Disables component updates.
-		disable_domain_reliability (bool): Disables domain reliability monitoring.
-		disable_new_content_rendering_timeout (bool): Disables timeout for new content rendering.
-		disable_threaded_animation (bool): Disables threaded animation.
-		disable_threaded_scrolling (bool): Disables threaded scrolling.
-		disable_checker_imaging (bool): Disables checker imaging.
-		disable_image_animation_resync (bool): Disables image animation resynchronization.
-		disable_partial_raster (bool): Disables partial rasterization.
-		disable_skia_runtime_opts (bool): Disables Skia runtime optimizations.
-		disable_dev_shm_usage (bool): Disables the use of /dev/shm (important for Docker).
-		disable_gpu (bool): Disables GPU hardware acceleration.
-		aggressive_cache_discard (bool): Enables aggressive discarding of cached data.
-		allow_running_insecure_content (bool): Allows running insecure content on HTTPS pages.
-		no_process_per_site (bool): Runs all sites in a single process (less secure, but saves memory).
-		enable_precise_memory_info (bool): Enables precise memory information reporting.
-		use_fake_device_for_media_stream (bool): Uses a fake camera/microphone for media streams.
-		use_fake_ui_for_media_stream (bool): Uses a fake UI for media stream requests.
-		deny_permission_prompts (bool): Automatically denies all permission prompts.
-		disable_external_intent_requests (bool): Disables external intent requests.
-		noerrdialogs (bool): Suppresses error dialogs.
-		enable_automation (bool): Enables automation features.
-		test_type (bool): Sets the browser to test mode.
-		remote_debugging_pipe (bool): Uses a pipe for remote debugging instead of a port.
-		silent_debugger_extension_api (bool): Silences debugger extension API warnings.
-		enable_logging_stderr (bool): Enables logging to stderr.
-		password_store_basic (bool): Uses a basic password store.
-		use_mock_keychain (bool): Uses a mock keychain for testing.
-		enable_crash_reporter_for_testing (bool): Enables crash reporter for testing purposes.
-		metrics_recording_only (bool): Records metrics without sending them.
-		no_pings (bool): Disables sending pings.
-		allow_pre_commit_input (bool): Allows pre-commit input.
-		deterministic_mode (bool): Runs the browser in a more deterministic mode.
-		run_all_compositor_stages_before_draw (bool): Runs all compositor stages before drawing.
-		enable_begin_frame_control (bool): Enables begin frame control.
-		in_process_gpu (bool): Runs the GPU process in-process.
-		block_new_web_contents (bool): Blocks new web contents (e.g., pop-ups).
-		new_window (bool): Opens a new window instead of a new tab.
-		no_service_autorun (bool): Disables service autorun.
-		process_per_tab (bool): Runs each tab in its own process.
-		single_process (bool): Runs the browser in a single process (less stable).
-		no_sandbox (bool): Disables the sandbox (less secure, but can fix some issues).
-		user_agent (Optional[str]): Sets a custom user agent string.
-		user_data_dir (Optional[str]): Specifies the user data directory.
-		proxy_server (Optional[str]): Specifies a proxy server to use.
-		remote_debugging_port (Optional[int]): Specifies the remote debugging port.
-		remote_debugging_address (Optional[str]): Specifies the remote debugging address.
-		use_file_for_fake_video_capture (Optional[Union[str, pathlib.Path]]): Uses a file for fake video capture.
-		autoplay_policy (Optional[AutoplayPolicyType]): Sets the autoplay policy.
-		log_level (Optional[LogLevelType]): Sets the browser's log level.
-		use_gl (Optional[UseGLType]): Specifies the GL backend to use.
-		force_color_profile (Optional[str]): Forces a specific color profile.
-	"""
-	
-	headless_mode: bool
-	mute_audio: bool
-	no_first_run: bool
-	disable_background_timer_throttling: bool
-	disable_backgrounding_occluded_windows: bool
-	disable_hang_monitor: bool
-	disable_ipc_flooding_protection: bool
-	disable_renderer_backgrounding: bool
-	disable_back_forward_cache: bool
-	disable_notifications: bool
-	disable_popup_blocking: bool
-	disable_prompt_on_repost: bool
-	disable_sync: bool
-	disable_background_networking: bool
-	disable_breakpad: bool
-	disable_component_update: bool
-	disable_domain_reliability: bool
-	disable_new_content_rendering_timeout: bool
-	disable_threaded_animation: bool
-	disable_threaded_scrolling: bool
-	disable_checker_imaging: bool
-	disable_image_animation_resync: bool
-	disable_partial_raster: bool
-	disable_skia_runtime_opts: bool
-	disable_dev_shm_usage: bool
-	disable_gpu: bool
-	aggressive_cache_discard: bool
-	allow_running_insecure_content: bool
-	no_process_per_site: bool
-	enable_precise_memory_info: bool
-	use_fake_device_for_media_stream: bool
-	use_fake_ui_for_media_stream: bool
-	deny_permission_prompts: bool
-	disable_external_intent_requests: bool
-	noerrdialogs: bool
-	enable_automation: bool
-	test_type: bool
-	remote_debugging_pipe: bool
-	silent_debugger_extension_api: bool
-	enable_logging_stderr: bool
-	password_store_basic: bool
-	use_mock_keychain: bool
-	enable_crash_reporter_for_testing: bool
-	metrics_recording_only: bool
-	no_pings: bool
-	allow_pre_commit_input: bool
-	deterministic_mode: bool
-	run_all_compositor_stages_before_draw: bool
-	enable_begin_frame_control: bool
-	in_process_gpu: bool
-	block_new_web_contents: bool
-	new_window: bool
-	no_service_autorun: bool
-	process_per_tab: bool
-	single_process: bool
-	no_sandbox: bool
-	user_agent: Optional[str]
-	user_data_dir: Optional[str]
-	proxy_server: Optional[str]
-	remote_debugging_port: Optional[int]
-	remote_debugging_address: Optional[str]
-	use_file_for_fake_video_capture: Optional[Union[str, pathlib.Path]]
-	autoplay_policy: Optional[AutoplayPolicyType]
-	log_level: Optional[LogLevelType]
-	use_gl: Optional[UseGLType]
-	force_color_profile: Optional[str]
-
-
-class BlinkFlags(TypedDict, total=False):
-	"""
-	Typed dictionary representing a collection of all flag types for Blink-based browsers.
-
-	Attributes:
-		argument (BlinkArguments): Command-line arguments for the browser.
-		experimental_option (BlinkExperimentalOptions): Experimental options for WebDriver.
-		attribute (BlinkAttributes): WebDriver attributes.
-		blink_feature (BlinkFeatures): Blink-specific feature flags.
-	"""
-	
-	argument: BlinkArguments
-	experimental_option: BlinkExperimentalOptions
-	attribute: BlinkAttributes
-	blink_feature: BlinkFeatures
+__all__ = ["BlinkFlagsManager"]
 
 
 class BlinkFlagsManager(BrowserFlagsManager):
@@ -271,27 +46,27 @@ class BlinkFlagsManager(BrowserFlagsManager):
 	a comprehensive set of predefined flags for these browsers.
 
 	Attributes:
-		_browser_exe (Optional[Union[str, pathlib.Path]]): Path to the browser executable.
+		_browser_exe (Optional[PATH_TYPEHINT]): Path to the browser executable.
 		_start_page_url (Optional[str]): The URL to open when the browser starts.
-		_enable_blink_features (dict[str, str]): Stores enabled Blink feature commands.
-		_disable_blink_features (dict[str, str]): Stores disabled Blink feature commands.
+		_enable_blink_features (Dict[str, str]): Stores enabled Blink feature commands.
+		_disable_blink_features (Dict[str, str]): Stores disabled Blink feature commands.
 	"""
 	
 	def __init__(
 			self,
-			browser_exe: Optional[Union[str, pathlib.Path]] = None,
+			browser_exe: Optional[PATH_TYPEHINT] = None,
 			start_page_url: Optional[str] = None,
-			flags_types: Optional[dict[str, FlagType]] = None,
-			flags_definitions: Optional[dict[str, FlagDefinition]] = None
+			flags_types: Optional[Dict[str, FlagType]] = None,
+			flags_definitions: Optional[Dict[str, FlagDefinition]] = None
 	):
 		"""
 		Initializes the BlinkFlagsManager.
 
 		Args:
-			browser_exe (Optional[Union[str, pathlib.Path]]): Path to the browser executable file.
+			browser_exe (Optional[PATH_TYPEHINT]): Path to the browser executable file.
 			start_page_url (Optional[str]): Initial URL to open on browser startup.
-			flags_types (Optional[dict[str, FlagType]]): Custom flag types to add or override.
-			flags_definitions (Optional[dict[str, FlagDefinition]]): Custom flag definitions to add or override.
+			flags_types (Optional[Dict[str, FlagType]]): Custom flag types to add or override.
+			flags_definitions (Optional[Dict[str, FlagDefinition]]): Custom flag definitions to add or override.
 		"""
 		
 		blink_flags_types = {
@@ -301,8 +76,8 @@ class BlinkFlagsManager(BrowserFlagsManager):
 					set_flags_function=self.set_blink_features,
 					update_flags_function=self.update_blink_features,
 					clear_flags_function=self.clear_blink_features,
-					build_options_function=self.build_options_blink_features,
-					build_start_args_function=self.build_start_args_blink_features
+					build_options_function=self._build_options_blink_features,
+					build_start_args_function=self._build_start_args_blink_features
 			),
 		}
 		
@@ -929,30 +704,31 @@ class BlinkFlagsManager(BrowserFlagsManager):
 				flags_definitions=blink_flags_definitions
 		)
 		
-		self._browser_exe = browser_exe
+		self._browser_exe = validate_path(path=browser_exe)
+		
 		self._start_page_url = start_page_url
-		self._enable_blink_features: dict[str, str] = {}
-		self._disable_blink_features: dict[str, str] = {}
+		self._enable_blink_features: Dict[str, str] = {}
+		self._disable_blink_features: Dict[str, str] = {}
 	
-	def build_start_args_blink_features(self) -> list[str]:
+	def _build_start_args_blink_features(self) -> List[str]:
 		"""
-		Builds a list of Blink feature arguments for browser startup.
+		Builds a List of Blink feature arguments for browser startup.
 
 		Returns:
-			list[str]: A list of startup arguments for Blink features.
+			List[str]: A List of startup arguments for Blink features.
 		"""
 		
 		start_args = []
 		
 		enable_blink_features = dict(
 				filter(
-						lambda item: self._flags_definitions_by_types["blink_feature"][item[0]]["mode"] in ["startup_argument", "both"],
+						lambda item: self._flags_definitions_by_types["blink_feature"][item[0]].mode in ["startup_argument", "both"],
 						self._enable_blink_features.items()
 				)
 		)
 		disable_blink_features = dict(
 				filter(
-						lambda item: self._flags_definitions_by_types["blink_feature"][item[0]]["mode"] in ["startup_argument", "both"],
+						lambda item: self._flags_definitions_by_types["blink_feature"][item[0]].mode in ["startup_argument", "both"],
 						self._disable_blink_features.items()
 				)
 		)
@@ -965,26 +741,26 @@ class BlinkFlagsManager(BrowserFlagsManager):
 		
 		return start_args
 	
-	def build_options_blink_features(self, options: _blink_webdriver_option_type) -> _blink_webdriver_option_type:
+	def _build_options_blink_features(self, options: BLINK_WEBDRIVER_OPTION_TYPEHINT) -> BLINK_WEBDRIVER_OPTION_TYPEHINT:
 		"""
 		Adds configured Blink features (`--enable-blink-features` and `--disable-blink-features`) to the WebDriver options.
 
 		Args:
-			options (_blink_webdriver_option_type): The WebDriver options object to modify.
+			options (blink_webdriver_option_type): The WebDriver options object to modify.
 
 		Returns:
-			_blink_webdriver_option_type: The modified WebDriver options object.
+			blink_webdriver_option_type: The modified WebDriver options object.
 		"""
 		
 		enable_blink_features = dict(
 				filter(
-						lambda item: self._flags_definitions_by_types["blink_feature"][item[0]]["mode"] in ["webdriver_option", "both"],
+						lambda item: self._flags_definitions_by_types["blink_feature"][item[0]].mode in ["webdriver_option", "both"],
 						self._enable_blink_features.items()
 				)
 		)
 		disable_blink_features = dict(
 				filter(
-						lambda item: self._flags_definitions_by_types["blink_feature"][item[0]]["mode"] in ["webdriver_option", "both"],
+						lambda item: self._flags_definitions_by_types["blink_feature"][item[0]].mode in ["webdriver_option", "both"],
 						self._disable_blink_features.items()
 				)
 		)
@@ -1025,9 +801,9 @@ class BlinkFlagsManager(BrowserFlagsManager):
 			enable (Optional[bool]): `True` to enable, `False` to disable. If `None`, the feature is removed.
 		"""
 		
-		blink_feature_name = blink_feature["name"]
-		blink_feature_command = blink_feature["command"]
-		adding_validation_function = blink_feature["adding_validation_function"]
+		blink_feature_name = blink_feature.name
+		blink_feature_command = blink_feature.command
+		adding_validation_function = blink_feature.adding_validation_function
 		
 		self.remove_blink_feature(blink_feature_command)
 		
@@ -1037,127 +813,127 @@ class BlinkFlagsManager(BrowserFlagsManager):
 			else:
 				self._disable_blink_features[blink_feature_name] = blink_feature_command
 	
-	def update_blink_features(self, blink_features: Union[BlinkFeatures, dict[str, Optional[bool]]]):
+	def update_blink_features(self, blink_features: BlinkFeatures):
 		"""
 		Updates Blink features from a dictionary without clearing existing ones.
 
 		Args:
-			blink_features (Union[BlinkFeatures, dict[str, Optional[bool]]]): A dictionary of Blink features to set or update.
+			blink_features (BlinkFeatures): A dictionary of Blink features to set or update.
 
 		Raises:
 			ValueError: If an unknown Blink feature key is provided.
 		"""
 		
-		for key, value in blink_features.items():
+		for key, value in blink_features.model_dump(exclude_none=True).items():
 			flag_definition = self._flags_definitions_by_types["blink_feature"].get(key, FlagNotDefined())
 		
 			if isinstance(flag_definition, FlagNotDefined):
-				raise ValueError(f"Unknown blink feature: {key}.")
+				raise FlagNotDefinedError(flag_name=key, flag_type="blink features")
 		
 			self.set_blink_feature(flag_definition, value)
 	
-	def set_blink_features(self, blink_features: Union[BlinkFeatures, dict[str, Optional[bool]]]):
+	def set_blink_features(self, blink_features: BlinkFeatures):
 		"""
 		Clears existing and sets new Blink features from a dictionary.
 
 		Args:
-			blink_features (Union[BlinkFeatures, dict[str, Optional[bool]]]): A dictionary of Blink features to set.
-
-		Raises:
-			ValueError: If an unknown Blink feature key is provided.
+			blink_features (BlinkFeatures): A dictionary of Blink features to set.
 		"""
 		
 		self.clear_blink_features()
 		self.update_blink_features(blink_features)
 	
-	def _renew_webdriver_options(self) -> _blink_webdriver_option_type:
+	def _build_options_arguments(self, options: BLINK_WEBDRIVER_OPTION_TYPEHINT) -> BLINK_WEBDRIVER_OPTION_TYPEHINT:
 		"""
-		Abstract method to renew WebDriver options. Must be implemented in child classes.
+		Adds configured command-line arguments to the WebDriver options.
 
-		This method is intended to be overridden in subclasses to provide
-		browser-specific WebDriver options instances (e.g., ChromeOptions, EdgeOptions).
+		Args:
+			options (blink_webdriver_option_type): The WebDriver options object.
 
 		Returns:
-			_blink_webdriver_option_type: A new instance of WebDriver options (e.g., ChromeOptions, EdgeOptions).
-
-		Raises:
-			NotImplementedError: If the method is not implemented in a subclass.
+			blink_webdriver_option_type: The modified WebDriver options object.
 		"""
 		
-		raise NotImplementedError("This function must be implemented in child classes.")
+		return super()._build_options_arguments(options)
 	
-	@property
-	def browser_exe(self) -> Optional[Union[str, pathlib.Path]]:
+	def _build_options_attributes(self, options: BLINK_WEBDRIVER_OPTION_TYPEHINT) -> BLINK_WEBDRIVER_OPTION_TYPEHINT:
 		"""
-		Returns the browser executable path.
+		Applies configured attributes to the WebDriver options.
 
-		This property retrieves the path to the browser executable that will be used to start the browser instance.
+		Args:
+			options (blink_webdriver_option_type): The WebDriver options object.
 
 		Returns:
-			Optional[Union[str, pathlib.Path]]: The path to the browser executable.
+			blink_webdriver_option_type: The modified WebDriver options object.
 		"""
 		
-		return self._browser_exe
+		return super()._build_options_attributes(options)
 	
-	@browser_exe.setter
-	def browser_exe(self, value: Optional[Union[str, pathlib.Path]]):
+	def _build_options_experimental_options(self, options: BLINK_WEBDRIVER_OPTION_TYPEHINT) -> BLINK_WEBDRIVER_OPTION_TYPEHINT:
 		"""
-		Sets the path to the browser executable.
+		Adds experimental options to the WebDriver options.
 
 		Args:
-			value (Optional[Union[str, pathlib.Path]]): The new path for the browser executable.
+			options (blink_webdriver_option_type): The WebDriver options object.
+
+		Returns:
+			blink_webdriver_option_type: The modified WebDriver options object.
 		"""
 		
-		self._browser_exe = value
+		return super()._build_options_experimental_options(options)
 	
-	def build_options_arguments(self, options: _blink_webdriver_option_type) -> _blink_webdriver_option_type:
+	def _build_start_args_arguments(self) -> List[str]:
 		"""
-		Adds configured command-line arguments to the WebDriver options.
-
-		Args:
-			options (_blink_webdriver_option_type): The WebDriver options object.
+		Builds a List of command-line arguments for browser startup.
 
 		Returns:
-			_blink_webdriver_option_type: The modified WebDriver options object.
+			List[str]: A List of startup arguments.
 		"""
 		
-		return super().build_options_arguments(options)
+		return super()._build_start_args_arguments()
 	
-	def build_options_attributes(self, options: _blink_webdriver_option_type) -> _blink_webdriver_option_type:
+	def _renew_webdriver_options(self) -> BLINK_WEBDRIVER_OPTION_TYPEHINT:
 		"""
-		Applies configured attributes to the WebDriver options.
+		Abstract method to renew WebDriver options. Must be implemented in child classes.
 
-		Args:
-			options (_blink_webdriver_option_type): The WebDriver options object.
+		This method is intended to be overridden in subclasses to provide
+		browser-specific WebDriver options instances (e.g., ChromeOptions, EdgeOptions).
 
 		Returns:
-			_blink_webdriver_option_type: The modified WebDriver options object.
+			blink_webdriver_option_type: A new instance of WebDriver options (e.g., ChromeOptions, EdgeOptions).
+
+		Raises:
+			NotImplementedError: If the method is not implemented in a subclass.
 		"""
 		
-		return super().build_options_attributes(options)
+		raise AbstractImplementationError(
+				method_name="_renew_webdriver_options",
+				class_name=self.__class__.__name__
+		)
 	
-	def build_options_experimental_options(self, options: _blink_webdriver_option_type) -> _blink_webdriver_option_type:
+	@property
+	def browser_exe(self) -> Optional[pathlib.Path]:
 		"""
-		Adds experimental options to the WebDriver options.
+		Returns the browser executable path.
 
-		Args:
-			options (_blink_webdriver_option_type): The WebDriver options object.
+		This property retrieves the path to the browser executable that will be used to start the browser instance.
 
 		Returns:
-			_blink_webdriver_option_type: The modified WebDriver options object.
+			Optional[pathlib.Path]: The path to the browser executable.
 		"""
 		
-		return super().build_options_experimental_options(options)
+		return self._browser_exe
 	
-	def build_start_args_arguments(self) -> list[str]:
+	@browser_exe.setter
+	def browser_exe(self, value: Optional[PATH_TYPEHINT]):
 		"""
-		Builds a list of command-line arguments for browser startup.
+		Sets the path to the browser executable.
 
-		Returns:
-			list[str]: A list of startup arguments.
+		Args:
+			value (Optional[pathlib.Path]): The new path for the browser executable.
 		"""
 		
-		return super().build_start_args_arguments()
+		self._browser_exe = validate_path(path=value)
 	
 	def clear_flags(self):
 		"""Clears all configured flags and resets the start page URL."""
@@ -1166,22 +942,22 @@ class BlinkFlagsManager(BrowserFlagsManager):
 		self._start_page_url = None
 	
 	@property
-	def options(self) -> _blink_webdriver_option_type:
+	def options(self) -> BLINK_WEBDRIVER_OPTION_TYPEHINT:
 		"""
 		Builds and returns a Blink-specific WebDriver options object.
 
 		Returns:
-			_blink_webdriver_option_type: A configured Blink-based WebDriver options object.
+			blink_webdriver_option_type: A configured Blink-based WebDriver options object.
 		"""
 		
 		return super().options
 	
-	def set_arguments(self, arguments: Union[BlinkArguments, dict[str, Any]]):
+	def set_arguments(self, arguments: BlinkArguments):
 		"""
 		Clears existing and sets new command-line arguments from a dictionary.
 
 		Args:
-			arguments (Union[BlinkArguments, dict[str, Any]]): A dictionary of arguments to set.
+			arguments (BlinkArguments): A dictionary of arguments to set.
 
 		Raises:
 			ValueError: If an unknown argument key is provided.
@@ -1189,36 +965,27 @@ class BlinkFlagsManager(BrowserFlagsManager):
 		
 		super().set_arguments(arguments)
 	
-	def set_attributes(self, attributes: Union[BlinkAttributes, dict[str, Any]]):
+	def set_attributes(self, attributes: BlinkAttributes):
 		"""
 		Clears existing and sets new browser attributes from a dictionary.
 
 		Args:
-			attributes (Union[BlinkAttributes, dict[str, Any]]): A dictionary of attributes to set.
-
-		Raises:
-			ValueError: If an unknown attribute key is provided.
+			attributes (BlinkAttributes): A dictionary of attributes to set.
 		"""
 		
 		super().set_attributes(attributes)
 	
-	def set_experimental_options(
-			self,
-			experimental_options: Union[BlinkExperimentalOptions, dict[str, Any]]
-	):
+	def set_experimental_options(self, experimental_options: BlinkExperimentalOptions):
 		"""
 		Clears existing and sets new experimental options from a dictionary.
 
 		Args:
-			experimental_options (Union[BlinkExperimentalOptions, dict[str, Any]]): A dictionary of experimental options to set.
-
-		Raises:
-			ValueError: If an unknown experimental option key is provided.
+			experimental_options (BlinkExperimentalOptions): A dictionary of experimental options to set.
 		"""
 		
 		super().set_experimental_options(experimental_options)
 	
-	def set_flags(self, flags: Union[BlinkFlags, dict[str, dict[str, Any]]]):
+	def set_flags(self, flags: BlinkFlags):
 		"""
 		Clears all existing flags and sets new ones, including Blink features.
 
@@ -1227,25 +994,25 @@ class BlinkFlagsManager(BrowserFlagsManager):
 		'attributes', and 'blink_features'.
 
 		Args:
-			flags (Union[BlinkFlags, dict[str, dict[str, Any]]]): A dictionary where keys are flag types
+			flags (BlinkFlags): A dictionary where keys are flag types
 				and values are dictionaries of flags to set for that type.
 		"""
 		
 		super().set_flags(flags)
 	
 	@property
-	def start_args(self) -> list[str]:
+	def start_args(self) -> List[str]:
 		"""
-		Builds and returns a list of all command-line arguments for browser startup.
+		Builds and returns a List of all command-line arguments for browser startup.
 
 		Returns:
-			list[str]: A list of startup arguments.
+			List[str]: A List of startup arguments.
 		"""
 		
 		args = []
 		
 		for type_name, type_functions in self._flags_types.items():
-			args += type_functions["build_start_args_function"]()
+			args += type_functions.build_start_args_function()
 		
 		return args
 	
@@ -1291,49 +1058,37 @@ class BlinkFlagsManager(BrowserFlagsManager):
 		
 		self._start_page_url = value
 	
-	def update_arguments(self, arguments: Union[BlinkArguments, dict[str, Any]]):
+	def update_arguments(self, arguments: BlinkArguments):
 		"""
 		Updates command-line arguments from a dictionary without clearing existing ones.
 
 		Args:
-			arguments (Union[BlinkArguments, dict[str, Any]]): A dictionary of arguments to set or update.
-
-		Raises:
-			ValueError: If an unknown argument key is provided.
+			arguments (BlinkArguments): A dictionary of arguments to set or update.
 		"""
 		
 		super().update_arguments(arguments)
 	
-	def update_attributes(self, attributes: Union[BlinkAttributes, dict[str, Any]]):
+	def update_attributes(self, attributes: BlinkAttributes):
 		"""
 		Updates browser attributes from a dictionary without clearing existing ones.
 
 		Args:
-			attributes (Union[BlinkAttributes, dict[str, Any]]): A dictionary of attributes to set or update.
-
-		Raises:
-			ValueError: If an unknown attribute key is provided.
+			attributes (BlinkAttributes): A dictionary of attributes to set or update.
 		"""
 		
 		super().update_attributes(attributes)
 	
-	def update_experimental_options(
-			self,
-			experimental_options: Union[BlinkExperimentalOptions, dict[str, Any]]
-	):
+	def update_experimental_options(self, experimental_options: BlinkExperimentalOptions):
 		"""
 		Updates experimental options from a dictionary without clearing existing ones.
 
 		Args:
-			experimental_options (Union[BlinkExperimentalOptions, dict[str, Any]]): A dictionary of experimental options to set or update.
-
-		Raises:
-			ValueError: If an unknown experimental option key is provided.
+			experimental_options (BlinkExperimentalOptions): A dictionary of experimental options to set or update.
 		"""
 		
 		super().update_experimental_options(experimental_options)
 	
-	def update_flags(self, flags: Union[BlinkFlags, dict[str, dict[str, Any]]]):
+	def update_flags(self, flags: BlinkFlags):
 		"""
 		Updates all flags, including Blink features, without clearing existing ones.
 
@@ -1342,8 +1097,15 @@ class BlinkFlagsManager(BrowserFlagsManager):
 		'attributes', and 'blink_features'.
 
 		Args:
-			flags (Union[BlinkFlags, dict[str, dict[str, Any]]]): A dictionary where keys are flag types
+			flags (BlinkFlags): A dictionary where keys are flag types
 				and values are dictionaries of flags to update for that type.
 		"""
 		
 		super().update_flags(flags)
+
+
+BlinkArguments.model_rebuild()
+BlinkExperimentalOptions.model_rebuild()
+BlinkAttributes.model_rebuild()
+BlinkFeatures.model_rebuild()
+BlinkFlags.model_rebuild()