class Turbopuffer::Internal::Type::BaseModel

def coerce(value, state:)
  exactness = state.fetch(:exactness)
  if value.is_a?(self)
    exactness[:yes] += 1
    return value
  end
  unless (val = Turbopuffer::Internal::Util.coerce_hash(value)).is_a?(Hash)
    exactness[:no] += 1
    state[:error] = TypeError.new("#{value.class} can't be coerced into #{Hash}")
    return value
  end
  exactness[:yes] += 1
  keys = val.keys.to_set
  instance = new
  data = instance.to_h
  status = instance.instance_variable_get(:@coerced)
  # rubocop:disable Metrics/BlockLength
  fields.each do |name, field|
    mode, required, target = field.fetch_values(:mode, :required, :type)
    api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const)
    src_name = state.fetch(:translate_names) ? api_name : name
    unless val.key?(src_name)
      if required && mode != :dump && const == Turbopuffer::Internal::OMIT
        exactness[nilable ? :maybe : :no] += 1
      else
        exactness[:yes] += 1
      end
      next
    end
    item = val.fetch(src_name)
    keys.delete(src_name)
    state[:error] = nil
    converted =
      if item.nil? && (nilable || !required)
        exactness[nilable ? :yes : :maybe] += 1
        nil
      else
        coerced = Turbopuffer::Internal::Type::Converter.coerce(target, item, state: state)
        case target
        in Turbopuffer::Internal::Type::Converter | Symbol
          coerced
        else
          item
        end
      end
    status.store(name, state.fetch(:error) || true)
    data.store(name, converted)
  end
  # rubocop:enable Metrics/BlockLength
  keys.each { data.store(_1, val.fetch(_1)) }
  instance
end