diff --git a/doc/sphinx/props/P_ITEMS.rst b/doc/sphinx/props/P_ITEMS.rst
index 3e4bbd8..855f861 100644
--- a/doc/sphinx/props/P_ITEMS.rst
+++ b/doc/sphinx/props/P_ITEMS.rst
@@ -3,20 +3,43 @@
 
 NAME
 ----
-::
 
-    P_ITEMS                       "items"                       
+  P_ITEMS                       "items"                       
 
 DEFINIERT IN
 ------------
-::
 
-    /sys/properties.h
+  /sys/container.h
 
 BESCHREIBUNG
 ------------
-::
 
-     Definition von Gegenstaenden, die in dem Raum liegen sollen.
-     Erklaerung in einem Extrafile.
+  P_ITEM enthaelt eine Datenstruktur vom Typ
+  < <object|<string|string*>|int|mapping>* >*. Jedes Unterarray enthaelt die
+  Daten zu einem per :doc:`../lfun/AddItem` hinzugefuegten Objekt. Der Aufbau
+  ist wie folgt:
 
+  - RITEM_OBJECT (object)
+    Das erzeugte Objekt
+  - RITEM_FILE (string|string*)
+    Die Dateinamen
+  - RITEM_REFRESH (int)
+    Refresh Flags, Konstanten aus rooms.h und npc.h
+  - RITEM_PROPS (mapping|int)
+    Properties oder unique Flag
+
+  Fuer Details zu den jeweiligen Eintraegen siehe :doc:`../lfun/AddItem` , die
+  Konstanten sind in rooms.h definiert.
+
+BEMERKUNGEN
+-----------
+
+  Diese Property keinesfalls von Hand setzen! Benutzt die Zugriffsfunktionen
+  :doc:`../lfun/AddItem`  und :doc:`../lfun/RemoveItem`.
+
+SIEHE AUCH
+----------
+
+  :doc:`../lfun/AddItem`, :doc:`../lfun/RemoveItem`
+
+Letzte Aenderung: 03.07.2025, Bugfix
