docs: def create_property(self, model, name, description=None, property_type=PropertyType.CHAR_VALUE, default_value=None,
                          unit=None, options=None):
          """Create a new property model under a given model.
  
          Use the :class:`enums.PropertyType` to select which property type to create to ensure that you
          provide the correct values to the KE-chain backend. The default is a `PropertyType.CHAR_VALUE` which is a
          single line text in KE-chain.
  
          :param model: parent model
          :type model: :class:`models.Part`
          :param name: property model name
          :type name: basestring
          :param description: property model description (optional)
          :type description: basestring or None
          :param property_type: choose one of the :class:`enums.PropertyType`, defaults to `PropertyType.CHAR_VALUE`.
          :type property_type: basestring or None
          :param default_value: (optional) default value used for part instances when creating a model.
          :type default_value: any
          :param unit: (optional) unit of the property
          :type unit: basestring or None
          :param options: (optional) property options (eg. validators or 'single selectlist choices')
          :type options: basestring or None
          :return: a :class:`models.Property` with category `MODEL`
          :raises IllegalArgumentError: When the provided arguments are incorrect
          :raises APIError: if the `Property` model could not be created
          """
          if model.category != Category.MODEL:
              raise IllegalArgumentError("The model should be of category MODEL")
  
          if not property_type.endswith('_VALUE'):
              warnings.warn("Please use the `PropertyType` enumeration to ensure providing correct "
                            "values to the backend.", UserWarning)
              property_type = '{}_VALUE'.format(property_type.upper())
  
          if property_type not in PropertyType.values():
              raise IllegalArgumentError("Please provide a valid propertytype, please use one of `enums.PropertyType`. "
                                         "Got: '{}'".format(property_type))
  
          # because the references value only accepts a single 'model_id' in the default value, we need to convert this
          # to a single value from the list of values.
          if property_type in (PropertyType.REFERENCE_VALUE, PropertyType.REFERENCES_VALUE) and \
                  isinstance(default_value, (list, tuple)) and default_value:
              default_value = default_value[0]
  
          data = {
              "name": name,
              "part": model.id,
              "description": description or '',
              "property_type": property_type.upper(),
              "value": default_value,
              "unit": unit or '',
              "options": options or {}
          }
  
          # # We add options after the fact only if they are available, otherwise the options will be set to null in the
          # # request and that can't be handled by KE-chain.
          # if options:
          #     data['options'] = options
  
          response = self._request('POST', self._build_url('properties'),
                                   json=data)
  
          if response.status_code != requests.codes.created:
              raise APIError("Could not create property")
  
          prop = Property.create(response.json()['results'][0], client=self)
  
          model.properties.append(prop)
  
          return prop