docs: def get_type_item(self, value, map_name=None, instances=None):
          """
          Converts the input to a InputConfigId tuple. It can be from a single string, list, or tuple. Single values
          (also single-element lists or tuples) are considered to be a container configuration on the default map. A string
          with two elements separated by a dot or two-element lists / tuples are considered to be referring to a specific
          map and configuration. Three strings concatenated with a dot or three-element lists / tuples are considered to be
          referring to a map, configuration, and instances. Multiple instances can be specified in the third element by
          passing a tuple or list.
  
          :param value: Input value for conversion.
          :param map_name: Map name; provides the default map name unless otherwise specified in ``value``.
          :type map_name: unicode | str
          :param instances: Instance names; instances to set if not otherwise specified in ``value``.
          :type instances: unicode | str | tuple[unicode | str | NoneType]
          :return: InputConfigId tuple.
          :rtype: InputConfigId
          """
          if isinstance(value, InputConfigId):
              return value
          elif isinstance(value, MapConfigId):
              if value.instance_name:
                  v_instances = value.instance_name,
              else:
                  v_instances = None
              return InputConfigId(value.config_type, value.map_name, value.config_name, v_instances or instances)
          elif isinstance(value, six.string_types):
              s_map_name, __, s_config_name = value.partition('.')
              if s_config_name:
                  config_name, __, s_instance = s_config_name.partition('.')
                  if s_instance:
                      s_instances = s_instance,
                  else:
                      s_instances = None
              else:
                  config_name = s_map_name
                  s_map_name = map_name
                  s_instances = None
              return InputConfigId(ItemType.CONTAINER, s_map_name, config_name, s_instances or instances)
          elif isinstance(value, (tuple, list)):
              v_len = len(value)
              if v_len == 3:
                  v_instances = value[2]
                  if not v_instances:
                      return InputConfigId(ItemType.CONTAINER, value[0], value[1])
                  if isinstance(v_instances, tuple):
                      return InputConfigId(ItemType.CONTAINER, *value)
                  elif isinstance(v_instances, list):
                      return InputConfigId(ItemType.CONTAINER, value[0], value[1], tuple(v_instances))
                  elif isinstance(v_instances, six.string_types):
                      return InputConfigId(ItemType.CONTAINER, value[0], value[1], (v_instances,))
                  raise ValueError(
                      "Invalid type of instance specification in '{0}'; expected a list, tuple, or string type, "
                      "found {1}.".format(value, type(v_instances).__name__), v_instances)
              elif v_len == 2:
                  return InputConfigId(ItemType.CONTAINER, value[0] or map_name, value[1], instances)
              elif v_len == 1:
                  return InputConfigId(ItemType.CONTAINER, map_name, value[0], instances)
              raise ValueError("Invalid element length; only tuples and lists of length 1-3 can be converted to a "
                               "InputConfigId tuple. Found length {0}.".format(v_len))
          elif isinstance(value, dict):
              kwargs = {
                  'config_type': ItemType.CONTAINER,
                  'map_name': map_name,
                  'instance_names': instances,
              }
              kwargs.update(value)
              return InputConfigId(**kwargs)
          raise ValueError(
              "Invalid type; expected a list, tuple, dict, or string type, found {0}.".format(type(value).__name__))