diff --git a/src/wifi/model/mgt-headers.cc b/src/wifi/model/mgt-headers.cc
index a9b5da7ae..52a2d0b5a 100644
--- a/src/wifi/model/mgt-headers.cc
+++ b/src/wifi/model/mgt-headers.cc
@@ -1681,11 +1681,26 @@ WifiActionHeader::SetAction (WifiActionHeader::CategoryValue type,
   m_category = static_cast<uint8_t> (type);
   switch (type)
     {
+    case QOS:
+      {
+        m_actionValue = static_cast<uint8_t> (action.qos);
+        break;
+      }
     case BLOCK_ACK:
       {
         m_actionValue = static_cast<uint8_t> (action.blockAck);
         break;
       }
+    case PUBLIC:
+      {
+        m_actionValue = static_cast<uint8_t> (action.publicAction);
+        break;
+      }
+    case RADIO_MEASUREMENT:
+      {
+        m_actionValue = static_cast<uint8_t> (action.radioMeasurementAction);
+        break;
+      }
     case MESH:
       {
         m_actionValue = static_cast<uint8_t> (action.meshAction);
@@ -1701,6 +1716,21 @@ WifiActionHeader::SetAction (WifiActionHeader::CategoryValue type,
         m_actionValue = static_cast<uint8_t> (action.selfProtectedAction);
         break;
       }
+    case DMG:
+      {
+        m_actionValue = static_cast<uint8_t> (action.dmgAction);
+        break;
+      }
+    case FST:
+      {
+        m_actionValue = static_cast<uint8_t> (action.fstAction);
+        break;
+      }
+    case UNPROTECTED_DMG:
+      {
+        m_actionValue = static_cast<uint8_t> (action.unprotectedDmgAction);
+        break;
+      }
     case VENDOR_SPECIFIC_ACTION:
       {
         break;
@@ -1713,14 +1743,26 @@ WifiActionHeader::GetCategory ()
 {
   switch (m_category)
     {
+    case QOS:
+      return QOS;
     case BLOCK_ACK:
       return BLOCK_ACK;
+    case PUBLIC:
+      return PUBLIC;
+    case RADIO_MEASUREMENT:
+      return RADIO_MEASUREMENT;
     case MESH:
       return MESH;
     case MULTIHOP:
       return MULTIHOP;
     case SELF_PROTECTED:
       return SELF_PROTECTED;
+    case DMG:
+      return DMG;
+    case FST:
+      return FST;
+    case UNPROTECTED_DMG:
+      return UNPROTECTED_DMG;
     case VENDOR_SPECIFIC_ACTION:
       return VENDOR_SPECIFIC_ACTION;
     default:
@@ -1736,6 +1778,30 @@ WifiActionHeader::GetAction ()
   retval.selfProtectedAction = PEER_LINK_OPEN; //Needs to be initialized to something to quiet valgrind in default cases
   switch (m_category)
     {
+    case QOS:
+      switch (m_actionValue)
+        {
+        case ADDTS_REQUEST:
+          retval.qos = ADDTS_REQUEST;
+          break;
+        case ADDTS_RESPONSE:
+          retval.qos = ADDTS_RESPONSE;
+          break;
+        case DELTS:
+          retval.qos = DELTS;
+          break;
+        case SCHEDULE:
+          retval.qos = SCHEDULE;
+          break;
+        case QOS_MAP_CONFIGURE:
+          retval.qos = QOS_MAP_CONFIGURE;
+          break;
+        default:
+          NS_FATAL_ERROR ("Unknown qos action code");
+          retval.qos = ADDTS_REQUEST; /* quiet compiler */
+        }
+      break;
+
     case BLOCK_ACK:
       switch (m_actionValue)
         {
@@ -1748,6 +1814,51 @@ WifiActionHeader::GetAction ()
         case BLOCK_ACK_DELBA:
           retval.blockAck = BLOCK_ACK_DELBA;
           break;
+        default:
+          NS_FATAL_ERROR ("Unknown block ack action code");
+          retval.blockAck = BLOCK_ACK_ADDBA_REQUEST; /* quiet compiler */
+        }
+      break;
+
+    case PUBLIC:
+      switch (m_actionValue)
+        {
+        case QAB_REQUEST:
+          retval.publicAction = QAB_REQUEST;
+          break;
+        case QAB_RESPONSE:
+          retval.publicAction = QAB_RESPONSE;
+          break;
+        default:
+          NS_FATAL_ERROR ("Unknown public action code");
+          retval.publicAction = QAB_REQUEST; /* quiet compiler */
+        }
+      break;
+
+    case RADIO_MEASUREMENT:
+      switch (m_actionValue)
+        {
+        case RADIO_MEASUREMENT_REQUEST:
+          retval.radioMeasurementAction = RADIO_MEASUREMENT_REQUEST;
+          break;
+        case RADIO_MEASUREMENT_REPORT:
+          retval.radioMeasurementAction = RADIO_MEASUREMENT_REPORT;
+          break;
+        case LINK_MEASUREMENT_REQUEST:
+          retval.radioMeasurementAction = LINK_MEASUREMENT_REQUEST;
+          break;
+        case LINK_MEASUREMENT_REPORT:
+          retval.radioMeasurementAction = LINK_MEASUREMENT_REPORT;
+          break;
+        case NEIGHBOR_REPORT_REQUEST:
+          retval.radioMeasurementAction = NEIGHBOR_REPORT_REQUEST;
+          break;
+        case NEIGHBOR_REPORT_RESPONSE:
+          retval.radioMeasurementAction = NEIGHBOR_REPORT_RESPONSE;
+          break;
+        default:
+          NS_FATAL_ERROR ("Unknown radio measurement action code");
+          retval.radioMeasurementAction = RADIO_MEASUREMENT_REQUEST; /* quiet compiler */
         }
       break;
 
@@ -1813,7 +1924,7 @@ WifiActionHeader::GetAction ()
           break;
         default:
           NS_FATAL_ERROR ("Unknown mesh peering management action code");
-          retval.selfProtectedAction = PEER_LINK_OPEN; /* quiet compiler */
+          retval.meshAction = LINK_METRIC_REPORT; /* quiet compiler */
         }
       break;
 
@@ -1828,11 +1939,141 @@ WifiActionHeader::GetAction ()
           break;
         default:
           NS_FATAL_ERROR ("Unknown mesh peering management action code");
-          retval.selfProtectedAction = PEER_LINK_OPEN; /* quiet compiler */
+          retval.multihopAction = PROXY_UPDATE; /* quiet compiler */
         }
       break;
+
+    case DMG:
+      switch (m_actionValue)
+        {
+        case DMG_POWER_SAVE_CONFIGURATION_REQUEST:
+          retval.dmgAction = DMG_POWER_SAVE_CONFIGURATION_REQUEST;
+          break;
+        case DMG_POWER_SAVE_CONFIGURATION_RESPONSE:
+          retval.dmgAction = DMG_POWER_SAVE_CONFIGURATION_RESPONSE;
+          break;
+        case DMG_INFORMATION_REQUEST:
+          retval.dmgAction = DMG_INFORMATION_REQUEST;
+          break;
+        case DMG_INFORMATION_RESPONSE:
+          retval.dmgAction = DMG_INFORMATION_RESPONSE;
+          break;
+        case DMG_HANDOVER_REQUEST:
+          retval.dmgAction = DMG_HANDOVER_REQUEST;
+          break;
+        case DMG_HANDOVER_RESPONSE:
+          retval.dmgAction = DMG_HANDOVER_RESPONSE;
+          break;
+        case DMG_DTP_REQUEST:
+          retval.dmgAction = DMG_DTP_REQUEST;
+          break;
+        case DMG_DTP_RESPONSE:
+          retval.dmgAction = DMG_DTP_RESPONSE;
+          break;
+        case DMG_RELAY_SEARCH_REQUEST:
+          retval.dmgAction = DMG_RELAY_SEARCH_REQUEST;
+          break;
+        case DMG_RELAY_SEARCH_RESPONSE:
+          retval.dmgAction = DMG_RELAY_SEARCH_RESPONSE;
+          break;
+        case DMG_MULTI_RELAY_CHANNEL_MEASUREMENT_REQUEST:
+          retval.dmgAction = DMG_MULTI_RELAY_CHANNEL_MEASUREMENT_REQUEST;
+          break;
+        case DMG_MULTI_RELAY_CHANNEL_MEASUREMENT_REPORT:
+          retval.dmgAction = DMG_MULTI_RELAY_CHANNEL_MEASUREMENT_REPORT;
+          break;
+        case DMG_RLS_REQUEST:
+          retval.dmgAction = DMG_RLS_REQUEST;
+          break;
+        case DMG_RLS_RESPONSE:
+          retval.dmgAction = DMG_RLS_RESPONSE;
+          break;
+        case DMG_RLS_ANNOUNCEMENT:
+          retval.dmgAction = DMG_RLS_ANNOUNCEMENT;
+          break;
+        case DMG_RLS_TEARDOWN:
+          retval.dmgAction = DMG_RLS_TEARDOWN;
+          break;
+        case DMG_RELAY_ACK_REQUEST:
+          retval.dmgAction = DMG_RELAY_ACK_REQUEST;
+          break;
+        case DMG_RELAY_ACK_RESPONSE:
+          retval.dmgAction = DMG_RELAY_ACK_RESPONSE;
+          break;
+        case DMG_TPA_REQUEST:
+          retval.dmgAction = DMG_TPA_REQUEST;
+          break;
+        case DMG_TPA_RESPONSE:
+          retval.dmgAction = DMG_TPA_RESPONSE;
+          break;
+        case DMG_ROC_REQUEST:
+          retval.dmgAction = DMG_ROC_REQUEST;
+          break;
+        case DMG_ROC_RESPONSE:
+          retval.dmgAction = DMG_ROC_RESPONSE;
+          break;
+        default:
+          NS_FATAL_ERROR ("Unknown DMG management action code");
+          retval.dmgAction = DMG_POWER_SAVE_CONFIGURATION_REQUEST; /* quiet compiler */
+        }
+      break;
+
+    case FST:
+      switch (m_actionValue)
+        {
+        case FST_SETUP_REQUEST:
+          retval.fstAction = FST_SETUP_REQUEST;
+          break;
+        case FST_SETUP_RESPONSE:
+          retval.fstAction = FST_SETUP_RESPONSE;
+          break;
+        case FST_TEAR_DOWN:
+          retval.fstAction = FST_TEAR_DOWN;
+          break;
+        case FST_ACK_REQUEST:
+          retval.fstAction = FST_ACK_REQUEST;
+          break;
+        case FST_ACK_RESPONSE:
+          retval.fstAction = FST_ACK_RESPONSE;
+          break;
+        case ON_CHANNEL_TUNNEL_REQUEST:
+          retval.fstAction = ON_CHANNEL_TUNNEL_REQUEST;
+          break;
+        default:
+          NS_FATAL_ERROR ("Unknown FST management action code");
+          retval.fstAction = FST_SETUP_REQUEST; /* quiet compiler */
+        }
+      break;
+
+    case UNPROTECTED_DMG:
+      switch (m_actionValue)
+        {
+        case UNPROTECTED_DMG_ANNOUNCE:
+          retval.unprotectedDmgAction = UNPROTECTED_DMG_ANNOUNCE;
+          break;
+        case UNPROTECTED_DMG_BRP:
+          retval.unprotectedDmgAction = UNPROTECTED_DMG_BRP;
+          break;
+        case UNPROTECTED_MIMO_BF_SETUP:
+          retval.unprotectedDmgAction = UNPROTECTED_MIMO_BF_SETUP;
+          break;
+        case UNPROTECTED_MIMO_BF_POLL:
+          retval.unprotectedDmgAction = UNPROTECTED_MIMO_BF_POLL;
+          break;
+        case UNPROTECTED_MIMO_BF_FEEDBACK:
+          retval.unprotectedDmgAction = UNPROTECTED_MIMO_BF_FEEDBACK;
+          break;
+        case UNPROTECTED_MIMO_BF_SELECTION:
+          retval.unprotectedDmgAction = UNPROTECTED_MIMO_BF_SELECTION;
+          break;
+        default:
+          NS_FATAL_ERROR ("Unknown Unprotected DMG action code");
+          retval.unprotectedDmgAction = UNPROTECTED_DMG_ANNOUNCE; /* quiet compiler */
+        }
+      break;
+
     default:
-      NS_FATAL_ERROR ("Unsupported mesh action");
+      NS_FATAL_ERROR ("Unsupported action");
       retval.selfProtectedAction = PEER_LINK_OPEN; /* quiet compiler */
     }
   return retval;
@@ -1858,29 +2099,37 @@ WifiActionHeader::GetInstanceTypeId () const
 std::string
 WifiActionHeader::CategoryValueToString (CategoryValue value) const
 {
-  if (value == BLOCK_ACK)
+  switch (value)
     {
+    case QOS:
+      return "QoS";
+    case BLOCK_ACK:
       return "BlockAck";
-    }
-  else if (value == MESH)
-    {
+    case PUBLIC:
+      return "Public";
+    case RADIO_MEASUREMENT:
+      return "RadioMeasurement";
+    case MESH:
       return "Mesh";
-    }
-  else if (value == SELF_PROTECTED)
-    {
+    case MULTIHOP:
+      return "Multihop";
+    case SELF_PROTECTED:
       return "SelfProtected";
-    }
-  else if (value == VENDOR_SPECIFIC_ACTION)
-    {
+    case DMG:
+      return "Dmg";
+    case FST:
+      return "Fst";
+    case UNPROTECTED_DMG:
+      return "UnprotectedDmg";
+    case VENDOR_SPECIFIC_ACTION:
       return "VendorSpecificAction";
-    }
-  else
-    {
+    default:
       std::ostringstream convert;
       convert << value;
       return convert.str ();
     }
 }
+
 std::string
 WifiActionHeader::SelfProtectedActionValueToString (SelfProtectedActionValue value) const
 {
diff --git a/src/wifi/model/mgt-headers.h b/src/wifi/model/mgt-headers.h
index c5888bd49..2cb02ddd3 100644
--- a/src/wifi/model/mgt-headers.h
+++ b/src/wifi/model/mgt-headers.h
@@ -1263,30 +1263,58 @@ public:
   ///CategoryValue enumeration
   enum CategoryValue //table 8-38 staring from IEEE 802.11, Part11, (Year 2012)
   {
+    QOS = 1,
     BLOCK_ACK = 3,
+    PUBLIC = 4,
+    RADIO_MEASUREMENT = 5,      //Category: Radio Measurement
     MESH = 13,                  //Category: Mesh
     MULTIHOP = 14,              //not used so far
     SELF_PROTECTED = 15,        //Category: Self Protected
+    DMG = 16,                   //Category: DMG
+    FST = 18,                   //Category: Fast Session Transfer
+    UNPROTECTED_DMG = 20,       //Category: Unprotected DMG
     //Since vendor specific action has no stationary Action value,the parse process is not here.
     //Refer to vendor-specific-action in wave module.
     VENDOR_SPECIFIC_ACTION = 127,
   };
 
-  ///SelfProtectedActionValue enumeration
-  enum SelfProtectedActionValue //Category: 15 (Self Protected)
+  ///QosActionValue enumeration
+  enum QosActionValue
   {
-    PEER_LINK_OPEN = 1,         //Mesh Peering Open
-    PEER_LINK_CONFIRM = 2,      //Mesh Peering Confirm
-    PEER_LINK_CLOSE = 3,        //Mesh Peering Close
-    GROUP_KEY_INFORM = 4,       //Mesh Group Key Inform
-    GROUP_KEY_ACK = 5,          //Mesh Group Key Acknowledge
+    ADDTS_REQUEST = 0,
+    ADDTS_RESPONSE = 1,
+    DELTS = 2,
+    SCHEDULE = 3,
+    QOS_MAP_CONFIGURE = 4,
   };
 
-  ///MultihopActionValue enumeration
-  enum MultihopActionValue
+  /**
+   * Block Ack Action field values
+   * See 802.11 Table 8-202
+   */
+  enum BlockAckActionValue
   {
-    PROXY_UPDATE = 0,                   //not used so far
-    PROXY_UPDATE_CONFIRMATION = 1,      //not used so far
+    BLOCK_ACK_ADDBA_REQUEST = 0,
+    BLOCK_ACK_ADDBA_RESPONSE = 1,
+    BLOCK_ACK_DELBA = 2
+  };
+
+  ///PublicActionValue enumeration
+  enum PublicActionValue
+  {
+    QAB_REQUEST = 16,
+    QAB_RESPONSE = 17,
+  };
+
+  ///RadioMeasurementActionValue enumeration
+  enum RadioMeasurementActionValue
+  {
+    RADIO_MEASUREMENT_REQUEST = 0,
+    RADIO_MEASUREMENT_REPORT = 1,
+    LINK_MEASUREMENT_REQUEST = 2,
+    LINK_MEASUREMENT_REPORT = 3,
+    NEIGHBOR_REPORT_REQUEST = 4,
+    NEIGHBOR_REPORT_RESPONSE = 5
   };
 
   ///MeshActionValue enumeration
@@ -1305,27 +1333,97 @@ public:
     TBTT_ADJUSTMENT_RESPONSE = 10,        //Action Value:10 in Category 13: Mesh (not used so far)
   };
 
-  /**
-   * Block Ack Action field values
-   * See 802.11 Table 8-202
-   */
-  enum BlockAckActionValue
+  ///MultihopActionValue enumeration
+  enum MultihopActionValue
   {
-    BLOCK_ACK_ADDBA_REQUEST = 0,
-    BLOCK_ACK_ADDBA_RESPONSE = 1,
-    BLOCK_ACK_DELBA = 2
+    PROXY_UPDATE = 0,                   //not used so far
+    PROXY_UPDATE_CONFIRMATION = 1,      //not used so far
   };
 
+  ///SelfProtectedActionValue enumeration
+  enum SelfProtectedActionValue //Category: 15 (Self Protected)
+  {
+    PEER_LINK_OPEN = 1,         //Mesh Peering Open
+    PEER_LINK_CONFIRM = 2,      //Mesh Peering Confirm
+    PEER_LINK_CLOSE = 3,        //Mesh Peering Close
+    GROUP_KEY_INFORM = 4,       //Mesh Group Key Inform
+    GROUP_KEY_ACK = 5,          //Mesh Group Key Acknowledge
+  };
+
+  /**
+   * DMG Action field values
+   * See 802.11ad Table 8-281b
+   */
+  enum DmgActionValue
+  {
+    DMG_POWER_SAVE_CONFIGURATION_REQUEST = 0,
+    DMG_POWER_SAVE_CONFIGURATION_RESPONSE = 1,
+    DMG_INFORMATION_REQUEST = 2,
+    DMG_INFORMATION_RESPONSE = 3,
+    DMG_HANDOVER_REQUEST = 4,
+    DMG_HANDOVER_RESPONSE = 5,
+    DMG_DTP_REQUEST = 6,
+    DMG_DTP_RESPONSE = 7,
+    DMG_RELAY_SEARCH_REQUEST = 8,
+    DMG_RELAY_SEARCH_RESPONSE = 9,
+    DMG_MULTI_RELAY_CHANNEL_MEASUREMENT_REQUEST = 10,
+    DMG_MULTI_RELAY_CHANNEL_MEASUREMENT_REPORT = 11,
+    DMG_RLS_REQUEST = 12,
+    DMG_RLS_RESPONSE = 13,
+    DMG_RLS_ANNOUNCEMENT = 14,
+    DMG_RLS_TEARDOWN = 15,
+    DMG_RELAY_ACK_REQUEST = 16,
+    DMG_RELAY_ACK_RESPONSE = 17,
+    DMG_TPA_REQUEST = 18,
+    DMG_TPA_RESPONSE = 19,
+    DMG_TPA_REPORT = 20,
+    DMG_ROC_REQUEST = 21,
+    DMG_ROC_RESPONSE = 22
+  };
+
+  /**
+   * FST Action field values
+   * See 802.11ad Table 8-281x
+   */
+  enum FstActionValue
+  {
+    FST_SETUP_REQUEST = 0,
+    FST_SETUP_RESPONSE = 1,
+    FST_TEAR_DOWN = 2,
+    FST_ACK_REQUEST = 3,
+    FST_ACK_RESPONSE = 4,
+    ON_CHANNEL_TUNNEL_REQUEST = 5
+  };
+
+  /**
+   * Unprotected DMG action field values
+   * See 802.11ad Table 8-281ae
+   */
+  enum UnprotectedDmgActionValue
+  {
+    UNPROTECTED_DMG_ANNOUNCE = 0,
+    UNPROTECTED_DMG_BRP = 1,
+    UNPROTECTED_MIMO_BF_SETUP = 2,
+    UNPROTECTED_MIMO_BF_POLL = 3,
+    UNPROTECTED_MIMO_BF_FEEDBACK = 4,
+    UNPROTECTED_MIMO_BF_SELECTION = 5,
+  };
 
   /**
    * typedef for union of different ActionValues
    */
   typedef union
   {
-    MeshActionValue meshAction; ///< mesh action
-    MultihopActionValue multihopAction; ///< multi hop action
-    SelfProtectedActionValue selfProtectedAction; ///< self protected action
+    QosActionValue qos; ///< qos
     BlockAckActionValue blockAck; ///< block ack
+    RadioMeasurementActionValue radioMeasurementAction; ///< radio measurement
+    PublicActionValue publicAction; ///< public
+    SelfProtectedActionValue selfProtectedAction; ///< self protected
+    MultihopActionValue multihopAction; ///< multi hop
+    MeshActionValue meshAction; ///< mesh
+    DmgActionValue dmgAction; ///< dmg
+    FstActionValue fstAction; ///< fst
+    UnprotectedDmgActionValue unprotectedDmgAction; ///< unprotected dmg
   } ActionValue; ///< the action value
   /**
    * Set action for this Action header.