Class: BiDiGenerate::Schema Private

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1064

def baked_discriminator?(field)
  field['type'].key?('const') && !field['type']['nullable']
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 699

def build_added_command(cmd, namespace, domain)
  command = BiDiGenerate.build_command(self, cmd.merge('name' => cmd['name'].delete_prefix("#{namespace}:")))
  spec_names = commands_for(domain).map do |c|
    BiDiGenerate.safe_method_name(BiDiGenerate.camel_to_snake(c['name']))
  end
  if spec_names.include?(command.method_name)
    raise "vendor command #{cmd['method']} would override spec command #{domain}.#{command.method_name}"
  end

  command
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 711

def build_vendor_command(cmd, type_name, entry, namespace)
  shared = record_params(@types[type_name]['fields'], extensible_record?(type_name))
  taken = shared.map(&:ruby_name)
  VendorCommand.new(
    method_name: BiDiGenerate.safe_method_name(BiDiGenerate.camel_to_snake(cmd['name'])),
    wire_name: cmd['method'],
    result_ref: cmd['result'] && structured_ref(cmd['result']['ref']),
    params_class: BiDiGenerate.type_class_name(type_name),
    shared_params: shared,
    vendor_params: entry['fields'].map { |field| vendor_param(field, namespace, taken) },
    spec_href: cmd['specHref']
  )
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 653

def command_wrapper_refs(domain)
  commands_for(domain).flat_map { |c| [c.dig('params', 'ref'), c.dig('result', 'ref')] }.compact.to_set
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 645

