* @throws ConfigurationChangeException Falls der Objekt-Typ nicht importiert werden konnte.
	 */
	private void handleSystemObjectType(ImportObject importObject) throws ConfigurationChangeException {
		final SystemObjectTypeProperties property = (SystemObjectTypeProperties)importObject.getProperties();
		try {
			// prüfen, ob die Pid des Objekt-Typen bereits eingetragen wurde, wenn ja, dann wurde eine Schleife erkannt, d.h. eine fehlerhafte Versorgung in
			// der Versorgungsdatei
			if(_objectTypesToCreate.contains(property.getPid())) {
				final String errorMessage = "Es gibt einen Fehler in der Versorgungsdatei. Zwei Objekt-Typen referenzieren sich gegenseitig.";
				_debug.error(errorMessage);
				throw new IllegalStateException(errorMessage);
			}
			// Pid des Objekt-Typen wird eingetragen
			_objectTypesToCreate.add(property.getPid());

			// Liste der erweiterten Typen (SuperTypen)
			final List<SystemObjectType> superTypes = new ArrayList<SystemObjectType>();

			// speichert, ob es sich um einen dynamischen oder einen konfigurierenden Typen handelt
			boolean isDynamicType = false;

			// ist dies ein Basis-Typ?
			if(property.getExtendedPids().length == 0) {
				if(property.getConfiguring()) {
					// ein konfigurierender Basis-Typ (typ.typ)
					isDynamicType = false;
				}
				else {
					// ein dynamischer Basis-Typ (typ.dynamischerTyp)
					isDynamicType = true;
				}
			}
			else {
				// es ist kein BasisTyp -> herausbekommen, was für ein Typ es ist
				// Liste der erweiterten Typen wird erstellt
				superTypes.addAll(createSuperTypes(property.getExtendedPids()));
				isDynamicType = isDynamicType(superTypes);
			}

			// Typ des Typs bestimmen (typ.typ oder typ.dynamischerTyp)
			final SystemObjectType type;
			if(isDynamicType) {
				type = _dataModel.getType(Pid.Type.DYNAMIC_TYPE);
			}
			else {
				type = _dataModel.getType(Pid.Type.TYPE);
			}

			SystemObjectType systemObjectType = (SystemObjectType)importObject.getSystemObject();
			if(systemObjectType != null) {
				// falls der Typ des bestehenden Typs nicht mit dem neuen Typ der Properties übereinstimmt, muss ein neuer Objekt-Typ erstellt werden
				if(type != systemObjectType.getType()) {
					_debug.finer(
							"Der Typ des Typs " + systemObjectType.getPid() + " hat sich geänder von " + systemObjectType.getType().getPid() + " zu "
							+ type.getPid()
					);

					// handelt es sich um ein in Bearbeitung erstellter Typ, dann muss es aus der EditingObjects-Map entfernt werden.
					final Collection<CheckedObject> objects = _editingObjects.get(importObject.getConfigurationArea());
					for(CheckedObject object : objects) {
						if(object.getSystemObject() == (SystemObject)systemObjectType) {
							objects.remove(object);
							break;
						}
					}

					// Typ muss jetzt schon auf ungültig gesetzt werden, damit ein neuer Typ mit gleicher Pid erstellt werden kann
					// in Bearbeitung erstellte Objekte werden direkt gelöscht.
					
					((ConfigSystemObject)systemObjectType).simpleInvalidation();
					systemObjectType = null;
					_dissolveReference = true;
				}
				else {
					setSystemObjectKeeping(systemObjectType);
				}
			}
			if(systemObjectType == null) {
				// Neuer Objekt-Typ wird angelegt.
				systemObjectType = (SystemObjectType)importObject.getConfigurationArea().createConfigurationObject(
						(ConfigurationObjectType)type, property.getPid(), property.getName(), null
				);
				_debug.finer("Ein Objekt-Typ mit der Pid '" + property.getPid() + "' wurde erstellt.");
			}

			// Namen überprüfen
			if(_objectDiffs.isNameDifferent(property.getName(), systemObjectType.getName())) {
				systemObjectType.setName(property.getName());
			}
			// Info überprüfen
			if(_objectDiffs.isInfoDifferent(property.getInfo(), systemObjectType.getInfo())) {
				setInfo(systemObjectType, property.getInfo());
			}
			// Eigenschaften überprüfen
//			if(systemObjectType.getConfigurationData(_dataModel.getAttributeGroup("atg.typEigenschaften")) == null
			if(getConfigurationData(systemObjectType, _dataModel.getAttributeGroup("atg.typEigenschaften")) == null
			   || _objectDiffs.isSystemObjectTypePropertiesDifferent(property, systemObjectType)) {
				setSystemObjectTypeProperties(systemObjectType, !isDynamicType, property.getObjectNamesPermanent());
			}

			// Die Menge der SuperTypen erstellen
			handleSystemObjectTypeSuperTypes(importObject.getConfigurationArea(), systemObjectType, superTypes);

			// bei dynamischen Objekt-Typen wird der Persistenz-Modus gespeichert
			if(isDynamicType) {
				DynamicObjectType.PersistenceMode persistenceMode;
				switch(property.getPersistenceMode()) {
					case TRANSIENT_OBJECTS:
						persistenceMode = DynamicObjectType.PersistenceMode.TRANSIENT_OBJECTS;
						break;
					case PERSISTENT_OBJECTS:
						persistenceMode = DynamicObjectType.PersistenceMode.PERSISTENT_OBJECTS;
						break;
					case PERSISTENT_AND_INVALID_ON_RESTART:
						persistenceMode = DynamicObjectType.PersistenceMode.PERSISTENT_AND_INVALID_ON_RESTART;
						break;
					default:
						persistenceMode = getSuperTypePersistenceMode(superTypes);
				}
				final DynamicObjectType dynamicObjectType = (DynamicObjectType)systemObjectType;
				if(getConfigurationData(dynamicObjectType, _dataModel.getAttributeGroup("atg.dynamischerTypEigenschaften")) == null
				   || persistenceMode != dynamicObjectType.getPersistenceMode()) {
					setDynamicObjectTypePersistenceMode(dynamicObjectType, persistenceMode);
				}
			}

			// nach der Erstellung des Objekt-Typs wird die Pid wieder aus der Liste entfernt
			_objectTypesToCreate.remove(property.getPid());
			importObject.setSystemObject(systemObjectType);
		}
		catch(ConfigurationChangeException ex) {
			final String errorMessage = "Der Objekt-Typ '" + property.getPid() + "' konnte nicht korrekt erstellt werden";
			_debug.error(errorMessage);
			throw new ConfigurationChangeException(errorMessage, ex);
		}
	}