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__))