def commands_for(domain)
  @commands.select { |c| c['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1290

def default_variant_enum_values(selector, by)
  default = selector['default']
  field = default && @types[default]['fields'].find { |f| f['wire'] == by }
  ref = field && field['type']['ref']
  ref && @types[ref] && @types[ref]['kind'] == 'enum' ? @types[ref]['values'] : []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1024

def directionality(name)
  node = @types[name]
  {outbound: node['outbound'] ? true : false, inbound: node['inbound'] ? true : false}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1154

def discriminated_variants(selector)
  variants = selector['variants'].map do |variant|
    VariantIR.new(mode: :value, value: variant['value'], ref: ruby_path(variant['ref']), requires: nil)
  end
  return variants unless selector['default']

  variants << VariantIR.new(mode: :fallback, value: nil, ref: ruby_path(selector['default']), requires: nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 609

def domain_href(domain)
  @domains.dig(domain, 'specHref')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 872

def domain_path(name)
  name.include?('.') ? ruby_path(name) : nil
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 671

def domain_relative_path(name)
  prefix = "#{BiDiGenerate.snake_to_class_name(BiDiGenerate.camel_to_snake(name.split('.', 2).first))}::"
  ruby_path(name).sub(/\A#{Regexp.escape(prefix)}/, '')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 641

def domains
  (@commands + @events).map { |entry| entry['domain'] }.uniq
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1247

def enum_const(field_type)
  ref = field_type['ref'] || field_type.dig('list', 'ref')
  return unless ref && @types[ref] && @types[ref]['kind'] == 'enum'

  BiDiGenerate.enum_const_path(ref)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 767

def enums_for(domain)
  owned_types(domain).filter_map do |name, type|
    next unless type['kind'] == 'enum'

    pairs = type['values'].map { |v| [BiDiGenerate.enum_key(v), v] }
    Enum.new(constant_name: BiDiGenerate.screaming_snake(name.split('.', 2).last), pairs: pairs,
             primitive: type['primitive'], spec_href: type['specHref'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 852

def envelope_synthetic?(type)
  return false unless type['synthetic']

  owner = @types[type['owner']]
  owner && owner['kind'] == 'record' && message_envelope?(owner)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 818

def error_codes
  @types.dig('ErrorCode', 'values') || []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 746

def events_for(domain)
  @events.select { |e| e['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1052

def extensible_record?(name)
  @types.dig(name, 'extensible') || vendor_extended?(name) ? true : false
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1068

def field_ir(field, extensible)
  resolved = resolve(field['type'])
  ruby_name = field_name(field, extensible)
  FieldIR.new(ruby_name: ruby_name, wire_key: field['wire'],
              required: field['required'], nullable: resolved[:nullable],
              ref: resolved[:ref], list: resolved[:list], enum: enum_const(field['type']),
              primitive: leaf_primitive(field['type']), scalar: resolved[:scalar],
              const: leaf_const(field['type']), rbs: resolved[:rbs])
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1056

def field_name(field, extensible)
  BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name']), extensible: extensible)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1313

def guard_union_dispatch_keys_simple!(selector, ref)
  keys = selector['by'] ? [selector['by']] : (selector['ordered'] || []).flat_map { |arm| arm['requires'] }
  camel = keys.reject { |k| BiDiGenerate.camel_to_snake(k) == k }
  return if camel.empty?

  raise "union command param #{ref} dispatches on non-snake wire key(s) #{camel.inspect}; " \
        'Union.build matches kwargs to dispatch keys by symbol, so give the outbound ' \
        'dispatch an explicit wire<->ruby mapping before shipping this.'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1082

def leaf_const(node, seen = {})
  return node['const'] if node.key?('const')
  return nil unless node.key?('ref')

  name = node['ref']
  type = @types[name]
  return nil if seen[name] || type.nil? || type['kind'] != 'alias'

  seen[name] = true
  leaf_const(type['type'], seen)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1099

def leaf_primitive(node, seen = {})
  return node['primitive'] if node.key?('primitive') && CHECKABLE_PRIMITIVES.include?(node['primitive'])
  return nil unless node.key?('ref')

  name = node['ref']
  type = @types[name]
  return nil if seen[name] || type.nil? || type['kind'] != 'alias'

  seen[name] = true
  leaf_primitive(type['type'], seen)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1299

def merged_params(variant_fields, extensible)
  all_fields = variant_fields.flatten
  all_fields.map { |f| f['wire'] }.uniq.map do |wire|
    field = all_fields.find { |f| f['wire'] == wire }
    required = variant_fields.all? { |fields| fields.any? { |f| f['wire'] == wire && f['required'] } }
    Param.new(ruby_name: field_name(field, extensible),
              wire_name: wire, required: required, rbs: rbs_type(field['type']))
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 847

def message_envelope?(type)
  type['fields'].any? { |f| f['wire'] == 'method' && f['type'].key?('const') }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 986

def named_type(name)
  {ref: domain_path(name), list: false, rbs: rbs_abs(ruby_path(name))}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 993

def named_union(name)
  {ref: domain_path(name), list: false, rbs: union_alias_path(name)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1018

def nilable(type, flag)
  flag ? BiDiGenerate.rbs_nilable(type) : type
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1163

def ordered_variants(selector)
  (selector['ordered'] || []).map do |arm|
    VariantIR.new(mode: :presence, value: nil, ref: ruby_path(arm['ref']), requires: arm['requires'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 781

def owned_types(domain)
  vendor = vendor_domain?(domain)
  prefixes = type_prefixes(domain).map { |prefix| "#{prefix}." }
  added = vendor ? Set.new : vendor_types_reached(domain)
  @types.select do |name, _|
    next false unless prefixes.any? { |p| name.start_with?(p) }

    @vendor_types.key?(name) ? vendor || added.include?(name) : !vendor
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 754

def params_for(params_ref)
  return [] unless params_ref

  type = @types[params_ref['ref']]
  return nil unless type

  case type['kind']
  when 'record' then record_params(type['fields'], extensible_record?(params_ref['ref']))
  when 'union' then union_params(type, params_ref['ref'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 879

def plain_refs(node)
  case node['kind']
  when 'record'
    refs = node['fields'].flat_map { |f| refs_in_type(f['type']) }
    node['map'] ? refs + refs_in_type(node['map']) : refs
  when 'alias' then refs_in_type(node['type'])
  else []
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 662

def plainly_reached_types
  @plainly_reached_types ||= @types.each_value.with_object(Set.new) do |node, reached|
    plain_refs(node).each { |ref| reached << ref }
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 621

def promote_command_params_records!
  @commands.each do |cmd|
    ref = cmd.dig('params', 'ref')
    next unless ref

    type = @types[ref]
    promote_to_domain_type!(ref) if type && envelope_synthetic?(type)
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 633

def promote_to_domain_type!(name)
  type = @types[name]
  type&.delete('synthetic')
  type&.delete('owner')
  type&.delete('label')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1240

def rbs_abs(path)
  "::Selenium::WebDriver::BiDi::Protocol::#{path}"
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1231

def rbs_const(value)
  case value
  when true, false then 'bool'
  when ::String then 'String'
  when ::Numeric then 'Numeric'
  else 'untyped'
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1205

def rbs_type(node)
  resolve(node)[:rbs]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1029

def record_class(name, type)
  extensible = extensible_record?(name)
  const = type['fields'].find { |f| baked_discriminator?(f) }
  discriminator = const && {ruby_name: field_name(const, extensible),
                            wire: const['wire'], value: const['type']['const'],
                            rbs: rbs_const(const['type']['const'])}
  fields = type['fields'].reject { |f| baked_discriminator?(f) }.map { |f| field_ir(f, extensible) }
  # Every extensible type gets the extensions store: an undeclared wire key is preserved
  # and echoed back on any type the spec marks extensible, whether or not it is re-sendable.
  # Extensibility alone is the signal; send-reachability does not enter into it. A type a
  # vendor extends is open too: its vendor variant composes the vendor fields through that
  # store (see VendorCommand), which a closed record would reject.
  TypeClass.new(ruby_name: BiDiGenerate.type_class_name(name), fields: fields,
                discriminator: discriminator, extensible: extensible,
                schema_name: name, synthetic: type['synthetic'] ? true : false,
                owner: type['owner'], label: type['label'], spec_href: type['specHref'],
                **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1193

def record_params(fields, extensible)
  fields.map do |field|
    Param.new(
      ruby_name: field_name(field, extensible),
      wire_name: field['wire'],
      required: field['required'],
      enum: enum_const(field['type']),
      rbs: rbs_type(field['type'])
    )
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 892

def refs_in_type(node)
  return [] unless node
  return [node['ref']] if node['ref']
  return refs_in_type(node['list']) if node['list']
  return refs_in_type(node['map']) if node['map']
  return node['union'].flat_map { |arm| refs_in_type(arm) } if node['union']
  return node['record'].flat_map { |f| refs_in_type(f['type']) } if node['record']

  []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 919

def resolve(node)
  nullable = node['nullable'] ? true : false
  if node.key?('list')
    element = resolve(node['list'])
    return {ref: element[:ref], list: true, nullable: nullable, scalar: element[:scalar],
            rbs: nilable("Array[#{element[:rbs]}]", nullable)}
  end
  if node.key?('ref')
    named = resolve_named(node['ref'])
    return {ref: named[:ref], list: named[:list], nullable: nullable, scalar: named[:scalar],
            rbs: nilable(named[:rbs], nullable)}
  end
  return resolve_union(node, nullable) if node.key?('union')

  {ref: nil, list: false, nullable: nullable, rbs: nilable(scalar_rbs(node), nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 967

def resolve_named(name, seen = {})
  return OPAQUE if name.nil? || seen[name]

  seen[name] = true
  type = @types[name]
  return OPAQUE unless type

  case type['kind']
  when 'record' then type['fields'].empty? ? OPAQUE : named_type(name)
  when 'union' then named_union(name)
  when 'enum' then {ref: nil, list: false, rbs: 'Symbol'}
  when 'alias' then resolve_named_alias(name, type['type'], seen)
  else OPAQUE
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1006

def resolve_named_alias(name, inner, seen)
  return named_union(name) if inner.key?('union')
  return resolve_named(inner['ref'], seen) if inner.key?('ref')

  if inner.key?('list')
    element = resolve(inner['list'])
    return {ref: element[:ref], list: true, scalar: element[:scalar], rbs: "Array[#{element[:rbs]}]"}
  end

  {ref: nil, list: false, rbs: scalar_rbs(inner)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 942

def resolve_union(node, nullable)
  refs = node['union'].select { |arm| arm.key?('ref') }
  opaque = {ref: nil, list: false, nullable: nullable, rbs: nilable('untyped', nullable)}
  return opaque unless refs.one? && union_ref?(refs.first['ref'])

  named = resolve_named(refs.first['ref'])
  {ref: named[:ref], list: named[:list], nullable: nullable, scalar: node['scalar'],
   rbs: nilable('untyped', nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 905

def ruby_path(name)
  type = @types[name]
  return BiDiGenerate.type_ruby_path(name) unless type && type['synthetic']

  "#{ruby_path(type['owner'])}::#{type['label']}"
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 868

def ruby_path_for(name) = ruby_path(name)

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1224

def scalar_rbs(node)
  return PRIMITIVE_RBS.fetch(node['primitive']) if node.key?('primitive')
  return rbs_const(node['const']) if node.key?('const')

  'untyped'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 861

def structured_ref(name)
  resolved = resolve_named(name)
  resolved[:list] ? nil : resolved[:ref]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 840

def suppressed_record?(type)
  message_envelope?(type) || envelope_synthetic?(type)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 742

def type_kind(ref)
  @types[ref]&.fetch('kind', nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 808

def type_prefixes(domain)
  return [domain] unless vendor_domain?(domain)

  messages = commands_for(domain) + events_for(domain)
  refs = messages.flat_map { |m| [m.dig('params', 'ref'), m.dig('result', 'ref')] }
  refs.compact.select { |ref| ref.include?('.') }.map { |ref| ref.split('.', 2).first }.uniq
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 827

def types_for(domain)
  owned_types(domain).filter_map do |name, type|
    case type['kind']
    when 'record' then record_class(name, type) unless type['fields'].empty? || suppressed_record?(type)
    when 'union' then union_class(name)
    when 'alias' then union_class(name) if type['type'].key?('union')
    end
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1000

def union_alias_path(name)
  segments = ruby_path(name).split('::')
  segments[-1] = BiDiGenerate.camel_to_snake(segments[-1])
  rbs_abs(segments.join('::'))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1111

def union_class(name)
  type = @types[name]
  # A first-class union carries the schema's authoritative dispatch `selector`
  # (derived spec-faithfully, including null discriminators and the spec's choice
  # order); consume it rather than re-deriving and silently depending on emit
  # order. An alias-to-union (only input.Origin) has no selector — its const-string
  # arms aren't first-class types — so it keeps the structural re-derivation.
  klass = type['kind'] == 'union' ? union_from_selector(name, type['selector']) : union_from_alias(name)
  # A non-object_only union has a bare-scalar arm; only const-literal arms (scalar_values) are
  # modeled, so the runtime can validate an outbound scalar. A non-object_only union without them
  # is a shape the generator doesn't yet handle — fail here, at generation, not at a caller's runtime.
  if !klass.object_only && !klass.scalar_values?
    raise "non-object_only union #{name} has no scalar_values to validate its bare-scalar arm"
  end

  klass
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1174

def union_from_alias(name)
  spec = @types[name]
  consts = spec['type']['union'].filter_map { |arm| arm['ref'] }.to_h do |ref|
    const = @types[ref]['fields'].find { |f| f['type'].key?('const') }
    const || raise("alias-union #{name} arm #{ref} has no const discriminator to dispatch on")
    [ref, const]
  end
  variants = consts.map do |ref, const|
    VariantIR.new(mode: :value, value: const['type']['const'], ref: ruby_path(ref), requires: nil)
  end
  # An alias-union carries bare-scalar arms (input.Origin's "viewport"/"pointer"), so it
  # is never object_only — those arms must still pass a non-Hash payload through, but only
  # a value the schema pins in scalarValues (so a stray "banana" is still rejected outbound).
  UnionClass.new(ruby_name: BiDiGenerate.type_class_name(name),
                 discriminator_wire: consts.values.first['wire'], variants: variants, schema_name: name,
                 spec_href: spec['specHref'], object_only: spec['objectOnly'] ? true : false,
                 scalar_values: spec['type']['scalarValues'], **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1136

def union_from_selector(name, selector)
  # A correlated union is resolved by request id, never the payload, so it carries
  # no dispatch — it must never be emitted (every one is a top-level result
  # grouping). Fail loudly if a future schema makes one domain-scoped rather than
  # emit a Union whose every parse would raise.
  if selector['correlated']
    raise "correlated union #{name} must not be emitted (resolved by request id, not payload)"
  end

  variants = selector['by'] ? discriminated_variants(selector) : ordered_variants(selector)
  raise "union #{name} selector yielded no dispatch variants" if variants.empty?

  UnionClass.new(ruby_name: BiDiGenerate.type_class_name(name),
                 discriminator_wire: selector['by'], variants: variants, schema_name: name,
                 spec_href: @types[name]['specHref'], object_only: @types[name]['objectOnly'] ? true : false,
                 **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1259

def union_params(type, ref = nil)
  variants = type['variants'].map { |variant_ref| @types[variant_ref] }
  return nil unless variants.all? { |v| v && v['kind'] == 'record' }

  selector = type['selector']
  guard_union_dispatch_keys_simple!(selector, ref)
  params = merged_params(variants.map { |v| v['fields'] }, type['variants'].any? { |v| extensible_record?(v) })
  annotate_discriminator_enum!(params, selector)
  params
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 954

def union_ref?(name)
  type = @types[name]
  return false unless type
  return union_ref?(type['type']['ref']) if type['kind'] == 'alias' && type['type'].key?('ref')

  type['kind'] == 'union'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 602

def vendor_added_commands(domain, namespace)
  return [] if vendor_domain?(domain)

  (@vendor.dig(namespace, 'commands') || []).select { |c| c['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 584

def vendor_domain?(domain) = domain.include?(':')

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 592

def vendor_events
  events = vendor_messages('events')
  stray = events.reject { |e| vendor_domain?(e['domain']) }
  raise "vendor event #{stray.first['method']} in spec domain #{stray.first['domain']} is unsupported" if stray.any?

  events
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1048

def vendor_extended?(name)
  @vendor.values.any? { |spec| (spec['extends'] || {}).key?(name) }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 586

def vendor_messages(kind)
  @vendor.values.flat_map { |section| section[kind] || [] }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 681

def vendor_modules_for(domain)
  parent = BiDiGenerate.snake_to_class_name(BiDiGenerate.camel_to_snake(domain))
  @vendor.filter_map do |namespace, spec|
    overrides = (spec['extends'] || {}).filter_map do |type_name, entry|
      cmd = @commands.find { |c| c.dig('params', 'ref') == type_name }
      build_vendor_command(cmd, type_name, entry, namespace) if cmd && cmd['domain'] == domain
    end
    added = vendor_added_commands(domain, namespace).map { |cmd| build_added_command(cmd, namespace, domain) }
    commands = overrides + added
    next if commands.empty?

    VendorModule.new(name: BiDiGenerate.snake_to_class_name(namespace), namespace: namespace, parent: parent,
                     commands: commands)
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 729

def vendor_param(field, namespace, taken)
  stripped = field['name'].sub(/\A#{Regexp.escape(namespace)}:/, '')
  ruby_name = BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(stripped))
  ruby_name = BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name'])) if taken.include?(ruby_name)
  Param.new(
    ruby_name: ruby_name,
    wire_name: field['wire'],
    required: field['required'],
    enum: enum_const(field['type']),
    rbs: rbs_type(field['type'])
  )
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 794

def vendor_types_reached(domain)
  commands = @vendor.keys.flat_map { |namespace| vendor_added_commands(domain, namespace) }
  pending = commands.flat_map { |c| [c.dig('params', 'ref'), c.dig('result', 'ref')] }.compact
  reached = Set.new
  until pending.empty?
    name = pending.pop
    next if reached.include?(name) || !@vendor_types.key?(name)

    reached << name
    pending.concat(plain_refs(@types[name]) + (@types[name]['variants'] || []))
  end
  reached
end