eyes_selenium 6.10.1 → 6.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f105f1ca4e098e9a2ceecc8516223fcafac5f0588d1efa4b8f7500d1cd4b78b3
-  data.tar.gz: d0a55eafd6590ff10431f47f4394df3fb66aaaa80953fb4a9fde801407c77140
+  metadata.gz: 68b8bdfa4db83133a0a620088cf46f761ff472fb052a6efe0a7d4d0383973600
+  data.tar.gz: e30ef6229d5009cd3983fc10cc75036c8e65170ba2a73722ca8a1d9d681b2119
 SHA512:
-  metadata.gz: cb27d925cb15b831a360788687d4429eda4ffa786bc9ae1d1ac108738cf706b4749278520297ab14c9108a4eb83c8b6837a5e60098388a56b83d7d152af198b1
-  data.tar.gz: e7fe16b21cdb4925f0419fedaab818c7ab9a5d705806a770b1064940c627095edfb65f8f363da115754ca161283eca8672fb8403c06f2aed128534ce46dd1a2f
+  metadata.gz: ecbe3d936bb5efc11b77b1b9e71fec189c823966ad06cf9890b497e70d025209edda67b72d11dd8860ab402b8c133ab653c26c1fef8d550c3bfe2ca0c5224550
+  data.tar.gz: a76959c54283e5a1c46331a40ef852ac29a3ef834918c1e2d39abdbb65541f0390794cfb8101bd19c98a58c2fa308c6ba854dc721272f752e7b2cda72213b18c

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [6.11.0](https://github.com/Applitools-Dev/sdk/compare/ruby/eyes_selenium@6.10.1...ruby/eyes_selenium@6.11.0) (2025-07-23)
+
+
+### Features
+
+* android multi target | AD-9868 ([#2943](https://github.com/Applitools-Dev/sdk/issues/2943)) ([808aa21](https://github.com/Applitools-Dev/sdk/commit/808aa21e489c3562b93006e2e26ff7ffbb743dd6))
+
+
+### Dependencies
+
+* @applitools/nml-client bumped to 1.10.0
+  #### Features
+
+  * android multi target | AD-9868 ([#2943](https://github.com/Applitools-Dev/sdk/issues/2943)) ([808aa21](https://github.com/Applitools-Dev/sdk/commit/808aa21e489c3562b93006e2e26ff7ffbb743dd6))
+
+
+
+* @applitools/core-base bumped to 1.26.0
+  #### Features
+
+  * batch properties limit | FLD-3174 ([#3080](https://github.com/Applitools-Dev/sdk/issues/3080)) ([feb9e79](https://github.com/Applitools-Dev/sdk/commit/feb9e79d79f5eab3c58eac2b4ef3c15a562f079c))
+* @applitools/ec-client bumped to 1.11.1
+
+* @applitools/core bumped to 4.43.0
+  #### Features
+
+  * android multi target | AD-9868 ([#2943](https://github.com/Applitools-Dev/sdk/issues/2943)) ([808aa21](https://github.com/Applitools-Dev/sdk/commit/808aa21e489c3562b93006e2e26ff7ffbb743dd6))
+  * batch properties limit | FLD-3174 ([#3080](https://github.com/Applitools-Dev/sdk/issues/3080)) ([feb9e79](https://github.com/Applitools-Dev/sdk/commit/feb9e79d79f5eab3c58eac2b4ef3c15a562f079c))
+
+
+
+* eyes_universal bumped to 4.43.0
+
+* eyes_core bumped to 6.8.2
+
+
 ## [6.10.1](https://github.com/Applitools-Dev/sdk/compare/ruby/eyes_selenium@6.10.0...ruby/eyes_selenium@6.10.1) (2025-07-15)
 
 

data/eyes_selenium.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = %w(lib)
-  spec.add_dependency 'eyes_core', "= 6.8.1"
+  spec.add_dependency 'eyes_core', "= 6.8.2"
   spec.add_dependency 'selenium-webdriver', '>= 3'
   spec.add_dependency 'css_parser'
   spec.add_dependency 'crass'

data/lib/applitools/eyes_selenium/version.rb

@@ -2,7 +2,7 @@
 
 module Applitools
   module EyesSelenium
-    VERSION = '6.10.1'.freeze
+    VERSION = '6.11.0'.freeze
   end
 end
 

data/lib/applitools/selenium/configuration.rb

@@ -2,6 +2,8 @@
 
 require 'applitools/selenium/stitch_modes'
 require 'applitools/selenium/browsers_info'
+require 'applitools/selenium/visual_grid/ios_multi_device_target'
+require 'applitools/selenium/visual_grid/android_multi_device_target'
 
 module Applitools
   module Selenium
@@ -42,29 +44,107 @@ module Applitools
         value
       end
 
+      # Adds multiple mobile device targets to the configuration.
+      #
+      # This method supports several ways to specify device information:
+      # - A hash with device configuration (e.g., { device_name: 'iPhone 13', screen_orientation: 'portrait' })
+      # - A single device name as a string or symbol (e.g., 'iPhone 13' or :iPhone_13)
+      # - Multiple device names as separate arguments
+      # - A platform flag to explicitly specify Android or iOS (e.g., { device_name: 'Pixel 5', platform: :android })
+      #
+      # Device names must be one of the valid device names from the respective platform:
+      # - iOS device names from IosMultiDeviceTargetGenerated ('iPhone 13', 'iPhone 14 Pro', etc.)
+      # - Android device names from AndroidMultiDeviceTargetGenerated ('Pixel 5', 'Galaxy S22', etc.)
+      #
+      # If no platform is specified, the method will attempt to determine the platform based on the device name.
+      #
+      # @param [Array] args device names or configuration hashes
+      # @option args [String, Symbol] :device_name The name of the mobile device
+      # @option args [String, Symbol] :screen_orientation The screen orientation ('portrait' or 'landscape')
+      # @option args [String] :ios_version The iOS version to use (for iOS devices)
+      # @option args [String] :android_version The Android version to use (for Android devices)
+      # @option args [Symbol] :platform The platform (:ios or :android)
+      #
+      # @example Add a single iOS device using a hash
+      #   config.add_multi_device_target(device_name: 'iPhone 13', screen_orientation: 'portrait')
+      #
+      # @example Add a single Android device using a hash
+      #   config.add_multi_device_target(device_name: 'Pixel 5', platform: :android, screen_orientation: 'portrait')
+      #
+      # @example Add a single device using a string (platform detected automatically)
+      #   config.add_multi_device_target('iPhone 13')  # iOS detected
+      #   config.add_multi_device_target('Pixel 5')    # Android detected
+      #
+      # @example Add multiple devices
+      #   config.add_multi_device_target('iPhone 13', 'Pixel 5', 'Galaxy S22')
+      #
+      # @return [Configuration] self for method chaining
       def add_multi_device_target(*args)
-        ios_devices = []
+        mobile_devices = []
 
         if args.length == 1 && args[0].is_a?(Hash)
           # Single hash passed directly
-          ios_devices << create_ios_device_info(args[0])
+          mobile_devices << create_mobile_device_info(args[0])
         elsif args.any? { |arg| arg.is_a?(Hash) }
           # One of the arguments is a hash with device configuration
           hash_arg = args.find { |arg| arg.is_a?(Hash) }
-          ios_devices << create_ios_device_info(hash_arg)
+          mobile_devices << create_mobile_device_info(hash_arg)
         else
           # Multiple device names as symbols or strings
           args.each do |device_name|
-            ios_devices << create_ios_device_info(device_name: device_name)
+            mobile_devices << create_mobile_device_info(device_name: device_name)
           end
         end
 
-        # Add each iOS device to the configuration
-        add_browsers(*ios_devices)
+        # Add each mobile device to the configuration
+        add_browsers(*mobile_devices)
         # Return the configuration object for method chaining
         self
       end
 
+      # Adds a browser configuration to be used for visual grid testing.
+      #
+      # This method can be called in several ways:
+      #
+      # 1. No arguments: Creates a default desktop browser configuration
+      # 2. One argument: Must be an IRenderBrowserInfo instance (like DesktopBrowserInfo or IosDeviceInfo)
+      # 3. Three arguments: width, height, and browser type to create a desktop browser config
+      # 4. With a block: Allows further configuration of the browser using fluent interface
+      #
+      # @overload add_browser()
+      #   Creates a default desktop browser configuration
+      #
+      # @overload add_browser(browser_info)
+      #   @param [IRenderBrowserInfo] browser_info A browser information instance
+      #   @raise [Applitools::EyesIllegalArgument] if browser_info is not an IRenderBrowserInfo instance
+      #
+      # @overload add_browser(width, height, browser_type)
+      #   @param [Integer] width The viewport width
+      #   @param [Integer] height The viewport height
+      #   @param [Symbol] browser_type The browser type (e.g., :chrome, :firefox)
+      #
+      # @yield [browser_config] Yields a RenderBrowserInfoFluent for further configuration
+      # @yieldparam [RenderBrowserInfoFluent] browser_config The browser configuration for fluent interface
+      #
+      # @example Add a default browser
+      #   config.add_browser
+      #
+      # @example Add a specific browser with viewport size
+      #   config.add_browser(1200, 800, :chrome)
+      #
+      # @example Add a browser with fluent interface
+      #   config.add_browser do |browser|
+      #     browser.viewport_size(1200, 800)
+      #           .browser_type(:chrome)
+      #   end
+      #
+      # @example Add a pre-configured browser info
+      #   desktop_browser = Applitools::Selenium::DesktopBrowserInfo.new
+      #   desktop_browser.viewport_size = Applitools::RectangleSize.new(1200, 800)
+      #   desktop_browser.browser_type = :chrome
+      #   config.add_browser(desktop_browser)
+      #
+      # @return [Configuration] self for method chaining
       def add_browser(*args)
         case args.size
         when 0
@@ -88,6 +168,27 @@ module Applitools
         self
       end
 
+      # Adds multiple browser configurations to be used for visual grid testing.
+      #
+      # This method takes an array of browser configurations and adds them all to the
+      # current Eyes configuration. It's useful for configuring multiple browsers at once,
+      # such as when testing across different browsers and devices.
+      #
+      # @param [Array<IRenderBrowserInfo>, Array<Array<IRenderBrowserInfo>>] browsers
+      #   An array of browser information objects or an array containing an array of browser information objects
+      #
+      # @example Add multiple browser configurations
+      #   config.add_browsers(
+      #     desktop_browser_info,
+      #     ios_device_info,
+      #     chrome_emulation_info
+      #   )
+      #
+      # @example Add an array of browser configurations
+      #   browsers = [desktop_browser_info, ios_device_info]
+      #   config.add_browsers(browsers)
+      #
+      # @return [Configuration] self for method chaining
       def add_browsers(*browsers)
         browsers = case browsers.first
                      when Applitools::Selenium::IRenderBrowserInfo
@@ -101,6 +202,23 @@ module Applitools
         self
       end
 
+      # Adds a Chrome device emulation configuration for visual grid testing.
+      #
+      # This method configures the visual grid to render using Chrome's device emulation mode,
+      # which simulates various mobile devices in desktop Chrome. This is useful for testing
+      # responsive designs across different device profiles.
+      #
+      # @param [Symbol] device_name The device to emulate, must be one of the values in Devices.enum_values
+      # @param [Symbol] orientation The screen orientation, defaults to portrait
+      #
+      # @example Add iPhone X emulation
+      #   config.add_device_emulation(Devices::iPhone_X)
+      #
+      # @example Add iPad emulation in landscape mode
+      #   config.add_device_emulation(Devices::iPad, Orientations::LANDSCAPE)
+      #
+      # @raise [Applitools::EyesIllegalArgument] if device_name is not in the list of supported devices
+      # @return [Configuration] self for method chaining
       def add_device_emulation(device_name, orientation = Orientations::PORTRAIT)
         Applitools::ArgumentGuard.not_nil device_name, 'device_name'
         raise Applitools::EyesIllegalArgument, 'Wrong device name!' unless Devices.enum_values.include? device_name
@@ -108,10 +226,25 @@ module Applitools
         add_browser emu
       end
 
+      # Adds a single mobile device configuration for visual grid testing.
+      #
+      # This is a convenience method that delegates to add_mobile_devices.
+      #
+      # @param [IRenderBrowserInfo] mobile_device_info The mobile device configuration
+      # @return [Configuration] self for method chaining
+      # @see #add_mobile_devices
       def add_mobile_device(mobile_device_info)
         add_mobile_devices(mobile_device_info)
       end
 
+      # Adds multiple mobile device configurations for visual grid testing.
+      #
+      # This method is a semantic alias for add_browsers that makes code more readable
+      # when specifically adding mobile device configurations.
+      #
+      # @param [Array<IRenderBrowserInfo>] mobile_device_infos An array of mobile device configurations
+      # @return [Configuration] self for method chaining
+      # @see #add_browsers
       def add_mobile_devices(mobile_device_infos)
         add_browsers(mobile_device_infos)
       end
@@ -128,16 +261,111 @@ module Applitools
 
       private
 
-      def create_ios_device_info(options)
-        if options.is_a?(Symbol)
-          # If a symbol is passed, treat it as a device name
-          Applitools::Selenium::IosDeviceInfo.new(device_name: options)
+      # Validates that a device name is a valid mobile device target name for the specified platform.
+      #
+      # @param [String, Symbol] device_name the name of the mobile device to validate
+      # @param [Symbol] platform the platform to validate against (:ios or :android)
+      # @raise [Applitools::EyesIllegalArgument] if the device name is not included in the list of valid device names
+      # @return [void]
+      def validate_mobile_device_target_name(device_name, platform)
+        return unless device_name
+        device_name = device_name.to_s
+
+        # If platform is nil or not recognized, raise an error
+        unless [:ios, :android].include?(platform)
+          raise Applitools::EyesIllegalArgument, "Invalid platform: #{platform}, must be :ios or :android"
+        end
+
+        case platform
+        when :ios
+          unless ::IosMultiDeviceTargetGenerated.enum_values.include?(device_name)
+            available_devices = ::IosMultiDeviceTargetGenerated.enum_values.join(", ")
+            raise Applitools::EyesIllegalArgument,
+                  "Invalid iOS multi device target name: '#{device_name}'. " +
+                  "Available iOS devices: #{available_devices}"
+          end
+        when :android
+          unless ::AndroidMultiDeviceTargetGenerated.enum_values.include?(device_name)
+            available_devices = ::AndroidMultiDeviceTargetGenerated.enum_values.join(", ")
+            raise Applitools::EyesIllegalArgument,
+                  "Invalid Android multi device target name: '#{device_name}'. " +
+                  "Available Android devices: #{available_devices}"
+          end
+        end
+      end
+
+      # Determines the platform (iOS or Android) based on the device name.
+      #
+      # @param [String, Symbol] device_name the name of the mobile device
+      # @return [Symbol] :ios or :android based on the device name pattern
+      # @raise [Applitools::EyesIllegalArgument] If device name is not officially supported
+      # @api private
+      def detect_platform(device_name)
+        return nil unless device_name
+        device_name = device_name.to_s
+
+        # Check if it's an officially supported iOS or Android devices
+        return :ios if ::IosMultiDeviceTargetGenerated.enum_values.include?(device_name)
+        return :android if ::AndroidMultiDeviceTargetGenerated.enum_values.include?(device_name)
+
+        # If not officially supported, raise an error
+        raise Applitools::EyesIllegalArgument,
+              "Device '#{device_name}' is not supported. Please use a device from " +
+              "IosMultiDeviceTargetGenerated or AndroidMultiDeviceTargetGenerated"
+      end
+
+      # Creates a mobile device info object based on the options.
+      #
+      # @param [Symbol, String, Hash] options Device name as Symbol/String or configuration hash
+      # @return [Applitools::Selenium::IosDeviceInfo, Applitools::Selenium::AndroidDeviceInfo]
+      #   The appropriate device info object
+      # @api private
+      def create_mobile_device_info(options)
+        if options.is_a?(Symbol) || options.is_a?(String)
+          # If a symbol or string is passed, treat it as a device name
+          device_name = options.to_s
+          platform = detect_platform(device_name)
+          validate_mobile_device_target_name(device_name, platform)
+
+          if platform == :android
+            Applitools::Selenium::AndroidDeviceInfo.new(device_name: device_name)
+          else
+            Applitools::Selenium::IosDeviceInfo.new(device_name: device_name)
+          end
         else
-          # Otherwise, pass the options hash to IosDeviceInfo
-          Applitools::Selenium::IosDeviceInfo.new(options)
+          # For a hash, check if we have both device name and platform
+          device_name = options[:device_name]
+          platform = options[:platform]
+
+          # Handle case where platform is specified but device name is not
+          if !device_name && platform
+            raise Applitools::EyesIllegalArgument,
+                  "When specifying a platform (:ios or :android), a device_name must also be provided"
+          end
+
+          # Either use the explicit platform or detect from device name
+          platform ||= detect_platform(device_name)
+
+          validate_mobile_device_target_name(device_name, platform)
+
+          if platform == :android
+            Applitools::Selenium::AndroidDeviceInfo.new(options)
+          else
+            Applitools::Selenium::IosDeviceInfo.new(options)
+          end
         end
       end
 
+      # Processes a device target and adds it to the configuration.
+      #
+      # This method handles iOS device targets, Android device targets, and regular device targets (emulated),
+      # converting them to the appropriate browser information objects.
+      #
+      # @param [Applitools::Selenium::IosDeviceTarget, Applitools::Selenium::AndroidDeviceTarget, Applitools::Selenium::DeviceTarget] target
+      #   The device target to process
+      #
+      # @raise [Applitools::EyesIllegalArgument] If the target is not a valid device target
+      # @api private
       def handle_device_target(target)
         if target.is_a?(Applitools::Selenium::IosDeviceTarget)
           ios_device_info = Applitools::Selenium::IosDeviceInfo.new(
@@ -146,6 +374,13 @@ module Applitools
             ios_version: target.version
           )
           add_browser(ios_device_info)
+        elsif target.is_a?(Applitools::Selenium::AndroidDeviceTarget)
+          android_device_info = Applitools::Selenium::AndroidDeviceInfo.new(
+            device_name: target.device_name,
+            screen_orientation: target.screen_orientation,
+            android_version: target.version
+          )
+          add_browser(android_device_info)
         elsif target.is_a?(Applitools::Selenium::DeviceTarget)
           device_name = target.device_name
           orientation = target.screen_orientation || Orientations::PORTRAIT
@@ -158,4 +393,4 @@ module Applitools
 
     end
   end
-end
+end

data/lib/applitools/selenium/visual_grid/android_device_info.rb

@@ -0,0 +1,91 @@
+require_relative 'android_multi_device_target'
+require_relative 'i_render_browser_info'
+require_relative 'emulation_base_info'
+require_relative '../orientations'
+require_relative '../browser_types'
+
+module Applitools
+  module Selenium
+    # AndroidDeviceInfo represents configuration for Android devices in mobile app testing
+    class AndroidDeviceInfo < Applitools::Selenium::IRenderBrowserInfo
+      # Default configuration for Android devices
+      DEFAULT_CONFIG = proc do
+        {
+          platform: 'android',
+          # Note: Browser type is less relevant for mobile app testing but kept for API consistency
+          browser_type: BrowserType::CHROME,
+          viewport_size: Applitools::RectangleSize.from_any_argument(width: 0, height: 0)
+        }
+      end
+
+      object_field :android_device_info, Applitools::Selenium::EmulationBaseInfo
+
+      class << self
+        def default_config
+          DEFAULT_CONFIG.call
+        end
+      end
+
+      # Initialize with device name, orientation, and version
+      # @param [Hash] options
+      # @option options [String] :device_name The Android device name
+      # @option options [String] :screen_orientation ('portrait' or 'landscape')
+      # @option options [String] :android_version The Android OS version
+      def initialize(options = {})
+        super
+        self.android_device_info = EmulationInfo.new.tap do |ei|
+          ei.device_name = options[:device_name]
+          ei.screen_orientation = options[:screen_orientation] || options[:orientation] || Orientation::PORTRAIT
+          ei.version = options[:android_version] || options[:version] || 'latest'
+        end
+      end
+
+      # String representation of the Android device
+      # @return [String]
+      def to_s
+        "#{android_device_info.device_name} - #{android_device_info.screen_orientation}"
+      end
+
+      # Get the device name
+      # @return [String]
+      def device_name
+        android_device_info.device_name
+      end
+
+      # Convert to hash for API requests
+      # @return [Hash]
+      def to_hash
+        {androidDeviceInfo: android_device_info.to_hash}
+      end
+
+      private
+
+      # Inner class for Android device information
+      class EmulationInfo < EmulationBaseInfo
+        enum_field :device_name, AndroidMultiDeviceTargetGenerated.enum_values
+        enum_field :screen_orientation, Orientation.enum_values
+        string_field :version
+
+        # Create JSON data for API requests
+        # @return [Hash]
+        def json_data
+          {
+            name: device_name,
+            screenOrientation: screen_orientation,
+            version: version || 'latest'
+          }
+        end
+
+        # Convert to hash for API requests
+        # @return [Hash]
+        def to_hash
+          {
+            deviceName: device_name,
+            screenOrientation: screen_orientation,
+            androidVersion: version || 'latest'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/visual_grid/android_device_target.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Applitools
+  module Selenium
+    # Represents an Android device target for mobile app testing
+    # Used in conjunction with the Visual Grid to render mobile app screenshots
+    # on specific Android device configurations
+    class AndroidDeviceTarget
+      attr_reader :device_name, :screen_orientation, :version
+
+      # Initialize a new Android device target
+      # @param [String] device_name The name of the Android device from AndroidMultiDeviceTargetGenerated
+      # @param [Hash] options Additional configuration options
+      # @option options [String] :screen_orientation ('portrait' or 'landscape')
+      # @option options [String] :orientation Alias for screen_orientation
+      # @option options [String] :android_version The Android OS version to use
+      # @option options [String] :version Alias for android_version
+      def initialize(device_name, options = {})
+        @device_name = device_name
+        @screen_orientation = options[:screen_orientation] || options[:orientation]
+        @version = options[:android_version] || options[:version]
+      end
+    end
+  end
+end

data/lib/applitools/selenium/visual_grid/android_multi_device_target.rb

@@ -0,0 +1,16 @@
+# GENERATED FILE #
+
+module AndroidMultiDeviceTargetGenerated
+  extend self
+  Galaxy_S25 = 'Galaxy S25'.freeze
+  Galaxy_S25_Ultra = 'Galaxy S25 Ultra'.freeze
+  Pixel_9 = 'Pixel 9'.freeze
+
+  def enum_values
+    [
+      Galaxy_S25,
+      Galaxy_S25_Ultra,
+      Pixel_9,
+    ]
+  end
+end

data/lib/applitools/selenium/visual_grid/ios_multi_device_target.rb

@@ -0,0 +1,56 @@
+# GENERATED FILE #
+
+module IosMultiDeviceTargetGenerated
+  extend self
+  IPhone_SE_3 = 'iPhone SE (3rd generation)'.freeze
+  IPhone_SE_2 = 'iPhone SE (2nd generation)'.freeze
+  IPhone_8 = 'iPhone 8'.freeze
+  IPhone_8_Plus = 'iPhone 8 Plus'.freeze
+  IPhone_13_mini = 'iPhone 13 mini'.freeze
+  IPhone_12_mini = 'iPhone 12 mini'.freeze
+  IPhone_11_Pro = 'iPhone 11 Pro'.freeze
+  IPhone_X = 'iPhone X'.freeze
+  IPhone_XR = 'iPhone XR'.freeze
+  IPhone_Xs = 'iPhone Xs'.freeze
+  IPhone_Xs_Max = 'iPhone Xs Max'.freeze
+  IPhone_11 = 'iPhone 11'.freeze
+  IPhone_11_Pro_Max = 'iPhone 11 Pro Max'.freeze
+  IPhone_12 = 'iPhone 12'.freeze
+  IPhone_12_Pro = 'iPhone 12 Pro'.freeze
+  IPhone_12_Pro_Max = 'iPhone 12 Pro Max'.freeze
+  IPhone_13 = 'iPhone 13'.freeze
+  IPhone_13_Pro = 'iPhone 13 Pro'.freeze
+  IPhone_13_Pro_Max = 'iPhone 13 Pro Max'.freeze
+  IPhone_14 = 'iPhone 14'.freeze
+  IPhone_14_Pro = 'iPhone 14 Pro'.freeze
+  IPhone_14_Plus = 'iPhone 14 Plus'.freeze
+  IPhone_14_Pro_Max = 'iPhone 14 Pro Max'.freeze
+
+  def enum_values
+    [
+      IPhone_SE_3,
+      IPhone_SE_2,
+      IPhone_8,
+      IPhone_8_Plus,
+      IPhone_13_mini,
+      IPhone_12_mini,
+      IPhone_11_Pro,
+      IPhone_X,
+      IPhone_XR,
+      IPhone_Xs,
+      IPhone_Xs_Max,
+      IPhone_11,
+      IPhone_11_Pro_Max,
+      IPhone_12,
+      IPhone_12_Pro,
+      IPhone_12_Pro_Max,
+      IPhone_13,
+      IPhone_13_Pro,
+      IPhone_13_Pro_Max,
+      IPhone_14,
+      IPhone_14_Pro,
+      IPhone_14_Plus,
+      IPhone_14_Pro_Max,
+    ]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_selenium
 version: !ruby/object:Gem::Version
-  version: 6.10.1
+  version: 6.11.0
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-07-15 00:00:00.000000000 Z
+date: 2025-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eyes_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.8.1
+        version: 6.8.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.8.1
+        version: 6.8.2
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
@@ -142,6 +142,9 @@ files:
 - lib/applitools/selenium/test_list.rb
 - lib/applitools/selenium/viewport_screenshot.rb
 - lib/applitools/selenium/viewport_size.rb
+- lib/applitools/selenium/visual_grid/android_device_info.rb
+- lib/applitools/selenium/visual_grid/android_device_target.rb
+- lib/applitools/selenium/visual_grid/android_multi_device_target.rb
 - lib/applitools/selenium/visual_grid/chrome_emulation_info.rb
 - lib/applitools/selenium/visual_grid/desktop_browser_info.rb
 - lib/applitools/selenium/visual_grid/dom_snapshot_script.rb
@@ -151,6 +154,7 @@ files:
 - lib/applitools/selenium/visual_grid/ios_device_info.rb
 - lib/applitools/selenium/visual_grid/ios_device_name.rb
 - lib/applitools/selenium/visual_grid/ios_device_name_generated.rb
+- lib/applitools/selenium/visual_grid/ios_multi_device_target.rb
 - lib/applitools/selenium/visual_grid/render_browser_info.rb
 - lib/applitools/selenium/visual_grid/render_info.rb
 - lib/applitools/selenium/visual_grid/render_request.rb