docs: def add_with_properties(self, model, name=None, update_dict=None, bulk=True, **kwargs):
          """
          Add a part and update its properties in one go.
  
          In order to prevent the backend from updating the frontend you may add `suppress_kevents=True` as
          additional keyword=value argument to this method. This will improve performance of the backend
          against a trade-off that someone looking at the frontend won't notice any changes unless the page
          is refreshed.
  
          :param model: model of the part which to add a new instance, should follow the model tree in KE-chain
          :type model: :class:`Part`
          :param name: (optional) name provided for the new instance as string otherwise use the name of the model
          :type name: basestring or None
          :param update_dict: dictionary with keys being property names (str) or property_id (from the property models)
                              and values being property values
          :type update_dict: dict or None
          :param bulk: True to use the bulk_update_properties API endpoint for KE-chain versions later then 2.1.0b
          :type bulk: boolean or None
          :param kwargs: (optional) additional keyword arguments that will be passed inside the update request
          :type kwargs: dict or None
          :return: the newly created :class:`Part`
          :raises NotFoundError: when the property name is not a valid property of this part
          :raises APIError: in case an Error occurs
  
          Examples
          --------
          >>> bike = client.scope('Bike Project').part('Bike')
          >>> wheel_model = client.scope('Bike Project').model('Wheel')
          >>> bike.add_with_properties(wheel_model, 'Wooden Wheel', {'Spokes': 11, 'Material': 'Wood'})
  
          """
          if self.category != Category.INSTANCE:
              raise APIError("Part should be of category INSTANCE")
          name = name or model.name
          action = 'new_instance_with_properties'
  
          properties_update_dict = dict()
          for prop_name_or_id, property_value in update_dict.items():
              if is_uuid(prop_name_or_id):
                  properties_update_dict[prop_name_or_id] = property_value
              else:
                  properties_update_dict[model.property(prop_name_or_id).id] = property_value
  
          if bulk:
              r = self._client._request('POST', self._client._build_url('parts'),
                                        data=dict(
                                            name=name,
                                            model=model.id,
                                            parent=self.id,
                                            properties=json.dumps(properties_update_dict),
                                            **kwargs
                                        ),
                                        params=dict(select_action=action))
  
              if r.status_code != requests.codes.created:  # pragma: no cover
                  raise APIError('{}: {}'.format(str(r), r.content))
              return Part(r.json()['results'][0], client=self._client)
          else:  # do the old way
              new_part = self.add(model, name=name)  # type: Part
              new_part.update(update_dict=update_dict, bulk=bulk)
              return new_part