def get_description(self):
        """Returns information about the virtual system as arrays of instruction items. In each array, the
        items with the same indices correspond and jointly represent an import instruction for VirtualBox.
        
        The list below identifies the value sets that are possible depending on the
        :py:class:`VirtualSystemDescriptionType`  enum value in the array item in @a aTypes[]. In each case,
        the array item with the same index in @a OVFValues[] will contain the original value as contained
        in the OVF file (just for informational purposes), and the corresponding item in @a aVBoxValues[]
        will contain a suggested value to be used for VirtualBox. Depending on the description type,
        the @a aExtraConfigValues[] array item may also be used.
        
        
        
        "OS": the guest operating system type. There must be exactly one such array item on import. The
        corresponding item in @a aVBoxValues[] contains the suggested guest operating system for VirtualBox.
        This will be one of the values listed in :py:func:`IVirtualBox.guest_os_types` . The corresponding
        item in @a OVFValues[] will contain a numerical value that described the operating system in the OVF.
        
        
        "Name": the name to give to the new virtual machine. There can be at most one such array item;
        if none is present on import, then an automatic name will be created from the operating system
        type. The corresponding item im @a OVFValues[] will contain the suggested virtual machine name
        from the OVF file, and @a aVBoxValues[] will contain a suggestion for a unique VirtualBox
        :py:class:`IMachine`  name that does not exist yet.
        
        
        "Description": an arbitrary description.
        
        
        "License": the EULA section from the OVF, if present. It is the responsibility of the calling
        code to display such a license for agreement; the Main API does not enforce any such policy.
        
        
        Miscellaneous: reserved for future use.
        
        
        "CPU": the number of CPUs. There can be at most one such item, which will presently be ignored.
        
        
        "Memory": the amount of guest RAM, in bytes. There can be at most one such array item; if none
        is present on import, then VirtualBox will set a meaningful default based on the operating system
        type.
        
        
        "HardDiskControllerIDE": an IDE hard disk controller. There can be at most two such items.
        An optional value in @a OVFValues[] and @a aVBoxValues[] can be "PIIX3" or "PIIX4" to specify
        the type of IDE controller; this corresponds to the ResourceSubType element which VirtualBox
        writes into the OVF.
        The matching item in the @a aRefs[] array will contain an integer that items of the "Harddisk"
        type can use to specify which hard disk controller a virtual disk should be connected to.
        Note that in OVF, an IDE controller has two channels, corresponding to "master" and "slave"
        in traditional terminology, whereas the IDE storage controller that VirtualBox supports in
        its virtual machines supports four channels (primary master, primary slave, secondary master,
        secondary slave) and thus maps to two IDE controllers in the OVF sense.
        
        
        "HardDiskControllerSATA": an SATA hard disk controller. There can be at most one such item. This
        has no value in @a OVFValues[] or @a aVBoxValues[].
        The matching item in the @a aRefs[] array will be used as with IDE controllers (see above).
        
        
        "HardDiskControllerSCSI": a SCSI hard disk controller. There can be at most one such item.
        The items in @a OVFValues[] and @a aVBoxValues[] will either be "LsiLogic", "BusLogic" or
        "LsiLogicSas". (Note that in OVF, the LsiLogicSas controller is treated as a SCSI controller
        whereas VirtualBox considers it a class of storage controllers of its own; see
        :py:class:`StorageControllerType` ).
        The matching item in the @a aRefs[] array will be used as with IDE controllers (see above).
        
        
        "HardDiskImage": a virtual hard disk, most probably as a reference to an image file. There can be an
        arbitrary number of these items, one for each virtual disk image that accompanies the OVF.
        
        The array item in @a OVFValues[] will contain the file specification from the OVF file (without
        a path since the image file should be in the same location as the OVF file itself), whereas the
        item in @a aVBoxValues[] will contain a qualified path specification to where VirtualBox uses the
        hard disk image. This means that on import the image will be copied and converted from the
        "ovf" location to the "vbox" location; on export, this will be handled the other way round.
        
        The matching item in the @a aExtraConfigValues[] array must contain a string of the following
        format: "controller=<index>;channel=<c>"
        In this string, <index> must be an integer specifying the hard disk controller to connect
        the image to. That number must be the index of an array item with one of the hard disk controller
        types (HardDiskControllerSCSI, HardDiskControllerSATA, HardDiskControllerIDE).
        In addition, <c> must specify the channel to use on that controller. For IDE controllers,
        this can be 0 or 1 for master or slave, respectively. For compatibility with VirtualBox versions
        before 3.2, the values 2 and 3 (for secondary master and secondary slave) are also supported, but
        no longer exported. For SATA and SCSI controllers, the channel can range from 0-29.
        
        
        "CDROM": a virtual CD-ROM drive. The matching item in @a aExtraConfigValue[] contains the same
        attachment information as with "HardDiskImage" items.
        
        
        "CDROM": a virtual floppy drive. The matching item in @a aExtraConfigValue[] contains the same
        attachment information as with "HardDiskImage" items.
        
        
        "NetworkAdapter": a network adapter. The array item in @a aVBoxValues[] will specify the hardware
        for the network adapter, whereas the array item in @a aExtraConfigValues[] will have a string
        of the "type=<X>" format, where <X> must be either "NAT" or "Bridged".
        
        
        "USBController": a USB controller. There can be at most one such item. If, and only if, such an
        item is present, USB support will be enabled for the new virtual machine.
        
        
        "SoundCard": a sound card. There can be at most one such item. If and only if such an item is
        present, sound support will be enabled for the new virtual machine. Note that the virtual
        machine in VirtualBox will always be presented with the standard VirtualBox soundcard, which
        may be different from the virtual soundcard expected by the appliance.

        out types of type :class:`VirtualSystemDescriptionType`

        out refs of type str

        out ovf_values of type str

        out v_box_values of type str

        out extra_config_values of type str

        """
        (types, refs, ovf_values, v_box_values, extra_config_values) = self._call("getDescription")
        types = [VirtualSystemDescriptionType(a) for a in types]
        return (types, refs, ovf_values, v_box_values, extra_config_values)