public String getPlcValueTypeForTypeReference(TypeReference typeReference) {
        if (typeReference == null) {
            // TODO: shouldn't this be an error case
            return "";
        }
        if (typeReference.isNonSimpleTypeReference()) {
            return ((NonSimpleTypeReference) typeReference).getName();
        }
        SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
        switch (simpleTypeReference.getBaseType()) {
            case BIT:
                // Bit values are represented as boolean in PLC4Py
                emitRequiredImport("from plc4py.spi.values.PlcValues import PlcBOOL");
                return "PlcBOOL";
            case BYTE:
                // Byte values are represented as signed integers in PLC4Py
                emitRequiredImport("from plc4py.spi.values.PlcValues import PlcSINT");
                return "PlcBYTE";
            case UINT:
                IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
                if (unsignedIntegerTypeReference.getSizeInBits() <= 4) {
                    // Ubyte values are represented as unsigned short integers in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcUSINT");
                    return "PlcUSINT";
                }
                if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
                    // Uword values are represented as unsigned integers in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcUINT");
                    return "PlcUINT";
                }
                if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
                    // Uword16 values are represented as unsigned long integers in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcUDINT");
                    return "PlcUDINT";
                }
                if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
                    // Uword32 values are represented as unsigned long long integers in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcULINT");
                    return "PlcULINT";
                }
            case INT:
                IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
                if (integerTypeReference.getSizeInBits() <= 8) {
                    // Byte values are represented as signed integers in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcSINT");
                    return "PlcSINT";
                }
                if (integerTypeReference.getSizeInBits() <= 16) {
                    // Word values are represented as signed long integers in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcINT");
                    return "PlcINT";
                }
                if (integerTypeReference.getSizeInBits() <= 32) {
                    // Dword values are represented as signed long long integers in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcDINT");
                    return "PlcDINT";
                }
                if (integerTypeReference.getSizeInBits() <= 64) {
                    // Lword values are represented as signed long long integers in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcLINT");
                    return "PlcLINT";
                }
            case FLOAT:
            case UFLOAT:
                FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
                int sizeInBits = floatTypeReference.getSizeInBits();
                if (sizeInBits <= 32) {
                    // Float values are represented as float in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcREAL");
                    return "PlcREAL";
                }
                if (sizeInBits <= 64) {
                    // Double values are represented as double in PLC4Py
                    emitRequiredImport("from plc4py.spi.values.PlcValues import PlcLREAL");
                    return "PlcLREAL";
                }
            case STRING:
            case VSTRING:
                // String values are represented as a string in PLC4Py
                emitRequiredImport("from plc4py.spi.values.PlcValues import PlcSTRING");
                return "PlcSTRING";
            case TIME:
            case DATE:
            case DATETIME:
                // Time values are represented as a time in PLC4Py
                emitRequiredImport("from plc4py.spi.values.PlcValues import PlcTIME");
                return "PlcTIME";
            default:
                return "";
        }
    }
Returns the name of the PLC4Py value type that corresponds to the given type reference.

<p>
This method is used to generate code for converting a type reference to a PLC4Py type name.

@param typeReference the type reference to get the PLC4Py type name for

@return the PLC4Py type name or an empty string if the type reference is not supported
code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java