code: func reflectValue(valueType string, value interface{}) (reflect.Value, error) {
  	theType, ok := typesMap[valueType]
  	if !ok {
  		return reflect.Value{}, NewErrUnsupportedType(valueType)
  	}
  	theValue := reflect.New(theType)
  
  	// Booleans
  	if theType.String() == "bool" {
  		boolValue, err := getBoolValue(theType.String(), value)
  		if err != nil {
  			return reflect.Value{}, err
  		}
  
  		theValue.Elem().SetBool(boolValue)
  		return theValue.Elem(), nil
  	}
  
  	// Integers
  	if strings.HasPrefix(theType.String(), "int") {
  		intValue, err := getIntValue(theType.String(), value)
  		if err != nil {
  			return reflect.Value{}, err
  		}
  
  		theValue.Elem().SetInt(intValue)
  		return theValue.Elem(), err
  	}
  
  	// Unsigned integers
  	if strings.HasPrefix(theType.String(), "uint") {
  		uintValue, err := getUintValue(theType.String(), value)
  		if err != nil {
  			return reflect.Value{}, err
  		}
  
  		theValue.Elem().SetUint(uintValue)
  		return theValue.Elem(), err
  	}
  
  	// Floating point numbers
  	if strings.HasPrefix(theType.String(), "float") {
  		floatValue, err := getFloatValue(theType.String(), value)
  		if err != nil {
  			return reflect.Value{}, err
  		}
  
  		theValue.Elem().SetFloat(floatValue)
  		return theValue.Elem(), err
  	}
  
  	// Strings
  	if theType.String() == "string" {
  		stringValue, err := getStringValue(theType.String(), value)
  		if err != nil {
  			return reflect.Value{}, err
  		}
  
  		theValue.Elem().SetString(stringValue)
  		return theValue.Elem(), nil
  	}
  
  	return reflect.Value{}, NewErrUnsupportedType(valueType)
  }
docs: // reflectValue converts interface{} to reflect.Value based on string type
  // representing a base type (not a slice)