//
//    Copyright (C) Microsoft.  All rights reserved.
//
//    Microsoft Confidential
//
//    THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
//    KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//    IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
//    PURPOSE.
//
//    NOTE: ALL CODE IN THIS FILE IS AUTOMATICALLY GENERATED.
//          MANUAL CHANGES WILL BE LOST NEXT TIME IT IS GENERATED.
// 


#include "Precomp.hpp"
#include "TlvFramework.hpp"
#include "TlvVersioningHelpers.hpp"
#include "TlvGenerated_.tmh"

#define TLV_FIELD_OFFSET(type, field) ((UINT16)FIELD_OFFSET(type, field))

ULONG g_DebugTlvParser = 0;


// Helpers for WDI_START_AP_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_START_AP_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_START_AP_PARAMETERS_V1_0_1
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_START_AP_PARAMETERS_V1_0_1_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_DELETE_PORT_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_DELETE_PORT_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT16 );
        }
    }
}
// Helpers for WDI_CREATE_PORT_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CREATE_PORT_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT16 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_DOT11_RESET_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_DOT11_RESET_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_SET_DEFAULT_KEY_ID_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_SET_DEFAULT_KEY_ID_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_PMK_NAME_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_PMK_NAME_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_TYPE_PMK_NAME );
        }
    }
}
// Helpers for WDI_PRIVACY_EXEMPTION_PARAMETERS_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_PRIVACY_EXEMPTION_PARAMETERS_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT16 ) + sizeof( WDI_EXEMPTION_ACTION_TYPE ) + sizeof( WDI_EXEMPTION_PACKET_TYPE );
        }
    }
}
// Helpers for WDI_LINK_STATE_CHANGE_PARAMETERS_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_LINK_STATE_CHANGE_PARAMETERS_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_P2P_CHANNEL
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_CHANNEL_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) * 3 + sizeof( UINT8 ) + sizeof( WDI_CHANNEL_NUMBER );
        }
    }
}
// Helpers for WDI_P2P_DEVICE_TYPE
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_DEVICE_TYPE_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT16 ) + sizeof( UINT8 ) * 4 + sizeof( UINT16 );
        }
    }
}
// Helpers for WDI_P2P_DEVICE_INFO_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_DEVICE_INFO_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) * 6 + sizeof( UINT16 ) + WDI_P2P_DEVICE_TYPE_HELPER::s_BinarySize;
        }
    }
}
// Helpers for WDI_TCP_RSC_STATISTICS_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_TCP_RSC_STATISTICS_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 );
        }
    }
}
// Helpers for WDI_P2P_DEVICE_CAPABILITY_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_DEVICE_CAPABILITY_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_BSSID_INFO_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_BSSID_INFO_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_P2P_GROUP_OWNER_CAPABILITY_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_GROUP_OWNER_CAPABILITY_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_P2P_DISCOVER_MODE
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_DISCOVER_MODE_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_P2P_DISCOVER_TYPE ) + sizeof( BOOLEAN ) + sizeof( WDI_P2P_SCAN_TYPE ) + sizeof( WDI_P2P_SERVICE_DISCOVERY_TYPE ) + sizeof( BOOLEAN ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_P2P_BACKGROUND_DISCOVER_MODE
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_BACKGROUND_DISCOVER_MODE_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_P2P_DISCOVER_TYPE ) + sizeof( WDI_P2P_SERVICE_DISCOVERY_TYPE ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_SCAN_DWELL_TIME
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_SCAN_DWELL_TIME_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_P2P_LISTEN_DURATION
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_LISTEN_DURATION_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_CANCEL_PARAMETERS_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CANCEL_PARAMETERS_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( NDIS_OID ) + sizeof( UINT32 ) + sizeof( WDI_PORT_ID );
        }
    }
}
// Helpers for WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT8 ) * 4 + sizeof( UINT8 ) * 4 + sizeof( WDI_MAC_ADDRESS );
        }
    }
}
// Helpers for WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT8 ) * 16 + sizeof( UINT8 ) * 16 + sizeof( UINT8 ) * 16 + sizeof( UINT8 ) * 16 + sizeof( WDI_MAC_ADDRESS );
        }
    }
}
// Helpers for WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT64 ) + sizeof( UINT8 ) * 16 + sizeof( UINT8 ) * 16;
        }
    }
}
// Helpers for WDI_SCAN_MODE
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_SCAN_MODE_HELPER
        {
            static const USHORT s_BinarySize = sizeof( BOOLEAN ) + sizeof( WDI_SCAN_TYPE ) + sizeof( BOOLEAN ) + sizeof( WDI_SCAN_TRIGGER );
        }
    }
}
// Helpers for WDI_CREATE_PORT_COMPLETE_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CREATE_PORT_COMPLETE_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT16 );
        }
    }
}
// Helpers for WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( BOOLEAN ) + sizeof( UINT16 ) + sizeof( UINT16 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_SIGNAL_INFO
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_SIGNAL_INFO_HELPER
        {
            static const USHORT s_BinarySize = sizeof( INT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_BSS_ENTRY_CHANNEL_INFO
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_BSS_ENTRY_CHANNEL_INFO_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_CHANNEL_NUMBER ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_BSS_ENTRY_AGE_INFO
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_BSS_ENTRY_AGE_INFO_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT64 ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_P2P_ACTION_FRAME_TYPE ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_MAC_STATISTICS_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_MAC_STATISTICS_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 );
        }
    }
}
// Helpers for WDI_PHY_STATISTICS_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_PHY_STATISTICS_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_PHY_TYPE ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 );
        }
    }
}
// Helpers for WDI_P2P_INVITATION_REQUEST_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_INVITATION_REQUEST_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT16 ) + sizeof( UINT16 ) + sizeof( UINT8 ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_LINK_QUALITY_BAR_MAP_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_LINK_QUALITY_BAR_MAP_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_GET_AUTO_POWER_SAVE_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_GET_AUTO_POWER_SAVE_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT16 ) + sizeof( UINT16 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( WDI_POWER_SAVE_LEVEL ) + sizeof( WDI_POWER_SAVE_LEVEL ) + sizeof( WDI_POWER_MODE_REASON_CODE ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 ) + sizeof( UINT64 );
        }
    }
}
// Helpers for WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_P2P_PROVISION_SERVICE_ATTRIBUTES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_PROVISION_SERVICE_ATTRIBUTES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT32 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT16 ) + sizeof( UINT16 ) + sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_COMMUNICATION_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_COMMUNICATION_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_INTERFACE_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_INTERFACE_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT16 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( WDI_BLUETOOTH_COEXISTENCE_SUPPORT ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_INTERFACE_CAPABILITIESV1_0_1
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_INTERFACE_CAPABILITIESV1_0_1_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT16 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( WDI_BLUETOOTH_COEXISTENCE_SUPPORT ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_INTERFACE_CAPABILITIESV1_0
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_INTERFACE_CAPABILITIESV1_0_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT16 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( WDI_BLUETOOTH_COEXISTENCE_SUPPORT ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_ALGO_PAIRS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_ALGO_PAIRS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_AUTH_ALGORITHM ) + sizeof( WDI_CIPHER_ALGORITHM );
        }
    }
}
// Helpers for WDI_STATION_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_STATION_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_COUNTRY_REGION_LIST
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_COUNTRY_REGION_LIST_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) * 3;
        }
    }
}
// Helpers for WDI_AP_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_AP_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_VIRTUALIZATION_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_VIRTUALIZATION_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_P2P_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT8 ) + sizeof( UINT8 ) * 6 + sizeof( UINT32 ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_P2P_CAPABILITIES_V1_0_10
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_CAPABILITIES_V1_0_10_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT8 ) + sizeof( UINT8 ) * 6 + sizeof( UINT32 ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_P2P_CAPABILITIES_V1_0_1
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_CAPABILITIES_V1_0_1_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT8 ) + sizeof( UINT8 ) * 6 + sizeof( UINT32 ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_DATAPATH_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_DATAPATH_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT16 ) + sizeof( UINT8 ) + sizeof( UINT16 ) + sizeof( UINT16 ) + sizeof( UINT8 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_BAND_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_BAND_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_PHY_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_PHY_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_PHY_TYPE ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_PM_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_PM_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( NDIS_DEVICE_POWER_STATE ) + sizeof( NDIS_DEVICE_POWER_STATE ) + sizeof( NDIS_DEVICE_POWER_STATE ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_RECEIVE_COALESCING_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_RECEIVE_COALESCING_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_DATA_RATE_LIST
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_DATA_RATE_LIST_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT16 );
        }
    }
}
// Helpers for WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_LSO_V1_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_LSO_V1_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_IPV4_LSO_V2
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_IPV4_LSO_V2_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_IPV6_LSO_V2
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_IPV6_LSO_V2_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_P2P_ACTION_FRAME_TYPE ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT8 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( BOOLEAN ) + sizeof( UINT16 ) + sizeof( UINT16 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT8 ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_P2P_INVITATION_RESPONSE_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_INVITATION_RESPONSE_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) + sizeof( UINT16 ) + sizeof( UINT16 );
        }
    }
}
// Helpers for WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_P2P_ACTION_FRAME_TYPE ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( BOOLEAN ) + sizeof( UINT16 );
        }
    }
}
// Helpers for WDI_AP_ASSOCIATION_REQUEST_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_AP_ASSOCIATION_REQUEST_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_MAC_ADDRESS ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_DISCONNECT_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_DISCONNECT_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT16 );
        }
    }
}
// Helpers for WDI_P2P_SEND_ACTION_FRAME_RESULT_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_P2P_SEND_ACTION_FRAME_RESULT_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT8 );
        }
    }
}
// Helpers for WDI_ASSOC_RESULT_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_ASSOC_RESULT_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_MAC_ADDRESS ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( WDI_AUTH_ALGORITHM ) + sizeof( WDI_CIPHER_ALGORITHM ) + sizeof( WDI_CIPHER_ALGORITHM );
        }
    }
}
// Helpers for WDI_DISCONNECT_INDICATION_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_DISCONNECT_INDICATION_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_MAC_ADDRESS ) + sizeof( WDI_ASSOC_STATUS );
        }
    }
}
// Helpers for WDI_RADIO_STATUS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_RADIO_STATUS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( BOOLEAN ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_CIPHER_KEY_ID_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CIPHER_KEY_ID_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_CIPHER_KEY_TYPE_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CIPHER_KEY_TYPE_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_CIPHER_ALGORITHM ) + sizeof( WDI_CIPHER_KEY_DIRECTION ) + sizeof( UINT8 ) + sizeof( WDI_CIPHER_KEY_TYPE );
        }
    }
}
// Helpers for WDI_RECEIVE_SEQUENCE_COUNT_STRUCT
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_RECEIVE_SEQUENCE_COUNT_STRUCT_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT8 ) * 6;
        }
    }
}
// Helpers for WDI_ACTION_FRAME_REQUEST_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_ACTION_FRAME_REQUEST_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_CHANNEL_NUMBER ) + sizeof( UINT32 ) + sizeof( WDI_MAC_ADDRESS ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_CONNECTION_SETTINGS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CONNECTION_SETTINGS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT32 ) + sizeof( WDI_ROAM_TRIGGER ) + sizeof( BOOLEAN );
        }
    }
}
// Helpers for WDI_CONNECTION_SETTINGSV1_0
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_CONNECTION_SETTINGSV1_0_HELPER
        {
            static const USHORT s_BinarySize = sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( UINT32 ) + sizeof( WDI_ROAM_TRIGGER );
        }
    }
}
// Helpers for WDI_BSS_SELECTION_PARAMETERS_CONTAINER
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_BSS_SELECTION_PARAMETERS_CONTAINER_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_ASSOCIATION_RESULT_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_ASSOCIATION_RESULT_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( WDI_ASSOC_STATUS ) + sizeof( UINT32 ) + sizeof( BOOLEAN ) + sizeof( WDI_AUTH_ALGORITHM ) + sizeof( WDI_CIPHER_ALGORITHM ) + sizeof( WDI_CIPHER_ALGORITHM ) + sizeof( WDI_CIPHER_ALGORITHM ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( BOOLEAN ) + sizeof( WDI_DS_INFO ) + sizeof( UINT32 ) + sizeof( WDI_BAND_ID ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_TKIP_MIC_FAILURE_PARAMETERS
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_TKIP_MIC_FAILURE_PARAMETERS_HELPER
        {
            static const USHORT s_BinarySize = sizeof( BOOLEAN ) + sizeof( UINT32 ) + sizeof( WDI_MAC_ADDRESS );
        }
    }
}
// Helpers for WDI_NETWORK_LIST_OFFLOAD_CONFIG
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_NETWORK_LIST_OFFLOAD_CONFIG_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_WAKE_EVENT_MASK
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_WAKE_EVENT_MASK_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_RECEIVE_COALESCING_CONFIG
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_RECEIVE_COALESCING_CONFIG_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( UINT32 ) + sizeof( UINT32 );
        }
    }
}
// Helpers for WDI_RECEIVE_COALESCING_FIELD
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_RECEIVE_COALESCING_FIELD_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( NDIS_FRAME_HEADER ) + sizeof( NDIS_RECEIVE_FILTER_TEST ) + sizeof( UINT32 ) + sizeof( WDI_BYTE16 ) + sizeof( WDI_BYTE16 );
        }
    }
}
// Helpers for WDI_IPv4_TCP_SYNC
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_IPv4_TCP_SYNC_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( WDI_BYTE4 ) + sizeof( WDI_BYTE4 ) + sizeof( UINT16 ) + sizeof( UINT16 );
        }
    }
}
// Helpers for WDI_IPv6TCP_SYNC
namespace WDI_TLV
{
    namespace PROPERTY_GROUPS
    {
        namespace WDI_IPv6TCP_SYNC_HELPER
        {
            static const USHORT s_BinarySize = sizeof( UINT32 ) + sizeof( WDI_BYTE16 ) + sizeof( WDI_BYTE16 ) + sizeof( UINT16 ) + sizeof( UINT16 );
        }
    }
}
//
// Helpers for WDI_SSID
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SSID_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT8 ), ENUMS::SSID, ENUMS::UINT8, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT8 ), sizeof( UINT8 ), TRUE, TRUE, TRUE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_BYTE_BLOB
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BYTE_BLOB_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT8 ), ENUMS::Payload, ENUMS::UINT8, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT8 ), sizeof( UINT8 ), TRUE, FALSE, TRUE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PRIVATE_BYTE_BLOB
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PRIVATE_BYTE_BLOB_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT8 ), ENUMS::Payload, ENUMS::UINT8, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT8 ), sizeof( UINT8 ), TRUE, FALSE, TRUE, TRUE, 0 };
        }
    }
}

//
// Helpers for WDI_STRING_Z
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_STRING_Z_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( CHAR ), ENUMS::Payload, ENUMS::CHAR, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( CHAR ), sizeof( CHAR ), TRUE, FALSE, TRUE, FALSE, 1 };
        }
    }
}

//
// Helpers for WDI_MAC_ADDRESS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_MAC_ADDRESS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_MAC_ADDRESS ), ENUMS::Address, ENUMS::WDI_MAC_ADDRESS, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_MAC_ADDRESS ), sizeof( WDI_MAC_ADDRESS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_ADDRESS_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ADDRESS_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_MAC_ADDRESS ), ENUMS::Address, ENUMS::WDI_MAC_ADDRESS, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_MAC_ADDRESS ), sizeof( WDI_MAC_ADDRESS ), TRUE, FALSE, FALSE, FALSE, 2 };
        }
    }
}

//
// Helpers for WDI_NDIS_GUID_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_NDIS_GUID_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( NDIS_GUID ), ENUMS::NdisGuid, ENUMS::NDIS_GUID, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( NDIS_GUID ), sizeof( NDIS_GUID ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_IHV_TASK_PRIORITY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_IHV_TASK_PRIORITY_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_IHV_TASK_PRIORITY ), ENUMS::PriorityValue, ENUMS::WDI_IHV_TASK_PRIORITY, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_IHV_TASK_PRIORITY ), sizeof( WDI_IHV_TASK_PRIORITY ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for UINT32_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace UINT32_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT32 ), ENUMS::Value, ENUMS::UINT32, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT32 ), sizeof( UINT32 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for UINT32_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace UINT32_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT32 ), ENUMS::Value, ENUMS::UINT32, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT32 ), sizeof( UINT32 ), TRUE, FALSE, FALSE, FALSE, 3 };
        }
    }
}

//
// Helpers for UINT64_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace UINT64_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT64 ), ENUMS::Value, ENUMS::UINT64, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT64 ), sizeof( UINT64 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_OPERATION_MODE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_OPERATION_MODE_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_OPERATION_MODE ), ENUMS::Value, ENUMS::WDI_OPERATION_MODE, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_OPERATION_MODE ), sizeof( WDI_OPERATION_MODE ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for UINT16_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace UINT16_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT16 ), ENUMS::Value, ENUMS::UINT16, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT16 ), sizeof( UINT16 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for UINT16_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace UINT16_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT16 ), ENUMS::Value, ENUMS::UINT16, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT16 ), sizeof( UINT16 ), TRUE, FALSE, FALSE, FALSE, 4 };
        }
    }
}

//
// Helpers for UINT8_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace UINT8_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( UINT8 ), ENUMS::Value, ENUMS::UINT8, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( UINT8 ), sizeof( UINT8 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for BOOL_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace BOOL_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( BOOLEAN ), ENUMS::Value, ENUMS::BOOLEAN, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( bool ), sizeof( bool ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_ROAMING_NEEDED_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ROAMING_NEEDED_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_ASSOC_STATUS ), ENUMS::AssociationStatus, ENUMS::WDI_ASSOC_STATUS, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_ASSOC_STATUS ), sizeof( WDI_ASSOC_STATUS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CONNECTION_QUALITY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CONNECTION_QUALITY_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_CONNECTION_QUALITY_HINT ), ENUMS::ConnectionQualityHint, ENUMS::WDI_CONNECTION_QUALITY_HINT, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_CONNECTION_QUALITY_HINT ), sizeof( WDI_CONNECTION_QUALITY_HINT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_TCP_RSC_STATISTICS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TCP_RSC_STATISTICS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_TCP_RSC_STATISTICS_STRUCT, CoalescedPkts ), sizeof( UINT64 ), ENUMS::CoalescedPkts, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_TCP_RSC_STATISTICS_STRUCT, CoalescedOctets ), sizeof( UINT64 ), ENUMS::CoalescedOctets, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_TCP_RSC_STATISTICS_STRUCT, CoalesceEvents ), sizeof( UINT64 ), ENUMS::CoalesceEvents, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_TCP_RSC_STATISTICS_STRUCT, Aborts ), sizeof( UINT64 ), ENUMS::Aborts, ENUMS::UINT64, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_TCP_RSC_STATISTICS_STRUCT_HELPER::s_BinarySize, sizeof( WDI_TCP_RSC_STATISTICS_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_CHANNEL_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_CHANNEL_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_CHANNEL, CountryOrRegionString ), (sizeof( UINT8 ) * 3), ENUMS::CountryOrRegionString, ENUMS::UINT8, 3 },
                { TLV_FIELD_OFFSET( WDI_P2P_CHANNEL, OperatingClass ), sizeof( UINT8 ), ENUMS::OperatingClass, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CHANNEL, ChannelNumber ), sizeof( WDI_CHANNEL_NUMBER ), ENUMS::ChannelNumber, ENUMS::WDI_CHANNEL_NUMBER, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_CHANNEL_HELPER::s_BinarySize, sizeof( WDI_P2P_CHANNEL ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_CHANNEL_INDICATE_REASON_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_CHANNEL_INDICATE_REASON_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_P2P_CHANNEL_INDICATE_REASON ), ENUMS::Reason, ENUMS::WDI_P2P_CHANNEL_INDICATE_REASON, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_P2P_CHANNEL_INDICATE_REASON ), sizeof( WDI_P2P_CHANNEL_INDICATE_REASON ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS, MaximumOffChannelOperationTime ), sizeof( UINT8 ), ENUMS::MaximumOffChannelOperationTime, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS, RoamingNeededLinkQualityThreshold ), sizeof( UINT8 ), ENUMS::RoamingNeededLinkQualityThreshold, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_TYPE_PMK_NAME_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TYPE_PMK_NAME_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_PMK_NAME_STRUCT, pmkname ), sizeof( WDI_TYPE_PMK_NAME ), ENUMS::pmkname, ENUMS::WDI_TYPE_PMK_NAME, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_PMK_NAME_STRUCT_HELPER::s_BinarySize, sizeof( WDI_PMK_NAME_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_STATUS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_STATUS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( NDIS_STATUS ), ENUMS::Status, ENUMS::NDIS_STATUS, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( NDIS_STATUS ), sizeof( NDIS_STATUS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_START_AP_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_START_AP_PARAMETERS_CONTAINER_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvStartApParameters[] =
            {
                { WDI_TASK_START_AP, WDI_VERSION_1_0_10, 0xFFFFFFFFul, TRUE, TRUE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS, BeaconPeriod ), sizeof( UINT32 ), ENUMS::BeaconPeriod, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS, DTIMPeriod ), sizeof( UINT32 ), ENUMS::DTIMPeriod, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS, ExcludeUnencrypted ), sizeof( BOOLEAN ), ENUMS::ExcludeUnencrypted, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS, DataRateSupport802_11b ), sizeof( BOOLEAN ), ENUMS::DataRateSupport802_11b, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS, AcceptNonP2PClients ), sizeof( BOOLEAN ), ENUMS::AcceptNonP2PClients, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS, MustUseSpecifiedChannels ), sizeof( BOOLEAN ), ENUMS::MustUseSpecifiedChannels, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_START_AP_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_START_AP_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_START_AP_PARAMETERS_CONTAINER_V1_0_1
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_START_AP_PARAMETERS_CONTAINER_V1_0_1_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvStartApParameters[] =
            {
                { WDI_TASK_START_AP, 0, WDI_VERSION_1_0_10, TRUE, TRUE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS_V1_0_1, BeaconPeriod ), sizeof( UINT32 ), ENUMS::BeaconPeriod, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS_V1_0_1, DTIMPeriod ), sizeof( UINT32 ), ENUMS::DTIMPeriod, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS_V1_0_1, ExcludeUnencrypted ), sizeof( BOOLEAN ), ENUMS::ExcludeUnencrypted, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_START_AP_PARAMETERS_V1_0_1, DataRateSupport802_11b ), sizeof( BOOLEAN ), ENUMS::DataRateSupport802_11b, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_START_AP_PARAMETERS_V1_0_1_HELPER::s_BinarySize, sizeof( WDI_START_AP_PARAMETERS_V1_0_1 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_BSSID_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BSSID_INFO_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, APReachability ), sizeof( UINT8 ), ENUMS::APReachability, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, Security ), sizeof( UINT8 ), ENUMS::Security, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, KeyScope ), sizeof( UINT8 ), ENUMS::KeyScope, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, SpectrumManagement ), sizeof( UINT8 ), ENUMS::SpectrumManagement, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, QoS ), sizeof( UINT8 ), ENUMS::QoS, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, APSD ), sizeof( UINT8 ), ENUMS::APSD, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, RadioMeasurement ), sizeof( UINT8 ), ENUMS::RadioMeasurement, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, DelayedBlockAck ), sizeof( UINT8 ), ENUMS::DelayedBlockAck, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, ImmediateBlockAck ), sizeof( UINT8 ), ENUMS::ImmediateBlockAck, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, MobilityDomain ), sizeof( UINT8 ), ENUMS::MobilityDomain, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_BSSID_INFO_STRUCT, HighThroughput ), sizeof( UINT8 ), ENUMS::HighThroughput, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_BSSID_INFO_STRUCT_HELPER::s_BinarySize, sizeof( WDI_BSSID_INFO_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_AUTH_ALGORITHM_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_AUTH_ALGORITHM_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_AUTH_ALGORITHM ), ENUMS::AuthAlgos, ENUMS::WDI_AUTH_ALGORITHM, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_AUTH_ALGORITHM ), sizeof( WDI_AUTH_ALGORITHM ), TRUE, FALSE, FALSE, FALSE, 5 };
        }
    }
}

//
// Helpers for WDI_CIPHER_ALGORITHM_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CIPHER_ALGORITHM_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_CIPHER_ALGORITHM ), ENUMS::CipherAlgos, ENUMS::WDI_CIPHER_ALGORITHM, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_CIPHER_ALGORITHM ), sizeof( WDI_CIPHER_ALGORITHM ), TRUE, FALSE, FALSE, FALSE, 6 };
        }
    }
}

//
// Helpers for WDI_PHY_TYPE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PHY_TYPE_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_PHY_TYPE ), ENUMS::PhyType, ENUMS::WDI_PHY_TYPE, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_PHY_TYPE ), sizeof( WDI_PHY_TYPE ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_ADDITIONAL_IES_CONTAINER * pField )
        {
            pField->AdditionalBeaconIEs.MemoryInternallyAllocated = FALSE;
            pField->AdditionalProbeResponseIEs.MemoryInternallyAllocated = FALSE;
            pField->AdditionalProbeRequestDefaultIEs.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_ADDITIONAL_IES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ADDITIONAL_IES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ADDITIONAL_BEACON_IES, TLV_FIELD_OFFSET( WDI_ADDITIONAL_IES_CONTAINER, AdditionalBeaconIEs ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ADDITIONAL_PROBE_RESPONSE_IES, TLV_FIELD_OFFSET( WDI_ADDITIONAL_IES_CONTAINER, AdditionalProbeResponseIEs ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ADDITIONAL_PROBE_REQUEST_DEFAULT_IES, TLV_FIELD_OFFSET( WDI_ADDITIONAL_IES_CONTAINER, AdditionalProbeRequestDefaultIEs ), TRUE, FALSE, 0, TRUE, 2 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_ADDITIONAL_IES_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_DEVICE_INFO_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_DEVICE_INFO_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_INFO_PARAMETERS, DeviceAddress ), (sizeof( UINT8 ) * 6), ENUMS::DeviceAddress, ENUMS::UINT8, 6 },
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_INFO_PARAMETERS, ConfigurationMethods ), sizeof( UINT16 ), ENUMS::ConfigurationMethods, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_INFO_PARAMETERS, DeviceType.CategoryID ), sizeof( UINT16 ), ENUMS::DeviceType_CategoryID, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_INFO_PARAMETERS, DeviceType.OUI ), (sizeof( UINT8 ) * 4), ENUMS::DeviceType_OUI, ENUMS::UINT8, 4 },
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_INFO_PARAMETERS, DeviceType.SubcategoryID ), sizeof( UINT16 ), ENUMS::DeviceType_SubcategoryID, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_DEVICE_INFO_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_DEVICE_INFO_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_DEVICE_INFO_CONTAINER * pField )
        {
            pField->DeviceName.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_DEVICE_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_DEVICE_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_DEVICE_INFO_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DEVICE_INFO_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_DEVICE_INFO_CONTAINER, DeviceInfoParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DEVICE_NAME, TLV_FIELD_OFFSET( WDI_P2P_DEVICE_INFO_CONTAINER, DeviceName ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_DEVICE_INFO_CONTAINER ) };
        }
    }
}


//
// Helpers for WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSSID, TLV_FIELD_OFFSET( WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER, Bssid ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BSSID_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSSID_INFO, TLV_FIELD_OFFSET( WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER, BSSIDInfo ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_OPERATING_CLASS, TLV_FIELD_OFFSET( WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER, OperatingClass ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHANNEL_NUMBER, TLV_FIELD_OFFSET( WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER, ChannelNumber ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_TYPE_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_TYPE, TLV_FIELD_OFFSET( WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER, PhyType ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_DEVICE_CAPABILITY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_DEVICE_CAPABILITY_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_CAPABILITY_PARAMETERS, DeviceCapabilityBitmap ), sizeof( UINT8 ), ENUMS::DeviceCapabilityBitmap, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_CAPABILITY_PARAMETERS, OSSetDeviceCapabilities ), sizeof( UINT8 ), ENUMS::OSSetDeviceCapabilities, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_CAPABILITY_PARAMETERS, WPSVersionsEnabled ), sizeof( UINT32 ), ENUMS::WPSVersionsEnabled, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_DEVICE_CAPABILITY_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_DEVICE_CAPABILITY_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_GROUP_OWNER_CAPABILITY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GROUP_OWNER_CAPABILITY_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_GROUP_OWNER_CAPABILITY_PARAMETERS, GroupCapabilityBitmap ), sizeof( UINT8 ), ENUMS::GroupCapabilityBitmap, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GROUP_OWNER_CAPABILITY_PARAMETERS, OSSetGroupCapabilities ), sizeof( UINT8 ), ENUMS::OSSetGroupCapabilities, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GROUP_OWNER_CAPABILITY_PARAMETERS, MaximumGroupLimit ), sizeof( UINT32 ), ENUMS::MaximumGroupLimit, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_GROUP_OWNER_CAPABILITY_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_GROUP_OWNER_CAPABILITY_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_SECONDARY_DEVICE_TYPE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_SECONDARY_DEVICE_TYPE_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_TYPE, CategoryID ), sizeof( UINT16 ), ENUMS::CategoryID, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_TYPE, OUI ), (sizeof( UINT8 ) * 4), ENUMS::OUI, ENUMS::UINT8, 4 },
                { TLV_FIELD_OFFSET( WDI_P2P_DEVICE_TYPE, SubcategoryID ), sizeof( UINT16 ), ENUMS::SubcategoryID, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_DEVICE_TYPE_HELPER::s_BinarySize, sizeof( WDI_P2P_DEVICE_TYPE ), TRUE, TRUE, FALSE, FALSE, 7 };
        }
    }
}

//
// Helpers for WDI_P2P_SERVICE_NAME_HASH_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_P2P_SERVICE_NAME_HASH ), ENUMS::ServiceNameHash, ENUMS::WDI_P2P_SERVICE_NAME_HASH, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_P2P_SERVICE_NAME_HASH ), sizeof( WDI_P2P_SERVICE_NAME_HASH ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER * pField )
        {
            pField->ServiceName.MemoryInternallyAllocated = FALSE;
            pField->ServiceInformation.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME, TLV_FIELD_OFFSET( WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceName ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME_HASH, TLV_FIELD_OFFSET( WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceNameHash ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_INFORMATION, TLV_FIELD_OFFSET( WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceInformation ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT16_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_UPDATE_INDICATOR, TLV_FIELD_OFFSET( WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceUpdateIndicator ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_TRANSACTION_ID, TLV_FIELD_OFFSET( WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceTransactionId ), TRUE, FALSE, 0, TRUE, 2 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER * pField )
        {
            pField->ServiceName.MemoryInternallyAllocated = FALSE;
            pField->InstanceName.MemoryInternallyAllocated = FALSE;
            pField->ServiceInformation.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME, TLV_FIELD_OFFSET( WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceName ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INSTANCE_NAME, TLV_FIELD_OFFSET( WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, InstanceName ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_INFORMATION, TLV_FIELD_OFFSET( WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceInformation ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT16_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_UPDATE_INDICATOR, TLV_FIELD_OFFSET( WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceUpdateIndicator ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_TRANSACTION_ID, TLV_FIELD_OFFSET( WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER, ServiceTransactionId ), TRUE, FALSE, 0, TRUE, 2 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER * pField )
        {
            pField->ServiceName.MemoryInternallyAllocated = FALSE;
            pField->ServiceInformation.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME, TLV_FIELD_OFFSET( WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER, ServiceName ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_INFORMATION, TLV_FIELD_OFFSET( WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER, ServiceInformation ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_STATUS, TLV_FIELD_OFFSET( WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER, ServiceStatus ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ADVERTISEMENT_ID, TLV_FIELD_OFFSET( WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER, AdvertisementID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT16_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CONFIG_METHODS, TLV_FIELD_OFFSET( WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER, ConfigurationMethods ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER * pField )
        {
            pField->ServiceName.MemoryInternallyAllocated = FALSE;
            pField->ServiceInformation.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER, ServiceName ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME_HASH, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER, ServiceNameHash ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_INFORMATION, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER, ServiceInformation ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_STATUS, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER, ServiceStatus ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ADVERTISEMENT_ID, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER, AdvertisementID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT16_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CONFIG_METHODS, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER, ConfigurationMethods ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER * pField )
        {
            pField->ServiceType.MemoryInternallyAllocated = FALSE;
            pField->InstanceName.MemoryInternallyAllocated = FALSE;
            pField->ServiceInformation.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_TYPE, TLV_FIELD_OFFSET( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER, ServiceType ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_TYPE_HASH, TLV_FIELD_OFFSET( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER, ServiceTypeHash ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INSTANCE_NAME, TLV_FIELD_OFFSET( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER, InstanceName ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INSTANCE_NAME_HASH, TLV_FIELD_OFFSET( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER, InstanceNameHash ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_INFORMATION, TLV_FIELD_OFFSET( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER, ServiceInformation ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_STATUS, TLV_FIELD_OFFSET( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER, ServiceStatus ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ADVERTISEMENT_ID, TLV_FIELD_OFFSET( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER, AdvertisementID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT16_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CONFIG_METHODS, TLV_FIELD_OFFSET( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER, ConfigurationMethods ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER * pField )
        {
            pField->PrefixName.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER, PrefixName ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME_HASH, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER, ServicePrefixHash ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_ADVERTISED_SERVICES_CONTAINER * pField )
        {
            pField->ServiceEntry.MemoryInternallyAllocated = FALSE;
            pField->ASP2ServiceEntry.MemoryInternallyAllocated = FALSE;
            pField->ServicePrefix.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_ADVERTISED_SERVICES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_ADVERTISED_SERVICES_CONTAINER_HELPER
        {
            static const VERSION_INFO s_versionedField1 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_20, 0, 0xFFFFFFFF };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ADVERTISED_SERVICE_ENTRY, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICES_CONTAINER, ServiceEntry ), FALSE, TRUE, 8, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER_HELPER::s_Container, &s_versionedField1, (ENUMS::TLV_ID)WDI_TLV_P2P_ASP2_ADVERTISED_SERVICE_ENTRY, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICES_CONTAINER, ASP2ServiceEntry ), FALSE, TRUE, 9, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ADVERTISED_PREFIX_ENTRY, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICES_CONTAINER, ServicePrefix ), FALSE, TRUE, 10, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT16_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_UPDATE_INDICATOR, TLV_FIELD_OFFSET( WDI_P2P_ADVERTISED_SERVICES_CONTAINER, ServiceUpdateIndicator ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_ADVERTISED_SERVICES_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_LISTEN_STATE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_LISTEN_STATE_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_P2P_LISTEN_STATE ), ENUMS::ListenState, ENUMS::WDI_P2P_LISTEN_STATE, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_P2P_LISTEN_STATE ), sizeof( WDI_P2P_LISTEN_STATE ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_DISCOVER_MODE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_DISCOVER_MODE_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_DISCOVER_MODE, DiscoveryType ), sizeof( WDI_P2P_DISCOVER_TYPE ), ENUMS::DiscoveryType, ENUMS::WDI_P2P_DISCOVER_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DISCOVER_MODE, ForcedDiscovery ), sizeof( BOOLEAN ), ENUMS::ForcedDiscovery, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DISCOVER_MODE, ScanType ), sizeof( WDI_P2P_SCAN_TYPE ), ENUMS::ScanType, ENUMS::WDI_P2P_SCAN_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DISCOVER_MODE, ServiceDiscoveryType ), sizeof( WDI_P2P_SERVICE_DISCOVERY_TYPE ), ENUMS::ServiceDiscoveryType, ENUMS::WDI_P2P_SERVICE_DISCOVERY_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DISCOVER_MODE, ScanRepeatCount ), sizeof( BOOLEAN ), ENUMS::ScanRepeatCount, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_DISCOVER_MODE, TimeBetweenScans ), sizeof( UINT32 ), ENUMS::TimeBetweenScans, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_DISCOVER_MODE_HELPER::s_BinarySize, sizeof( WDI_P2P_DISCOVER_MODE ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_BACKGROUND_DISCOVER_MODE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_BACKGROUND_DISCOVER_MODE_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_BACKGROUND_DISCOVER_MODE, DiscoveryType ), sizeof( WDI_P2P_DISCOVER_TYPE ), ENUMS::DiscoveryType, ENUMS::WDI_P2P_DISCOVER_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_BACKGROUND_DISCOVER_MODE, ServiceDiscoveryType ), sizeof( WDI_P2P_SERVICE_DISCOVERY_TYPE ), ENUMS::ServiceDiscoveryType, ENUMS::WDI_P2P_SERVICE_DISCOVERY_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_BACKGROUND_DISCOVER_MODE, DeviceVisiblilityTimeout ), sizeof( UINT32 ), ENUMS::DeviceVisiblilityTimeout, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_BACKGROUND_DISCOVER_MODE_HELPER::s_BinarySize, sizeof( WDI_P2P_BACKGROUND_DISCOVER_MODE ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_SCAN_DWELL_TIME_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SCAN_DWELL_TIME_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_SCAN_DWELL_TIME, ActiveChannelDwellTime ), sizeof( UINT32 ), ENUMS::ActiveChannelDwellTime, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_SCAN_DWELL_TIME, PassiveChannelDwellTime ), sizeof( UINT32 ), ENUMS::PassiveChannelDwellTime, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_SCAN_DWELL_TIME, MaximumScanTime ), sizeof( UINT32 ), ENUMS::MaximumScanTime, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_SCAN_DWELL_TIME_HELPER::s_BinarySize, sizeof( WDI_SCAN_DWELL_TIME ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CHANNEL_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CHANNEL_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_CHANNEL_NUMBER ), ENUMS::ChannelList, ENUMS::WDI_CHANNEL_NUMBER, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_CHANNEL_NUMBER ), sizeof( WDI_CHANNEL_NUMBER ), TRUE, FALSE, FALSE, FALSE, 11 };
        }
    }
}

//
// Helpers for WDI_BAND_ID_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BAND_ID_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_BAND_ID ), ENUMS::BandID, ENUMS::WDI_BAND_ID, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_BAND_ID ), sizeof( WDI_BAND_ID ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_BAND_ID_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BAND_ID_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_BAND_ID ), ENUMS::BandID, ENUMS::WDI_BAND_ID, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_BAND_ID ), sizeof( WDI_BAND_ID ), TRUE, FALSE, FALSE, FALSE, 12 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_AP_BAND_CHANNEL_LIST_CONTAINER * pField )
        {
            pField->ChannelList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_AP_BAND_CHANNEL_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_AP_BAND_CHANNEL_LIST_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BAND_ID_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BANDID, TLV_FIELD_OFFSET( WDI_AP_BAND_CHANNEL_LIST_CONTAINER, BandID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHANNEL_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHANNEL_INFO_LIST, TLV_FIELD_OFFSET( WDI_AP_BAND_CHANNEL_LIST_CONTAINER, ChannelList ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_AP_BAND_CHANNEL_LIST_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_BAND_CHANNEL_LIST_CONTAINER * pField )
        {
            pField->ChannelList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_BAND_CHANNEL_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BAND_CHANNEL_LIST_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BAND_ID_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BANDID, TLV_FIELD_OFFSET( WDI_BAND_CHANNEL_LIST_CONTAINER, BandID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHANNEL_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHANNEL_INFO_LIST, TLV_FIELD_OFFSET( WDI_BAND_CHANNEL_LIST_CONTAINER, ChannelList ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_BAND_CHANNEL_LIST_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_SIGNAL_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SIGNAL_INFO_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_SIGNAL_INFO, RSSI ), sizeof( INT32 ), ENUMS::RSSI, ENUMS::INT32, 1 },
                { TLV_FIELD_OFFSET( WDI_SIGNAL_INFO, LinkQuality ), sizeof( UINT32 ), ENUMS::LinkQuality, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_SIGNAL_INFO_HELPER::s_BinarySize, sizeof( WDI_SIGNAL_INFO ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CHANNEL_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CHANNEL_INFO_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CHANNEL_INFO, ChannelNumber ), sizeof( WDI_CHANNEL_NUMBER ), ENUMS::ChannelNumber, ENUMS::WDI_CHANNEL_NUMBER, 1 },
                { TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CHANNEL_INFO, BandId ), sizeof( UINT32 ), ENUMS::BandId, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_BSS_ENTRY_CHANNEL_INFO_HELPER::s_BinarySize, sizeof( WDI_BSS_ENTRY_CHANNEL_INFO ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_AGE_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_AGE_INFO_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_BSS_ENTRY_AGE_INFO, HostTimeStamp ), sizeof( UINT64 ), ENUMS::HostTimeStamp, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_BSS_ENTRY_AGE_INFO, CachedInformation ), sizeof( BOOLEAN ), ENUMS::CachedInformation, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_BSS_ENTRY_AGE_INFO_HELPER::s_BinarySize, sizeof( WDI_BSS_ENTRY_AGE_INFO ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_LINK_QUALITY_BAR_MAP_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_LINK_QUALITY_BAR_MAP_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_LINK_QUALITY_BAR_MAP_PARAMETERS, StartRange ), sizeof( UINT8 ), ENUMS::StartRange, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_LINK_QUALITY_BAR_MAP_PARAMETERS, EndRange ), sizeof( UINT8 ), ENUMS::EndRange, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_LINK_QUALITY_BAR_MAP_PARAMETERS, BarNumber ), sizeof( UINT8 ), ENUMS::BarNumber, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_LINK_QUALITY_BAR_MAP_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_LINK_QUALITY_BAR_MAP_PARAMETERS ), TRUE, FALSE, FALSE, FALSE, 13 };
        }
    }
}

//
// Helpers for WDI_ADAPTER_NLO_SCAN_MODE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ADAPTER_NLO_SCAN_MODE_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_SCAN_TYPE ), ENUMS::NloScanMode, ENUMS::WDI_SCAN_TYPE, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_SCAN_TYPE ), sizeof( WDI_SCAN_TYPE ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_BSS_ENTRY_CONTAINER * pField )
        {
            pField->ProbeResponseFrame.MemoryInternallyAllocated = FALSE;
            pField->BeaconFrame.MemoryInternallyAllocated = FALSE;
            pField->DeviceSpecificContext.MemoryInternallyAllocated = FALSE;
            pField->P2PDiscoveredServiceEntry.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_BSS_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BSS_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSSID, TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CONTAINER, BSSID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PROBE_RESPONSE_FRAME, TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CONTAINER, ProbeResponseFrame ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BEACON_FRAME, TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CONTAINER, BeaconFrame ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SIGNAL_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY_SIGNAL_INFO, TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CONTAINER, SignalInfo ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHANNEL_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY_CHANNEL_INFO, TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CONTAINER, ChannelInfo ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY_DEVICE_CONTEXT, TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CONTAINER, DeviceSpecificContext ), TRUE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_AGE_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY_AGE_INFO, TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CONTAINER, EntryAgeInfo ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DISCOVERED_SERVICE_ENTRY, TLV_FIELD_OFFSET( WDI_BSS_ENTRY_CONTAINER, P2PDiscoveredServiceEntry ), FALSE, TRUE, 14, TRUE, 4 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_BSS_ENTRY_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_LISTEN_DURATION_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_LISTEN_DURATION_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_LISTEN_DURATION, CycleDuration ), sizeof( UINT32 ), ENUMS::CycleDuration, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_LISTEN_DURATION, ListenActiveDuration ), sizeof( UINT32 ), ENUMS::ListenActiveDuration, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_LISTEN_DURATION_HELPER::s_BinarySize, sizeof( WDI_P2P_LISTEN_DURATION ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER * pField )
        {
            pField->BandChannelList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_LISTEN_DURATION_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_LISTEN_DURATION, TLV_FIELD_OFFSET( WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER, ListenDuration ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BAND_CHANNEL_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BAND_CHANNEL, TLV_FIELD_OFFSET( WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER, BandChannelList ), FALSE, TRUE, 15, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_ACTION_FRAME_REQUEST_PARAMETERS, ChannelNumber ), sizeof( WDI_CHANNEL_NUMBER ), ENUMS::ChannelNumber, ENUMS::WDI_CHANNEL_NUMBER, 1 },
                { TLV_FIELD_OFFSET( WDI_ACTION_FRAME_REQUEST_PARAMETERS, BandId ), sizeof( UINT32 ), ENUMS::BandId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_ACTION_FRAME_REQUEST_PARAMETERS, DestinationAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::DestinationAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_ACTION_FRAME_REQUEST_PARAMETERS, SendTimeout ), sizeof( UINT32 ), ENUMS::SendTimeout, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_ACTION_FRAME_REQUEST_PARAMETERS, PostACKDwellTime ), sizeof( UINT32 ), ENUMS::PostACKDwellTime, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_ACTION_FRAME_REQUEST_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_ACTION_FRAME_REQUEST_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS, RequestFrameType ), sizeof( WDI_P2P_ACTION_FRAME_TYPE ), ENUMS::RequestFrameType, ENUMS::WDI_P2P_ACTION_FRAME_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS, PeerDeviceAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::PeerDeviceAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS, DialogToken ), sizeof( UINT8 ), ENUMS::DialogToken, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS, SendTimeout ), sizeof( UINT32 ), ENUMS::SendTimeout, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS, PostACKDwellTime ), sizeof( UINT32 ), ENUMS::PostACKDwellTime, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_ACTION_FRAME_REQUEST_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, GOIntent ), sizeof( UINT8 ), ENUMS::GOIntent, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, TieBreaker ), sizeof( BOOLEAN ), ENUMS::TieBreaker, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, GOConfigTimeout ), sizeof( UINT16 ), ENUMS::GOConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, ClientConfigTimeout ), sizeof( UINT16 ), ENUMS::ClientConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, IntendedInterfaceAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::IntendedInterfaceAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, GroupCapability ), sizeof( UINT8 ), ENUMS::GroupCapability, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, OSSetGroupCapabilityBitmask ), sizeof( UINT8 ), ENUMS::OSSetGroupCapabilityBitmask, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}


//
// Helpers for WDI_P2P_GO_NEGOTIATION_REQUEST_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GO_NEGOTIATION_REQUEST_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_INFO_CONTAINER, RequestParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_LISTEN_CHANNEL, TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_REQUEST_INFO_CONTAINER, RemoteListenChannel ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_GO_NEGOTIATION_REQUEST_INFO_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_INVITATION_REQUEST_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_INVITATION_REQUEST_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_INVITATION_REQUEST_PARAMETERS, GOConfigTimeout ), sizeof( UINT16 ), ENUMS::GOConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_INVITATION_REQUEST_PARAMETERS, ClientConfigTimeout ), sizeof( UINT16 ), ENUMS::ClientConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_INVITATION_REQUEST_PARAMETERS, InvitationFlags ), sizeof( UINT8 ), ENUMS::InvitationFlags, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_INVITATION_REQUEST_PARAMETERS, IsLocalGO ), sizeof( BOOLEAN ), ENUMS::IsLocalGO, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_INVITATION_REQUEST_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_INVITATION_REQUEST_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_GROUP_ID * pField )
        {
            pField->GroupSSID.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_GROUP_ID
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GROUP_ID_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DEVICE_ADDRESS, TLV_FIELD_OFFSET( WDI_P2P_GROUP_ID, DeviceAddress ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SSID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SSID, TLV_FIELD_OFFSET( WDI_P2P_GROUP_ID, GroupSSID ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_GROUP_ID ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER * pField )
        {
            pField->GroupID.GroupSSID.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_INVITATION_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INVITATION_REQUEST_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER, RequestParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GROUP_BSSID, TLV_FIELD_OFFSET( WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER, GroupBSSID ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_NUMBER, TLV_FIELD_OFFSET( WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER, OperatingChannel ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GROUP_ID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GROUP_ID, TLV_FIELD_OFFSET( WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER, GroupID ), FALSE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS, GroupCapability ), sizeof( UINT8 ), ENUMS::GroupCapability, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS, OSSetGroupCapabilityBitmask ), sizeof( UINT8 ), ENUMS::OSSetGroupCapabilityBitmask, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS, GroupCapability ), sizeof( UINT8 ), ENUMS::GroupCapability, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS, OSSetGroupCapabilityBitmask ), sizeof( UINT8 ), ENUMS::OSSetGroupCapabilityBitmask, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_PROVISION_SERVICE_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_PROVISION_SERVICE_ATTRIBUTES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, StatusCode ), sizeof( UINT8 ), ENUMS::StatusCode, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, IntendedInterfaceAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::IntendedInterfaceAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, ConnectionCapability ), sizeof( UINT8 ), ENUMS::ConnectionCapability, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, FeatureCapability ), sizeof( UINT32 ), ENUMS::FeatureCapability, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, AdvertisementID ), sizeof( UINT32 ), ENUMS::AdvertisementID, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, ServiceAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::ServiceAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, SessionID ), sizeof( UINT32 ), ENUMS::SessionID, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, SessionAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::SessionAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, GOConfigTimeout ), sizeof( UINT16 ), ENUMS::GOConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, ClientConfigTimeout ), sizeof( UINT16 ), ENUMS::ClientConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, UsePersistentGroup ), sizeof( UINT8 ), ENUMS::UsePersistentGroup, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES, FollowOnProvisionDiscovery ), sizeof( UINT8 ), ENUMS::FollowOnProvisionDiscovery, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_PROVISION_SERVICE_ATTRIBUTES_HELPER::s_BinarySize, sizeof( WDI_P2P_PROVISION_SERVICE_ATTRIBUTES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER * pField )
        {
            pField->GroupID.GroupSSID.MemoryInternallyAllocated = FALSE;
            pField->PersistentGroupID.GroupSSID.MemoryInternallyAllocated = FALSE;
            pField->ServiceSessionInfo.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER, RequestParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GROUP_ID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GROUP_ID, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER, GroupID ), FALSE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_PROVISION_SERVICE_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_PROVISION_SERVICE_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER, ServiceAttributes ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GROUP_ID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_PERSISTENT_GROUP_ID, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER, PersistentGroupID ), FALSE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_SESSION_INFO, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER, ServiceSessionInfo ), TRUE, FALSE, 0, TRUE, 3 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER * pField )
        {
            pField->GroupID.GroupSSID.MemoryInternallyAllocated = FALSE;
            pField->PersistentGroupID.GroupSSID.MemoryInternallyAllocated = FALSE;
            pField->ServiceSessionInfo.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER, ResponseParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_PROVISION_SERVICE_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_PROVISION_SERVICE_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER, ServiceAttributes ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GROUP_ID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GROUP_ID, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER, GroupID ), FALSE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GROUP_ID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_PERSISTENT_GROUP_ID, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER, PersistentGroupID ), FALSE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_SESSION_INFO, TLV_FIELD_OFFSET( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER, ServiceSessionInfo ), TRUE, FALSE, 0, TRUE, 3 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS, ResponseFrameType ), sizeof( WDI_P2P_ACTION_FRAME_TYPE ), ENUMS::ResponseFrameType, ENUMS::WDI_P2P_ACTION_FRAME_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS, PeerDeviceAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::PeerDeviceAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS, DialogToken ), sizeof( UINT8 ), ENUMS::DialogToken, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS, SendTimeout ), sizeof( UINT32 ), ENUMS::SendTimeout, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS, PostACKDwellTime ), sizeof( UINT32 ), ENUMS::PostACKDwellTime, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, StatusCode ), sizeof( UINT8 ), ENUMS::StatusCode, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, GOIntent ), sizeof( UINT8 ), ENUMS::GOIntent, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, TieBreaker ), sizeof( BOOLEAN ), ENUMS::TieBreaker, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, GOConfigTimeout ), sizeof( UINT16 ), ENUMS::GOConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, ClientConfigTimeout ), sizeof( UINT16 ), ENUMS::ClientConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, IntendedInterfaceAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::IntendedInterfaceAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, GroupCapability ), sizeof( UINT8 ), ENUMS::GroupCapability, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, OSSetGroupCapabilityBitmask ), sizeof( UINT8 ), ENUMS::OSSetGroupCapabilityBitmask, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_STRUCT, ProtocolOffloadId ), sizeof( UINT32 ), ENUMS::ProtocolOffloadId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_STRUCT, RemoteIPV4Address ), (sizeof( UINT8 ) * 4), ENUMS::RemoteIPV4Address, ENUMS::UINT8, 4 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_STRUCT, HostIPV4Address ), (sizeof( UINT8 ) * 4), ENUMS::HostIPV4Address, ENUMS::UINT8, 4 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_STRUCT, MacAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MacAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_STRUCT_HELPER::s_BinarySize, sizeof( WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PM_PROTOCOL_OFFLOAD_IPv6NS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PM_PROTOCOL_OFFLOAD_IPv6NS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT, ProtocolOffloadId ), sizeof( UINT32 ), ENUMS::ProtocolOffloadId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT, RemoteIPV6Address ), (sizeof( UINT8 ) * 16), ENUMS::RemoteIPV6Address, ENUMS::UINT8, 16 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT, SolicitdNodeIPv6Address ), (sizeof( UINT8 ) * 16), ENUMS::SolicitdNodeIPv6Address, ENUMS::UINT8, 16 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT, TargetIPV6Address1 ), (sizeof( UINT8 ) * 16), ENUMS::TargetIPV6Address1, ENUMS::UINT8, 16 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT, TargetIPV6Address2 ), (sizeof( UINT8 ) * 16), ENUMS::TargetIPV6Address2, ENUMS::UINT8, 16 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT, MacAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MacAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT_HELPER::s_BinarySize, sizeof( WDI_PM_PROTOCOL_OFFLOAD_IPv6_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_STRUCT, ProtocolOffloadId ), sizeof( UINT32 ), ENUMS::ProtocolOffloadId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_STRUCT, ReplayCounter ), sizeof( UINT64 ), ENUMS::ReplayCounter, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_STRUCT, KCK_CONTENT ), (sizeof( UINT8 ) * 16), ENUMS::KCK_CONTENT, ENUMS::UINT8, 16 },
                { TLV_FIELD_OFFSET( WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_STRUCT, KEK_CONTENT ), (sizeof( UINT8 ) * 16), ENUMS::KEK_CONTENT, ENUMS::UINT8, 16 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_STRUCT_HELPER::s_BinarySize, sizeof( WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_GO_NEGOTIATION_RESPONSE_INFO_CONTAINER * pField )
        {
            pField->GroupID.GroupSSID.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_GO_NEGOTIATION_RESPONSE_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GO_NEGOTIATION_RESPONSE_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_INFO_CONTAINER, ResponseParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GROUP_ID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GROUP_ID, TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_RESPONSE_INFO_CONTAINER, GroupID ), FALSE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_GO_NEGOTIATION_RESPONSE_INFO_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS, StatusCode ), sizeof( UINT8 ), ENUMS::StatusCode, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS, GroupCapability ), sizeof( UINT8 ), ENUMS::GroupCapability, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS, OSSetGroupCapabilityBitmask ), sizeof( UINT8 ), ENUMS::OSSetGroupCapabilityBitmask, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_MAC_STATISTICS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_MAC_STATISTICS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, MACAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MACAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, TransmittedFrameCount ), sizeof( UINT64 ), ENUMS::TransmittedFrameCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, ReceivedFrameCount ), sizeof( UINT64 ), ENUMS::ReceivedFrameCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, WEPExcludedCount ), sizeof( UINT64 ), ENUMS::WEPExcludedCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, TKIPLocalMICFailures ), sizeof( UINT64 ), ENUMS::TKIPLocalMICFailures, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, TKIPReplays ), sizeof( UINT64 ), ENUMS::TKIPReplays, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, TKIPICVErrorCount ), sizeof( UINT64 ), ENUMS::TKIPICVErrorCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, CCMPFormatErrors ), sizeof( UINT64 ), ENUMS::CCMPFormatErrors, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, CCMPReplays ), sizeof( UINT64 ), ENUMS::CCMPReplays, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, CCMPDecryptErrors ), sizeof( UINT64 ), ENUMS::CCMPDecryptErrors, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, WEPUndecryptableCount ), sizeof( UINT64 ), ENUMS::WEPUndecryptableCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, WEPICVErrorCount ), sizeof( UINT64 ), ENUMS::WEPICVErrorCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, DecryptSuccessCount ), sizeof( UINT64 ), ENUMS::DecryptSuccessCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_MAC_STATISTICS_PARAMETERS, DecryptFailureCount ), sizeof( UINT64 ), ENUMS::DecryptFailureCount, ENUMS::UINT64, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_MAC_STATISTICS_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_MAC_STATISTICS_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PHY_STATISTICS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PHY_STATISTICS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, PhyType ), sizeof( WDI_PHY_TYPE ), ENUMS::PhyType, ENUMS::WDI_PHY_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, TransmittedFrameCount ), sizeof( UINT64 ), ENUMS::TransmittedFrameCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, GroupTransmittedFrameCount ), sizeof( UINT64 ), ENUMS::GroupTransmittedFrameCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, FailedCount ), sizeof( UINT64 ), ENUMS::FailedCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, RetryCount ), sizeof( UINT64 ), ENUMS::RetryCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, MultipleRetryCount ), sizeof( UINT64 ), ENUMS::MultipleRetryCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, MaxTXLifetimeExceededCount ), sizeof( UINT64 ), ENUMS::MaxTXLifetimeExceededCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, TransmittedFragmentCount ), sizeof( UINT64 ), ENUMS::TransmittedFragmentCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, RTSSuccessCount ), sizeof( UINT64 ), ENUMS::RTSSuccessCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, RTSFailureCount ), sizeof( UINT64 ), ENUMS::RTSFailureCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, ACKFailureCount ), sizeof( UINT64 ), ENUMS::ACKFailureCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, ReceivedFrameCount ), sizeof( UINT64 ), ENUMS::ReceivedFrameCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, GroupReceivedFrameCount ), sizeof( UINT64 ), ENUMS::GroupReceivedFrameCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, PromiscuousReceivedFrameCount ), sizeof( UINT64 ), ENUMS::PromiscuousReceivedFrameCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, MaxRXLifetimeExceededCount ), sizeof( UINT64 ), ENUMS::MaxRXLifetimeExceededCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, FrameDuplicateCount ), sizeof( UINT64 ), ENUMS::FrameDuplicateCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, ReceivedFragmentCount ), sizeof( UINT64 ), ENUMS::ReceivedFragmentCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, PromiscuousReceivedFragmentCount ), sizeof( UINT64 ), ENUMS::PromiscuousReceivedFragmentCount, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_STATISTICS_PARAMETERS, FCSErrorCount ), sizeof( UINT64 ), ENUMS::FCSErrorCount, ENUMS::UINT64, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_PHY_STATISTICS_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_PHY_STATISTICS_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_SET_OFFLOAD_PARAMS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_OFFLOAD_PARAMS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, IPv4Checksum ), sizeof( UINT8 ), ENUMS::IPv4Checksum, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, TCPIPv4Checksum ), sizeof( UINT8 ), ENUMS::TCPIPv4Checksum, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, UDPIPv4Checksum ), sizeof( UINT8 ), ENUMS::UDPIPv4Checksum, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, TCPIPv6Checksum ), sizeof( UINT8 ), ENUMS::TCPIPv6Checksum, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, UDPIPv6Checksum ), sizeof( UINT8 ), ENUMS::UDPIPv6Checksum, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, LsoV1 ), sizeof( UINT8 ), ENUMS::LsoV1, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, IPsecV1 ), sizeof( UINT8 ), ENUMS::IPsecV1, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, LsoV2IPv4 ), sizeof( UINT8 ), ENUMS::LsoV2IPv4, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, LsoV2IPv6 ), sizeof( UINT8 ), ENUMS::LsoV2IPv6, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, TcpConnectionIPv4 ), sizeof( UINT8 ), ENUMS::TcpConnectionIPv4, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, TcpConnectionIPv6 ), sizeof( UINT8 ), ENUMS::TcpConnectionIPv6, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, RscIPv4 ), sizeof( UINT8 ), ENUMS::RscIPv4, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, RscIPv6 ), sizeof( UINT8 ), ENUMS::RscIPv6, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, Flags ), sizeof( UINT32 ), ENUMS::Flags, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, IPsecV2 ), sizeof( UINT8 ), ENUMS::IPsecV2, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, IPsecV2IPv4 ), sizeof( UINT8 ), ENUMS::IPsecV2IPv4, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, EncapsulatedPacketTaskOffload ), sizeof( UINT8 ), ENUMS::EncapsulatedPacketTaskOffload, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT, EncapsulationTypes ), sizeof( UINT8 ), ENUMS::EncapsulationTypes, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT_HELPER::s_BinarySize, sizeof( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_GO_NEGOTIATION_CONFIRMATION_INFO_CONTAINER * pField )
        {
            pField->GroupID.GroupSSID.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_GO_NEGOTIATION_CONFIRMATION_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GO_NEGOTIATION_CONFIRMATION_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_CONFIRMATION_INFO_CONTAINER, ConfirmationParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GROUP_ID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GROUP_ID, TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_CONFIRMATION_INFO_CONTAINER, GroupID ), FALSE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_LISTEN_CHANNEL, TLV_FIELD_OFFSET( WDI_P2P_GO_NEGOTIATION_CONFIRMATION_INFO_CONTAINER, RemoteListenChannel ), TRUE, FALSE, 0, TRUE, 1 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_GO_NEGOTIATION_CONFIRMATION_INFO_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_INVITATION_RESPONSE_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_INVITATION_RESPONSE_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_INVITATION_RESPONSE_PARAMETERS, StatusCode ), sizeof( UINT8 ), ENUMS::StatusCode, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_INVITATION_RESPONSE_PARAMETERS, GOConfigTimeout ), sizeof( UINT16 ), ENUMS::GOConfigTimeout, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_INVITATION_RESPONSE_PARAMETERS, ClientConfigTimeout ), sizeof( UINT16 ), ENUMS::ClientConfigTimeout, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_INVITATION_RESPONSE_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_INVITATION_RESPONSE_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}


//
// Helpers for WDI_P2P_INVITATION_RESPONSE_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_INVITATION_RESPONSE_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_INVITATION_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INVITATION_RESPONSE_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_INVITATION_RESPONSE_INFO_CONTAINER, ResponseParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GROUP_BSSID, TLV_FIELD_OFFSET( WDI_P2P_INVITATION_RESPONSE_INFO_CONTAINER, GroupBSSID ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_NUMBER, TLV_FIELD_OFFSET( WDI_P2P_INVITATION_RESPONSE_INFO_CONTAINER, OperatingChannel ), TRUE, FALSE, 0, TRUE, 1 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_INVITATION_RESPONSE_INFO_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS, ActionFrameType ), sizeof( WDI_P2P_ACTION_FRAME_TYPE ), ENUMS::ActionFrameType, ENUMS::WDI_P2P_ACTION_FRAME_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS, PeerDeviceAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::PeerDeviceAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS, DialogToken ), sizeof( UINT8 ), ENUMS::DialogToken, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_INCOMING_P2P_ACTION_FRAME_INFO * pField )
        {
            pField->FrameIEs.MemoryInternallyAllocated = FALSE;
            pField->DeviceContext.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_INCOMING_P2P_ACTION_FRAME_INFO
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INCOMING_P2P_ACTION_FRAME_INFO_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INCOMING_FRAME_PARAMETERS, TLV_FIELD_OFFSET( WDI_INCOMING_P2P_ACTION_FRAME_INFO, FrameParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ACTION_FRAME_IES, TLV_FIELD_OFFSET( WDI_INCOMING_P2P_ACTION_FRAME_INFO, FrameIEs ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ACTION_FRAME_DEVICE_CONTEXT, TLV_FIELD_OFFSET( WDI_INCOMING_P2P_ACTION_FRAME_INFO, DeviceContext ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INCOMING_P2P_ACTION_FRAME_INFO ) };
        }
    }
}

//
// Helpers for WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS, AcceptRequest ), sizeof( BOOLEAN ), ENUMS::AcceptRequest, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS, ReasonCode ), sizeof( UINT16 ), ENUMS::ReasonCode, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_AP_ASSOCIATION_REQUEST_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_AP_ASSOCIATION_REQUEST_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_AP_ASSOCIATION_REQUEST_PARAMETERS, PeerMacAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::PeerMacAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_ASSOCIATION_REQUEST_PARAMETERS, IsReassociationRequest ), sizeof( BOOLEAN ), ENUMS::IsReassociationRequest, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_AP_ASSOCIATION_REQUEST_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_AP_ASSOCIATION_REQUEST_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER * pField )
        {
            pField->AssocRequestFrame.MemoryInternallyAllocated = FALSE;
            pField->AssocRequestDeviceContext.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_AP_ASSOCIATION_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INCOMING_ASSOCIATION_REQUEST_PARAMETERS, TLV_FIELD_OFFSET( WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER, AssocRequestParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_REQUEST_FRAME, TLV_FIELD_OFFSET( WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER, AssocRequestFrame ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_REQUEST_DEVICE_CONTEXT, TLV_FIELD_OFFSET( WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER, AssocRequestDeviceContext ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_DISCONNECT_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_DISCONNECT_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_DISCONNECT_PARAMETERS, MacAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MacAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_DISCONNECT_PARAMETERS, Disassociation80211Reason ), sizeof( UINT16 ), ENUMS::Disassociation80211Reason, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_DISCONNECT_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_DISCONNECT_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_SEND_ACTION_FRAME_RESULT_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SEND_ACTION_FRAME_RESULT_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESULT_PARAMETERS, PeerDeviceAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::PeerDeviceAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESULT_PARAMETERS, DialogToken ), sizeof( UINT8 ), ENUMS::DialogToken, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_SEND_ACTION_FRAME_RESULT_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_P2P_SEND_ACTION_FRAME_RESULT_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_SEND_ACTION_FRAME_RESULT_CONTAINER * pField )
        {
            pField->FrameIEs.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_SEND_ACTION_FRAME_RESULT_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_SEND_ACTION_FRAME_RESULT_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SEND_ACTION_FRAME_RESULT_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SEND_ACTION_FRAME_RESULT_PARAMETERS, TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESULT_CONTAINER, FrameParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ACTION_FRAME_IES, TLV_FIELD_OFFSET( WDI_P2P_SEND_ACTION_FRAME_RESULT_CONTAINER, FrameIEs ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_SEND_ACTION_FRAME_RESULT_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_ASSOC_RESPONSE_RESULT_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ASSOC_RESPONSE_RESULT_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_ASSOC_RESULT_PARAMETERS, PeerMACAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::PeerMACAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOC_RESULT_PARAMETERS, IsReassociationRequest ), sizeof( BOOLEAN ), ENUMS::IsReassociationRequest, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOC_RESULT_PARAMETERS, IsReAssociationResponse ), sizeof( BOOLEAN ), ENUMS::IsReAssociationResponse, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOC_RESULT_PARAMETERS, AuthAlgorithm ), sizeof( WDI_AUTH_ALGORITHM ), ENUMS::AuthAlgorithm, ENUMS::WDI_AUTH_ALGORITHM, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOC_RESULT_PARAMETERS, UnicastCipherAlgorithm ), sizeof( WDI_CIPHER_ALGORITHM ), ENUMS::UnicastCipherAlgorithm, ENUMS::WDI_CIPHER_ALGORITHM, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOC_RESULT_PARAMETERS, MulticastCipherAlgorithm ), sizeof( WDI_CIPHER_ALGORITHM ), ENUMS::MulticastCipherAlgorithm, ENUMS::WDI_CIPHER_ALGORITHM, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_ASSOC_RESULT_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_ASSOC_RESULT_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PHY_TYPE_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PHY_TYPE_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_PHY_TYPE ), ENUMS::PhyTypes, ENUMS::WDI_PHY_TYPE, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_PHY_TYPE ), sizeof( WDI_PHY_TYPE ), TRUE, FALSE, FALSE, FALSE, 16 };
        }
    }
}

//
// Helpers for WDI_DISCONNECT_INDICATION_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_DISCONNECT_INDICATION_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_DISCONNECT_INDICATION_PARAMETERS, MacAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MacAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_DISCONNECT_INDICATION_PARAMETERS, DisassociationWABIReason ), sizeof( WDI_ASSOC_STATUS ), ENUMS::DisassociationWABIReason, ENUMS::WDI_ASSOC_STATUS, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_DISCONNECT_INDICATION_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_DISCONNECT_INDICATION_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_GO_INTERNAL_RESET_POLICY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_GO_INTERNAL_RESET_POLICY_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_P2P_GO_INTERNAL_RESET_POLICY ), ENUMS::ResetPolicy, ENUMS::WDI_P2P_GO_INTERNAL_RESET_POLICY, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_P2P_GO_INTERNAL_RESET_POLICY ), sizeof( WDI_P2P_GO_INTERNAL_RESET_POLICY ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS, Encapsulation ), sizeof( UINT32 ), ENUMS::Encapsulation, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS, IpOptionsSupported ), sizeof( UINT32 ), ENUMS::IpOptionsSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS, TcpOptionsSupported ), sizeof( UINT32 ), ENUMS::TcpOptionsSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS, TcpChecksum ), sizeof( UINT32 ), ENUMS::TcpChecksum, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS, UdpChecksum ), sizeof( UINT32 ), ENUMS::UdpChecksum, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS, IpChecksum ), sizeof( UINT32 ), ENUMS::IpChecksum, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS, Encapsulation ), sizeof( UINT32 ), ENUMS::Encapsulation, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS, IpExtensionHeadersSupported ), sizeof( UINT32 ), ENUMS::IpExtensionHeadersSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS, TcpOptionsSupported ), sizeof( UINT32 ), ENUMS::TcpOptionsSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS, TcpChecksum ), sizeof( UINT32 ), ENUMS::TcpChecksum, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS, UdpChecksum ), sizeof( UINT32 ), ENUMS::UdpChecksum, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}


//
// Helpers for WDI_IPV4_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_IPV4_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHECKSUM_OFFLOAD_V4_TX_PARAMETERS, TLV_FIELD_OFFSET( WDI_IPV4_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER, IpV4Transmit ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHECKSUM_OFFLOAD_V4_RX_PARAMETERS, TLV_FIELD_OFFSET( WDI_IPV4_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER, IpV4Receive ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_IPV4_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER ) };
        }
    }
}


//
// Helpers for WDI_IPV6_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_IPV6_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHECKSUM_OFFLOAD_V6_TX_PARAMETERS, TLV_FIELD_OFFSET( WDI_IPV6_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER, IpV6Transmit ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHECKSUM_OFFLOAD_V6_RX_PARAMETERS, TLV_FIELD_OFFSET( WDI_IPV6_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER, IpV6Receive ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_IPV6_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER ) };
        }
    }
}


//
// Helpers for WDI_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_IPV4_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IPV4_CHECKSUM_OFFLOAD, TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER, ipv4ChecksumOffload ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_IPV6_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IPV6_CHECKSUM_OFFLOAD, TLV_FIELD_OFFSET( WDI_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER, ipv6ChecksumOffload ), FALSE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_LSO_V1_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_LSO_V1_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_LSO_V1_CAPABILITIES, Encapsulation ), sizeof( UINT32 ), ENUMS::Encapsulation, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_LSO_V1_CAPABILITIES, MaxOffLoadSize ), sizeof( UINT32 ), ENUMS::MaxOffLoadSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_LSO_V1_CAPABILITIES, MinSegmentCount ), sizeof( UINT32 ), ENUMS::MinSegmentCount, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_LSO_V1_CAPABILITIES, TcpOptions ), sizeof( UINT32 ), ENUMS::TcpOptions, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_LSO_V1_CAPABILITIES, IpOptions ), sizeof( UINT32 ), ENUMS::IpOptions, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_LSO_V1_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_LSO_V1_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_IPV4_LSO_V2_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_IPV4_LSO_V2_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_IPV4_LSO_V2, EncapsulationV4 ), sizeof( UINT32 ), ENUMS::EncapsulationV4, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_IPV4_LSO_V2, MaxOffloadSizeV4 ), sizeof( UINT32 ), ENUMS::MaxOffloadSizeV4, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_IPV4_LSO_V2, MinSegmentCountV4 ), sizeof( UINT32 ), ENUMS::MinSegmentCountV4, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_IPV4_LSO_V2_HELPER::s_BinarySize, sizeof( WDI_IPV4_LSO_V2 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_IPV6_LSO_V2_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_IPV6_LSO_V2_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_IPV6_LSO_V2, EncapsulationV6 ), sizeof( UINT32 ), ENUMS::EncapsulationV6, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_IPV6_LSO_V2, MaxOffloadSizeV6 ), sizeof( UINT32 ), ENUMS::MaxOffloadSizeV6, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_IPV6_LSO_V2, MinSegmentCountV6 ), sizeof( UINT32 ), ENUMS::MinSegmentCountV6, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_IPV6_LSO_V2, IpExtensionHeadersSupported ), sizeof( UINT32 ), ENUMS::IpExtensionHeadersSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_IPV6_LSO_V2, TcpOptionsSupported ), sizeof( UINT32 ), ENUMS::TcpOptionsSupported, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_IPV6_LSO_V2_HELPER::s_BinarySize, sizeof( WDI_IPV6_LSO_V2 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CANCEL_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CANCEL_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CANCEL_PARAMETERS_STRUCT, OriginalTaskOID ), sizeof( NDIS_OID ), ENUMS::OriginalTaskOID, ENUMS::NDIS_OID, 1 },
                { TLV_FIELD_OFFSET( WDI_CANCEL_PARAMETERS_STRUCT, OriginalTransactionId ), sizeof( UINT32 ), ENUMS::OriginalTransactionId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CANCEL_PARAMETERS_STRUCT, OriginalPortId ), sizeof( WDI_PORT_ID ), ENUMS::OriginalPortId, ENUMS::WDI_PORT_ID, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CANCEL_PARAMETERS_STRUCT_HELPER::s_BinarySize, sizeof( WDI_CANCEL_PARAMETERS_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PORT_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PORT_ATTRIBUTES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CREATE_PORT_COMPLETE_STRUCT, MacAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MacAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_CREATE_PORT_COMPLETE_STRUCT, PortNumber ), sizeof( UINT16 ), ENUMS::PortNumber, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CREATE_PORT_COMPLETE_STRUCT_HELPER::s_BinarySize, sizeof( WDI_CREATE_PORT_COMPLETE_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES, Ipv4Enabled ), sizeof( UINT8 ), ENUMS::Ipv4Enabled, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES, Ipv6Enabled ), sizeof( UINT8 ), ENUMS::Ipv6Enabled, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}


//
// Helpers for WDI_LSO_V2_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_LSO_V2_CAPABILITIES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_IPV4_LSO_V2_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IPV4_LSO_V2, TLV_FIELD_OFFSET( WDI_LSO_V2_CAPABILITIES_CONTAINER, Ipv4LSO ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_IPV6_LSO_V2_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IPV6_LSO_V2, TLV_FIELD_OFFSET( WDI_LSO_V2_CAPABILITIES_CONTAINER, Ipv6LSO ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_LSO_V2_CAPABILITIES_CONTAINER ) };
        }
    }
}


//
// Helpers for WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHECKSUM_OFFLOAD_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHECKSUM_OFFLOAD_CAPABILITIES, TLV_FIELD_OFFSET( WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER, ChecksumOffload ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_LSO_V1_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_LSO_V1_CAPABILITIES, TLV_FIELD_OFFSET( WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER, LsoV1Capabilities ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_LSO_V2_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_LSO_V2_CAPABILITIES, TLV_FIELD_OFFSET( WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER, LsoV2Capabilities ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES, TLV_FIELD_OFFSET( WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER, ReceiveOffloadCapabilities ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_TASK_DELETE_PORT_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_DELETE_PORT_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_DELETE_PORT_PARAMETERS, PortNumber ), sizeof( UINT16 ), ENUMS::PortNumber, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_DELETE_PORT_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_DELETE_PORT_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_TASK_CREATE_PORT_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_CREATE_PORT_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CREATE_PORT_PARAMETERS, OpModeMask ), sizeof( UINT16 ), ENUMS::OpModeMask, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_CREATE_PORT_PARAMETERS, NdisPortNumber ), sizeof( UINT32 ), ENUMS::NdisPortNumber, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CREATE_PORT_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_CREATE_PORT_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_DOT11_RESET_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_DOT11_RESET_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_DOT11_RESET_PARAMETERS, SetDefaultMIB ), sizeof( UINT8 ), ENUMS::SetDefaultMIB, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_DOT11_RESET_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_DOT11_RESET_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_SCAN_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SCAN_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_SCAN_MODE, ScanRepeatCount ), sizeof( BOOLEAN ), ENUMS::ScanRepeatCount, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_SCAN_MODE, AllowedScanType ), sizeof( WDI_SCAN_TYPE ), ENUMS::AllowedScanType, ENUMS::WDI_SCAN_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_SCAN_MODE, LiveUpdatesNeeded ), sizeof( BOOLEAN ), ENUMS::LiveUpdatesNeeded, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_SCAN_MODE, ScanTrigger ), sizeof( WDI_SCAN_TRIGGER ), ENUMS::ScanTrigger, ENUMS::WDI_SCAN_TRIGGER, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_SCAN_MODE_HELPER::s_BinarySize, sizeof( WDI_SCAN_MODE ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_COMMUNICATION_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_COMMUNICATION_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_COMMUNICATION_CAPABILITIES, MaxCommandSize ), sizeof( UINT32 ), ENUMS::MaxCommandSize, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_COMMUNICATION_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_COMMUNICATION_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_INTERFACE_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INTERFACE_CAPABILITIES_CONTAINER_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvInterfaceCapabilities[] =
            {
                { WDI_TLV_INTERFACE_ATTRIBUTES, WDI_VERSION_1_0_20, 0xFFFFFFFFul, FALSE, FALSE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, MTUSize ), sizeof( UINT32 ), ENUMS::MTUSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, MaxMultiCastListSize ), sizeof( UINT32 ), ENUMS::MaxMultiCastListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, BackFillSize ), sizeof( UINT16 ), ENUMS::BackFillSize, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, Address ), sizeof( WDI_MAC_ADDRESS ), ENUMS::Address, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, MaxTxRate ), sizeof( UINT32 ), ENUMS::MaxTxRate, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, MaxRxRate ), sizeof( UINT32 ), ENUMS::MaxRxRate, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, HardwareRadioState ), sizeof( BOOLEAN ), ENUMS::HardwareRadioState, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, SoftwareRadioState ), sizeof( BOOLEAN ), ENUMS::SoftwareRadioState, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, SupportPLR ), sizeof( BOOLEAN ), ENUMS::SupportPLR, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, SupportFLR ), sizeof( BOOLEAN ), ENUMS::SupportFLR, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, ActionFramesSupported ), sizeof( BOOLEAN ), ENUMS::ActionFramesSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, NumRxStreams ), sizeof( UINT8 ), ENUMS::NumRxStreams, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, NumTxStreams ), sizeof( UINT8 ), ENUMS::NumTxStreams, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, NumChannels ), sizeof( UINT8 ), ENUMS::NumChannels, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, AntennaDiversity ), sizeof( BOOLEAN ), ENUMS::AntennaDiversity, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, Support_eCSA ), sizeof( BOOLEAN ), ENUMS::Support_eCSA, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, MACAddressRandomization ), sizeof( BOOLEAN ), ENUMS::MACAddressRandomization, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, MACAddressRandomizationMask ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MACAddressRandomizationMask, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, BluetoothCoexistenceSupport ), sizeof( WDI_BLUETOOTH_COEXISTENCE_SUPPORT ), ENUMS::BluetoothCoexistenceSupport, ENUMS::WDI_BLUETOOTH_COEXISTENCE_SUPPORT, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, SupportsNonWdiOidRequests ), sizeof( BOOLEAN ), ENUMS::SupportsNonWdiOidRequests, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, FastTransitionSupported ), sizeof( BOOLEAN ), ENUMS::FastTransitionSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, MU_MIMOSupported ), sizeof( BOOLEAN ), ENUMS::MU_MIMOSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, CannotSupportMiracastSink ), sizeof( BOOLEAN ), ENUMS::CannotSupportMiracastSink, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, BSSTransitionSupported ), sizeof( BOOLEAN ), ENUMS::BSSTransitionSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIES, IPDockingSupported ), sizeof( BOOLEAN ), ENUMS::IPDockingSupported, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_INTERFACE_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_INTERFACE_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_1
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_1_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvInterfaceCapabilities[] =
            {
                { WDI_TLV_INTERFACE_ATTRIBUTES, WDI_VERSION_1_0_1, WDI_VERSION_1_0_20, FALSE, FALSE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, MTUSize ), sizeof( UINT32 ), ENUMS::MTUSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, MaxMultiCastListSize ), sizeof( UINT32 ), ENUMS::MaxMultiCastListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, BackFillSize ), sizeof( UINT16 ), ENUMS::BackFillSize, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, Address ), sizeof( WDI_MAC_ADDRESS ), ENUMS::Address, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, MaxTxRate ), sizeof( UINT32 ), ENUMS::MaxTxRate, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, MaxRxRate ), sizeof( UINT32 ), ENUMS::MaxRxRate, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, HardwareRadioState ), sizeof( BOOLEAN ), ENUMS::HardwareRadioState, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, SoftwareRadioState ), sizeof( BOOLEAN ), ENUMS::SoftwareRadioState, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, SupportPLR ), sizeof( BOOLEAN ), ENUMS::SupportPLR, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, SupportFLR ), sizeof( BOOLEAN ), ENUMS::SupportFLR, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, ActionFramesSupported ), sizeof( BOOLEAN ), ENUMS::ActionFramesSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, NumRxStreams ), sizeof( UINT8 ), ENUMS::NumRxStreams, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, NumTxStreams ), sizeof( UINT8 ), ENUMS::NumTxStreams, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, NumChannels ), sizeof( UINT8 ), ENUMS::NumChannels, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, AntennaDiversity ), sizeof( BOOLEAN ), ENUMS::AntennaDiversity, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, Support_eCSA ), sizeof( BOOLEAN ), ENUMS::Support_eCSA, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, MACAddressRandomization ), sizeof( BOOLEAN ), ENUMS::MACAddressRandomization, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, MACAddressRandomizationMask ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MACAddressRandomizationMask, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, BluetoothCoexistenceSupport ), sizeof( WDI_BLUETOOTH_COEXISTENCE_SUPPORT ), ENUMS::BluetoothCoexistenceSupport, ENUMS::WDI_BLUETOOTH_COEXISTENCE_SUPPORT, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, SupportsNonWdiOidRequests ), sizeof( BOOLEAN ), ENUMS::SupportsNonWdiOidRequests, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, FastTransitionSupported ), sizeof( BOOLEAN ), ENUMS::FastTransitionSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, MU_MIMOSupported ), sizeof( BOOLEAN ), ENUMS::MU_MIMOSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, CannotSupportMiracastSink ), sizeof( BOOLEAN ), ENUMS::CannotSupportMiracastSink, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0_1, BSSTransitionSupported ), sizeof( BOOLEAN ), ENUMS::BSSTransitionSupported, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_INTERFACE_CAPABILITIESV1_0_1_HELPER::s_BinarySize, sizeof( WDI_INTERFACE_CAPABILITIESV1_0_1 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvInterfaceCapabilities[] =
            {
                { WDI_TLV_INTERFACE_ATTRIBUTES, 0, WDI_VERSION_1_0_1, FALSE, FALSE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, MTUSize ), sizeof( UINT32 ), ENUMS::MTUSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, MaxMultiCastListSize ), sizeof( UINT32 ), ENUMS::MaxMultiCastListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, BackFillSize ), sizeof( UINT16 ), ENUMS::BackFillSize, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, Address ), sizeof( WDI_MAC_ADDRESS ), ENUMS::Address, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, MaxTxRate ), sizeof( UINT32 ), ENUMS::MaxTxRate, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, MaxRxRate ), sizeof( UINT32 ), ENUMS::MaxRxRate, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, HardwareRadioState ), sizeof( BOOLEAN ), ENUMS::HardwareRadioState, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, SoftwareRadioState ), sizeof( BOOLEAN ), ENUMS::SoftwareRadioState, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, SupportPLR ), sizeof( BOOLEAN ), ENUMS::SupportPLR, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, SupportFLR ), sizeof( BOOLEAN ), ENUMS::SupportFLR, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, ActionFramesSupported ), sizeof( BOOLEAN ), ENUMS::ActionFramesSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, NumRxStreams ), sizeof( UINT8 ), ENUMS::NumRxStreams, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, NumTxStreams ), sizeof( UINT8 ), ENUMS::NumTxStreams, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, NumChannels ), sizeof( UINT8 ), ENUMS::NumChannels, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, AntennaDiversity ), sizeof( BOOLEAN ), ENUMS::AntennaDiversity, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, Support_eCSA ), sizeof( BOOLEAN ), ENUMS::Support_eCSA, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, MACAddressRandomization ), sizeof( BOOLEAN ), ENUMS::MACAddressRandomization, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, MACAddressRandomizationMask ), sizeof( WDI_MAC_ADDRESS ), ENUMS::MACAddressRandomizationMask, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, BluetoothCoexistenceSupport ), sizeof( WDI_BLUETOOTH_COEXISTENCE_SUPPORT ), ENUMS::BluetoothCoexistenceSupport, ENUMS::WDI_BLUETOOTH_COEXISTENCE_SUPPORT, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, SupportsNonWdiOidRequests ), sizeof( BOOLEAN ), ENUMS::SupportsNonWdiOidRequests, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, FastTransitionSupported ), sizeof( BOOLEAN ), ENUMS::FastTransitionSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, MU_MIMOSupported ), sizeof( BOOLEAN ), ENUMS::MU_MIMOSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_INTERFACE_CAPABILITIESV1_0, CannotSupportMiracastSink ), sizeof( BOOLEAN ), ENUMS::CannotSupportMiracastSink, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_INTERFACE_CAPABILITIESV1_0_HELPER::s_BinarySize, sizeof( WDI_INTERFACE_CAPABILITIESV1_0 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_ALGO_PAIRS_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_ALGO_PAIRS, AuthAlgorithm ), sizeof( WDI_AUTH_ALGORITHM ), ENUMS::AuthAlgorithm, ENUMS::WDI_AUTH_ALGORITHM, 1 },
                { TLV_FIELD_OFFSET( WDI_ALGO_PAIRS, CipherAlgorithm ), sizeof( WDI_CIPHER_ALGORITHM ), ENUMS::CipherAlgorithm, ENUMS::WDI_CIPHER_ALGORITHM, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_ALGO_PAIRS_HELPER::s_BinarySize, sizeof( WDI_ALGO_PAIRS ), TRUE, FALSE, FALSE, FALSE, 17 };
        }
    }
}

//
// Helpers for WDI_STATION_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_STATION_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, ScanSSIDListSize ), sizeof( UINT32 ), ENUMS::ScanSSIDListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, DesiredBSSIDListSize ), sizeof( UINT32 ), ENUMS::DesiredBSSIDListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, DesiredSSIDListSize ), sizeof( UINT32 ), ENUMS::DesiredSSIDListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, PrivacyExemptionListSize ), sizeof( UINT32 ), ENUMS::PrivacyExemptionListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, KeyMappingTableSize ), sizeof( UINT32 ), ENUMS::KeyMappingTableSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, DefaultKeyTableSize ), sizeof( UINT32 ), ENUMS::DefaultKeyTableSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, WEPKeyValueMaxLength ), sizeof( UINT32 ), ENUMS::WEPKeyValueMaxLength, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, MaxNumPerSTA ), sizeof( UINT32 ), ENUMS::MaxNumPerSTA, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, SupportedQOSFlags ), sizeof( UINT8 ), ENUMS::SupportedQOSFlags, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, HostFIPSModeImplemented ), sizeof( UINT8 ), ENUMS::HostFIPSModeImplemented, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, MFPCapable ), sizeof( UINT8 ), ENUMS::MFPCapable, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, AutoPowerSaveMode ), sizeof( BOOLEAN ), ENUMS::AutoPowerSaveMode, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, BSSListCachemanagement ), sizeof( BOOLEAN ), ENUMS::BSSListCachemanagement, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, ConnectBSSSelectionOverride ), sizeof( BOOLEAN ), ENUMS::ConnectBSSSelectionOverride, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, uMaxNetworkOffloadListSize ), sizeof( UINT32 ), ENUMS::uMaxNetworkOffloadListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, HESSIDConnectionSupported ), sizeof( BOOLEAN ), ENUMS::HESSIDConnectionSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_STATION_CAPABILITIES, DisconnectedStandbySupported ), sizeof( BOOLEAN ), ENUMS::DisconnectedStandbySupported, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_STATION_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_STATION_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_AP_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_AP_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_AP_CAPABILITIES, ScanSSIDListSize ), sizeof( UINT32 ), ENUMS::ScanSSIDListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_CAPABILITIES, DesiredSSIDListSize ), sizeof( UINT32 ), ENUMS::DesiredSSIDListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_CAPABILITIES, PrivacyExemptionListSize ), sizeof( UINT32 ), ENUMS::PrivacyExemptionListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_CAPABILITIES, AssociationTableSize ), sizeof( UINT32 ), ENUMS::AssociationTableSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_CAPABILITIES, KeyMappingTableSize ), sizeof( UINT32 ), ENUMS::KeyMappingTableSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_CAPABILITIES, DefaultKeyTableSize ), sizeof( UINT32 ), ENUMS::DefaultKeyTableSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_CAPABILITIES, WEPKeyValueMaxLength ), sizeof( UINT32 ), ENUMS::WEPKeyValueMaxLength, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_AP_CAPABILITIES, RadarDetectionSupported ), sizeof( BOOLEAN ), ENUMS::RadarDetectionSupported, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_AP_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_AP_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_COUNTRY_REGION_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_COUNTRY_REGION_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_COUNTRY_REGION_LIST, CountryOrRegionString ), (sizeof( UINT8 ) * 3), ENUMS::CountryOrRegionString, ENUMS::UINT8, 3 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_COUNTRY_REGION_LIST_HELPER::s_BinarySize, sizeof( WDI_COUNTRY_REGION_LIST ), TRUE, FALSE, FALSE, FALSE, 18 };
        }
    }
}

//
// Helpers for WDI_VIRTUALIZATION_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_VIRTUALIZATION_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_VIRTUALIZATION_CAPABILITIES, ExtSTACount ), sizeof( UINT8 ), ENUMS::ExtSTACount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_VIRTUALIZATION_CAPABILITIES, WiFiDirectGroupCount ), sizeof( UINT8 ), ENUMS::WiFiDirectGroupCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_VIRTUALIZATION_CAPABILITIES, APCount ), sizeof( UINT8 ), ENUMS::APCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_VIRTUALIZATION_CAPABILITIES, SimultaneousGoCount ), sizeof( UINT8 ), ENUMS::SimultaneousGoCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_VIRTUALIZATION_CAPABILITIES, SimultaneousMultiChannelOperationLimit ), sizeof( UINT8 ), ENUMS::SimultaneousMultiChannelOperationLimit, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_VIRTUALIZATION_CAPABILITIES, SimultaneousSTAWFDClientCount ), sizeof( UINT8 ), ENUMS::SimultaneousSTAWFDClientCount, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_VIRTUALIZATION_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_VIRTUALIZATION_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_CAPABILITIES_CONTAINER_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvP2pCapabilities[] =
            {
                { WDI_TLV_P2P_ATTRIBUTES, WDI_VERSION_1_0_20, 0xFFFFFFFFul, FALSE, FALSE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ConcurrentGOCount ), sizeof( UINT8 ), ENUMS::ConcurrentGOCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ConcurrentClientCount ), sizeof( UINT8 ), ENUMS::ConcurrentClientCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, WPSVersionSupport ), sizeof( UINT32 ), ENUMS::WPSVersionSupport, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ServiceDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ServiceNameDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceNameDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ServiceInformationDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceInformationDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ServiceNameAdvertisementsMaxBytesSupported ), sizeof( UINT32 ), ENUMS::ServiceNameAdvertisementsMaxBytesSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ServiceInformationAdvertisementsMaxBytesSupported ), sizeof( UINT32 ), ENUMS::ServiceInformationAdvertisementsMaxBytesSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, BackgroundDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::BackgroundDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ClientDiscoverabilitySupported ), sizeof( BOOLEAN ), ENUMS::ClientDiscoverabilitySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, InfrastructureManagementSupported ), sizeof( BOOLEAN ), ENUMS::InfrastructureManagementSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, MaxSecondaryAdapterTypeListSize ), sizeof( UINT8 ), ENUMS::MaxSecondaryAdapterTypeListSize, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, DeviceAddress ), (sizeof( UINT8 ) * 6), ENUMS::DeviceAddress, ENUMS::UINT8, 6 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, DiscoveryFilterListSize ), sizeof( UINT32 ), ENUMS::DiscoveryFilterListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, GOClientTableSize ), sizeof( UINT8 ), ENUMS::GOClientTableSize, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, MaxVendorSpecificExtensionIESize ), sizeof( UINT32 ), ENUMS::MaxVendorSpecificExtensionIESize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, PassiveAvailabilityListenStateSupported ), sizeof( BOOLEAN ), ENUMS::PassiveAvailabilityListenStateSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, OperatingChannelUpdatesSupported ), sizeof( BOOLEAN ), ENUMS::OperatingChannelUpdatesSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, GOon5GHzBandSupported ), sizeof( BOOLEAN ), ENUMS::GOon5GHzBandSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ASP20ServiceNameDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ASP20ServiceNameDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES, ASP20ServiceInformationDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ASP20ServiceInformationDiscoverySupported, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_P2P_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_CAPABILITIES_CONTAINER_V1_0_10
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_CAPABILITIES_CONTAINER_V1_0_10_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvP2pCapabilities[] =
            {
                { WDI_TLV_P2P_ATTRIBUTES, WDI_VERSION_1_0_10, WDI_VERSION_1_0_20, FALSE, FALSE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, ConcurrentGOCount ), sizeof( UINT8 ), ENUMS::ConcurrentGOCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, ConcurrentClientCount ), sizeof( UINT8 ), ENUMS::ConcurrentClientCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, WPSVersionSupport ), sizeof( UINT32 ), ENUMS::WPSVersionSupport, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, ServiceDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, ServiceNameDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceNameDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, ServiceInformationDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceInformationDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, ServiceNameAdvertisementsMaxBytesSupported ), sizeof( UINT32 ), ENUMS::ServiceNameAdvertisementsMaxBytesSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, ServiceInformationAdvertisementsMaxBytesSupported ), sizeof( UINT32 ), ENUMS::ServiceInformationAdvertisementsMaxBytesSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, BackgroundDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::BackgroundDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, ClientDiscoverabilitySupported ), sizeof( BOOLEAN ), ENUMS::ClientDiscoverabilitySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, InfrastructureManagementSupported ), sizeof( BOOLEAN ), ENUMS::InfrastructureManagementSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, MaxSecondaryAdapterTypeListSize ), sizeof( UINT8 ), ENUMS::MaxSecondaryAdapterTypeListSize, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, DeviceAddress ), (sizeof( UINT8 ) * 6), ENUMS::DeviceAddress, ENUMS::UINT8, 6 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, DiscoveryFilterListSize ), sizeof( UINT32 ), ENUMS::DiscoveryFilterListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, GOClientTableSize ), sizeof( UINT8 ), ENUMS::GOClientTableSize, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, MaxVendorSpecificExtensionIESize ), sizeof( UINT32 ), ENUMS::MaxVendorSpecificExtensionIESize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, PassiveAvailabilityListenStateSupported ), sizeof( BOOLEAN ), ENUMS::PassiveAvailabilityListenStateSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, OperatingChannelUpdatesSupported ), sizeof( BOOLEAN ), ENUMS::OperatingChannelUpdatesSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_10, GOon5GHzBandSupported ), sizeof( BOOLEAN ), ENUMS::GOon5GHzBandSupported, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_CAPABILITIES_V1_0_10_HELPER::s_BinarySize, sizeof( WDI_P2P_CAPABILITIES_V1_0_10 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_P2P_CAPABILITIES_CONTAINER_V1_0_1
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_CAPABILITIES_CONTAINER_V1_0_1_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvP2pCapabilities[] =
            {
                { WDI_TLV_P2P_ATTRIBUTES, 0, WDI_VERSION_1_0_10, FALSE, FALSE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, ConcurrentGOCount ), sizeof( UINT8 ), ENUMS::ConcurrentGOCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, ConcurrentClientCount ), sizeof( UINT8 ), ENUMS::ConcurrentClientCount, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, WPSVersionSupport ), sizeof( UINT32 ), ENUMS::WPSVersionSupport, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, ServiceDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, ServiceNameDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceNameDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, ServiceInformationDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::ServiceInformationDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, ServiceNameAdvertisementsMaxBytesSupported ), sizeof( UINT32 ), ENUMS::ServiceNameAdvertisementsMaxBytesSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, ServiceInformationAdvertisementsMaxBytesSupported ), sizeof( UINT32 ), ENUMS::ServiceInformationAdvertisementsMaxBytesSupported, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, BackgroundDiscoverySupported ), sizeof( BOOLEAN ), ENUMS::BackgroundDiscoverySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, ClientDiscoverabilitySupported ), sizeof( BOOLEAN ), ENUMS::ClientDiscoverabilitySupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, InfrastructureManagementSupported ), sizeof( BOOLEAN ), ENUMS::InfrastructureManagementSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, MaxSecondaryAdapterTypeListSize ), sizeof( UINT8 ), ENUMS::MaxSecondaryAdapterTypeListSize, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, DeviceAddress ), (sizeof( UINT8 ) * 6), ENUMS::DeviceAddress, ENUMS::UINT8, 6 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, DiscoveryFilterListSize ), sizeof( UINT32 ), ENUMS::DiscoveryFilterListSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, GOClientTableSize ), sizeof( UINT8 ), ENUMS::GOClientTableSize, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, MaxVendorSpecificExtensionIESize ), sizeof( UINT32 ), ENUMS::MaxVendorSpecificExtensionIESize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, PassiveAvailabilityListenStateSupported ), sizeof( BOOLEAN ), ENUMS::PassiveAvailabilityListenStateSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_P2P_CAPABILITIES_V1_0_1, OperatingChannelUpdatesSupported ), sizeof( BOOLEAN ), ENUMS::OperatingChannelUpdatesSupported, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_P2P_CAPABILITIES_V1_0_1_HELPER::s_BinarySize, sizeof( WDI_P2P_CAPABILITIES_V1_0_1 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_DATAPATH_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_DATAPATH_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, InterconnectType ), sizeof( UINT32 ), ENUMS::InterconnectType, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, MaxNumPeers ), sizeof( UINT8 ), ENUMS::MaxNumPeers, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, TxTargetPriorityQueueing ), sizeof( UINT8 ), ENUMS::TxTargetPriorityQueueing, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, TxMaxScatterGatherElementsPerFrame ), sizeof( UINT16 ), ENUMS::TxMaxScatterGatherElementsPerFrame, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, TxExplicitSendCompleteFlagRequired ), sizeof( UINT8 ), ENUMS::TxExplicitSendCompleteFlagRequired, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, TxMinEffectiveFrameSize ), sizeof( UINT16 ), ENUMS::TxMinEffectiveFrameSize, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, TxFrameSizeGranularity ), sizeof( UINT16 ), ENUMS::TxFrameSizeGranularity, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, RxTxForwarding ), sizeof( UINT8 ), ENUMS::RxTxForwarding, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_DATAPATH_CAPABILITIES, RxMaxThroughput ), sizeof( UINT32 ), ENUMS::RxMaxThroughput, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_DATAPATH_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_DATAPATH_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CHANNEL_MAPPING_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CHANNEL_MAPPING_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_CHANNEL_MAPPING_ENTRY ), ENUMS::ChannelMappingEntry, ENUMS::WDI_CHANNEL_MAPPING_ENTRY, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_CHANNEL_MAPPING_ENTRY ), sizeof( WDI_CHANNEL_MAPPING_ENTRY ), TRUE, FALSE, FALSE, FALSE, 19 };
        }
    }
}

//
// Helpers for WDI_BAND_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BAND_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_BAND_CAPABILITIES, BandID ), sizeof( UINT32 ), ENUMS::BandID, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_BAND_CAPABILITIES, BandState ), sizeof( BOOLEAN ), ENUMS::BandState, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_BAND_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_BAND_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PHY_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PHY_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_PHY_CAPABILITIES, PhyType ), sizeof( WDI_PHY_TYPE ), ENUMS::PhyType, ENUMS::WDI_PHY_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_CAPABILITIES, SupportsCFPoll ), sizeof( UINT8 ), ENUMS::SupportsCFPoll, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_CAPABILITIES, MPDUMaxLength ), sizeof( UINT32 ), ENUMS::MPDUMaxLength, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_CAPABILITIES, TemperatureClass ), sizeof( UINT32 ), ENUMS::TemperatureClass, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PHY_CAPABILITIES, DiversitySupport ), sizeof( UINT32 ), ENUMS::DiversitySupport, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_PHY_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_PHY_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PHY_DATA_RATE_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PHY_DATA_RATE_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_DATA_RATE_LIST, DataRateFlag ), sizeof( UINT8 ), ENUMS::DataRateFlag, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_DATA_RATE_LIST, DataRateValue ), sizeof( UINT16 ), ENUMS::DataRateValue, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_DATA_RATE_LIST_HELPER::s_BinarySize, sizeof( WDI_DATA_RATE_LIST ), TRUE, FALSE, FALSE, FALSE, 20 };
        }
    }
}

//
// Helpers for WDI_PM_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PM_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, Flags ), sizeof( UINT32 ), ENUMS::Flags, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, SupportedWoLPacketPatterns ), sizeof( UINT32 ), ENUMS::SupportedWoLPacketPatterns, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, NumTotalWoLPatterns ), sizeof( UINT32 ), ENUMS::NumTotalWoLPatterns, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, MaxWoLPatternSize ), sizeof( UINT32 ), ENUMS::MaxWoLPatternSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, MaxWoLPatternOffset ), sizeof( UINT32 ), ENUMS::MaxWoLPatternOffset, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, MaxWoLPacketSaveBuffer ), sizeof( UINT32 ), ENUMS::MaxWoLPacketSaveBuffer, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, SupportedProtocolOffloads ), sizeof( UINT32 ), ENUMS::SupportedProtocolOffloads, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, NumArpOffloadIPv4Addresses ), sizeof( UINT32 ), ENUMS::NumArpOffloadIPv4Addresses, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, NumNSOffloadIPv6Addresses ), sizeof( UINT32 ), ENUMS::NumNSOffloadIPv6Addresses, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, MinMagicPacketWakeUp ), sizeof( NDIS_DEVICE_POWER_STATE ), ENUMS::MinMagicPacketWakeUp, ENUMS::NDIS_DEVICE_POWER_STATE, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, MinPatternWakeUp ), sizeof( NDIS_DEVICE_POWER_STATE ), ENUMS::MinPatternWakeUp, ENUMS::NDIS_DEVICE_POWER_STATE, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, MinLinkChangeWakeUp ), sizeof( NDIS_DEVICE_POWER_STATE ), ENUMS::MinLinkChangeWakeUp, ENUMS::NDIS_DEVICE_POWER_STATE, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, SupportedWakeUpEvents ), sizeof( UINT32 ), ENUMS::SupportedWakeUpEvents, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_PM_CAPABILITIES, MediaSpecificWakeUpEvents ), sizeof( UINT32 ), ENUMS::MediaSpecificWakeUpEvents, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_PM_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_PM_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_RECEIVE_COALESCING_CAPABILITIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_RECEIVE_COALESCING_CAPABILITIES_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, EnableFilterTypes ), sizeof( UINT32 ), ENUMS::EnableFilterTypes, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, EnabledQueueTypes ), sizeof( UINT32 ), ENUMS::EnabledQueueTypes, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, NumQueues ), sizeof( UINT32 ), ENUMS::NumQueues, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, SupportedQueueProperties ), sizeof( UINT32 ), ENUMS::SupportedQueueProperties, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, SupportedFilterTests ), sizeof( UINT32 ), ENUMS::SupportedFilterTests, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, SupportedHeaders ), sizeof( UINT32 ), ENUMS::SupportedHeaders, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, SupportedMacHeaderFields ), sizeof( UINT32 ), ENUMS::SupportedMacHeaderFields, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, MaxMacHeaderFilters ), sizeof( UINT32 ), ENUMS::MaxMacHeaderFilters, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, MaxQueueGroups ), sizeof( UINT32 ), ENUMS::MaxQueueGroups, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, MaxQueuesPerQueueGroup ), sizeof( UINT32 ), ENUMS::MaxQueuesPerQueueGroup, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, MinLookaheadSplitSize ), sizeof( UINT32 ), ENUMS::MinLookaheadSplitSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, MaxLookaheadSplitSize ), sizeof( UINT32 ), ENUMS::MaxLookaheadSplitSize, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, SupportedARPHeaderFields ), sizeof( UINT32 ), ENUMS::SupportedARPHeaderFields, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, SupportedIPv4HeaderFields ), sizeof( UINT32 ), ENUMS::SupportedIPv4HeaderFields, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, SupportedIPv6HeaderFields ), sizeof( UINT32 ), ENUMS::SupportedIPv6HeaderFields, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, SupportedUdpHeaderFields ), sizeof( UINT32 ), ENUMS::SupportedUdpHeaderFields, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, MaxFieldTestsPerPacketCoalescingFilter ), sizeof( UINT32 ), ENUMS::MaxFieldTestsPerPacketCoalescingFilter, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CAPABILITIES, MaxPacketCoalescingFilters ), sizeof( UINT32 ), ENUMS::MaxPacketCoalescingFilters, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_RECEIVE_COALESCING_CAPABILITIES_HELPER::s_BinarySize, sizeof( WDI_RECEIVE_COALESCING_CAPABILITIES ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_PRIVACY_EXEMPTION_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PRIVACY_EXEMPTION_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_PRIVACY_EXEMPTION_PARAMETERS_STRUCT, EtherType ), sizeof( UINT16 ), ENUMS::EtherType, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_PRIVACY_EXEMPTION_PARAMETERS_STRUCT, ExemptionActionType ), sizeof( WDI_EXEMPTION_ACTION_TYPE ), ENUMS::ExemptionActionType, ENUMS::WDI_EXEMPTION_ACTION_TYPE, 1 },
                { TLV_FIELD_OFFSET( WDI_PRIVACY_EXEMPTION_PARAMETERS_STRUCT, ExemptionPacketType ), sizeof( WDI_EXEMPTION_PACKET_TYPE ), ENUMS::ExemptionPacketType, ENUMS::WDI_EXEMPTION_PACKET_TYPE, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_PRIVACY_EXEMPTION_PARAMETERS_STRUCT_HELPER::s_BinarySize, sizeof( WDI_PRIVACY_EXEMPTION_PARAMETERS_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_STATION_ATTRIBUTES_CONTAINER * pField )
        {
            pField->UnicastAlgorithms.MemoryInternallyAllocated = FALSE;
            pField->MulticastDataAlgorithms.MemoryInternallyAllocated = FALSE;
            pField->MulticastManagementAlgorithms.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_STATION_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_STATION_ATTRIBUTES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_STATION_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_STATION_CAPABILITIES, TLV_FIELD_OFFSET( WDI_STATION_ATTRIBUTES_CONTAINER, StationCapabilities ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_UNICAST_ALGORITHM_LIST, TLV_FIELD_OFFSET( WDI_STATION_ATTRIBUTES_CONTAINER, UnicastAlgorithms ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_MULTICAST_DATA_ALGORITHM_LIST, TLV_FIELD_OFFSET( WDI_STATION_ATTRIBUTES_CONTAINER, MulticastDataAlgorithms ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_MULTICAST_MGMT_ALGORITHM_LIST, TLV_FIELD_OFFSET( WDI_STATION_ATTRIBUTES_CONTAINER, MulticastManagementAlgorithms ), TRUE, FALSE, 0, TRUE, 2 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_STATION_ATTRIBUTES_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_AP_ATTRIBUTES_CONTAINER * pField )
        {
            pField->UnicastAlgorithms.MemoryInternallyAllocated = FALSE;
            pField->MulticastDataAlgorithms.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_AP_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_AP_ATTRIBUTES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_AP_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_AP_CAPABILITIES, TLV_FIELD_OFFSET( WDI_AP_ATTRIBUTES_CONTAINER, APCapabilities ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_UNICAST_ALGORITHM_LIST, TLV_FIELD_OFFSET( WDI_AP_ATTRIBUTES_CONTAINER, UnicastAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_MULTICAST_DATA_ALGORITHM_LIST, TLV_FIELD_OFFSET( WDI_AP_ATTRIBUTES_CONTAINER, MulticastDataAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_AP_ATTRIBUTES_CONTAINER ) };
        }
    }
}


//
// Helpers for WDI_VIRTUALIZATION_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_VIRTUALIZATION_ATTRIBUTES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_VIRTUALIZATION_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_VIRTUALIZATION_CAPABILITIES, TLV_FIELD_OFFSET( WDI_VIRTUALIZATION_ATTRIBUTES_CONTAINER, VirtualizationCapabilities ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_VIRTUALIZATION_ATTRIBUTES_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_ATTRIBUTES_CONTAINER * pField )
        {
            pField->InterfaceAddressList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_ATTRIBUTES_CONTAINER_HELPER
        {
            static const VERSION_INFO s_versionedField0 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_20, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper1( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_P2P_CAPABILITIES>( p, (const WDI_P2P_CAPABILITIES_CONTAINER *)i, s, c, (WDI_P2P_CAPABILITIES_CONTAINER_V1_0_10 *)o); }
            static NDIS_STATUS ParseHelper1( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_P2P_CAPABILITIES>( (WDI_P2P_CAPABILITIES_CONTAINER_V1_0_10 *)i, c, (WDI_P2P_CAPABILITIES_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField1 = { NULL, &GenerateHelper1, NULL, &ParseHelper1, WDI_VERSION_1_0_10, WDI_VERSION_1_0_20, 0 };
            static NDIS_STATUS GenerateHelper2( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_P2P_CAPABILITIES>( p, (const WDI_P2P_CAPABILITIES_CONTAINER *)i, s, c, (WDI_P2P_CAPABILITIES_CONTAINER_V1_0_1 *)o); }
            static NDIS_STATUS ParseHelper2( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_P2P_CAPABILITIES>( (WDI_P2P_CAPABILITIES_CONTAINER_V1_0_1 *)i, c, (WDI_P2P_CAPABILITIES_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField2 = { NULL, &GenerateHelper2, NULL, &ParseHelper2, 0, WDI_VERSION_1_0_10, 0 };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CAPABILITIES_CONTAINER_HELPER::s_Container, &s_versionedField0, (ENUMS::TLV_ID)WDI_TLV_P2P_CAPABILITIES, TLV_FIELD_OFFSET( WDI_P2P_ATTRIBUTES_CONTAINER, P2PCapabilities ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CAPABILITIES_CONTAINER_V1_0_10_HELPER::s_Container, &s_versionedField1, (ENUMS::TLV_ID)WDI_TLV_P2P_CAPABILITIES, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CAPABILITIES_CONTAINER_V1_0_1_HELPER::s_Container, &s_versionedField2, (ENUMS::TLV_ID)WDI_TLV_P2P_CAPABILITIES, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INTERFACE_ADDRESS_LIST, TLV_FIELD_OFFSET( WDI_P2P_ATTRIBUTES_CONTAINER, InterfaceAddressList ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_ATTRIBUTES_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_BAND_INFO_CONTAINER * pField )
        {
            pField->ValidPhyTypes.MemoryInternallyAllocated = FALSE;
            pField->ValidChannelTypes.MemoryInternallyAllocated = FALSE;
            pField->ChannelWidthList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_BAND_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BAND_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BAND_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BAND_CAPABILITIES, TLV_FIELD_OFFSET( WDI_BAND_INFO_CONTAINER, BandCapabilities ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_TYPE_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_TYPE_LIST, TLV_FIELD_OFFSET( WDI_BAND_INFO_CONTAINER, ValidPhyTypes ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHANNEL_MAPPING_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHANNEL_LIST, TLV_FIELD_OFFSET( WDI_BAND_INFO_CONTAINER, ValidChannelTypes ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHANNEL_WIDTH_LIST, TLV_FIELD_OFFSET( WDI_BAND_INFO_CONTAINER, ChannelWidthList ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_BAND_INFO_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_PHY_INFO_CONTAINER * pField )
        {
            pField->TxPowerLevelList.MemoryInternallyAllocated = FALSE;
            pField->DataRateList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_PHY_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PHY_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_CAPABILITIES, TLV_FIELD_OFFSET( WDI_PHY_INFO_CONTAINER, PhyCapabilities ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_TX_POWER_LEVEL_LIST, TLV_FIELD_OFFSET( WDI_PHY_INFO_CONTAINER, TxPowerLevelList ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_DATA_RATE_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_DATA_RATE_LIST, TLV_FIELD_OFFSET( WDI_PHY_INFO_CONTAINER, DataRateList ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_PHY_INFO_CONTAINER ) };
        }
    }
}


//
// Helpers for WDI_COMMUNICATION_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_COMMUNICATION_ATTRIBUTES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_COMMUNICATION_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_COMMUNICATION_CAPABILITIES, TLV_FIELD_OFFSET( WDI_COMMUNICATION_ATTRIBUTES_CONTAINER, CommunicationCapabilities ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_COMMUNICATION_ATTRIBUTES_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_INTERFACE_ATTRIBUTES_CONTAINER * pField )
        {
            pField->FirmwareVersion.MemoryInternallyAllocated = FALSE;
            pField->NonWdiOidsList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_INTERFACE_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INTERFACE_ATTRIBUTES_CONTAINER_HELPER
        {
            static const VERSION_INFO s_versionedField0 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_20, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper1( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_INTERFACE_CAPABILITIES>( p, (const WDI_INTERFACE_CAPABILITIES_CONTAINER *)i, s, c, (WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_1 *)o); }
            static NDIS_STATUS ParseHelper1( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_INTERFACE_CAPABILITIES>( (WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_1 *)i, c, (WDI_INTERFACE_CAPABILITIES_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField1 = { NULL, &GenerateHelper1, NULL, &ParseHelper1, WDI_VERSION_1_0_1, WDI_VERSION_1_0_20, 0 };
            static NDIS_STATUS GenerateHelper2( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_INTERFACE_CAPABILITIES>( p, (const WDI_INTERFACE_CAPABILITIES_CONTAINER *)i, s, c, (WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0 *)o); }
            static NDIS_STATUS ParseHelper2( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_INTERFACE_CAPABILITIES>( (WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0 *)i, c, (WDI_INTERFACE_CAPABILITIES_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField2 = { NULL, &GenerateHelper2, NULL, &ParseHelper2, 0, WDI_VERSION_1_0_1, 0 };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_INTERFACE_CAPABILITIES_CONTAINER_HELPER::s_Container, &s_versionedField0, (ENUMS::TLV_ID)WDI_TLV_INTERFACE_CAPABILITIES, TLV_FIELD_OFFSET( WDI_INTERFACE_ATTRIBUTES_CONTAINER, InterfaceCapabilities ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_1_HELPER::s_Container, &s_versionedField1, (ENUMS::TLV_ID)WDI_TLV_INTERFACE_CAPABILITIES, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_HELPER::s_Container, &s_versionedField2, (ENUMS::TLV_ID)WDI_TLV_INTERFACE_CAPABILITIES, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_STRING_Z_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FIRMWARE_VERSION, TLV_FIELD_OFFSET( WDI_INTERFACE_ATTRIBUTES_CONTAINER, FirmwareVersion ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IHV_NON_WDI_OIDS_LIST, TLV_FIELD_OFFSET( WDI_INTERFACE_ATTRIBUTES_CONTAINER, NonWdiOidsList ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INTERFACE_ATTRIBUTES_CONTAINER ) };
        }
    }
}


//
// Helpers for WDI_DATAPATH_ATTRIBUTES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_DATAPATH_ATTRIBUTES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_DATAPATH_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DATAPATH_CAPABILITIES, TLV_FIELD_OFFSET( WDI_DATAPATH_ATTRIBUTES_CONTAINER, DataPathCapabilities ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_DATAPATH_ATTRIBUTES_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_RADIO_STATUS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_RADIO_STATUS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_RADIO_STATUS, HardwareState ), sizeof( BOOLEAN ), ENUMS::HardwareState, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_RADIO_STATUS, SoftwareState ), sizeof( BOOLEAN ), ENUMS::SoftwareState, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_RADIO_STATUS_HELPER::s_BinarySize, sizeof( WDI_RADIO_STATUS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_GET_AUTO_POWER_SAVE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_AUTO_POWER_SAVE_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, EnableAutoPSM ), sizeof( UINT8 ), ENUMS::EnableAutoPSM, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, bReserved ), sizeof( UINT8 ), ENUMS::bReserved, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, wReserved ), sizeof( UINT16 ), ENUMS::wReserved, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, BeaconInterval ), sizeof( UINT16 ), ENUMS::BeaconInterval, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, ListenInterval ), sizeof( UINT8 ), ENUMS::ListenInterval, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, ListenIntervalInDx ), sizeof( UINT8 ), ENUMS::ListenIntervalInDx, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, PowerMode ), sizeof( WDI_POWER_SAVE_LEVEL ), ENUMS::PowerMode, ENUMS::WDI_POWER_SAVE_LEVEL, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, PowerModeinDx ), sizeof( WDI_POWER_SAVE_LEVEL ), ENUMS::PowerModeinDx, ENUMS::WDI_POWER_SAVE_LEVEL, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, Reason ), sizeof( WDI_POWER_MODE_REASON_CODE ), ENUMS::Reason, ENUMS::WDI_POWER_MODE_REASON_CODE, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, MillisecondsSinceStart ), sizeof( UINT64 ), ENUMS::MillisecondsSinceStart, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, MillisecondsInPowerSave ), sizeof( UINT64 ), ENUMS::MillisecondsInPowerSave, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, ReceivedMulticastPackets ), sizeof( UINT64 ), ENUMS::ReceivedMulticastPackets, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, SentMulticastPackets ), sizeof( UINT64 ), ENUMS::SentMulticastPackets, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, ReceivedUnicastPackets ), sizeof( UINT64 ), ENUMS::ReceivedUnicastPackets, ENUMS::UINT64, 1 },
                { TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_STRUCT, SentUnicastPacket ), sizeof( UINT64 ), ENUMS::SentUnicastPacket, ENUMS::UINT64, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_GET_AUTO_POWER_SAVE_STRUCT_HELPER::s_BinarySize, sizeof( WDI_GET_AUTO_POWER_SAVE_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CONNECTION_SETTINGS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CONNECTION_SETTINGS_CONTAINER_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvConnectionSettings[] =
            {
                { WDI_TLV_CONNECT_PARAMETERS, WDI_VERSION_1_0_1, 0xFFFFFFFFul, FALSE, FALSE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGS, RoamRequest ), sizeof( BOOLEAN ), ENUMS::RoamRequest, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGS, HiddenNetwork ), sizeof( BOOLEAN ), ENUMS::HiddenNetwork, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGS, ExcludeUnencrypted ), sizeof( BOOLEAN ), ENUMS::ExcludeUnencrypted, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGS, MFPEnabled ), sizeof( BOOLEAN ), ENUMS::MFPEnabled, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGS, HostFIPSModeEnabled ), sizeof( BOOLEAN ), ENUMS::HostFIPSModeEnabled, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGS, RoamNeededReason ), sizeof( UINT32 ), ENUMS::RoamNeededReason, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGS, RoamTrigger ), sizeof( WDI_ROAM_TRIGGER ), ENUMS::RoamTrigger, ENUMS::WDI_ROAM_TRIGGER, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGS, BSSTransitionSupported ), sizeof( BOOLEAN ), ENUMS::BSSTransitionSupported, ENUMS::BOOLEAN, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CONNECTION_SETTINGS_HELPER::s_BinarySize, sizeof( WDI_CONNECTION_SETTINGS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CONNECTION_SETTINGS_CONTAINER_V1_0
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CONNECTION_SETTINGS_CONTAINER_V1_0_HELPER
        {
            static const DUMPER::CONTAINER_REF s_RefsWdiTlvConnectionSettings[] =
            {
                { WDI_TLV_CONNECT_PARAMETERS, 0, WDI_VERSION_1_0_1, FALSE, FALSE },
            };
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGSV1_0, RoamRequest ), sizeof( BOOLEAN ), ENUMS::RoamRequest, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGSV1_0, HiddenNetwork ), sizeof( BOOLEAN ), ENUMS::HiddenNetwork, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGSV1_0, ExcludeUnencrypted ), sizeof( BOOLEAN ), ENUMS::ExcludeUnencrypted, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGSV1_0, MFPEnabled ), sizeof( BOOLEAN ), ENUMS::MFPEnabled, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGSV1_0, HostFIPSModeEnabled ), sizeof( BOOLEAN ), ENUMS::HostFIPSModeEnabled, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGSV1_0, RoamNeededReason ), sizeof( UINT32 ), ENUMS::RoamNeededReason, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_CONNECTION_SETTINGSV1_0, RoamTrigger ), sizeof( WDI_ROAM_TRIGGER ), ENUMS::RoamTrigger, ENUMS::WDI_ROAM_TRIGGER, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CONNECTION_SETTINGSV1_0_HELPER::s_BinarySize, sizeof( WDI_CONNECTION_SETTINGSV1_0 ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_ASSOCIATION_RESULT_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ASSOCIATION_RESULT_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, AssociationStatus ), sizeof( WDI_ASSOC_STATUS ), ENUMS::AssociationStatus, ENUMS::WDI_ASSOC_STATUS, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, StatusCode ), sizeof( UINT32 ), ENUMS::StatusCode, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, ReAssociation ), sizeof( BOOLEAN ), ENUMS::ReAssociation, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, AuthAlgorithm ), sizeof( WDI_AUTH_ALGORITHM ), ENUMS::AuthAlgorithm, ENUMS::WDI_AUTH_ALGORITHM, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, UnicastCipherAlgorithm ), sizeof( WDI_CIPHER_ALGORITHM ), ENUMS::UnicastCipherAlgorithm, ENUMS::WDI_CIPHER_ALGORITHM, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, MulticastDataCipherAlgorithm ), sizeof( WDI_CIPHER_ALGORITHM ), ENUMS::MulticastDataCipherAlgorithm, ENUMS::WDI_CIPHER_ALGORITHM, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, MulticastMgmtCipherAlgorithm ), sizeof( WDI_CIPHER_ALGORITHM ), ENUMS::MulticastMgmtCipherAlgorithm, ENUMS::WDI_CIPHER_ALGORITHM, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, FourAddressSupported ), sizeof( BOOLEAN ), ENUMS::FourAddressSupported, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, PortAuthorized ), sizeof( BOOLEAN ), ENUMS::PortAuthorized, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, WMMQoSEnabled ), sizeof( BOOLEAN ), ENUMS::WMMQoSEnabled, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, DSInfo ), sizeof( WDI_DS_INFO ), ENUMS::DSInfo, ENUMS::WDI_DS_INFO, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, AssociationComebackTime ), sizeof( UINT32 ), ENUMS::AssociationComebackTime, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, BandID ), sizeof( WDI_BAND_ID ), ENUMS::BandID, ENUMS::WDI_BAND_ID, 1 },
                { TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_PARAMETERS, IHVAssociationStatus ), sizeof( UINT32 ), ENUMS::IHVAssociationStatus, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_ASSOCIATION_RESULT_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_ASSOCIATION_RESULT_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_ETHERTYPE_ENCAPSULATION_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ETHERTYPE_ENCAPSULATION_LIST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( WDI_ETHERTYPE_ENCAPSULATION_ENTRY ), ENUMS::EtherTypeEncapsulations, ENUMS::WDI_ETHERTYPE_ENCAPSULATION_ENTRY, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( WDI_ETHERTYPE_ENCAPSULATION_ENTRY ), sizeof( WDI_ETHERTYPE_ENCAPSULATION_ENTRY ), TRUE, FALSE, FALSE, FALSE, 21 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_FT_REASSOC_PARAMETERS_CONTAINER * pField )
        {
            pField->MDE.MemoryInternallyAllocated = FALSE;
            pField->FTE.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_FT_REASSOC_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_FT_REASSOC_PARAMETERS_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_MDE, TLV_FIELD_OFFSET( WDI_FT_REASSOC_PARAMETERS_CONTAINER, MDE ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_FTE, TLV_FIELD_OFFSET( WDI_FT_REASSOC_PARAMETERS_CONTAINER, FTE ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_TYPE_PMK_NAME_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_PMKR0NAME, TLV_FIELD_OFFSET( WDI_FT_REASSOC_PARAMETERS_CONTAINER, PMKR0Name ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_FT_REASSOC_PARAMETERS_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_FT_INITIAL_ASSOC_PARAMETERS_CONTAINER * pField )
        {
            pField->MDE.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_FT_INITIAL_ASSOC_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_FT_INITIAL_ASSOC_PARAMETERS_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_MDE, TLV_FIELD_OFFSET( WDI_FT_INITIAL_ASSOC_PARAMETERS_CONTAINER, MDE ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_FT_INITIAL_ASSOC_PARAMETERS_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_HESSID_INFO_CONTAINER * pField )
        {
            pField->HESSIDList.MemoryInternallyAllocated = FALSE;
            pField->HSIndicationElement.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_HESSID_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_HESSID_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ACCESS_NETWORK_TYPE, TLV_FIELD_OFFSET( WDI_HESSID_INFO_CONTAINER, AccessNetworkType ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_HESSID, TLV_FIELD_OFFSET( WDI_HESSID_INFO_CONTAINER, HESSIDList ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_HOTSPOT_INDICATION_ELEMENT, TLV_FIELD_OFFSET( WDI_HESSID_INFO_CONTAINER, HSIndicationElement ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_HESSID_INFO_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_CONNECT_PARAMETERS_CONTAINER * pField )
        {
            pField->SSIDList.MemoryInternallyAllocated = FALSE;
            pField->HESSIDInfo.HESSIDList.MemoryInternallyAllocated = FALSE;
            pField->HESSIDInfo.HSIndicationElement.MemoryInternallyAllocated = FALSE;
            pField->AuthenticationAlgorithms.MemoryInternallyAllocated = FALSE;
            pField->MulticastCipherAlgorithms.MemoryInternallyAllocated = FALSE;
            pField->UnicastCipherAlgorithms.MemoryInternallyAllocated = FALSE;
            pField->AssociationRequestVendorIE.MemoryInternallyAllocated = FALSE;
            pField->ActivePhyTypeList.MemoryInternallyAllocated = FALSE;
            pField->DisallowedBSSIDs.MemoryInternallyAllocated = FALSE;
            pField->AllowedBSSIDs.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_CONNECT_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CONNECT_PARAMETERS_CONTAINER_HELPER
        {
            static const VERSION_INFO s_versionedField0 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_1, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper1( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_CONNECTION_SETTINGS>( p, (const WDI_CONNECTION_SETTINGS_CONTAINER *)i, s, c, (WDI_CONNECTION_SETTINGS_CONTAINER_V1_0 *)o); }
            static NDIS_STATUS ParseHelper1( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_CONNECTION_SETTINGS>( (WDI_CONNECTION_SETTINGS_CONTAINER_V1_0 *)i, c, (WDI_CONNECTION_SETTINGS_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField1 = { NULL, &GenerateHelper1, NULL, &ParseHelper1, 0, WDI_VERSION_1_0_1, 0 };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CONNECTION_SETTINGS_CONTAINER_HELPER::s_Container, &s_versionedField0, (ENUMS::TLV_ID)WDI_TLV_CONNECTION_SETTINGS, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, ConnectionSettings ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CONNECTION_SETTINGS_CONTAINER_V1_0_HELPER::s_Container, &s_versionedField1, (ENUMS::TLV_ID)WDI_TLV_CONNECTION_SETTINGS, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SSID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SSID, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, SSIDList ), TRUE, TRUE, 22, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_HESSID_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_HESSID_INFO, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, HESSIDInfo ), FALSE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_AUTH_ALGORITHM_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_AUTH_ALGO_LIST, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, AuthenticationAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_ALGORITHM_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_MULTICAST_CIPHER_ALGO_LIST, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, MulticastCipherAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_ALGORITHM_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_UNICAST_CIPHER_ALGO_LIST, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, UnicastCipherAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_EXTRA_ASSOCIATION_REQUEST_IES, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, AssociationRequestVendorIE ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_TYPE_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_TYPE_LIST, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, ActivePhyTypeList ), TRUE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DISALLOWED_BSSIDS_LIST, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, DisallowedBSSIDs ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ALLOWED_BSSIDS_LIST, TLV_FIELD_OFFSET( WDI_CONNECT_PARAMETERS_CONTAINER, AllowedBSSIDs ), TRUE, FALSE, 0, TRUE, 4 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_CONNECT_PARAMETERS_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_BSS_SELECTION_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_BSS_SELECTION_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_BSS_SELECTION_PARAMETERS_CONTAINER, SelectionFlags ), sizeof( UINT32 ), ENUMS::SelectionFlags, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_BSS_SELECTION_PARAMETERS_CONTAINER_HELPER::s_BinarySize, sizeof( WDI_BSS_SELECTION_PARAMETERS_CONTAINER ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_CONNECT_BSS_ENTRY_CONTAINER * pField )
        {
            pField->ProbeResponseFrame.MemoryInternallyAllocated = FALSE;
            pField->BeaconFrame.MemoryInternallyAllocated = FALSE;
            pField->DeviceSpecificContext.MemoryInternallyAllocated = FALSE;
            pField->PMKID.MemoryInternallyAllocated = FALSE;
            pField->AssociationRequestVendorIE.MemoryInternallyAllocated = FALSE;
            pField->FTInitialAssocParameters.MDE.MemoryInternallyAllocated = FALSE;
            pField->FTReAssocParameters.MDE.MemoryInternallyAllocated = FALSE;
            pField->FTReAssocParameters.FTE.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_CONNECT_BSS_ENTRY_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CONNECT_BSS_ENTRY_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSSID, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, BSSID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PROBE_RESPONSE_FRAME, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, ProbeResponseFrame ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BEACON_FRAME, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, BeaconFrame ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SIGNAL_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY_SIGNAL_INFO, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, SignalInfo ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHANNEL_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY_CHANNEL_INFO, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, ChannelInfo ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY_DEVICE_CONTEXT, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, DeviceSpecificContext ), TRUE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PMKID, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, PMKID ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_EXTRA_ASSOCIATION_REQUEST_IES, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, AssociationRequestVendorIE ), TRUE, FALSE, 0, TRUE, 4 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_FT_INITIAL_ASSOC_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_INITIAL_ASSOC_PARAMETERS, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, FTInitialAssocParameters ), FALSE, FALSE, 0, TRUE, 5 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_FT_REASSOC_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_REASSOC_PARAMETERS, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, FTReAssocParameters ), FALSE, FALSE, 0, TRUE, 6 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BSS_SELECTION_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_SELECTION_PARAMETERS, TLV_FIELD_OFFSET( WDI_CONNECT_BSS_ENTRY_CONTAINER, BSSSelectionParameters ), TRUE, FALSE, 0, TRUE, 7 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_CONNECT_BSS_ENTRY_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_ASSOCIATION_RESULT_CONTAINER * pField )
        {
            pField->AssociationRequestFrame.MemoryInternallyAllocated = FALSE;
            pField->AssociationResponseFrame.MemoryInternallyAllocated = FALSE;
            pField->AuthenticationResponseFrame.MemoryInternallyAllocated = FALSE;
            pField->BeaconProbeResponse.MemoryInternallyAllocated = FALSE;
            pField->EthertypeEncapTable.MemoryInternallyAllocated = FALSE;
            pField->ActivePhyTypeList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_ASSOCIATION_RESULT_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_ASSOCIATION_RESULT_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSSID, TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_CONTAINER, BSSID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ASSOCIATION_RESULT_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_RESULT_PARAMETERS, TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_CONTAINER, AssociationResultParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_REQUEST_FRAME, TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_CONTAINER, AssociationRequestFrame ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_RESPONSE_FRAME, TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_CONTAINER, AssociationResponseFrame ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_AUTHENTICATION_RESPONSE_FRAME, TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_CONTAINER, AuthenticationResponseFrame ), TRUE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BEACON_PROBE_RESPONSE, TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_CONTAINER, BeaconProbeResponse ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ETHERTYPE_ENCAPSULATION_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ETHERTYPE_ENCAP_TABLE, TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_CONTAINER, EthertypeEncapTable ), TRUE, FALSE, 0, TRUE, 4 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_TYPE_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_TYPE_LIST, TLV_FIELD_OFFSET( WDI_ASSOCIATION_RESULT_CONTAINER, ActivePhyTypeList ), TRUE, FALSE, 0, TRUE, 5 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_ASSOCIATION_RESULT_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_TKIP_MIC_FAILURE_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TKIP_MIC_FAILURE_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_TKIP_MIC_FAILURE_PARAMETERS, DefaultKeyFailure ), sizeof( BOOLEAN ), ENUMS::DefaultKeyFailure, ENUMS::BOOLEAN, 1 },
                { TLV_FIELD_OFFSET( WDI_TKIP_MIC_FAILURE_PARAMETERS, KeyIndex ), sizeof( UINT32 ), ENUMS::KeyIndex, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_TKIP_MIC_FAILURE_PARAMETERS, PeerMacAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::PeerMacAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_TKIP_MIC_FAILURE_PARAMETERS_HELPER::s_BinarySize, sizeof( WDI_TKIP_MIC_FAILURE_PARAMETERS ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CIPHER_KEY_ID_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CIPHER_KEY_ID_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CIPHER_KEY_ID_STRUCT, CipherKeyID ), sizeof( UINT32 ), ENUMS::CipherKeyID, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CIPHER_KEY_ID_STRUCT_HELPER::s_BinarySize, sizeof( WDI_CIPHER_KEY_ID_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_SET_DEFAULT_KEY_ID_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_DEFAULT_KEY_ID_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_SET_DEFAULT_KEY_ID_STRUCT, KeyID ), sizeof( UINT32 ), ENUMS::KeyID, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_SET_DEFAULT_KEY_ID_STRUCT_HELPER::s_BinarySize, sizeof( WDI_SET_DEFAULT_KEY_ID_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_CIPHER_KEY_TYPE_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CIPHER_KEY_TYPE_INFO_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_CIPHER_KEY_TYPE_STRUCT, CipherAlgorithm ), sizeof( WDI_CIPHER_ALGORITHM ), ENUMS::CipherAlgorithm, ENUMS::WDI_CIPHER_ALGORITHM, 1 },
                { TLV_FIELD_OFFSET( WDI_CIPHER_KEY_TYPE_STRUCT, Direction ), sizeof( WDI_CIPHER_KEY_DIRECTION ), ENUMS::Direction, ENUMS::WDI_CIPHER_KEY_DIRECTION, 1 },
                { TLV_FIELD_OFFSET( WDI_CIPHER_KEY_TYPE_STRUCT, Static ), sizeof( UINT8 ), ENUMS::Static, ENUMS::UINT8, 1 },
                { TLV_FIELD_OFFSET( WDI_CIPHER_KEY_TYPE_STRUCT, KeyType ), sizeof( WDI_CIPHER_KEY_TYPE ), ENUMS::KeyType, ENUMS::WDI_CIPHER_KEY_TYPE, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_CIPHER_KEY_TYPE_STRUCT_HELPER::s_BinarySize, sizeof( WDI_CIPHER_KEY_TYPE_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_RECEIVE_SEQUENCE_COUNT_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_RECEIVE_SEQUENCE_COUNT_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_RECEIVE_SEQUENCE_COUNT_STRUCT, ReceiveSequenceCount ), (sizeof( UINT8 ) * 6), ENUMS::ReceiveSequenceCount, ENUMS::UINT8, 6 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_RECEIVE_SEQUENCE_COUNT_STRUCT_HELPER::s_BinarySize, sizeof( WDI_RECEIVE_SEQUENCE_COUNT_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_LINK_STATE_CHANGE_PARAMETERS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_LINK_STATE_CHANGE_PARAMETERS_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_LINK_STATE_CHANGE_PARAMETERS_STRUCT, PeerMACAddress ), sizeof( WDI_MAC_ADDRESS ), ENUMS::PeerMACAddress, ENUMS::WDI_MAC_ADDRESS, 1 },
                { TLV_FIELD_OFFSET( WDI_LINK_STATE_CHANGE_PARAMETERS_STRUCT, TxLinkSpeed ), sizeof( UINT32 ), ENUMS::TxLinkSpeed, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_LINK_STATE_CHANGE_PARAMETERS_STRUCT, RxLinkSpeed ), sizeof( UINT32 ), ENUMS::RxLinkSpeed, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_LINK_STATE_CHANGE_PARAMETERS_STRUCT, LinkQuality ), sizeof( UINT8 ), ENUMS::LinkQuality, ENUMS::UINT8, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_LINK_STATE_CHANGE_PARAMETERS_STRUCT_HELPER::s_BinarySize, sizeof( WDI_LINK_STATE_CHANGE_PARAMETERS_STRUCT ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_CIPHER_KEY_TKIP_INFO_CONTAINER * pField )
        {
            pField->TKIPKey.MemoryInternallyAllocated = FALSE;
            pField->TKIPMIC.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_CIPHER_KEY_TKIP_INFO_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_CIPHER_KEY_TKIP_INFO_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_TKIP_KEY, TLV_FIELD_OFFSET( WDI_CIPHER_KEY_TKIP_INFO_CONTAINER, TKIPKey ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_TKIP_MIC, TLV_FIELD_OFFSET( WDI_CIPHER_KEY_TKIP_INFO_CONTAINER, TKIPMIC ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_CIPHER_KEY_TKIP_INFO_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_SET_ADD_CIPHER_KEYS_CONTAINER * pField )
        {
            pField->CCMPKey.MemoryInternallyAllocated = FALSE;
            pField->GCMPKey.MemoryInternallyAllocated = FALSE;
            pField->TKIPInfo.TKIPKey.MemoryInternallyAllocated = FALSE;
            pField->TKIPInfo.TKIPMIC.MemoryInternallyAllocated = FALSE;
            pField->BIPKey.MemoryInternallyAllocated = FALSE;
            pField->WEPKey.MemoryInternallyAllocated = FALSE;
            pField->IHVKey.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_SET_ADD_CIPHER_KEYS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_ADD_CIPHER_KEYS_CONTAINER_HELPER
        {
            static const VERSION_INFO s_versionedField5 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_20, 0, 0xFFFFFFFF };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PEER_MAC_ADDRESS, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, PeerMacAddress ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_KEY_ID_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_ID, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, CipherKeyID ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_KEY_TYPE_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_TYPE_INFO, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, CipherKeyTypeInfo ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_RECEIVE_SEQUENCE_COUNT_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_RECEIVE_SEQUENCE_COUNT, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, ReceiveSequenceCount ), TRUE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_CCMP_KEY, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, CCMPKey ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container, &s_versionedField5, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_GCMP_KEY, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, GCMPKey ), TRUE, FALSE, 0, TRUE, 4 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_KEY_TKIP_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_TKIP_INFO, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, TKIPInfo ), FALSE, FALSE, 0, TRUE, 5 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_BIP_KEY, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, BIPKey ), TRUE, FALSE, 0, TRUE, 6 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_WEP_KEY, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, WEPKey ), TRUE, FALSE, 0, TRUE, 7 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_IHV_KEY, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_CONTAINER, IHVKey ), TRUE, FALSE, 0, TRUE, 8 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_ADD_CIPHER_KEYS_CONTAINER ) };
        }
    }
}


//
// Helpers for WDI_SET_DELETE_CIPHER_KEYS_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_DELETE_CIPHER_KEYS_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PEER_MAC_ADDRESS, TLV_FIELD_OFFSET( WDI_SET_DELETE_CIPHER_KEYS_CONTAINER, PeerMacAddress ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_KEY_ID_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_ID, TLV_FIELD_OFFSET( WDI_SET_DELETE_CIPHER_KEYS_CONTAINER, CipherKeyID ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_KEY_TYPE_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CIPHER_KEY_TYPE_INFO, TLV_FIELD_OFFSET( WDI_SET_DELETE_CIPHER_KEYS_CONTAINER, CipherKeyTypeInfo ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_DELETE_CIPHER_KEYS_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_NETWORK_LIST_OFFLOAD_CONFIG_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_NETWORK_LIST_OFFLOAD_CONFIG_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_NETWORK_LIST_OFFLOAD_CONFIG, ulFlags ), sizeof( UINT32 ), ENUMS::ulFlags, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_NETWORK_LIST_OFFLOAD_CONFIG, DelayStartInSeconds ), sizeof( UINT32 ), ENUMS::DelayStartInSeconds, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_NETWORK_LIST_OFFLOAD_CONFIG, FastScanPeriodinSeconds ), sizeof( UINT32 ), ENUMS::FastScanPeriodinSeconds, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_NETWORK_LIST_OFFLOAD_CONFIG, FastScanIterations ), sizeof( UINT32 ), ENUMS::FastScanIterations, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_NETWORK_LIST_OFFLOAD_CONFIG, SlowScanPeriodinSeconds ), sizeof( UINT32 ), ENUMS::SlowScanPeriodinSeconds, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_NETWORK_LIST_OFFLOAD_CONFIG_HELPER::s_BinarySize, sizeof( WDI_NETWORK_LIST_OFFLOAD_CONFIG ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_SSID_OFFLOAD_CONTAINER * pField )
        {
            pField->SsidToScan.MemoryInternallyAllocated = FALSE;
            pField->UnicastAlgorithms.MemoryInternallyAllocated = FALSE;
            pField->ChannellHintList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_SSID_OFFLOAD_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SSID_OFFLOAD_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SSID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SSID, TLV_FIELD_OFFSET( WDI_SSID_OFFLOAD_CONTAINER, SsidToScan ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_UNICAST_ALGORITHM_LIST, TLV_FIELD_OFFSET( WDI_SSID_OFFLOAD_CONTAINER, UnicastAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHANNEL_MAPPING_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHANNEL_LIST, TLV_FIELD_OFFSET( WDI_SSID_OFFLOAD_CONTAINER, ChannellHintList ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SSID_OFFLOAD_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_NETWORK_LIST_OFFLOAD_INFO * pField )
        {
            pField->SsidOffload.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_NETWORK_LIST_OFFLOAD_INFO
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_NETWORK_LIST_OFFLOAD_INFO_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_NETWORK_LIST_OFFLOAD_CONFIG_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_NETWORK_LIST_OFFLOAD_CONFIG, TLV_FIELD_OFFSET( WDI_NETWORK_LIST_OFFLOAD_INFO, NetworkListOffloadConfig ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SSID_OFFLOAD_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SSID_OFFLOAD, TLV_FIELD_OFFSET( WDI_NETWORK_LIST_OFFLOAD_INFO, SsidOffload ), FALSE, TRUE, 23, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_NETWORK_LIST_OFFLOAD_INFO ) };
        }
    }
}

//
// Helpers for WDI_WAKE_EVENT_MASK_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_WAKE_EVENT_MASK_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_WAKE_EVENT_MASK, EnabledWoLPacketPatterns ), sizeof( UINT32 ), ENUMS::EnabledWoLPacketPatterns, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_WAKE_EVENT_MASK, EnabledProtocolOffloads ), sizeof( UINT32 ), ENUMS::EnabledProtocolOffloads, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_WAKE_EVENT_MASK, WakeUpFlags ), sizeof( UINT32 ), ENUMS::WakeUpFlags, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_WAKE_EVENT_MASK, MediaSpecificWakeUpEvents ), sizeof( UINT32 ), ENUMS::MediaSpecificWakeUpEvents, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_WAKE_EVENT_MASK_HELPER::s_BinarySize, sizeof( WDI_WAKE_EVENT_MASK ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_RECEIVE_COALESCING_CONFIG_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_RECEIVE_COALESCING_CONFIG_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CONFIG, QueueId ), sizeof( UINT32 ), ENUMS::QueueId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CONFIG, FilterId ), sizeof( UINT32 ), ENUMS::FilterId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_CONFIG, MaxCoalescingDelay ), sizeof( UINT32 ), ENUMS::MaxCoalescingDelay, ENUMS::UINT32, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_RECEIVE_COALESCING_CONFIG_HELPER::s_BinarySize, sizeof( WDI_RECEIVE_COALESCING_CONFIG ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_RECEIVE_COALESCING_FIELD_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_RECEIVE_COALESCING_FIELD_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_FIELD, Flags ), sizeof( UINT32 ), ENUMS::Flags, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_FIELD, FrameHeader ), sizeof( NDIS_FRAME_HEADER ), ENUMS::FrameHeader, ENUMS::NDIS_FRAME_HEADER, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_FIELD, ReceiveFilterTest ), sizeof( NDIS_RECEIVE_FILTER_TEST ), ENUMS::ReceiveFilterTest, ENUMS::NDIS_RECEIVE_FILTER_TEST, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_FIELD, HeaderField ), sizeof( UINT32 ), ENUMS::HeaderField, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_FIELD, FieldValue ), sizeof( WDI_BYTE16 ), ENUMS::FieldValue, ENUMS::WDI_BYTE16, 1 },
                { TLV_FIELD_OFFSET( WDI_RECEIVE_COALESCING_FIELD, ResultValue ), sizeof( WDI_BYTE16 ), ENUMS::ResultValue, ENUMS::WDI_BYTE16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_RECEIVE_COALESCING_FIELD_HELPER::s_BinarySize, sizeof( WDI_RECEIVE_COALESCING_FIELD ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ ADD_RECEIVE_COALESCING_INFO * pField )
        {
            pField->ReceiveCoalescingField.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for ADD_RECEIVE_COALESCING_INFO
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace ADD_RECEIVE_COALESCING_INFO_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_RECEIVE_COALESCING_CONFIG_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_RECEIVE_COALESCING_CONFIG, TLV_FIELD_OFFSET( ADD_RECEIVE_COALESCING_INFO, ReceivingCoalesingConfig ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_RECEIVE_COALESCING_FIELD_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_RECEIVE_FILTER_FIELD, TLV_FIELD_OFFSET( ADD_RECEIVE_COALESCING_INFO, ReceiveCoalescingField ), TRUE, TRUE, 24, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( ADD_RECEIVE_COALESCING_INFO ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_PACKET_PATTERN_CONTAINER * pField )
        {
            pField->PacketPattern.MemoryInternallyAllocated = FALSE;
            pField->PacketPatternMask.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_PACKET_PATTERN_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_PACKET_PATTERN_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_WAKE_PACKET_BITMAP_PATTERN_ID, TLV_FIELD_OFFSET( WDI_PACKET_PATTERN_CONTAINER, WakePacketPatternId ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BITMAP_PATTERN, TLV_FIELD_OFFSET( WDI_PACKET_PATTERN_CONTAINER, PacketPattern ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BITMAP_PATTERN_MASK, TLV_FIELD_OFFSET( WDI_PACKET_PATTERN_CONTAINER, PacketPatternMask ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_PACKET_PATTERN_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_IPv4_TCP_SYNC_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_IPv4_TCP_SYNC_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_IPv4_TCP_SYNC, PatternId ), sizeof( UINT32 ), ENUMS::PatternId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_IPv4_TCP_SYNC, IPv4SourceAddr ), sizeof( WDI_BYTE4 ), ENUMS::IPv4SourceAddr, ENUMS::WDI_BYTE4, 1 },
                { TLV_FIELD_OFFSET( WDI_IPv4_TCP_SYNC, IPv4DestAddr ), sizeof( WDI_BYTE4 ), ENUMS::IPv4DestAddr, ENUMS::WDI_BYTE4, 1 },
                { TLV_FIELD_OFFSET( WDI_IPv4_TCP_SYNC, TcpSourcePort ), sizeof( UINT16 ), ENUMS::TcpSourcePort, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_IPv4_TCP_SYNC, TcpDestPort ), sizeof( UINT16 ), ENUMS::TcpDestPort, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_IPv4_TCP_SYNC_HELPER::s_BinarySize, sizeof( WDI_IPv4_TCP_SYNC ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

//
// Helpers for WDI_IPv6TCP_SYNC_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_IPv6TCP_SYNC_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { TLV_FIELD_OFFSET( WDI_IPv6TCP_SYNC, PatternId ), sizeof( UINT32 ), ENUMS::PatternId, ENUMS::UINT32, 1 },
                { TLV_FIELD_OFFSET( WDI_IPv6TCP_SYNC, IPv6SourceAddr ), sizeof( WDI_BYTE16 ), ENUMS::IPv6SourceAddr, ENUMS::WDI_BYTE16, 1 },
                { TLV_FIELD_OFFSET( WDI_IPv6TCP_SYNC, IPv6DestAddr ), sizeof( WDI_BYTE16 ), ENUMS::IPv6DestAddr, ENUMS::WDI_BYTE16, 1 },
                { TLV_FIELD_OFFSET( WDI_IPv6TCP_SYNC, TcpSourcePort ), sizeof( UINT16 ), ENUMS::TcpSourcePort, ENUMS::UINT16, 1 },
                { TLV_FIELD_OFFSET( WDI_IPv6TCP_SYNC, TcpDestPort ), sizeof( UINT16 ), ENUMS::TcpDestPort, ENUMS::UINT16, 1 },
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), PROPERTY_GROUPS::WDI_IPv6TCP_SYNC_HELPER::s_BinarySize, sizeof( WDI_IPv6TCP_SYNC ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_CHANNEL_ENTRIES_CONTAINER * pField )
        {
            pField->ChannelList.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_CHANNEL_ENTRIES_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_CHANNEL_ENTRIES_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_OPERATING_CLASS, TLV_FIELD_OFFSET( WDI_P2P_CHANNEL_ENTRIES_CONTAINER, OperatingClass ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHANNEL_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CHANNEL_INFO_LIST, TLV_FIELD_OFFSET( WDI_P2P_CHANNEL_ENTRIES_CONTAINER, ChannelList ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_CHANNEL_ENTRIES_CONTAINER ) };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ WDI_P2P_CHANNEL_LIST_CONTAINER * pField )
        {
            pField->CountryRegionList.MemoryInternallyAllocated = FALSE;
            pField->ChannelEntries.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for WDI_P2P_CHANNEL_LIST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_P2P_CHANNEL_LIST_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_COUNTRY_REGION_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_COUNTRY_REGION_LIST, TLV_FIELD_OFFSET( WDI_P2P_CHANNEL_LIST_CONTAINER, CountryRegionList ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_ENTRIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_ENTRY_LIST, TLV_FIELD_OFFSET( WDI_P2P_CHANNEL_LIST_CONTAINER, ChannelEntries ), FALSE, TRUE, 25, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_P2P_CHANNEL_LIST_CONTAINER ) };
        }
    }
}

//
// Helpers for TEST_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace TEST_CONTAINER_HELPER
        {
            static const FIELD_INFO s_rgFields[] =
            {
                { 0, sizeof( ULONG ), ENUMS::Field, ENUMS::ULONG, 1 }
            };
            static const CONTAINER_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( FIELD_INFO ), sizeof( ULONG ), sizeof( ULONG ), FALSE, FALSE, FALSE, FALSE, 0 };
        }
    }
}

namespace WDI_TLV
{
    namespace PARSER
    {
        void MarkArrayOfElementFieldsAsCopied( _Inout_ TEST_AGGREGATE_CONTAINER * pField )
        {
            pField->TestField.MemoryInternallyAllocated = FALSE;
        }
    }
}


//
// Helpers for TEST_AGGREGATE_CONTAINER
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace TEST_AGGREGATE_CONTAINER_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_TEST2, TLV_FIELD_OFFSET( TEST_AGGREGATE_CONTAINER, TestField ), TRUE, TRUE, 26, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( TEST_AGGREGATE_CONTAINER ) };
        }
    }
}

//
// Helpers for WDI_SCAN_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SCAN_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSSID, TLV_FIELD_OFFSET( WDI_SCAN_PARAMETERS, BSSID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SSID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SSID, TLV_FIELD_OFFSET( WDI_SCAN_PARAMETERS, SSIDList ), TRUE, TRUE, 22, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_VENDOR_SPECIFIC_IE, TLV_FIELD_OFFSET( WDI_SCAN_PARAMETERS, VendorIEs ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SCAN_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SCAN_MODE, TLV_FIELD_OFFSET( WDI_SCAN_PARAMETERS, ScanModeParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SCAN_DWELL_TIME_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SCAN_DWELL_TIME, TLV_FIELD_OFFSET( WDI_SCAN_PARAMETERS, DwellTime ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BAND_CHANNEL_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BAND_CHANNEL, TLV_FIELD_OFFSET( WDI_SCAN_PARAMETERS, BandChannelList ), FALSE, TRUE, 15, TRUE, 1 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SCAN_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_P2P_DISCOVER_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_P2P_DISCOVER_PARAMETERS_HELPER
        {
            static const VERSION_INFO s_versionedField7 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_20, 0, 0xFFFFFFFF };
            static const VERSION_INFO s_versionedField8 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_20, 0, 0xFFFFFFFF };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_DISCOVER_MODE_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DISCOVER_MODE, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, DiscoverMode ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SCAN_DWELL_TIME_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SCAN_DWELL_TIME, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, DwellTime ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DISCOVERY_CHANNEL_SETTINGS, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, DiscoveryChannelSettings ), FALSE, TRUE, 27, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SSID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SSID, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, SSIDList ), TRUE, TRUE, 22, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME_HASH, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, ServiceNameHash ), TRUE, TRUE, 28, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_VENDOR_SPECIFIC_IE, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, VendorIEs ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, ServiceInformationDiscoveryEntry ), FALSE, TRUE, 29, TRUE, 4 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER_HELPER::s_Container, &s_versionedField7, (ENUMS::TLV_ID)WDI_TLV_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, ASP2ServiceInformationDiscoveryEntry ), FALSE, TRUE, 30, TRUE, 5 },
                { (CONTAINER_INFO*)&CONTAINERS::BOOL_CONTAINER_HELPER::s_Container, &s_versionedField8, (ENUMS::TLV_ID)WDI_TLV_P2P_INCLUDE_LISTEN_CHANNEL, TLV_FIELD_OFFSET( WDI_TASK_P2P_DISCOVER_PARAMETERS, bIncludeListenChannel ), TRUE, FALSE, 0, TRUE, 6 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_P2P_DISCOVER_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_BACKGROUND_DISCOVER_MODE_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_BACKGROUND_DISCOVER_MODE, TLV_FIELD_OFFSET( WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS, DiscoverMode ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DISCOVERY_CHANNEL_SETTINGS, TLV_FIELD_OFFSET( WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS, DiscoveryChannelSettings ), FALSE, TRUE, 27, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DEVICE_FILTER_LIST, TLV_FIELD_OFFSET( WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS, DeviceFilterList ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SERVICE_NAME_HASH, TLV_FIELD_OFFSET( WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS, ServiceNameHash ), TRUE, TRUE, 28, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_VENDOR_SPECIFIC_IE, TLV_FIELD_OFFSET( WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS, VendorIEs ), TRUE, FALSE, 0, TRUE, 3 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_CONNECT_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_CONNECT_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CONNECT_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CONNECT_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_CONNECT_PARAMETERS, ConnectParameters ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CONNECT_BSS_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CONNECT_BSS_ENTRY, TLV_FIELD_OFFSET( WDI_TASK_CONNECT_PARAMETERS, PreferredBSSEntryList ), FALSE, TRUE, 31, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_CONNECT_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_DOT11_RESET_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_DOT11_RESET_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_DOT11_RESET_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DOT11_RESET_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_DOT11_RESET_PARAMETERS, Dot11ResetParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CONFIGURED_MAC_ADDRESS, TLV_FIELD_OFFSET( WDI_TASK_DOT11_RESET_PARAMETERS, ResetMACAddress ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_DOT11_RESET_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_DISCONNECT_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_DISCONNECT_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_DISCONNECT_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DISCONNECT_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_DISCONNECT_PARAMETERS, DisconnectParameters ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_DISCONNECT_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SEND_ACTION_REQUEST_FRAME_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS, RequestParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GO_NEGOTIATION_REQUEST_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GO_NEGOTIATION_REQUEST_INFO, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS, GONegotiationRequestInfo ), FALSE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_INVITATION_REQUEST_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INVITATION_REQUEST_INFO, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS, InvitationRequestInfo ), FALSE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_PROVISION_DISCOVERY_REQUEST_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_PROVISION_DISCOVERY_REQUEST_INFO, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS, ProvisionDiscoveryRequestInfo ), FALSE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BSS_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS, DeviceDescriptor ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_VENDOR_SPECIFIC_IE, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS, VendorIEs ), TRUE, FALSE, 0, TRUE, 3 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ACTION_FRAME_RESPONSE_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, ResponseParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GO_NEGOTIATION_RESPONSE_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GO_NEGOTIATION_RESPONSE_INFO, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, GONegotiationResponseInfo ), FALSE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GO_NEGOTIATION_CONFIRMATION_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GO_NEGOTIATION_CONFIRMATION_INFO, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, GONegotiationConfirmationInfo ), FALSE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_INVITATION_RESPONSE_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INVITATION_RESPONSE_INFO, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, InvitationResponseInfo ), FALSE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_PROVISION_DISCOVERY_RESPONSE_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_PROVISION_DISCOVERY_RESPONSE_INFO, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, ProvisionDiscoveryResponseInfo ), FALSE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_INCOMING_P2P_ACTION_FRAME_INFO_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INCOMING_FRAME_INFORMATION, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, PrecedingFrameInformation ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_VENDOR_SPECIFIC_IE, TLV_FIELD_OFFSET( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, VendorIEs ), TRUE, FALSE, 0, TRUE, 4 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_RADIO_STATE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_RADIO_STATE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_RADIO_STATE_PARAMETERS, TLV_FIELD_OFFSET( WDI_SET_RADIO_STATE_PARAMETERS, SoftwareRadioState ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_RADIO_STATE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_CREATE_PORT_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_CREATE_PORT_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_TASK_CREATE_PORT_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CREATE_PORT_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_CREATE_PORT_PARAMETERS, CreatePortParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CREATE_PORT_MAC_ADDRESS, TLV_FIELD_OFFSET( WDI_TASK_CREATE_PORT_PARAMETERS, MacAddress ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_CREATE_PORT_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_DELETE_PORT_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_DELETE_PORT_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_TASK_DELETE_PORT_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DELETE_PORT_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_DELETE_PORT_PARAMETERS, DeletePortParameters ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_DELETE_PORT_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_START_AP_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_START_AP_PARAMETERS_HELPER
        {
            static const VERSION_INFO s_versionedField1 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_10, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper2( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_START_AP_PARAMETERS>( p, (const WDI_START_AP_PARAMETERS_CONTAINER *)i, s, c, (WDI_START_AP_PARAMETERS_CONTAINER_V1_0_1 *)o); }
            static NDIS_STATUS ParseHelper2( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_START_AP_PARAMETERS>( (WDI_START_AP_PARAMETERS_CONTAINER_V1_0_1 *)i, c, (WDI_START_AP_PARAMETERS_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField2 = { NULL, &GenerateHelper2, NULL, &ParseHelper2, 0, WDI_VERSION_1_0_10, 1 };
            static const VERSION_INFO s_versionedField7 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_10, 0, 0xFFFFFFFF };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SSID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SSID, TLV_FIELD_OFFSET( WDI_TASK_START_AP_PARAMETERS, DesiredSSID ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_START_AP_PARAMETERS_CONTAINER_HELPER::s_Container, &s_versionedField1, (ENUMS::TLV_ID)WDI_TLV_START_AP_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_START_AP_PARAMETERS, StaticParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_START_AP_PARAMETERS_CONTAINER_V1_0_1_HELPER::s_Container, &s_versionedField2, (ENUMS::TLV_ID)WDI_TLV_START_AP_PARAMETERS, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_AUTH_ALGORITHM_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_AUTH_ALGO_LIST, TLV_FIELD_OFFSET( WDI_TASK_START_AP_PARAMETERS, AuthenticationAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_ALGORITHM_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_MULTICAST_CIPHER_ALGO_LIST, TLV_FIELD_OFFSET( WDI_TASK_START_AP_PARAMETERS, MulticastCipherAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CIPHER_ALGORITHM_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_UNICAST_CIPHER_ALGO_LIST, TLV_FIELD_OFFSET( WDI_TASK_START_AP_PARAMETERS, UnicastCipherAlgorithms ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_NUMBER, TLV_FIELD_OFFSET( WDI_TASK_START_AP_PARAMETERS, AdvertisedOperatingChannel ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_AP_BAND_CHANNEL_LIST_CONTAINER_HELPER::s_Container, &s_versionedField7, (ENUMS::TLV_ID)WDI_TLV_AP_BAND_CHANNEL, TLV_FIELD_OFFSET( WDI_TASK_START_AP_PARAMETERS, APBandChannelList ), FALSE, TRUE, 32, TRUE, 1 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_START_AP_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_RESPONSE_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS, AssocResponseParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_VENDOR_SPECIFIC_IE, TLV_FIELD_OFFSET( WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS, VendorIEs ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INCOMING_ASSOCIATION_REQUEST_INFO, TLV_FIELD_OFFSET( WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS, IncomingRequestInfo ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_WFD_ASSOCIATION_STATUS, TLV_FIELD_OFFSET( WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS, WFDAssociationStatus ), TRUE, FALSE, 0, TRUE, 1 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_POWER_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_POWER_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_POWER_STATE, TLV_FIELD_OFFSET( WDI_SET_POWER_PARAMETERS, PowerState ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_WAKE_EVENT_MASK_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ENABLE_WAKE_EVENTS, TLV_FIELD_OFFSET( WDI_SET_POWER_PARAMETERS, WakeEventMask ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SET_POWER_DX_REASON, TLV_FIELD_OFFSET( WDI_SET_POWER_PARAMETERS, SetPowerDxReason ), TRUE, FALSE, 0, TRUE, 1 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_POWER_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_POWER_RESULTS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_POWER_RESULTS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::BOOL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ADAPTER_RESUME_REQUIRED, TLV_FIELD_OFFSET( WDI_SET_POWER_RESULTS, bResumeRequired ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_POWER_RESULTS ) };
        }
    }
}

//
// Helpers for WDI_SET_P2P_LISTEN_STATE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_P2P_LISTEN_STATE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_LISTEN_STATE_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_LISTEN_STATE, TLV_FIELD_OFFSET( WDI_SET_P2P_LISTEN_STATE_PARAMETERS, ListenState ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_NUMBER, TLV_FIELD_OFFSET( WDI_SET_P2P_LISTEN_STATE_PARAMETERS, ListenChannel ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_LISTEN_DURATION_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_LISTEN_DURATION, TLV_FIELD_OFFSET( WDI_SET_P2P_LISTEN_STATE_PARAMETERS, ListenDuration ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_P2P_LISTEN_STATE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PRIVACY_EXEMPTION_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PRIVACY_EXEMPTION_ENTRY, TLV_FIELD_OFFSET( WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS, PrivacyExemptionEntry ), TRUE, TRUE, 33, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_ADD_CIPHER_KEYS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_ADD_CIPHER_KEYS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SET_ADD_CIPHER_KEYS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SET_CIPHER_KEY_INFO, TLV_FIELD_OFFSET( WDI_SET_ADD_CIPHER_KEYS_PARAMETERS, SetCipherKey ), FALSE, TRUE, 34, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_ADD_CIPHER_KEYS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SET_DELETE_CIPHER_KEYS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DELETE_CIPHER_KEY_INFO, TLV_FIELD_OFFSET( WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS, CipherKeyInfo ), FALSE, TRUE, 35, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_DEFAULT_KEY_ID_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_DEFAULT_KEY_ID_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SET_DEFAULT_KEY_ID_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DEFAULT_TX_KEY_ID_PARAMETERS, TLV_FIELD_OFFSET( WDI_SET_DEFAULT_KEY_ID_PARAMETERS, DefaultKeyIdParameters ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_DEFAULT_KEY_ID_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_CONNECTION_QUALITY_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_CONNECTION_QUALITY_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CONNECTION_QUALITY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CONNECTION_QUALITY_PARAMETERS, TLV_FIELD_OFFSET( WDI_SET_CONNECTION_QUALITY_PARAMETERS, Quality ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS, TLV_FIELD_OFFSET( WDI_SET_CONNECTION_QUALITY_PARAMETERS, LowLatencyParameters ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_CONNECTION_QUALITY_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_GET_STATISTICS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_STATISTICS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_STATISTICS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_MAC_STATISTICS, TLV_FIELD_OFFSET( WDI_GET_STATISTICS_PARAMETERS, PeerMACStatistics ), TRUE, TRUE, 36, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_STATISTICS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_STATISTICS, TLV_FIELD_OFFSET( WDI_GET_STATISTICS_PARAMETERS, PhyStatistics ), TRUE, TRUE, 37, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_GET_STATISTICS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PACKET_FILTER_PARAMETERS, TLV_FIELD_OFFSET( WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS, PacketFilterType ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS_HELPER
        {
            static const VERSION_INFO s_versionedField13 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_21, 0, 0xFFFFFFFF };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_COMMUNICATION_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_COMMUNICATION_CONFIGURATION_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, CommunicationAttributes ), FALSE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_INTERFACE_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INTERFACE_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, InterfaceAttributes ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_STATION_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_STATION_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, StationAttributes ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_AP_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_AP_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, APAttributes ), FALSE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_VIRTUALIZATION_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_VIRTUALIZATION_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, VirtualizationAttributes ), FALSE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, P2PAttributes ), FALSE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_DATAPATH_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DATAPATH_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, DatapathAttributes ), FALSE, FALSE, 0, TRUE, 4 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BAND_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BAND_INFO, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, BandInfo ), FALSE, TRUE, 38, TRUE, 5 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_INFO, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, PhyInfo ), FALSE, TRUE, 39, TRUE, 6 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PM_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_CAPABILITIES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, PmCapabilities ), TRUE, FALSE, 0, TRUE, 7 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_COUNTRY_REGION_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_COUNTRY_REGION_LIST, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, CountryRegionList ), TRUE, FALSE, 0, TRUE, 8 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_RECEIVE_COALESCING_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_RECEIVE_COALESCING_CAPABILITIES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, ReceiveCoalescingCapabilities ), TRUE, FALSE, 0, TRUE, 9 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_TCP_OFFLOAD_CAPABILITIES, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, TcpOffloadCapabilities ), FALSE, FALSE, 0, TRUE, 10 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_NDIS_GUID_CONTAINER_HELPER::s_Container, &s_versionedField13, (ENUMS::TLV_ID)WDI_TLV_SUPPORTED_GUIDS, TLV_FIELD_OFFSET( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS, SupportedGuids ), TRUE, TRUE, 40, TRUE, 11 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_NETWORK_LIST_OFFLOAD_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_NETWORK_LIST_OFFLOAD_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_NETWORK_LIST_OFFLOAD_INFO_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_NETWORK_LIST_OFFLOAD_PARAMETERS, TLV_FIELD_OFFSET( WDI_NETWORK_LIST_OFFLOAD_PARAMETERS, NetworkListOffload ), FALSE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_NETWORK_LIST_OFFLOAD_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_RECEIVE_COALESCING_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_RECEIVE_COALESCING_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::ADD_RECEIVE_COALESCING_INFO_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SET_RECEIVE_COALESCING, TLV_FIELD_OFFSET( WDI_SET_RECEIVE_COALESCING_PARAMETERS, AddReceiveCoalescing ), FALSE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_RECEIVE_COALESCING_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SSID_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SSID, TLV_FIELD_OFFSET( WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS, SSID ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_DISASSOCIATION_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_DISASSOCIATION_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_DISCONNECT_INDICATION_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DISASSOCIATION_INDICATION_PARAMETERS, TLV_FIELD_OFFSET( WDI_INDICATION_DISASSOCIATION_PARAMETERS, DisconnectIndicationParameters ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DISCONNECT_DEAUTH_FRAME, TLV_FIELD_OFFSET( WDI_INDICATION_DISASSOCIATION_PARAMETERS, DeauthFrame ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DISCONNECT_DISASSOCIATION_FRAME, TLV_FIELD_OFFSET( WDI_INDICATION_DISASSOCIATION_PARAMETERS, DisassociationFrame ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::BOOL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_DISASSOCIATION_PARAMETERS, TLV_FIELD_OFFSET( WDI_INDICATION_DISASSOCIATION_PARAMETERS, NeedPeerStateCleanup ), TRUE, FALSE, 0, TRUE, 2 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_DISASSOCIATION_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_ROAMING_NEEDED_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_ROAMING_NEEDED_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ROAMING_NEEDED_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ROAMING_NEEDED_PARAMETERS, TLV_FIELD_OFFSET( WDI_INDICATION_ROAMING_NEEDED_PARAMETERS, RoamingReason ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_ROAMING_NEEDED_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_LINK_STATE_CHANGE_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_LINK_STATE_CHANGE_PARAMETERS, TLV_FIELD_OFFSET( WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS, LinkStateChangeParameters ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_INCOMING_P2P_ACTION_FRAME_INFO_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_INCOMING_FRAME_INFORMATION, TLV_FIELD_OFFSET( WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS, FrameInfo ), FALSE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_INCOMING_ASSOCIATION_REQUEST_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INCOMING_ASSOCIATION_REQUEST_INFO, TLV_FIELD_OFFSET( WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS, IncomingRequestInfo ), FALSE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_NLO_DISCOVERY_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_NLO_DISCOVERY_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BSS_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY, TLV_FIELD_OFFSET( WDI_INDICATION_NLO_DISCOVERY_PARAMETERS, DeviceDescriptor ), FALSE, TRUE, 41, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_NLO_DISCOVERY_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_WAKE_REASON_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_WAKE_REASON_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INDICATION_WAKE_REASON, TLV_FIELD_OFFSET( WDI_INDICATION_WAKE_REASON_PARAMETERS, WakeEventCode ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INDICATION_WAKE_PACKET, TLV_FIELD_OFFSET( WDI_INDICATION_WAKE_REASON_PARAMETERS, WakePacket ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INDICATION_WAKE_PACKET_PATTERN_ID, TLV_FIELD_OFFSET( WDI_INDICATION_WAKE_REASON_PARAMETERS, WakePacketPatternId ), TRUE, FALSE, 0, TRUE, 1 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_WAKE_REASON_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_TKIP_MIC_FAILURE_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_TKIP_MIC_FAILURE_INFO, TLV_FIELD_OFFSET( WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS, FailureInfo ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BSS_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY, TLV_FIELD_OFFSET( WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS, DeviceDescriptor ), FALSE, TRUE, 41, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SEND_ACTION_FRAME_RESULT_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SEND_ACTION_FRAME_RESULT, TLV_FIELD_OFFSET( WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS, SendActionFrameResult ), FALSE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SEND_ACTION_FRAME_RESULT_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SEND_ACTION_FRAME_RESULT, TLV_FIELD_OFFSET( WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS, SendActionFrameResult ), FALSE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_RADIO_STATUS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_RADIO_STATUS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_RADIO_STATUS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_RADIO_STATE, TLV_FIELD_OFFSET( WDI_INDICATION_RADIO_STATUS_PARAMETERS, RadioState ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_RADIO_STATUS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PORT_ATTRIBUTES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PORT_ATTRIBUTES, TLV_FIELD_OFFSET( WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS, PortAttributes ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_STOP_AP_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_STOP_AP_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INDICATION_STOP_AP, TLV_FIELD_OFFSET( WDI_INDICATION_STOP_AP_PARAMETERS, Reason ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_STOP_AP_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_INDICATION_CAN_SUSTAIN_AP, TLV_FIELD_OFFSET( WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS, Reason ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ASSOC_RESPONSE_RESULT_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_RESPONSE_RESULT_PARAMETERS, TLV_FIELD_OFFSET( WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS, AssocResponseResult ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_RESPONSE_FRAME, TLV_FIELD_OFFSET( WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS, AssocResponseFrame ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BEACON_IES, TLV_FIELD_OFFSET( WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS, BeaconIEs ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PHY_TYPE_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PHY_TYPE_LIST, TLV_FIELD_OFFSET( WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS, ActivePhyList ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_ASSOCIATION_RESULT_LIST
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_ASSOCIATION_RESULT_LIST_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ASSOCIATION_RESULT_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_RESULT, TLV_FIELD_OFFSET( WDI_INDICATION_ASSOCIATION_RESULT_LIST, AssociationResults ), FALSE, TRUE, 42, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_ASSOCIATION_RESULT_LIST ) };
        }
    }
}

//
// Helpers for WDI_GET_AUTO_POWER_SAVE_RESULTS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_AUTO_POWER_SAVE_RESULTS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_GET_AUTO_POWER_SAVE_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_GET_AUTO_POWER_SAVE, TLV_FIELD_OFFSET( WDI_GET_AUTO_POWER_SAVE_RESULTS, AutoPowerSaveParameters ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_GET_AUTO_POWER_SAVE_RESULTS ) };
        }
    }
}

//
// Helpers for WDI_SET_ADD_WOL_PATTERN_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_ADD_WOL_PATTERN_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PACKET_PATTERN_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_WAKE_PACKET_BITMAP_PATTERN, TLV_FIELD_OFFSET( WDI_SET_ADD_WOL_PATTERN_PARAMETERS, WakePacketPattern ), FALSE, TRUE, 43, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_WAKE_PACKET_MAGIC_PACKET, TLV_FIELD_OFFSET( WDI_SET_ADD_WOL_PATTERN_PARAMETERS, WakePacketMagicPacketPatternId ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_IPv4_TCP_SYNC_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_WAKE_PACKET_IPv4_TCP_SYNC, TLV_FIELD_OFFSET( WDI_SET_ADD_WOL_PATTERN_PARAMETERS, WakePacketIpv4TcpSync ), TRUE, TRUE, 44, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_IPv6TCP_SYNC_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_WAKE_PACKET_IPv6_TCP_SYNC, TLV_FIELD_OFFSET( WDI_SET_ADD_WOL_PATTERN_PARAMETERS, WakePacketIpv6TcpSync ), TRUE, TRUE, 45, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_WAKE_PACKET_EAPOL_REQUEST_ID_MESSAGE, TLV_FIELD_OFFSET( WDI_SET_ADD_WOL_PATTERN_PARAMETERS, WakePacketEapolRequestIdPatternId ), TRUE, FALSE, 0, TRUE, 4 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_ADD_WOL_PATTERN_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_WAKE_PACKET_PATTERN_REMOVE, TLV_FIELD_OFFSET( WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS, PatternId ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_MULTICAST_LIST_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_MULTICAST_LIST_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_MULTICAST_LIST, TLV_FIELD_OFFSET( WDI_SET_MULTICAST_LIST_PARAMETERS, MulticastList ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_MULTICAST_LIST_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_PROTOCOL_OFFLOAD_IPv4ARP, TLV_FIELD_OFFSET( WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS, ipv4ARPOffload ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PM_PROTOCOL_OFFLOAD_IPv6NS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_PROTOCOL_OFFLOAD_IPv6NS, TLV_FIELD_OFFSET( WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS, ipv6ARPOffload ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY, TLV_FIELD_OFFSET( WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS, DOT11RSNREKeyOffload ), TRUE, FALSE, 0, TRUE, 2 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_PROTOCOL_OFFLOAD_REMOVE, TLV_FIELD_OFFSET( WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS, RemovePMOffload ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_NUMBER, TLV_FIELD_OFFSET( WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS, Channel ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_INDICATE_REASON_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_INDICATE_REASON, TLV_FIELD_OFFSET( WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS, IndicateReason ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_NUMBER, TLV_FIELD_OFFSET( WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS, PreferredOperatingChannel ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_CHANNEL_LIST_ATTRIBUTE, TLV_FIELD_OFFSET( WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS, ChannelList ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_LISTEN_CHANNEL, TLV_FIELD_OFFSET( WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS, PreferredListenChannel ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS_HELPER
        {
            static const VERSION_INFO s_versionedField6 = { NULL, NULL, NULL, NULL, WDI_VERSION_1_0_10, 0, 0xFFFFFFFF };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CONFIGURED_MAC_ADDRESS, TLV_FIELD_OFFSET( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS, MacAddress ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_UNREACHABLE_DETECTION_THRESHOLD, TLV_FIELD_OFFSET( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS, UnreachableDetectionThreshold ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GO_INTERNAL_RESET_POLICY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GO_INTERNAL_RESET_POLICY, TLV_FIELD_OFFSET( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS, GroupOwnerResetPolicy ), TRUE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BAND_ID_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BAND_ID_LIST, TLV_FIELD_OFFSET( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS, DisallowedBandList ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_LINK_QUALITY_BAR_MAP_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_LINK_QUALITY_BAR_MAP, TLV_FIELD_OFFSET( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS, LinkQualityBarMap ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ADAPTER_NLO_SCAN_MODE_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ADAPTER_NLO_SCAN_MODE, TLV_FIELD_OFFSET( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS, AdapterNloScanMode ), TRUE, FALSE, 0, TRUE, 4 },
                { (CONTAINER_INFO*)&CONTAINERS::BOOL_CONTAINER_HELPER::s_Container, &s_versionedField6, (ENUMS::TLV_ID)WDI_TLV_PLDR_SUPPORT, TLV_FIELD_OFFSET( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS, PLDRSupport ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT64_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_COALESCING_FILTER_MATCH_COUNT, TLV_FIELD_OFFSET( WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS, MatchCount ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SET_CLEAR_RECEIVE_COALESCING, TLV_FIELD_OFFSET( WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS, FilterId ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT32_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_PROTOCOL_OFFLOAD_GET, TLV_FIELD_OFFSET( WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS, GetPMOffload ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_PROTOCOL_OFFLOAD_IPv4ARP, TLV_FIELD_OFFSET( WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS, ipv4ARPOffload ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PM_PROTOCOL_OFFLOAD_IPv6NS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_PROTOCOL_OFFLOAD_IPv6NS, TLV_FIELD_OFFSET( WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS, ipv6ARPOffload ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY, TLV_FIELD_OFFSET( WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS, DOT11RSNREKeyOffload ), TRUE, FALSE, 0, TRUE, 2 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS ) };
        }
    }
}

//
// Helpers for WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_ADDITIONAL_IES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ADDITIONAL_IES, TLV_FIELD_OFFSET( WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS, AdditionalIEs ), FALSE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_DEVICE_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DEVICE_INFO, TLV_FIELD_OFFSET( WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS, DeviceInformation ), FALSE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_DEVICE_CAPABILITY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_DEVICE_CAPABILITY, TLV_FIELD_OFFSET( WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS, DeviceCapability ), TRUE, FALSE, 0, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_GROUP_OWNER_CAPABILITY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_GROUP_OWNER_CAPABILITY, TLV_FIELD_OFFSET( WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS, GroupOwnerCapability ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_SECONDARY_DEVICE_TYPE_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_SECONDARY_DEVICE_TYPE_LIST, TLV_FIELD_OFFSET( WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS, SecondaryDeviceTypeList ), TRUE, FALSE, 0, TRUE, 4 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_P2P_ADVERTISED_SERVICES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_ADVERTISED_SERVICES, TLV_FIELD_OFFSET( WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS, AdvertisedServices ), FALSE, FALSE, 0, TRUE, 5 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_OPERATION_MODE_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_OPERATION_MODE, TLV_FIELD_OFFSET( WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS, OperationMode ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_IHV_REQUEST_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_IHV_REQUEST_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IHV_DATA, TLV_FIELD_OFFSET( WDI_IHV_REQUEST_PARAMETERS, IHVData ), TRUE, TRUE, 46, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_IHV_REQUEST_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_IHV_EVENT_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_IHV_EVENT_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IHV_DATA, TLV_FIELD_OFFSET( WDI_INDICATION_IHV_EVENT_PARAMETERS, IHVData ), TRUE, TRUE, 46, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_IHV_EVENT_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT16_LIST_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ASSOCIATION_PARAMETERS_REQUESTED_TYPE, TLV_FIELD_OFFSET( WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS, AssociationParameterTypes ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BSS_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY, TLV_FIELD_OFFSET( WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS, BSSEntryList ), FALSE, TRUE, 41, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_ASSOCIATION_PARAMS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_ASSOCIATION_PARAMS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CONNECT_BSS_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CONNECT_BSS_ENTRY, TLV_FIELD_OFFSET( WDI_SET_ASSOCIATION_PARAMS_PARAMETERS, BSSEntryList ), FALSE, TRUE, 31, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_ASSOCIATION_PARAMS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_ROAM_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_ROAM_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CONNECT_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CONNECT_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_ROAM_PARAMETERS, ConnectParameters ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CONNECT_BSS_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CONNECT_BSS_ENTRY, TLV_FIELD_OFFSET( WDI_TASK_ROAM_PARAMETERS, PreferredBSSEntryList ), FALSE, TRUE, 31, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_ROAM_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SEND_ACTION_FRAME_REQUEST_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS, RequestParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ACTION_FRAME_BODY, TLV_FIELD_OFFSET( WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS, ActionFrameBody ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSSID, TLV_FIELD_OFFSET( WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS, SourceAddress ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CHANNEL_INFO_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSS_ENTRY_CHANNEL_INFO, TLV_FIELD_OFFSET( WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS, ChannelInfo ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ACTION_FRAME_BODY, TLV_FIELD_OFFSET( WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS, ActionFrameBody ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_TCP_OFFLOAD_CAPABILITIES_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_TCP_OFFLOAD_CAPABILITIES, TLV_FIELD_OFFSET( WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS, TcpOffloadCapabilities ), FALSE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SEND_ACTION_FRAME_RESPONSE_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, ResponseParams ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_ACTION_FRAME_BODY, TLV_FIELD_OFFSET( WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS, ActionFrameBody ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_NEXT_DIALOG_TOKEN, TLV_FIELD_OFFSET( WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS, NextDialogToken ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_P2P_WPS_ENABLED_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_P2P_WPS_ENABLED_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_P2P_WPS_ENABLED, TLV_FIELD_OFFSET( WDI_SET_P2P_WPS_ENABLED_PARAMETERS, WPSEnabled ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_P2P_WPS_ENABLED_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_IHV_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_IHV_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IHV_TASK_DEVICE_CONTEXT, TLV_FIELD_OFFSET( WDI_TASK_IHV_PARAMETERS, IHVSpecificContext ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_IHV_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_IHV_TASK_PRIORITY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IHV_TASK_REQUEST_PARAMETERS, TLV_FIELD_OFFSET( WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS, RequestedPriority ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_IHV_TASK_DEVICE_CONTEXT, TLV_FIELD_OFFSET( WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS, IHVSpecificContext ), TRUE, FALSE, 0, TRUE, 0 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_ABORT_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_ABORT_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_CANCEL_PARAMETERS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_CANCEL_PARAMETERS, TLV_FIELD_OFFSET( WDI_TASK_ABORT_PARAMETERS, CancelParameters ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_ABORT_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_SET_OFFLOAD_PARAMS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_TCP_SET_OFFLOAD_PARAMETERS, TLV_FIELD_OFFSET( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS, SetOffloadParameters ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TCP_RSC_STATISTICS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TCP_RSC_STATISTICS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_TCP_RSC_STATISTICS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_TCP_RSC_STATISTICS_PARAMETERS, TLV_FIELD_OFFSET( WDI_TCP_RSC_STATISTICS_PARAMETERS, RscStatsParams ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TCP_RSC_STATISTICS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SET_ENCAPSULATION_OFFLOAD_V4_PARAMETERS, TLV_FIELD_OFFSET( WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS, EnabledV4 ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::UINT8_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_SET_ENCAPSULATION_OFFLOAD_V6_PARAMETERS, TLV_FIELD_OFFSET( WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS, EnabledV6 ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_BSSID, TLV_FIELD_OFFSET( WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS, BssId ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_AUTH_REQUEST, TLV_FIELD_OFFSET( WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS, AuthRequest ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_AUTH_RESPONSE, TLV_FIELD_OFFSET( WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS, AuthResponse ), TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_STATUS_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_STATUS, TLV_FIELD_OFFSET( WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND, status ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_RSNIE, TLV_FIELD_OFFSET( WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND, RSNIE ), TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_MDE, TLV_FIELD_OFFSET( WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND, MDE ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::WDI_BYTE_BLOB_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_FT_FTE, TLV_FIELD_OFFSET( WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND, FTE ), TRUE, FALSE, 0, TRUE, 2 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND ) };
        }
    }
}

//
// Helpers for WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS_HELPER
        {
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER_HELPER::s_Container, NULL, (ENUMS::TLV_ID)WDI_TLV_NEIGHBOR_REPORT_ENTRY, TLV_FIELD_OFFSET( WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS, NeighborReportEntry ), FALSE, TRUE, 47, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS ) };
        }
    }
}

//
// Helpers for WDI_TASK_TEST_PARAMETERS
//
namespace WDI_TLV
{
    namespace CONTAINERS
    {
        namespace WDI_TASK_TEST_PARAMETERS_HELPER
        {
            static const VERSION_INFO s_versionedField0 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper1( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST1>( p, (const ArrayOfElements<TEST_CONTAINER> *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper1( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST1>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static const VERSION_INFO s_versionedField1 = { NULL, &GenerateHelper1, NULL, &ParseHelper1, 0, WDI_VERSION_LATEST, 0 };
            static const VERSION_INFO s_versionedField2 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper3( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST2>( p, (const TEST_CONTAINER *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper3( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST2>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (TEST_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField3 = { NULL, &GenerateHelper3, NULL, &ParseHelper3, 0, WDI_VERSION_LATEST, 2 };
            static const VERSION_INFO s_versionedField4 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper5( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST3>( p, (const ArrayOfElements<TEST_CONTAINER> *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper5( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST3>( (TEST_CONTAINER *)i, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static const VERSION_INFO s_versionedField5 = { NULL, &GenerateHelper5, NULL, &ParseHelper5, 0, WDI_VERSION_LATEST, 4 };
            static const VERSION_INFO s_versionedField6 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper7( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST4>( p, (const TEST_CONTAINER *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper7( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST4>( (TEST_CONTAINER *)i, c, (TEST_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField7 = { NULL, &GenerateHelper7, NULL, &ParseHelper7, 0, WDI_VERSION_LATEST, 6 };
            static const VERSION_INFO s_versionedField8 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper9( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST5>( p, (const ArrayOfElements<TEST_CONTAINER> *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper9( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST5>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static const VERSION_INFO s_versionedField9 = { NULL, &GenerateHelper9, NULL, &ParseHelper9, 0, WDI_VERSION_LATEST, 8 };
            static const VERSION_INFO s_versionedField10 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper11( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST6>( p, (const TEST_CONTAINER *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper11( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST6>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (TEST_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField11 = { NULL, &GenerateHelper11, NULL, &ParseHelper11, 0, WDI_VERSION_LATEST, 10 };
            static const VERSION_INFO s_versionedField12 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper13( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST7>( p, (const ArrayOfElements<TEST_CONTAINER> *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper13( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST7>( (TEST_CONTAINER *)i, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static const VERSION_INFO s_versionedField13 = { NULL, &GenerateHelper13, NULL, &ParseHelper13, 0, WDI_VERSION_LATEST, 12 };
            static const VERSION_INFO s_versionedField14 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper15( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST8>( p, (const TEST_CONTAINER *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper15( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST8>( (TEST_CONTAINER *)i, c, (TEST_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField15 = { NULL, &GenerateHelper15, NULL, &ParseHelper15, 0, WDI_VERSION_LATEST, 14 };
            static const VERSION_INFO s_versionedField16 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper17( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST9>( p, (const ArrayOfElements<TEST_CONTAINER> *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper17( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST9>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static const VERSION_INFO s_versionedField17 = { NULL, &GenerateHelper17, NULL, &ParseHelper17, 0, WDI_VERSION_LATEST, 16 };
            static const VERSION_INFO s_versionedField18 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper19( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST10>( p, (const TEST_CONTAINER *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper19( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST10>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (TEST_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField19 = { NULL, &GenerateHelper19, NULL, &ParseHelper19, 0, WDI_VERSION_LATEST, 18 };
            static const VERSION_INFO s_versionedField20 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper21( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST11>( p, (const ArrayOfElements<TEST_CONTAINER> *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper21( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST11>( (TEST_CONTAINER *)i, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static const VERSION_INFO s_versionedField21 = { NULL, &GenerateHelper21, NULL, &ParseHelper21, 0, WDI_VERSION_LATEST, 20 };
            static const VERSION_INFO s_versionedField22 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper23( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST12>( p, (const TEST_AGGREGATE_CONTAINER *)i, s, c, (TEST_AGGREGATE_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper23( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST12>( (TEST_AGGREGATE_CONTAINER *)i, c, (TEST_AGGREGATE_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField23 = { NULL, &GenerateHelper23, NULL, &ParseHelper23, 0, WDI_VERSION_LATEST, 22 };
            static const VERSION_INFO s_versionedField24 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper25( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST13>( p, (const ArrayOfElements<TEST_CONTAINER> *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper25( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST13>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static const VERSION_INFO s_versionedField25 = { NULL, &GenerateHelper25, NULL, &ParseHelper25, 0, WDI_VERSION_LATEST, 24 };
            static const VERSION_INFO s_versionedField26 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper27( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST14>( p, (const TEST_CONTAINER *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper27( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST14>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (TEST_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField27 = { NULL, &GenerateHelper27, NULL, &ParseHelper27, 0, WDI_VERSION_LATEST, 26 };
            static const VERSION_INFO s_versionedField28 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper29( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST15>( p, (const ArrayOfElements<TEST_CONTAINER> *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper29( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST15>( (TEST_CONTAINER *)i, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static const VERSION_INFO s_versionedField29 = { NULL, &GenerateHelper29, NULL, &ParseHelper29, 0, WDI_VERSION_LATEST, 28 };
            static const VERSION_INFO s_versionedField30 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper31( _In_ bool p, _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructReplacedFieldForGenerate<WDI_TLV_TEST16>( p, (const TEST_CONTAINER *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper31( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertReplacedFieldFromParse<WDI_TLV_TEST16>( (TEST_CONTAINER *)i, c, (TEST_CONTAINER *)o); }
            static const VERSION_INFO s_versionedField31 = { NULL, &GenerateHelper31, NULL, &ParseHelper31, 0, WDI_VERSION_LATEST, 30 };
            static const VERSION_INFO s_versionedField32 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static const VERSION_INFO s_versionedField33 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static const VERSION_INFO s_versionedField34 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static const VERSION_INFO s_versionedField35 = { NULL, NULL, NULL, NULL, WDI_VERSION_LATEST, 0, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper36( _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructRemovedFieldForGenerate<WDI_TLV_TEST21>( (const WDI_TASK_TEST_PARAMETERS *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper36( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertRemovedFieldFromParse<WDI_TLV_TEST21>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (WDI_TASK_TEST_PARAMETERS *)o); }
            static const VERSION_INFO s_versionedField36 = { &GenerateHelper36, NULL, &ParseHelper36, NULL, 0, WDI_VERSION_LATEST, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper37( _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructRemovedFieldForGenerate<WDI_TLV_TEST22>( (const WDI_TASK_TEST_PARAMETERS *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper37( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertRemovedFieldFromParse<WDI_TLV_TEST22>( (TEST_CONTAINER *)i, c, (WDI_TASK_TEST_PARAMETERS *)o); }
            static const VERSION_INFO s_versionedField37 = { &GenerateHelper37, NULL, &ParseHelper37, NULL, 0, WDI_VERSION_LATEST, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper38( _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructRemovedFieldForGenerate<WDI_TLV_TEST23>( (const WDI_TASK_TEST_PARAMETERS *)i, s, c, (ArrayOfElements<TEST_CONTAINER> *)o); }
            static NDIS_STATUS ParseHelper38( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertRemovedFieldFromParse<WDI_TLV_TEST23>( (ArrayOfElements<TEST_CONTAINER> *)i, c, (WDI_TASK_TEST_PARAMETERS *)o); }
            static const VERSION_INFO s_versionedField38 = { &GenerateHelper38, NULL, &ParseHelper38, NULL, 0, WDI_VERSION_LATEST, 0xFFFFFFFF };
            static NDIS_STATUS GenerateHelper39( _In_ const void * i, _In_ bool s, _In_ PCTLV_CONTEXT c, _Out_ void * o) { return TlvReconstructRemovedFieldForGenerate<WDI_TLV_TEST24>( (const WDI_TASK_TEST_PARAMETERS *)i, s, c, (TEST_CONTAINER *)o); }
            static NDIS_STATUS ParseHelper39( _In_opt_ void * i, _In_ PCTLV_CONTEXT c, _Inout_ void * o) { return TlvConvertRemovedFieldFromParse<WDI_TLV_TEST24>( (TEST_CONTAINER *)i, c, (WDI_TASK_TEST_PARAMETERS *)o); }
            static const VERSION_INFO s_versionedField39 = { &GenerateHelper39, NULL, &ParseHelper39, NULL, 0, WDI_VERSION_LATEST, 0xFFFFFFFF };
            static const CONTAINER_REF_INFO s_rgFields[] =
            {
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField0, (ENUMS::TLV_ID)WDI_TLV_TEST1, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsocoomomc ), TRUE, TRUE, 26, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField1, (ENUMS::TLV_ID)WDI_TLV_TEST1, 1, TRUE, TRUE, 26, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField2, (ENUMS::TLV_ID)WDI_TLV_TEST2, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsocoomosc ), TRUE, FALSE, 0, TRUE, 1 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField3, (ENUMS::TLV_ID)WDI_TLV_TEST2, 1, TRUE, TRUE, 26, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField4, (ENUMS::TLV_ID)WDI_TLV_TEST3, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsocoosomc ), TRUE, TRUE, 26, TRUE, 2 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField5, (ENUMS::TLV_ID)WDI_TLV_TEST3, 1, TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField6, (ENUMS::TLV_ID)WDI_TLV_TEST4, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsocoososc ), TRUE, FALSE, 0, TRUE, 3 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField7, (ENUMS::TLV_ID)WDI_TLV_TEST4, 1, TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField8, (ENUMS::TLV_ID)WDI_TLV_TEST5, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsocromomc ), TRUE, TRUE, 26, TRUE, 4 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField9, (ENUMS::TLV_ID)WDI_TLV_TEST5, 1, TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField10, (ENUMS::TLV_ID)WDI_TLV_TEST6, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsocromosc ), TRUE, FALSE, 0, TRUE, 5 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField11, (ENUMS::TLV_ID)WDI_TLV_TEST6, 1, TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField12, (ENUMS::TLV_ID)WDI_TLV_TEST7, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsocrosomc ), TRUE, TRUE, 26, TRUE, 6 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField13, (ENUMS::TLV_ID)WDI_TLV_TEST7, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField14, (ENUMS::TLV_ID)WDI_TLV_TEST8, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsocrososc ), TRUE, FALSE, 0, TRUE, 7 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField15, (ENUMS::TLV_ID)WDI_TLV_TEST8, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField16, (ENUMS::TLV_ID)WDI_TLV_TEST9, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsrcoomomc ), TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField17, (ENUMS::TLV_ID)WDI_TLV_TEST9, 1, TRUE, TRUE, 26, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField18, (ENUMS::TLV_ID)WDI_TLV_TEST10, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsrcoomosc ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField19, (ENUMS::TLV_ID)WDI_TLV_TEST10, 1, TRUE, TRUE, 26, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField20, (ENUMS::TLV_ID)WDI_TLV_TEST11, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsrcoosomc ), TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField21, (ENUMS::TLV_ID)WDI_TLV_TEST11, 1, TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_AGGREGATE_CONTAINER_HELPER::s_Container, &s_versionedField22, (ENUMS::TLV_ID)WDI_TLV_TEST12, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsrcoososc ), FALSE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_AGGREGATE_CONTAINER_HELPER::s_Container, &s_versionedField23, (ENUMS::TLV_ID)WDI_TLV_TEST12, 1, FALSE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField24, (ENUMS::TLV_ID)WDI_TLV_TEST13, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsrcromomc ), TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField25, (ENUMS::TLV_ID)WDI_TLV_TEST13, 1, TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField26, (ENUMS::TLV_ID)WDI_TLV_TEST14, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsrcromosc ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField27, (ENUMS::TLV_ID)WDI_TLV_TEST14, 1, TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField28, (ENUMS::TLV_ID)WDI_TLV_TEST15, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsrcrosomc ), TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField29, (ENUMS::TLV_ID)WDI_TLV_TEST15, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField30, (ENUMS::TLV_ID)WDI_TLV_TEST16, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newsrcrososc ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField31, (ENUMS::TLV_ID)WDI_TLV_TEST16, 1, TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField32, (ENUMS::TLV_ID)WDI_TLV_TEST17, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newnocmc ), TRUE, TRUE, 26, TRUE, 8 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField33, (ENUMS::TLV_ID)WDI_TLV_TEST18, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newnocsc ), TRUE, FALSE, 0, TRUE, 9 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField34, (ENUMS::TLV_ID)WDI_TLV_TEST19, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newnrcmc ), TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField35, (ENUMS::TLV_ID)WDI_TLV_TEST20, TLV_FIELD_OFFSET( WDI_TASK_TEST_PARAMETERS, Newnrcsc ), TRUE, FALSE, 0, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField36, (ENUMS::TLV_ID)WDI_TLV_TEST21, 1, TRUE, TRUE, 26, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField37, (ENUMS::TLV_ID)WDI_TLV_TEST22, 1, TRUE, FALSE, 0, TRUE, 0 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField38, (ENUMS::TLV_ID)WDI_TLV_TEST23, 1, TRUE, TRUE, 26, FALSE, 32767 },
                { (CONTAINER_INFO*)&CONTAINERS::TEST_CONTAINER_HELPER::s_Container, &s_versionedField39, (ENUMS::TLV_ID)WDI_TLV_TEST24, 1, TRUE, FALSE, 0, FALSE, 32767 },
            };
            static const AGGREGATE_INFO s_Container = { s_rgFields, sizeof( s_rgFields ) / sizeof( CONTAINER_REF_INFO ), sizeof( WDI_TASK_TEST_PARAMETERS ) };
        }
    }
}

namespace WDI_TLV
{
    const ARRAY_HELPERS g_ArrayHelpers[] =
    {
        { &ArrayOfElements<UINT8>::AllocateElements, &ArrayOfElements<UINT8>::Cleanup },
        { &ArrayOfElements<CHAR>::AllocateElements, &ArrayOfElements<CHAR>::Cleanup },
        { &ArrayOfElements<WDI_MAC_ADDRESS>::AllocateElements, &ArrayOfElements<WDI_MAC_ADDRESS>::Cleanup },
        { &ArrayOfElements<UINT32>::AllocateElements, &ArrayOfElements<UINT32>::Cleanup },
        { &ArrayOfElements<UINT16>::AllocateElements, &ArrayOfElements<UINT16>::Cleanup },
        { &ArrayOfElements<WDI_AUTH_ALGORITHM>::AllocateElements, &ArrayOfElements<WDI_AUTH_ALGORITHM>::Cleanup },
        { &ArrayOfElements<WDI_CIPHER_ALGORITHM>::AllocateElements, &ArrayOfElements<WDI_CIPHER_ALGORITHM>::Cleanup },
        { &ArrayOfElements<WDI_P2P_DEVICE_TYPE>::AllocateElements, &ArrayOfElements<WDI_P2P_DEVICE_TYPE>::Cleanup },
        { &ArrayOfElements<WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_ADVERTISED_SERVICE_ENTRY_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_ASP2_ADVERTISED_SERVICE_ENTRY_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_ADVERTISED_PREFIX_ENTRY_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_CHANNEL_NUMBER>::AllocateElements, &ArrayOfElements<WDI_CHANNEL_NUMBER>::Cleanup },
        { &ArrayOfElements<WDI_BAND_ID>::AllocateElements, &ArrayOfElements<WDI_BAND_ID>::Cleanup },
        { &ArrayOfElements<WDI_LINK_QUALITY_BAR_MAP_PARAMETERS>::AllocateElements, &ArrayOfElements<WDI_LINK_QUALITY_BAR_MAP_PARAMETERS>::Cleanup },
        { &ArrayOfElements<WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_DISCOVERED_SERVICE_ENTRY_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_BAND_CHANNEL_LIST_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_BAND_CHANNEL_LIST_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_PHY_TYPE>::AllocateElements, &ArrayOfElements<WDI_PHY_TYPE>::Cleanup },
        { &ArrayOfElements<WDI_ALGO_PAIRS>::AllocateElements, &ArrayOfElements<WDI_ALGO_PAIRS>::Cleanup },
        { &ArrayOfElements<WDI_COUNTRY_REGION_LIST>::AllocateElements, &ArrayOfElements<WDI_COUNTRY_REGION_LIST>::Cleanup },
        { &ArrayOfElements<WDI_CHANNEL_MAPPING_ENTRY>::AllocateElements, &ArrayOfElements<WDI_CHANNEL_MAPPING_ENTRY>::Cleanup },
        { &ArrayOfElements<WDI_DATA_RATE_LIST>::AllocateElements, &ArrayOfElements<WDI_DATA_RATE_LIST>::Cleanup },
        { &ArrayOfElements<WDI_ETHERTYPE_ENCAPSULATION_ENTRY>::AllocateElements, &ArrayOfElements<WDI_ETHERTYPE_ENCAPSULATION_ENTRY>::Cleanup },
        { &ArrayOfElements<WDI_SSID>::AllocateElements, &ArrayOfElements<WDI_SSID>::Cleanup },
        { &ArrayOfElements<WDI_SSID_OFFLOAD_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_SSID_OFFLOAD_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_RECEIVE_COALESCING_FIELD_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_RECEIVE_COALESCING_FIELD_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_P2P_CHANNEL_ENTRIES_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_CHANNEL_ENTRIES_CONTAINER>::Cleanup },
        { &ArrayOfElements<TEST_CONTAINER>::AllocateElements, &ArrayOfElements<TEST_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_DISCOVERY_CHANNEL_SETTINGS_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_P2P_SERVICE_NAME_HASH_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_SERVICE_NAME_HASH_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_CONNECT_BSS_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_CONNECT_BSS_ENTRY_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_AP_BAND_CHANNEL_LIST_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_AP_BAND_CHANNEL_LIST_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_PRIVACY_EXEMPTION_LIST_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_PRIVACY_EXEMPTION_LIST_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_SET_ADD_CIPHER_KEYS_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_SET_ADD_CIPHER_KEYS_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_SET_DELETE_CIPHER_KEYS_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_SET_DELETE_CIPHER_KEYS_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_MAC_STATISTICS_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_MAC_STATISTICS_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_PHY_STATISTICS_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_PHY_STATISTICS_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_BAND_INFO_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_BAND_INFO_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_PHY_INFO_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_PHY_INFO_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_NDIS_GUID_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_NDIS_GUID_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_BSS_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_BSS_ENTRY_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_ASSOCIATION_RESULT_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_ASSOCIATION_RESULT_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_PACKET_PATTERN_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_PACKET_PATTERN_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_IPv4_TCP_SYNC_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_IPv4_TCP_SYNC_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_IPv6TCP_SYNC_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_IPv6TCP_SYNC_CONTAINER>::Cleanup },
        { &ArrayOfElements<WDI_BYTE_BLOB>::AllocateElements, &ArrayOfElements<WDI_BYTE_BLOB>::Cleanup },
        { &ArrayOfElements<WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER>::AllocateElements, &ArrayOfElements<WDI_NEIGHBOR_REPORT_ENTRY_CONTAINER>::Cleanup },
    };
    namespace CONTAINERS
    {
        static const DUMPER::INFO s_rgWdiTlvBssidDumpers[] =
        {
            { 0, NULL, &WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSsidDumpers[] =
        {
            { 0, NULL, &WDI_SSID_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvVendorSpecificIeDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvScanModeDumpers[] =
        {
            { 0, NULL, &WDI_SCAN_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvScanDwellTimeDumpers[] =
        {
            { 0, NULL, &WDI_SCAN_DWELL_TIME_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBandChannelDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDiscoverModeDumpers[] =
        {
            { 0, NULL, &WDI_P2P_DISCOVER_MODE_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDiscoveryChannelSettingsDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceNameHashDumpers[] =
        {
            { 0, NULL, &WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceInformationDiscoveryEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pAsp2ServiceInformationDiscoveryEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pIncludeListenChannelDumpers[] =
        {
            { 0, NULL, &BOOL_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pBackgroundDiscoverModeDumpers[] =
        {
            { 0, NULL, &WDI_P2P_BACKGROUND_DISCOVER_MODE_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDeviceFilterListDumpers[] =
        {
            { 0, NULL, &WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvConnectParametersDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvConnectBssEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvDot11ResetParametersDumpers[] =
        {
            { 0, NULL, &WDI_DOT11_RESET_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvConfiguredMacAddressDumpers[] =
        {
            { 0, NULL, &WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvDisconnectParametersDumpers[] =
        {
            { 0, NULL, &WDI_DISCONNECT_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pSendActionRequestFrameParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGoNegotiationRequestInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pInvitationRequestInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pProvisionDiscoveryRequestInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvBssEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pActionFrameResponseParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_SEND_ACTION_FRAME_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGoNegotiationResponseInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGoNegotiationConfirmationInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pInvitationResponseInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pProvisionDiscoveryResponseInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pIncomingFrameInformationDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvRadioStateParametersDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCreatePortParametersDumpers[] =
        {
            { 0, NULL, &WDI_TASK_CREATE_PORT_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCreatePortMacAddressDumpers[] =
        {
            { 0, NULL, &WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvDeletePortParametersDumpers[] =
        {
            { 0, NULL, &WDI_TASK_DELETE_PORT_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvStartApParametersDumpers[] =
        {
            { sizeof( WDI_START_AP_PARAMETERS_CONTAINER_HELPER::s_RefsWdiTlvStartApParameters ) / sizeof( DUMPER::CONTAINER_REF ), WDI_START_AP_PARAMETERS_CONTAINER_HELPER::s_RefsWdiTlvStartApParameters, &WDI_START_AP_PARAMETERS_CONTAINER_HELPER::s_Container },
            { sizeof( WDI_START_AP_PARAMETERS_CONTAINER_V1_0_1_HELPER::s_RefsWdiTlvStartApParameters ) / sizeof( DUMPER::CONTAINER_REF ), WDI_START_AP_PARAMETERS_CONTAINER_V1_0_1_HELPER::s_RefsWdiTlvStartApParameters, &WDI_START_AP_PARAMETERS_CONTAINER_V1_0_1_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAuthAlgoListDumpers[] =
        {
            { 0, NULL, &WDI_AUTH_ALGORITHM_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvMulticastCipherAlgoListDumpers[] =
        {
            { 0, NULL, &WDI_CIPHER_ALGORITHM_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvUnicastCipherAlgoListDumpers[] =
        {
            { 0, NULL, &WDI_CIPHER_ALGORITHM_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pChannelNumberDumpers[] =
        {
            { 0, NULL, &WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvApBandChannelDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvAssociationResponseParametersDumpers[] =
        {
            { 0, NULL, &WDI_AP_ASSOCIATION_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIncomingAssociationRequestInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvWfdAssociationStatusDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPowerStateDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvEnableWakeEventsDumpers[] =
        {
            { 0, NULL, &WDI_WAKE_EVENT_MASK_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSetPowerDxReasonDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAdapterResumeRequiredDumpers[] =
        {
            { 0, NULL, &BOOL_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pListenStateDumpers[] =
        {
            { 0, NULL, &WDI_P2P_LISTEN_STATE_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pListenDurationDumpers[] =
        {
            { 0, NULL, &WDI_P2P_LISTEN_DURATION_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPrivacyExemptionEntryDumpers[] =
        {
            { 0, NULL, &WDI_PRIVACY_EXEMPTION_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSetCipherKeyInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvDeleteCipherKeyInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvDefaultTxKeyIdParametersDumpers[] =
        {
            { 0, NULL, &WDI_SET_DEFAULT_KEY_ID_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvConnectionQualityParametersDumpers[] =
        {
            { 0, NULL, &WDI_CONNECTION_QUALITY_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvLowLatencyConnectionQualityParametersDumpers[] =
        {
            { 0, NULL, &WDI_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvMacStatisticsDumpers[] =
        {
            { 0, NULL, &WDI_MAC_STATISTICS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPhyStatisticsDumpers[] =
        {
            { 0, NULL, &WDI_PHY_STATISTICS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPacketFilterParametersDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCommunicationConfigurationAttributesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvInterfaceAttributesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvStationAttributesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvApAttributesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvVirtualizationAttributesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pAttributesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvDatapathAttributesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvBandInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvPhyInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvPmCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_PM_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCountryRegionListDumpers[] =
        {
            { 0, NULL, &WDI_COUNTRY_REGION_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvReceiveCoalescingCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_RECEIVE_COALESCING_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTcpOffloadCapabilitiesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvSupportedGuidsDumpers[] =
        {
            { 0, NULL, &WDI_NDIS_GUID_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvNetworkListOffloadParametersDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvSetReceiveCoalescingDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvDisassociationIndicationParametersDumpers[] =
        {
            { 0, NULL, &WDI_DISCONNECT_INDICATION_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvDisconnectDeauthFrameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvDisconnectDisassociationFrameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvDisassociationParametersDumpers[] =
        {
            { 0, NULL, &BOOL_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvRoamingNeededParametersDumpers[] =
        {
            { 0, NULL, &WDI_ROAMING_NEEDED_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvLinkStateChangeParametersDumpers[] =
        {
            { 0, NULL, &WDI_LINK_STATE_CHANGE_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIndicationWakeReasonDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIndicationWakePacketDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIndicationWakePacketPatternIdDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTkipMicFailureInfoDumpers[] =
        {
            { 0, NULL, &WDI_TKIP_MIC_FAILURE_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pSendActionFrameResultDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvRadioStateDumpers[] =
        {
            { 0, NULL, &WDI_RADIO_STATUS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPortAttributesDumpers[] =
        {
            { 0, NULL, &WDI_PORT_ATTRIBUTES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIndicationStopApDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIndicationCanSustainApDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAssociationResponseResultParametersDumpers[] =
        {
            { 0, NULL, &WDI_ASSOC_RESPONSE_RESULT_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAssociationResponseFrameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBeaconIesDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPhyTypeListDumpers[] =
        {
            { 0, NULL, &WDI_PHY_TYPE_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAssociationResultDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvGetAutoPowerSaveDumpers[] =
        {
            { 0, NULL, &WDI_GET_AUTO_POWER_SAVE_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvWakePacketBitmapPatternDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvWakePacketMagicPacketDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvWakePacketIpv4TcpSyncDumpers[] =
        {
            { 0, NULL, &WDI_IPv4_TCP_SYNC_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvWakePacketIpv6TcpSyncDumpers[] =
        {
            { 0, NULL, &WDI_IPv6TCP_SYNC_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvWakePacketEapolRequestIdMessageDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvWakePacketPatternRemoveDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvMulticastListDumpers[] =
        {
            { 0, NULL, &WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPmProtocolOffloadIpv4arpDumpers[] =
        {
            { 0, NULL, &WDI_PM_PROTOCOL_OFFLOAD_IPv4ARP_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPmProtocolOffloadIpv6nsDumpers[] =
        {
            { 0, NULL, &WDI_PM_PROTOCOL_OFFLOAD_IPv6NS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPmProtocolOffload80211rsnRekeyDumpers[] =
        {
            { 0, NULL, &WDI_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPmProtocolOffloadRemoveDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pChannelIndicateReasonDumpers[] =
        {
            { 0, NULL, &WDI_P2P_CHANNEL_INDICATE_REASON_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pChannelListAttributeDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pListenChannelDumpers[] =
        {
            { 0, NULL, &WDI_P2P_CHANNEL_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvUnreachableDetectionThresholdDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGoInternalResetPolicyDumpers[] =
        {
            { 0, NULL, &WDI_P2P_GO_INTERNAL_RESET_POLICY_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBandIdListDumpers[] =
        {
            { 0, NULL, &WDI_BAND_ID_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvLinkQualityBarMapDumpers[] =
        {
            { 0, NULL, &WDI_LINK_QUALITY_BAR_MAP_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAdapterNloScanModeDumpers[] =
        {
            { 0, NULL, &WDI_ADAPTER_NLO_SCAN_MODE_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPldrSupportDumpers[] =
        {
            { 0, NULL, &BOOL_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCoalescingFilterMatchCountDumpers[] =
        {
            { 0, NULL, &UINT64_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSetClearReceiveCoalescingDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPmProtocolOffloadGetDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAdditionalIesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDeviceInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDeviceCapabilityDumpers[] =
        {
            { 0, NULL, &WDI_P2P_DEVICE_CAPABILITY_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGroupOwnerCapabilityDumpers[] =
        {
            { 0, NULL, &WDI_P2P_GROUP_OWNER_CAPABILITY_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pSecondaryDeviceTypeListDumpers[] =
        {
            { 0, NULL, &WDI_P2P_SECONDARY_DEVICE_TYPE_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pAdvertisedServicesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvOperationModeDumpers[] =
        {
            { 0, NULL, &WDI_OPERATION_MODE_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIhvDataDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAssociationParametersRequestedTypeDumpers[] =
        {
            { 0, NULL, &UINT16_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSendActionFrameRequestParametersDumpers[] =
        {
            { 0, NULL, &WDI_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvActionFrameBodyDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBssEntryChannelInfoDumpers[] =
        {
            { 0, NULL, &WDI_CHANNEL_INFO_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSendActionFrameResponseParametersDumpers[] =
        {
            { 0, NULL, &WDI_SEND_ACTION_FRAME_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvNextDialogTokenDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pWpsEnabledDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIhvTaskDeviceContextDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIhvTaskRequestParametersDumpers[] =
        {
            { 0, NULL, &WDI_IHV_TASK_PRIORITY_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCancelParametersDumpers[] =
        {
            { 0, NULL, &WDI_CANCEL_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTcpSetOffloadParametersDumpers[] =
        {
            { 0, NULL, &WDI_SET_OFFLOAD_PARAMS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTcpRscStatisticsParametersDumpers[] =
        {
            { 0, NULL, &WDI_TCP_RSC_STATISTICS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSetEncapsulationOffloadV4ParametersDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSetEncapsulationOffloadV6ParametersDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvFtAuthRequestDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvFtAuthResponseDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvStatusDumpers[] =
        {
            { 0, NULL, &WDI_STATUS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvFtRsnieDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvFtMdeDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvFtFteDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvNeighborReportEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvTest1Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest2Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest3Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest4Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest5Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest6Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest7Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest8Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest9Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest10Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest11Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest12Dumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvTest13Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest14Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest15Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest16Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest17Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest18Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest19Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest20Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest21Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest22Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest23Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvTest24Dumpers[] =
        {
            { 0, NULL, &TEST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAdditionalBeaconIesDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAdditionalProbeResponseIesDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAdditionalProbeRequestDefaultIesDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDeviceInfoParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_DEVICE_INFO_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDeviceNameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBssidInfoDumpers[] =
        {
            { 0, NULL, &WDI_BSSID_INFO_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvOperatingClassDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChannelNumberDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPhyTypeDumpers[] =
        {
            { 0, NULL, &WDI_PHY_TYPE_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceNameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceInformationDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceUpdateIndicatorDumpers[] =
        {
            { 0, NULL, &UINT16_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceTransactionIdDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pInstanceNameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceStatusDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pAdvertisementIdDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pConfigMethodsDumpers[] =
        {
            { 0, NULL, &UINT16_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceTypeDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceTypeHashDumpers[] =
        {
            { 0, NULL, &WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pInstanceNameHashDumpers[] =
        {
            { 0, NULL, &WDI_P2P_SERVICE_NAME_HASH_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pAdvertisedServiceEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pAsp2AdvertisedServiceEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pAdvertisedPrefixEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvBandidDumpers[] =
        {
            { 0, NULL, &WDI_BAND_ID_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChannelInfoListDumpers[] =
        {
            { 0, NULL, &WDI_CHANNEL_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvProbeResponseFrameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBeaconFrameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBssEntrySignalInfoDumpers[] =
        {
            { 0, NULL, &WDI_SIGNAL_INFO_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBssEntryDeviceContextDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBssEntryAgeInfoDumpers[] =
        {
            { 0, NULL, &WDI_AGE_INFO_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDiscoveredServiceEntryDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGoNegotiationRequestParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pDeviceAddressDumpers[] =
        {
            { 0, NULL, &WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pInvitationRequestParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_INVITATION_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGroupBssidDumpers[] =
        {
            { 0, NULL, &WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGroupIdDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pProvisionDiscoveryRequestParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pProvisionServiceAttributesDumpers[] =
        {
            { 0, NULL, &WDI_P2P_PROVISION_SERVICE_ATTRIBUTES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pPersistentGroupIdDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pServiceSessionInfoDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pProvisionDiscoveryResponseParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGoNegotiationResponseParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pGoNegotiationConfirmationParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pInvitationResponseParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_INVITATION_RESPONSE_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pIncomingFrameParametersDumpers[] =
        {
            { 0, NULL, &WDI_P2P_INCOMING_ACTION_FRAME_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pActionFrameIesDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvActionFrameDeviceContextDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIncomingAssociationRequestParametersDumpers[] =
        {
            { 0, NULL, &WDI_AP_ASSOCIATION_REQUEST_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAssociationRequestFrameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAssociationRequestDeviceContextDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pSendActionFrameResultParametersDumpers[] =
        {
            { 0, NULL, &WDI_SEND_ACTION_FRAME_RESULT_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChecksumOffloadV4TxParametersDumpers[] =
        {
            { 0, NULL, &WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChecksumOffloadV4RxParametersDumpers[] =
        {
            { 0, NULL, &WDI_CHECKSUM_OFFLOAD_V4_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChecksumOffloadV6TxParametersDumpers[] =
        {
            { 0, NULL, &WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChecksumOffloadV6RxParametersDumpers[] =
        {
            { 0, NULL, &WDI_CHECKSUM_OFFLOAD_V6_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIpv4ChecksumOffloadDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvIpv6ChecksumOffloadDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvIpv4LsoV2Dumpers[] =
        {
            { 0, NULL, &WDI_IPV4_LSO_V2_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIpv6LsoV2Dumpers[] =
        {
            { 0, NULL, &WDI_IPV6_LSO_V2_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChecksumOffloadCapabilitiesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvLsoV1CapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_LSO_V1_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvLsoV2CapabilitiesDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvReceiveCoalesceOffloadCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvStationCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_STATION_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvUnicastAlgorithmListDumpers[] =
        {
            { 0, NULL, &WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvMulticastDataAlgorithmListDumpers[] =
        {
            { 0, NULL, &WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvMulticastMgmtAlgorithmListDumpers[] =
        {
            { 0, NULL, &WDI_ALGO_PAIRS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvApCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_AP_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvVirtualizationCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_VIRTUALIZATION_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pCapabilitiesDumpers[] =
        {
            { sizeof( WDI_P2P_CAPABILITIES_CONTAINER_HELPER::s_RefsWdiTlvP2pCapabilities ) / sizeof( DUMPER::CONTAINER_REF ), WDI_P2P_CAPABILITIES_CONTAINER_HELPER::s_RefsWdiTlvP2pCapabilities, &WDI_P2P_CAPABILITIES_CONTAINER_HELPER::s_Container },
            { sizeof( WDI_P2P_CAPABILITIES_CONTAINER_V1_0_10_HELPER::s_RefsWdiTlvP2pCapabilities ) / sizeof( DUMPER::CONTAINER_REF ), WDI_P2P_CAPABILITIES_CONTAINER_V1_0_10_HELPER::s_RefsWdiTlvP2pCapabilities, &WDI_P2P_CAPABILITIES_CONTAINER_V1_0_10_HELPER::s_Container },
            { sizeof( WDI_P2P_CAPABILITIES_CONTAINER_V1_0_1_HELPER::s_RefsWdiTlvP2pCapabilities ) / sizeof( DUMPER::CONTAINER_REF ), WDI_P2P_CAPABILITIES_CONTAINER_V1_0_1_HELPER::s_RefsWdiTlvP2pCapabilities, &WDI_P2P_CAPABILITIES_CONTAINER_V1_0_1_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pInterfaceAddressListDumpers[] =
        {
            { 0, NULL, &WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBandCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_BAND_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChannelListDumpers[] =
        {
            { 0, NULL, &WDI_CHANNEL_MAPPING_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvChannelWidthListDumpers[] =
        {
            { 0, NULL, &UINT32_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPhyCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_PHY_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPhyTxPowerLevelListDumpers[] =
        {
            { 0, NULL, &UINT32_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPhyDataRateListDumpers[] =
        {
            { 0, NULL, &WDI_PHY_DATA_RATE_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCommunicationCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_COMMUNICATION_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvInterfaceCapabilitiesDumpers[] =
        {
            { sizeof( WDI_INTERFACE_CAPABILITIES_CONTAINER_HELPER::s_RefsWdiTlvInterfaceCapabilities ) / sizeof( DUMPER::CONTAINER_REF ), WDI_INTERFACE_CAPABILITIES_CONTAINER_HELPER::s_RefsWdiTlvInterfaceCapabilities, &WDI_INTERFACE_CAPABILITIES_CONTAINER_HELPER::s_Container },
            { sizeof( WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_1_HELPER::s_RefsWdiTlvInterfaceCapabilities ) / sizeof( DUMPER::CONTAINER_REF ), WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_1_HELPER::s_RefsWdiTlvInterfaceCapabilities, &WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_1_HELPER::s_Container },
            { sizeof( WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_HELPER::s_RefsWdiTlvInterfaceCapabilities ) / sizeof( DUMPER::CONTAINER_REF ), WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_HELPER::s_RefsWdiTlvInterfaceCapabilities, &WDI_INTERFACE_CAPABILITIES_CONTAINER_V1_0_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvFirmwareVersionDumpers[] =
        {
            { 0, NULL, &WDI_STRING_Z_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvIhvNonWdiOidsListDumpers[] =
        {
            { 0, NULL, &UINT32_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvDatapathCapabilitiesDumpers[] =
        {
            { 0, NULL, &WDI_DATAPATH_CAPABILITIES_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvFtPmkr0nameDumpers[] =
        {
            { 0, NULL, &WDI_TYPE_PMK_NAME_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAccessNetworkTypeDumpers[] =
        {
            { 0, NULL, &UINT8_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvHessidDumpers[] =
        {
            { 0, NULL, &WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvHotspotIndicationElementDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvConnectionSettingsDumpers[] =
        {
            { sizeof( WDI_CONNECTION_SETTINGS_CONTAINER_HELPER::s_RefsWdiTlvConnectionSettings ) / sizeof( DUMPER::CONTAINER_REF ), WDI_CONNECTION_SETTINGS_CONTAINER_HELPER::s_RefsWdiTlvConnectionSettings, &WDI_CONNECTION_SETTINGS_CONTAINER_HELPER::s_Container },
            { sizeof( WDI_CONNECTION_SETTINGS_CONTAINER_V1_0_HELPER::s_RefsWdiTlvConnectionSettings ) / sizeof( DUMPER::CONTAINER_REF ), WDI_CONNECTION_SETTINGS_CONTAINER_V1_0_HELPER::s_RefsWdiTlvConnectionSettings, &WDI_CONNECTION_SETTINGS_CONTAINER_V1_0_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvHessidInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvExtraAssociationRequestIesDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvDisallowedBssidsListDumpers[] =
        {
            { 0, NULL, &WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAllowedBssidsListDumpers[] =
        {
            { 0, NULL, &WDI_ADDRESS_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPmkidDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvFtInitialAssocParametersDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvFtReassocParametersDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvBssSelectionParametersDumpers[] =
        {
            { 0, NULL, &WDI_BSS_SELECTION_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAssociationResultParametersDumpers[] =
        {
            { 0, NULL, &WDI_ASSOCIATION_RESULT_PARAMETERS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvAuthenticationResponseFrameDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBeaconProbeResponseDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvEthertypeEncapTableDumpers[] =
        {
            { 0, NULL, &WDI_ETHERTYPE_ENCAPSULATION_LIST_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyTkipKeyDumpers[] =
        {
            { 0, NULL, &WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyTkipMicDumpers[] =
        {
            { 0, NULL, &WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvPeerMacAddressDumpers[] =
        {
            { 0, NULL, &WDI_MAC_ADDRESS_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyIdDumpers[] =
        {
            { 0, NULL, &WDI_CIPHER_KEY_ID_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyTypeInfoDumpers[] =
        {
            { 0, NULL, &WDI_CIPHER_KEY_TYPE_INFO_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyReceiveSequenceCountDumpers[] =
        {
            { 0, NULL, &WDI_RECEIVE_SEQUENCE_COUNT_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyCcmpKeyDumpers[] =
        {
            { 0, NULL, &WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyGcmpKeyDumpers[] =
        {
            { 0, NULL, &WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyTkipInfoDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyBipKeyDumpers[] =
        {
            { 0, NULL, &WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyWepKeyDumpers[] =
        {
            { 0, NULL, &WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvCipherKeyIhvKeyDumpers[] =
        {
            { 0, NULL, &WDI_PRIVATE_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvNetworkListOffloadConfigDumpers[] =
        {
            { 0, NULL, &WDI_NETWORK_LIST_OFFLOAD_CONFIG_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvSsidOffloadDumpers[] =
        {
            { 0, NULL, NULL },
        };
        static const DUMPER::INFO s_rgWdiTlvReceiveCoalescingConfigDumpers[] =
        {
            { 0, NULL, &WDI_RECEIVE_COALESCING_CONFIG_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvReceiveFilterFieldDumpers[] =
        {
            { 0, NULL, &WDI_RECEIVE_COALESCING_FIELD_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvWakePacketBitmapPatternIdDumpers[] =
        {
            { 0, NULL, &UINT32_CONTAINER_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBitmapPatternDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvBitmapPatternMaskDumpers[] =
        {
            { 0, NULL, &WDI_BYTE_BLOB_HELPER::s_Container },
        };
        static const DUMPER::INFO s_rgWdiTlvP2pChannelEntryListDumpers[] =
        {
            { 0, NULL, NULL },
        };
    }
    namespace DUMPER
    {
        const MAP_ENTRY s_rgAllDumpers[] =
        {
            { WDI_TLV_BSSID, sizeof( CONTAINERS::s_rgWdiTlvBssidDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBssidDumpers },
            { WDI_TLV_SSID, sizeof( CONTAINERS::s_rgWdiTlvSsidDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSsidDumpers },
            { WDI_TLV_VENDOR_SPECIFIC_IE, sizeof( CONTAINERS::s_rgWdiTlvVendorSpecificIeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvVendorSpecificIeDumpers },
            { WDI_TLV_SCAN_MODE, sizeof( CONTAINERS::s_rgWdiTlvScanModeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvScanModeDumpers },
            { WDI_TLV_SCAN_DWELL_TIME, sizeof( CONTAINERS::s_rgWdiTlvScanDwellTimeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvScanDwellTimeDumpers },
            { WDI_TLV_BAND_CHANNEL, sizeof( CONTAINERS::s_rgWdiTlvBandChannelDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBandChannelDumpers },
            { WDI_TLV_P2P_DISCOVER_MODE, sizeof( CONTAINERS::s_rgWdiTlvP2pDiscoverModeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDiscoverModeDumpers },
            { WDI_TLV_P2P_DISCOVERY_CHANNEL_SETTINGS, sizeof( CONTAINERS::s_rgWdiTlvP2pDiscoveryChannelSettingsDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDiscoveryChannelSettingsDumpers },
            { WDI_TLV_P2P_SERVICE_NAME_HASH, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceNameHashDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceNameHashDumpers },
            { WDI_TLV_P2P_SERVICE_INFORMATION_DISCOVERY_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceInformationDiscoveryEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceInformationDiscoveryEntryDumpers },
            { WDI_TLV_P2P_ASP2_SERVICE_INFORMATION_DISCOVERY_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvP2pAsp2ServiceInformationDiscoveryEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pAsp2ServiceInformationDiscoveryEntryDumpers },
            { WDI_TLV_P2P_INCLUDE_LISTEN_CHANNEL, sizeof( CONTAINERS::s_rgWdiTlvP2pIncludeListenChannelDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pIncludeListenChannelDumpers },
            { WDI_TLV_P2P_BACKGROUND_DISCOVER_MODE, sizeof( CONTAINERS::s_rgWdiTlvP2pBackgroundDiscoverModeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pBackgroundDiscoverModeDumpers },
            { WDI_TLV_P2P_DEVICE_FILTER_LIST, sizeof( CONTAINERS::s_rgWdiTlvP2pDeviceFilterListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDeviceFilterListDumpers },
            { WDI_TLV_CONNECT_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvConnectParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvConnectParametersDumpers },
            { WDI_TLV_CONNECT_BSS_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvConnectBssEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvConnectBssEntryDumpers },
            { WDI_TLV_DOT11_RESET_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvDot11ResetParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDot11ResetParametersDumpers },
            { WDI_TLV_CONFIGURED_MAC_ADDRESS, sizeof( CONTAINERS::s_rgWdiTlvConfiguredMacAddressDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvConfiguredMacAddressDumpers },
            { WDI_TLV_DISCONNECT_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvDisconnectParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDisconnectParametersDumpers },
            { WDI_TLV_P2P_SEND_ACTION_REQUEST_FRAME_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pSendActionRequestFrameParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pSendActionRequestFrameParametersDumpers },
            { WDI_TLV_P2P_GO_NEGOTIATION_REQUEST_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pGoNegotiationRequestInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGoNegotiationRequestInfoDumpers },
            { WDI_TLV_P2P_INVITATION_REQUEST_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pInvitationRequestInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pInvitationRequestInfoDumpers },
            { WDI_TLV_P2P_PROVISION_DISCOVERY_REQUEST_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pProvisionDiscoveryRequestInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pProvisionDiscoveryRequestInfoDumpers },
            { WDI_TLV_BSS_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvBssEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBssEntryDumpers },
            { WDI_TLV_P2P_ACTION_FRAME_RESPONSE_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pActionFrameResponseParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pActionFrameResponseParametersDumpers },
            { WDI_TLV_P2P_GO_NEGOTIATION_RESPONSE_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pGoNegotiationResponseInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGoNegotiationResponseInfoDumpers },
            { WDI_TLV_P2P_GO_NEGOTIATION_CONFIRMATION_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pGoNegotiationConfirmationInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGoNegotiationConfirmationInfoDumpers },
            { WDI_TLV_P2P_INVITATION_RESPONSE_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pInvitationResponseInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pInvitationResponseInfoDumpers },
            { WDI_TLV_P2P_PROVISION_DISCOVERY_RESPONSE_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pProvisionDiscoveryResponseInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pProvisionDiscoveryResponseInfoDumpers },
            { WDI_TLV_P2P_INCOMING_FRAME_INFORMATION, sizeof( CONTAINERS::s_rgWdiTlvP2pIncomingFrameInformationDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pIncomingFrameInformationDumpers },
            { WDI_TLV_RADIO_STATE_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvRadioStateParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvRadioStateParametersDumpers },
            { WDI_TLV_CREATE_PORT_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvCreatePortParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCreatePortParametersDumpers },
            { WDI_TLV_CREATE_PORT_MAC_ADDRESS, sizeof( CONTAINERS::s_rgWdiTlvCreatePortMacAddressDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCreatePortMacAddressDumpers },
            { WDI_TLV_DELETE_PORT_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvDeletePortParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDeletePortParametersDumpers },
            { WDI_TLV_START_AP_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvStartApParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvStartApParametersDumpers },
            { WDI_TLV_AUTH_ALGO_LIST, sizeof( CONTAINERS::s_rgWdiTlvAuthAlgoListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAuthAlgoListDumpers },
            { WDI_TLV_MULTICAST_CIPHER_ALGO_LIST, sizeof( CONTAINERS::s_rgWdiTlvMulticastCipherAlgoListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvMulticastCipherAlgoListDumpers },
            { WDI_TLV_UNICAST_CIPHER_ALGO_LIST, sizeof( CONTAINERS::s_rgWdiTlvUnicastCipherAlgoListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvUnicastCipherAlgoListDumpers },
            { WDI_TLV_P2P_CHANNEL_NUMBER, sizeof( CONTAINERS::s_rgWdiTlvP2pChannelNumberDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pChannelNumberDumpers },
            { WDI_TLV_AP_BAND_CHANNEL, sizeof( CONTAINERS::s_rgWdiTlvApBandChannelDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvApBandChannelDumpers },
            { WDI_TLV_ASSOCIATION_RESPONSE_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvAssociationResponseParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAssociationResponseParametersDumpers },
            { WDI_TLV_INCOMING_ASSOCIATION_REQUEST_INFO, sizeof( CONTAINERS::s_rgWdiTlvIncomingAssociationRequestInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIncomingAssociationRequestInfoDumpers },
            { WDI_TLV_WFD_ASSOCIATION_STATUS, sizeof( CONTAINERS::s_rgWdiTlvWfdAssociationStatusDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvWfdAssociationStatusDumpers },
            { WDI_TLV_POWER_STATE, sizeof( CONTAINERS::s_rgWdiTlvPowerStateDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPowerStateDumpers },
            { WDI_TLV_ENABLE_WAKE_EVENTS, sizeof( CONTAINERS::s_rgWdiTlvEnableWakeEventsDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvEnableWakeEventsDumpers },
            { WDI_TLV_SET_POWER_DX_REASON, sizeof( CONTAINERS::s_rgWdiTlvSetPowerDxReasonDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSetPowerDxReasonDumpers },
            { WDI_TLV_ADAPTER_RESUME_REQUIRED, sizeof( CONTAINERS::s_rgWdiTlvAdapterResumeRequiredDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAdapterResumeRequiredDumpers },
            { WDI_TLV_P2P_LISTEN_STATE, sizeof( CONTAINERS::s_rgWdiTlvP2pListenStateDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pListenStateDumpers },
            { WDI_TLV_P2P_LISTEN_DURATION, sizeof( CONTAINERS::s_rgWdiTlvP2pListenDurationDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pListenDurationDumpers },
            { WDI_TLV_PRIVACY_EXEMPTION_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvPrivacyExemptionEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPrivacyExemptionEntryDumpers },
            { WDI_TLV_SET_CIPHER_KEY_INFO, sizeof( CONTAINERS::s_rgWdiTlvSetCipherKeyInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSetCipherKeyInfoDumpers },
            { WDI_TLV_DELETE_CIPHER_KEY_INFO, sizeof( CONTAINERS::s_rgWdiTlvDeleteCipherKeyInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDeleteCipherKeyInfoDumpers },
            { WDI_TLV_DEFAULT_TX_KEY_ID_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvDefaultTxKeyIdParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDefaultTxKeyIdParametersDumpers },
            { WDI_TLV_CONNECTION_QUALITY_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvConnectionQualityParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvConnectionQualityParametersDumpers },
            { WDI_TLV_LOW_LATENCY_CONNECTION_QUALITY_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvLowLatencyConnectionQualityParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvLowLatencyConnectionQualityParametersDumpers },
            { WDI_TLV_MAC_STATISTICS, sizeof( CONTAINERS::s_rgWdiTlvMacStatisticsDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvMacStatisticsDumpers },
            { WDI_TLV_PHY_STATISTICS, sizeof( CONTAINERS::s_rgWdiTlvPhyStatisticsDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPhyStatisticsDumpers },
            { WDI_TLV_PACKET_FILTER_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvPacketFilterParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPacketFilterParametersDumpers },
            { WDI_TLV_COMMUNICATION_CONFIGURATION_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvCommunicationConfigurationAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCommunicationConfigurationAttributesDumpers },
            { WDI_TLV_INTERFACE_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvInterfaceAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvInterfaceAttributesDumpers },
            { WDI_TLV_STATION_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvStationAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvStationAttributesDumpers },
            { WDI_TLV_AP_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvApAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvApAttributesDumpers },
            { WDI_TLV_VIRTUALIZATION_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvVirtualizationAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvVirtualizationAttributesDumpers },
            { WDI_TLV_P2P_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvP2pAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pAttributesDumpers },
            { WDI_TLV_DATAPATH_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvDatapathAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDatapathAttributesDumpers },
            { WDI_TLV_BAND_INFO, sizeof( CONTAINERS::s_rgWdiTlvBandInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBandInfoDumpers },
            { WDI_TLV_PHY_INFO, sizeof( CONTAINERS::s_rgWdiTlvPhyInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPhyInfoDumpers },
            { WDI_TLV_PM_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvPmCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPmCapabilitiesDumpers },
            { WDI_TLV_COUNTRY_REGION_LIST, sizeof( CONTAINERS::s_rgWdiTlvCountryRegionListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCountryRegionListDumpers },
            { WDI_TLV_RECEIVE_COALESCING_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvReceiveCoalescingCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvReceiveCoalescingCapabilitiesDumpers },
            { WDI_TLV_TCP_OFFLOAD_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvTcpOffloadCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTcpOffloadCapabilitiesDumpers },
            { WDI_TLV_SUPPORTED_GUIDS, sizeof( CONTAINERS::s_rgWdiTlvSupportedGuidsDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSupportedGuidsDumpers },
            { WDI_TLV_NETWORK_LIST_OFFLOAD_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvNetworkListOffloadParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvNetworkListOffloadParametersDumpers },
            { WDI_TLV_SET_RECEIVE_COALESCING, sizeof( CONTAINERS::s_rgWdiTlvSetReceiveCoalescingDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSetReceiveCoalescingDumpers },
            { WDI_TLV_DISASSOCIATION_INDICATION_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvDisassociationIndicationParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDisassociationIndicationParametersDumpers },
            { WDI_TLV_DISCONNECT_DEAUTH_FRAME, sizeof( CONTAINERS::s_rgWdiTlvDisconnectDeauthFrameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDisconnectDeauthFrameDumpers },
            { WDI_TLV_DISCONNECT_DISASSOCIATION_FRAME, sizeof( CONTAINERS::s_rgWdiTlvDisconnectDisassociationFrameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDisconnectDisassociationFrameDumpers },
            { WDI_TLV_DISASSOCIATION_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvDisassociationParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDisassociationParametersDumpers },
            { WDI_TLV_ROAMING_NEEDED_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvRoamingNeededParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvRoamingNeededParametersDumpers },
            { WDI_TLV_LINK_STATE_CHANGE_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvLinkStateChangeParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvLinkStateChangeParametersDumpers },
            { WDI_TLV_INDICATION_WAKE_REASON, sizeof( CONTAINERS::s_rgWdiTlvIndicationWakeReasonDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIndicationWakeReasonDumpers },
            { WDI_TLV_INDICATION_WAKE_PACKET, sizeof( CONTAINERS::s_rgWdiTlvIndicationWakePacketDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIndicationWakePacketDumpers },
            { WDI_TLV_INDICATION_WAKE_PACKET_PATTERN_ID, sizeof( CONTAINERS::s_rgWdiTlvIndicationWakePacketPatternIdDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIndicationWakePacketPatternIdDumpers },
            { WDI_TLV_TKIP_MIC_FAILURE_INFO, sizeof( CONTAINERS::s_rgWdiTlvTkipMicFailureInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTkipMicFailureInfoDumpers },
            { WDI_TLV_P2P_SEND_ACTION_FRAME_RESULT, sizeof( CONTAINERS::s_rgWdiTlvP2pSendActionFrameResultDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pSendActionFrameResultDumpers },
            { WDI_TLV_RADIO_STATE, sizeof( CONTAINERS::s_rgWdiTlvRadioStateDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvRadioStateDumpers },
            { WDI_TLV_PORT_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvPortAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPortAttributesDumpers },
            { WDI_TLV_INDICATION_STOP_AP, sizeof( CONTAINERS::s_rgWdiTlvIndicationStopApDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIndicationStopApDumpers },
            { WDI_TLV_INDICATION_CAN_SUSTAIN_AP, sizeof( CONTAINERS::s_rgWdiTlvIndicationCanSustainApDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIndicationCanSustainApDumpers },
            { WDI_TLV_ASSOCIATION_RESPONSE_RESULT_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvAssociationResponseResultParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAssociationResponseResultParametersDumpers },
            { WDI_TLV_ASSOCIATION_RESPONSE_FRAME, sizeof( CONTAINERS::s_rgWdiTlvAssociationResponseFrameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAssociationResponseFrameDumpers },
            { WDI_TLV_BEACON_IES, sizeof( CONTAINERS::s_rgWdiTlvBeaconIesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBeaconIesDumpers },
            { WDI_TLV_PHY_TYPE_LIST, sizeof( CONTAINERS::s_rgWdiTlvPhyTypeListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPhyTypeListDumpers },
            { WDI_TLV_ASSOCIATION_RESULT, sizeof( CONTAINERS::s_rgWdiTlvAssociationResultDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAssociationResultDumpers },
            { WDI_TLV_GET_AUTO_POWER_SAVE, sizeof( CONTAINERS::s_rgWdiTlvGetAutoPowerSaveDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvGetAutoPowerSaveDumpers },
            { WDI_TLV_WAKE_PACKET_BITMAP_PATTERN, sizeof( CONTAINERS::s_rgWdiTlvWakePacketBitmapPatternDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvWakePacketBitmapPatternDumpers },
            { WDI_TLV_WAKE_PACKET_MAGIC_PACKET, sizeof( CONTAINERS::s_rgWdiTlvWakePacketMagicPacketDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvWakePacketMagicPacketDumpers },
            { WDI_TLV_WAKE_PACKET_IPv4_TCP_SYNC, sizeof( CONTAINERS::s_rgWdiTlvWakePacketIpv4TcpSyncDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvWakePacketIpv4TcpSyncDumpers },
            { WDI_TLV_WAKE_PACKET_IPv6_TCP_SYNC, sizeof( CONTAINERS::s_rgWdiTlvWakePacketIpv6TcpSyncDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvWakePacketIpv6TcpSyncDumpers },
            { WDI_TLV_WAKE_PACKET_EAPOL_REQUEST_ID_MESSAGE, sizeof( CONTAINERS::s_rgWdiTlvWakePacketEapolRequestIdMessageDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvWakePacketEapolRequestIdMessageDumpers },
            { WDI_TLV_WAKE_PACKET_PATTERN_REMOVE, sizeof( CONTAINERS::s_rgWdiTlvWakePacketPatternRemoveDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvWakePacketPatternRemoveDumpers },
            { WDI_TLV_MULTICAST_LIST, sizeof( CONTAINERS::s_rgWdiTlvMulticastListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvMulticastListDumpers },
            { WDI_TLV_PM_PROTOCOL_OFFLOAD_IPv4ARP, sizeof( CONTAINERS::s_rgWdiTlvPmProtocolOffloadIpv4arpDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPmProtocolOffloadIpv4arpDumpers },
            { WDI_TLV_PM_PROTOCOL_OFFLOAD_IPv6NS, sizeof( CONTAINERS::s_rgWdiTlvPmProtocolOffloadIpv6nsDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPmProtocolOffloadIpv6nsDumpers },
            { WDI_TLV_PM_PROTOCOL_OFFLOAD_80211RSN_REKEY, sizeof( CONTAINERS::s_rgWdiTlvPmProtocolOffload80211rsnRekeyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPmProtocolOffload80211rsnRekeyDumpers },
            { WDI_TLV_PM_PROTOCOL_OFFLOAD_REMOVE, sizeof( CONTAINERS::s_rgWdiTlvPmProtocolOffloadRemoveDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPmProtocolOffloadRemoveDumpers },
            { WDI_TLV_P2P_CHANNEL_INDICATE_REASON, sizeof( CONTAINERS::s_rgWdiTlvP2pChannelIndicateReasonDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pChannelIndicateReasonDumpers },
            { WDI_TLV_P2P_CHANNEL_LIST_ATTRIBUTE, sizeof( CONTAINERS::s_rgWdiTlvP2pChannelListAttributeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pChannelListAttributeDumpers },
            { WDI_TLV_P2P_LISTEN_CHANNEL, sizeof( CONTAINERS::s_rgWdiTlvP2pListenChannelDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pListenChannelDumpers },
            { WDI_TLV_UNREACHABLE_DETECTION_THRESHOLD, sizeof( CONTAINERS::s_rgWdiTlvUnreachableDetectionThresholdDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvUnreachableDetectionThresholdDumpers },
            { WDI_TLV_P2P_GO_INTERNAL_RESET_POLICY, sizeof( CONTAINERS::s_rgWdiTlvP2pGoInternalResetPolicyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGoInternalResetPolicyDumpers },
            { WDI_TLV_BAND_ID_LIST, sizeof( CONTAINERS::s_rgWdiTlvBandIdListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBandIdListDumpers },
            { WDI_TLV_LINK_QUALITY_BAR_MAP, sizeof( CONTAINERS::s_rgWdiTlvLinkQualityBarMapDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvLinkQualityBarMapDumpers },
            { WDI_TLV_ADAPTER_NLO_SCAN_MODE, sizeof( CONTAINERS::s_rgWdiTlvAdapterNloScanModeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAdapterNloScanModeDumpers },
            { WDI_TLV_PLDR_SUPPORT, sizeof( CONTAINERS::s_rgWdiTlvPldrSupportDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPldrSupportDumpers },
            { WDI_TLV_COALESCING_FILTER_MATCH_COUNT, sizeof( CONTAINERS::s_rgWdiTlvCoalescingFilterMatchCountDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCoalescingFilterMatchCountDumpers },
            { WDI_TLV_SET_CLEAR_RECEIVE_COALESCING, sizeof( CONTAINERS::s_rgWdiTlvSetClearReceiveCoalescingDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSetClearReceiveCoalescingDumpers },
            { WDI_TLV_PM_PROTOCOL_OFFLOAD_GET, sizeof( CONTAINERS::s_rgWdiTlvPmProtocolOffloadGetDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPmProtocolOffloadGetDumpers },
            { WDI_TLV_ADDITIONAL_IES, sizeof( CONTAINERS::s_rgWdiTlvAdditionalIesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAdditionalIesDumpers },
            { WDI_TLV_P2P_DEVICE_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pDeviceInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDeviceInfoDumpers },
            { WDI_TLV_P2P_DEVICE_CAPABILITY, sizeof( CONTAINERS::s_rgWdiTlvP2pDeviceCapabilityDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDeviceCapabilityDumpers },
            { WDI_TLV_P2P_GROUP_OWNER_CAPABILITY, sizeof( CONTAINERS::s_rgWdiTlvP2pGroupOwnerCapabilityDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGroupOwnerCapabilityDumpers },
            { WDI_TLV_P2P_SECONDARY_DEVICE_TYPE_LIST, sizeof( CONTAINERS::s_rgWdiTlvP2pSecondaryDeviceTypeListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pSecondaryDeviceTypeListDumpers },
            { WDI_TLV_P2P_ADVERTISED_SERVICES, sizeof( CONTAINERS::s_rgWdiTlvP2pAdvertisedServicesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pAdvertisedServicesDumpers },
            { WDI_TLV_OPERATION_MODE, sizeof( CONTAINERS::s_rgWdiTlvOperationModeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvOperationModeDumpers },
            { WDI_TLV_IHV_DATA, sizeof( CONTAINERS::s_rgWdiTlvIhvDataDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIhvDataDumpers },
            { WDI_TLV_ASSOCIATION_PARAMETERS_REQUESTED_TYPE, sizeof( CONTAINERS::s_rgWdiTlvAssociationParametersRequestedTypeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAssociationParametersRequestedTypeDumpers },
            { WDI_TLV_SEND_ACTION_FRAME_REQUEST_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvSendActionFrameRequestParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSendActionFrameRequestParametersDumpers },
            { WDI_TLV_ACTION_FRAME_BODY, sizeof( CONTAINERS::s_rgWdiTlvActionFrameBodyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvActionFrameBodyDumpers },
            { WDI_TLV_BSS_ENTRY_CHANNEL_INFO, sizeof( CONTAINERS::s_rgWdiTlvBssEntryChannelInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBssEntryChannelInfoDumpers },
            { WDI_TLV_SEND_ACTION_FRAME_RESPONSE_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvSendActionFrameResponseParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSendActionFrameResponseParametersDumpers },
            { WDI_TLV_NEXT_DIALOG_TOKEN, sizeof( CONTAINERS::s_rgWdiTlvNextDialogTokenDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvNextDialogTokenDumpers },
            { WDI_TLV_P2P_WPS_ENABLED, sizeof( CONTAINERS::s_rgWdiTlvP2pWpsEnabledDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pWpsEnabledDumpers },
            { WDI_TLV_IHV_TASK_DEVICE_CONTEXT, sizeof( CONTAINERS::s_rgWdiTlvIhvTaskDeviceContextDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIhvTaskDeviceContextDumpers },
            { WDI_TLV_IHV_TASK_REQUEST_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvIhvTaskRequestParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIhvTaskRequestParametersDumpers },
            { WDI_TLV_CANCEL_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvCancelParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCancelParametersDumpers },
            { WDI_TLV_TCP_SET_OFFLOAD_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvTcpSetOffloadParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTcpSetOffloadParametersDumpers },
            { WDI_TLV_TCP_RSC_STATISTICS_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvTcpRscStatisticsParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTcpRscStatisticsParametersDumpers },
            { WDI_TLV_SET_ENCAPSULATION_OFFLOAD_V4_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvSetEncapsulationOffloadV4ParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSetEncapsulationOffloadV4ParametersDumpers },
            { WDI_TLV_SET_ENCAPSULATION_OFFLOAD_V6_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvSetEncapsulationOffloadV6ParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSetEncapsulationOffloadV6ParametersDumpers },
            { WDI_TLV_FT_AUTH_REQUEST, sizeof( CONTAINERS::s_rgWdiTlvFtAuthRequestDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFtAuthRequestDumpers },
            { WDI_TLV_FT_AUTH_RESPONSE, sizeof( CONTAINERS::s_rgWdiTlvFtAuthResponseDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFtAuthResponseDumpers },
            { WDI_TLV_STATUS, sizeof( CONTAINERS::s_rgWdiTlvStatusDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvStatusDumpers },
            { WDI_TLV_FT_RSNIE, sizeof( CONTAINERS::s_rgWdiTlvFtRsnieDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFtRsnieDumpers },
            { WDI_TLV_FT_MDE, sizeof( CONTAINERS::s_rgWdiTlvFtMdeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFtMdeDumpers },
            { WDI_TLV_FT_FTE, sizeof( CONTAINERS::s_rgWdiTlvFtFteDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFtFteDumpers },
            { WDI_TLV_NEIGHBOR_REPORT_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvNeighborReportEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvNeighborReportEntryDumpers },
            { WDI_TLV_TEST1, sizeof( CONTAINERS::s_rgWdiTlvTest1Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest1Dumpers },
            { WDI_TLV_TEST2, sizeof( CONTAINERS::s_rgWdiTlvTest2Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest2Dumpers },
            { WDI_TLV_TEST3, sizeof( CONTAINERS::s_rgWdiTlvTest3Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest3Dumpers },
            { WDI_TLV_TEST4, sizeof( CONTAINERS::s_rgWdiTlvTest4Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest4Dumpers },
            { WDI_TLV_TEST5, sizeof( CONTAINERS::s_rgWdiTlvTest5Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest5Dumpers },
            { WDI_TLV_TEST6, sizeof( CONTAINERS::s_rgWdiTlvTest6Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest6Dumpers },
            { WDI_TLV_TEST7, sizeof( CONTAINERS::s_rgWdiTlvTest7Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest7Dumpers },
            { WDI_TLV_TEST8, sizeof( CONTAINERS::s_rgWdiTlvTest8Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest8Dumpers },
            { WDI_TLV_TEST9, sizeof( CONTAINERS::s_rgWdiTlvTest9Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest9Dumpers },
            { WDI_TLV_TEST10, sizeof( CONTAINERS::s_rgWdiTlvTest10Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest10Dumpers },
            { WDI_TLV_TEST11, sizeof( CONTAINERS::s_rgWdiTlvTest11Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest11Dumpers },
            { WDI_TLV_TEST12, sizeof( CONTAINERS::s_rgWdiTlvTest12Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest12Dumpers },
            { WDI_TLV_TEST13, sizeof( CONTAINERS::s_rgWdiTlvTest13Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest13Dumpers },
            { WDI_TLV_TEST14, sizeof( CONTAINERS::s_rgWdiTlvTest14Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest14Dumpers },
            { WDI_TLV_TEST15, sizeof( CONTAINERS::s_rgWdiTlvTest15Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest15Dumpers },
            { WDI_TLV_TEST16, sizeof( CONTAINERS::s_rgWdiTlvTest16Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest16Dumpers },
            { WDI_TLV_TEST17, sizeof( CONTAINERS::s_rgWdiTlvTest17Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest17Dumpers },
            { WDI_TLV_TEST18, sizeof( CONTAINERS::s_rgWdiTlvTest18Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest18Dumpers },
            { WDI_TLV_TEST19, sizeof( CONTAINERS::s_rgWdiTlvTest19Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest19Dumpers },
            { WDI_TLV_TEST20, sizeof( CONTAINERS::s_rgWdiTlvTest20Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest20Dumpers },
            { WDI_TLV_TEST21, sizeof( CONTAINERS::s_rgWdiTlvTest21Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest21Dumpers },
            { WDI_TLV_TEST22, sizeof( CONTAINERS::s_rgWdiTlvTest22Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest22Dumpers },
            { WDI_TLV_TEST23, sizeof( CONTAINERS::s_rgWdiTlvTest23Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest23Dumpers },
            { WDI_TLV_TEST24, sizeof( CONTAINERS::s_rgWdiTlvTest24Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvTest24Dumpers },
            { WDI_TLV_ADDITIONAL_BEACON_IES, sizeof( CONTAINERS::s_rgWdiTlvAdditionalBeaconIesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAdditionalBeaconIesDumpers },
            { WDI_TLV_ADDITIONAL_PROBE_RESPONSE_IES, sizeof( CONTAINERS::s_rgWdiTlvAdditionalProbeResponseIesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAdditionalProbeResponseIesDumpers },
            { WDI_TLV_ADDITIONAL_PROBE_REQUEST_DEFAULT_IES, sizeof( CONTAINERS::s_rgWdiTlvAdditionalProbeRequestDefaultIesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAdditionalProbeRequestDefaultIesDumpers },
            { WDI_TLV_P2P_DEVICE_INFO_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pDeviceInfoParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDeviceInfoParametersDumpers },
            { WDI_TLV_P2P_DEVICE_NAME, sizeof( CONTAINERS::s_rgWdiTlvP2pDeviceNameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDeviceNameDumpers },
            { WDI_TLV_BSSID_INFO, sizeof( CONTAINERS::s_rgWdiTlvBssidInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBssidInfoDumpers },
            { WDI_TLV_OPERATING_CLASS, sizeof( CONTAINERS::s_rgWdiTlvOperatingClassDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvOperatingClassDumpers },
            { WDI_TLV_CHANNEL_NUMBER, sizeof( CONTAINERS::s_rgWdiTlvChannelNumberDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChannelNumberDumpers },
            { WDI_TLV_PHY_TYPE, sizeof( CONTAINERS::s_rgWdiTlvPhyTypeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPhyTypeDumpers },
            { WDI_TLV_P2P_SERVICE_NAME, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceNameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceNameDumpers },
            { WDI_TLV_P2P_SERVICE_INFORMATION, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceInformationDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceInformationDumpers },
            { WDI_TLV_P2P_SERVICE_UPDATE_INDICATOR, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceUpdateIndicatorDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceUpdateIndicatorDumpers },
            { WDI_TLV_P2P_SERVICE_TRANSACTION_ID, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceTransactionIdDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceTransactionIdDumpers },
            { WDI_TLV_P2P_INSTANCE_NAME, sizeof( CONTAINERS::s_rgWdiTlvP2pInstanceNameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pInstanceNameDumpers },
            { WDI_TLV_P2P_SERVICE_STATUS, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceStatusDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceStatusDumpers },
            { WDI_TLV_P2P_ADVERTISEMENT_ID, sizeof( CONTAINERS::s_rgWdiTlvP2pAdvertisementIdDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pAdvertisementIdDumpers },
            { WDI_TLV_P2P_CONFIG_METHODS, sizeof( CONTAINERS::s_rgWdiTlvP2pConfigMethodsDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pConfigMethodsDumpers },
            { WDI_TLV_P2P_SERVICE_TYPE, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceTypeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceTypeDumpers },
            { WDI_TLV_P2P_SERVICE_TYPE_HASH, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceTypeHashDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceTypeHashDumpers },
            { WDI_TLV_P2P_INSTANCE_NAME_HASH, sizeof( CONTAINERS::s_rgWdiTlvP2pInstanceNameHashDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pInstanceNameHashDumpers },
            { WDI_TLV_P2P_ADVERTISED_SERVICE_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvP2pAdvertisedServiceEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pAdvertisedServiceEntryDumpers },
            { WDI_TLV_P2P_ASP2_ADVERTISED_SERVICE_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvP2pAsp2AdvertisedServiceEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pAsp2AdvertisedServiceEntryDumpers },
            { WDI_TLV_P2P_ADVERTISED_PREFIX_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvP2pAdvertisedPrefixEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pAdvertisedPrefixEntryDumpers },
            { WDI_TLV_BANDID, sizeof( CONTAINERS::s_rgWdiTlvBandidDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBandidDumpers },
            { WDI_TLV_CHANNEL_INFO_LIST, sizeof( CONTAINERS::s_rgWdiTlvChannelInfoListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChannelInfoListDumpers },
            { WDI_TLV_PROBE_RESPONSE_FRAME, sizeof( CONTAINERS::s_rgWdiTlvProbeResponseFrameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvProbeResponseFrameDumpers },
            { WDI_TLV_BEACON_FRAME, sizeof( CONTAINERS::s_rgWdiTlvBeaconFrameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBeaconFrameDumpers },
            { WDI_TLV_BSS_ENTRY_SIGNAL_INFO, sizeof( CONTAINERS::s_rgWdiTlvBssEntrySignalInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBssEntrySignalInfoDumpers },
            { WDI_TLV_BSS_ENTRY_DEVICE_CONTEXT, sizeof( CONTAINERS::s_rgWdiTlvBssEntryDeviceContextDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBssEntryDeviceContextDumpers },
            { WDI_TLV_BSS_ENTRY_AGE_INFO, sizeof( CONTAINERS::s_rgWdiTlvBssEntryAgeInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBssEntryAgeInfoDumpers },
            { WDI_TLV_P2P_DISCOVERED_SERVICE_ENTRY, sizeof( CONTAINERS::s_rgWdiTlvP2pDiscoveredServiceEntryDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDiscoveredServiceEntryDumpers },
            { WDI_TLV_P2P_GO_NEGOTIATION_REQUEST_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pGoNegotiationRequestParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGoNegotiationRequestParametersDumpers },
            { WDI_TLV_P2P_DEVICE_ADDRESS, sizeof( CONTAINERS::s_rgWdiTlvP2pDeviceAddressDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pDeviceAddressDumpers },
            { WDI_TLV_P2P_INVITATION_REQUEST_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pInvitationRequestParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pInvitationRequestParametersDumpers },
            { WDI_TLV_P2P_GROUP_BSSID, sizeof( CONTAINERS::s_rgWdiTlvP2pGroupBssidDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGroupBssidDumpers },
            { WDI_TLV_P2P_GROUP_ID, sizeof( CONTAINERS::s_rgWdiTlvP2pGroupIdDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGroupIdDumpers },
            { WDI_TLV_P2P_PROVISION_DISCOVERY_REQUEST_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pProvisionDiscoveryRequestParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pProvisionDiscoveryRequestParametersDumpers },
            { WDI_TLV_P2P_PROVISION_SERVICE_ATTRIBUTES, sizeof( CONTAINERS::s_rgWdiTlvP2pProvisionServiceAttributesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pProvisionServiceAttributesDumpers },
            { WDI_TLV_P2P_PERSISTENT_GROUP_ID, sizeof( CONTAINERS::s_rgWdiTlvP2pPersistentGroupIdDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pPersistentGroupIdDumpers },
            { WDI_TLV_P2P_SERVICE_SESSION_INFO, sizeof( CONTAINERS::s_rgWdiTlvP2pServiceSessionInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pServiceSessionInfoDumpers },
            { WDI_TLV_P2P_PROVISION_DISCOVERY_RESPONSE_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pProvisionDiscoveryResponseParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pProvisionDiscoveryResponseParametersDumpers },
            { WDI_TLV_P2P_GO_NEGOTIATION_RESPONSE_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pGoNegotiationResponseParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGoNegotiationResponseParametersDumpers },
            { WDI_TLV_P2P_GO_NEGOTIATION_CONFIRMATION_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pGoNegotiationConfirmationParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pGoNegotiationConfirmationParametersDumpers },
            { WDI_TLV_P2P_INVITATION_RESPONSE_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pInvitationResponseParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pInvitationResponseParametersDumpers },
            { WDI_TLV_P2P_INCOMING_FRAME_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pIncomingFrameParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pIncomingFrameParametersDumpers },
            { WDI_TLV_P2P_ACTION_FRAME_IES, sizeof( CONTAINERS::s_rgWdiTlvP2pActionFrameIesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pActionFrameIesDumpers },
            { WDI_TLV_ACTION_FRAME_DEVICE_CONTEXT, sizeof( CONTAINERS::s_rgWdiTlvActionFrameDeviceContextDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvActionFrameDeviceContextDumpers },
            { WDI_TLV_INCOMING_ASSOCIATION_REQUEST_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvIncomingAssociationRequestParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIncomingAssociationRequestParametersDumpers },
            { WDI_TLV_ASSOCIATION_REQUEST_FRAME, sizeof( CONTAINERS::s_rgWdiTlvAssociationRequestFrameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAssociationRequestFrameDumpers },
            { WDI_TLV_ASSOCIATION_REQUEST_DEVICE_CONTEXT, sizeof( CONTAINERS::s_rgWdiTlvAssociationRequestDeviceContextDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAssociationRequestDeviceContextDumpers },
            { WDI_TLV_P2P_SEND_ACTION_FRAME_RESULT_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvP2pSendActionFrameResultParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pSendActionFrameResultParametersDumpers },
            { WDI_TLV_CHECKSUM_OFFLOAD_V4_TX_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvChecksumOffloadV4TxParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChecksumOffloadV4TxParametersDumpers },
            { WDI_TLV_CHECKSUM_OFFLOAD_V4_RX_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvChecksumOffloadV4RxParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChecksumOffloadV4RxParametersDumpers },
            { WDI_TLV_CHECKSUM_OFFLOAD_V6_TX_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvChecksumOffloadV6TxParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChecksumOffloadV6TxParametersDumpers },
            { WDI_TLV_CHECKSUM_OFFLOAD_V6_RX_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvChecksumOffloadV6RxParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChecksumOffloadV6RxParametersDumpers },
            { WDI_TLV_IPV4_CHECKSUM_OFFLOAD, sizeof( CONTAINERS::s_rgWdiTlvIpv4ChecksumOffloadDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIpv4ChecksumOffloadDumpers },
            { WDI_TLV_IPV6_CHECKSUM_OFFLOAD, sizeof( CONTAINERS::s_rgWdiTlvIpv6ChecksumOffloadDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIpv6ChecksumOffloadDumpers },
            { WDI_TLV_IPV4_LSO_V2, sizeof( CONTAINERS::s_rgWdiTlvIpv4LsoV2Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIpv4LsoV2Dumpers },
            { WDI_TLV_IPV6_LSO_V2, sizeof( CONTAINERS::s_rgWdiTlvIpv6LsoV2Dumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIpv6LsoV2Dumpers },
            { WDI_TLV_CHECKSUM_OFFLOAD_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvChecksumOffloadCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChecksumOffloadCapabilitiesDumpers },
            { WDI_TLV_LSO_V1_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvLsoV1CapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvLsoV1CapabilitiesDumpers },
            { WDI_TLV_LSO_V2_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvLsoV2CapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvLsoV2CapabilitiesDumpers },
            { WDI_TLV_RECEIVE_COALESCE_OFFLOAD_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvReceiveCoalesceOffloadCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvReceiveCoalesceOffloadCapabilitiesDumpers },
            { WDI_TLV_STATION_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvStationCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvStationCapabilitiesDumpers },
            { WDI_TLV_UNICAST_ALGORITHM_LIST, sizeof( CONTAINERS::s_rgWdiTlvUnicastAlgorithmListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvUnicastAlgorithmListDumpers },
            { WDI_TLV_MULTICAST_DATA_ALGORITHM_LIST, sizeof( CONTAINERS::s_rgWdiTlvMulticastDataAlgorithmListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvMulticastDataAlgorithmListDumpers },
            { WDI_TLV_MULTICAST_MGMT_ALGORITHM_LIST, sizeof( CONTAINERS::s_rgWdiTlvMulticastMgmtAlgorithmListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvMulticastMgmtAlgorithmListDumpers },
            { WDI_TLV_AP_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvApCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvApCapabilitiesDumpers },
            { WDI_TLV_VIRTUALIZATION_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvVirtualizationCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvVirtualizationCapabilitiesDumpers },
            { WDI_TLV_P2P_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvP2pCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pCapabilitiesDumpers },
            { WDI_TLV_P2P_INTERFACE_ADDRESS_LIST, sizeof( CONTAINERS::s_rgWdiTlvP2pInterfaceAddressListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pInterfaceAddressListDumpers },
            { WDI_TLV_BAND_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvBandCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBandCapabilitiesDumpers },
            { WDI_TLV_CHANNEL_LIST, sizeof( CONTAINERS::s_rgWdiTlvChannelListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChannelListDumpers },
            { WDI_TLV_CHANNEL_WIDTH_LIST, sizeof( CONTAINERS::s_rgWdiTlvChannelWidthListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvChannelWidthListDumpers },
            { WDI_TLV_PHY_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvPhyCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPhyCapabilitiesDumpers },
            { WDI_TLV_PHY_TX_POWER_LEVEL_LIST, sizeof( CONTAINERS::s_rgWdiTlvPhyTxPowerLevelListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPhyTxPowerLevelListDumpers },
            { WDI_TLV_PHY_DATA_RATE_LIST, sizeof( CONTAINERS::s_rgWdiTlvPhyDataRateListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPhyDataRateListDumpers },
            { WDI_TLV_COMMUNICATION_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvCommunicationCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCommunicationCapabilitiesDumpers },
            { WDI_TLV_INTERFACE_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvInterfaceCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvInterfaceCapabilitiesDumpers },
            { WDI_TLV_FIRMWARE_VERSION, sizeof( CONTAINERS::s_rgWdiTlvFirmwareVersionDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFirmwareVersionDumpers },
            { WDI_TLV_IHV_NON_WDI_OIDS_LIST, sizeof( CONTAINERS::s_rgWdiTlvIhvNonWdiOidsListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvIhvNonWdiOidsListDumpers },
            { WDI_TLV_DATAPATH_CAPABILITIES, sizeof( CONTAINERS::s_rgWdiTlvDatapathCapabilitiesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDatapathCapabilitiesDumpers },
            { WDI_TLV_FT_PMKR0NAME, sizeof( CONTAINERS::s_rgWdiTlvFtPmkr0nameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFtPmkr0nameDumpers },
            { WDI_TLV_ACCESS_NETWORK_TYPE, sizeof( CONTAINERS::s_rgWdiTlvAccessNetworkTypeDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAccessNetworkTypeDumpers },
            { WDI_TLV_HESSID, sizeof( CONTAINERS::s_rgWdiTlvHessidDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvHessidDumpers },
            { WDI_TLV_HOTSPOT_INDICATION_ELEMENT, sizeof( CONTAINERS::s_rgWdiTlvHotspotIndicationElementDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvHotspotIndicationElementDumpers },
            { WDI_TLV_CONNECTION_SETTINGS, sizeof( CONTAINERS::s_rgWdiTlvConnectionSettingsDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvConnectionSettingsDumpers },
            { WDI_TLV_HESSID_INFO, sizeof( CONTAINERS::s_rgWdiTlvHessidInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvHessidInfoDumpers },
            { WDI_TLV_EXTRA_ASSOCIATION_REQUEST_IES, sizeof( CONTAINERS::s_rgWdiTlvExtraAssociationRequestIesDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvExtraAssociationRequestIesDumpers },
            { WDI_TLV_DISALLOWED_BSSIDS_LIST, sizeof( CONTAINERS::s_rgWdiTlvDisallowedBssidsListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvDisallowedBssidsListDumpers },
            { WDI_TLV_ALLOWED_BSSIDS_LIST, sizeof( CONTAINERS::s_rgWdiTlvAllowedBssidsListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAllowedBssidsListDumpers },
            { WDI_TLV_PMKID, sizeof( CONTAINERS::s_rgWdiTlvPmkidDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPmkidDumpers },
            { WDI_TLV_FT_INITIAL_ASSOC_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvFtInitialAssocParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFtInitialAssocParametersDumpers },
            { WDI_TLV_FT_REASSOC_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvFtReassocParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvFtReassocParametersDumpers },
            { WDI_TLV_BSS_SELECTION_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvBssSelectionParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBssSelectionParametersDumpers },
            { WDI_TLV_ASSOCIATION_RESULT_PARAMETERS, sizeof( CONTAINERS::s_rgWdiTlvAssociationResultParametersDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAssociationResultParametersDumpers },
            { WDI_TLV_AUTHENTICATION_RESPONSE_FRAME, sizeof( CONTAINERS::s_rgWdiTlvAuthenticationResponseFrameDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvAuthenticationResponseFrameDumpers },
            { WDI_TLV_BEACON_PROBE_RESPONSE, sizeof( CONTAINERS::s_rgWdiTlvBeaconProbeResponseDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBeaconProbeResponseDumpers },
            { WDI_TLV_ETHERTYPE_ENCAP_TABLE, sizeof( CONTAINERS::s_rgWdiTlvEthertypeEncapTableDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvEthertypeEncapTableDumpers },
            { WDI_TLV_CIPHER_KEY_TKIP_KEY, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyTkipKeyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyTkipKeyDumpers },
            { WDI_TLV_CIPHER_KEY_TKIP_MIC, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyTkipMicDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyTkipMicDumpers },
            { WDI_TLV_PEER_MAC_ADDRESS, sizeof( CONTAINERS::s_rgWdiTlvPeerMacAddressDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvPeerMacAddressDumpers },
            { WDI_TLV_CIPHER_KEY_ID, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyIdDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyIdDumpers },
            { WDI_TLV_CIPHER_KEY_TYPE_INFO, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyTypeInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyTypeInfoDumpers },
            { WDI_TLV_CIPHER_KEY_RECEIVE_SEQUENCE_COUNT, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyReceiveSequenceCountDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyReceiveSequenceCountDumpers },
            { WDI_TLV_CIPHER_KEY_CCMP_KEY, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyCcmpKeyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyCcmpKeyDumpers },
            { WDI_TLV_CIPHER_KEY_GCMP_KEY, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyGcmpKeyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyGcmpKeyDumpers },
            { WDI_TLV_CIPHER_KEY_TKIP_INFO, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyTkipInfoDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyTkipInfoDumpers },
            { WDI_TLV_CIPHER_KEY_BIP_KEY, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyBipKeyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyBipKeyDumpers },
            { WDI_TLV_CIPHER_KEY_WEP_KEY, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyWepKeyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyWepKeyDumpers },
            { WDI_TLV_CIPHER_KEY_IHV_KEY, sizeof( CONTAINERS::s_rgWdiTlvCipherKeyIhvKeyDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvCipherKeyIhvKeyDumpers },
            { WDI_TLV_NETWORK_LIST_OFFLOAD_CONFIG, sizeof( CONTAINERS::s_rgWdiTlvNetworkListOffloadConfigDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvNetworkListOffloadConfigDumpers },
            { WDI_TLV_SSID_OFFLOAD, sizeof( CONTAINERS::s_rgWdiTlvSsidOffloadDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvSsidOffloadDumpers },
            { WDI_TLV_RECEIVE_COALESCING_CONFIG, sizeof( CONTAINERS::s_rgWdiTlvReceiveCoalescingConfigDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvReceiveCoalescingConfigDumpers },
            { WDI_TLV_RECEIVE_FILTER_FIELD, sizeof( CONTAINERS::s_rgWdiTlvReceiveFilterFieldDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvReceiveFilterFieldDumpers },
            { WDI_TLV_WAKE_PACKET_BITMAP_PATTERN_ID, sizeof( CONTAINERS::s_rgWdiTlvWakePacketBitmapPatternIdDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvWakePacketBitmapPatternIdDumpers },
            { WDI_TLV_BITMAP_PATTERN, sizeof( CONTAINERS::s_rgWdiTlvBitmapPatternDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBitmapPatternDumpers },
            { WDI_TLV_BITMAP_PATTERN_MASK, sizeof( CONTAINERS::s_rgWdiTlvBitmapPatternMaskDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvBitmapPatternMaskDumpers },
            { WDI_TLV_P2P_CHANNEL_ENTRY_LIST, sizeof( CONTAINERS::s_rgWdiTlvP2pChannelEntryListDumpers ) / sizeof( INFO ), CONTAINERS::s_rgWdiTlvP2pChannelEntryListDumpers },
        };
        const size_t s_cAllDumpers = sizeof( s_rgAllDumpers ) / sizeof( MAP_ENTRY );
    }
}
NDIS_STATUS __stdcall GenerateWdiTaskOpen(
    _In_opt_ WDI_TASK_OPEN_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskOpen(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_OPEN_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskOpen( _In_ WDI_TASK_OPEN_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_OPEN_PARAMETERS*>(pParsedMessage)->~WDI_TASK_OPEN_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_OPEN_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskClose(
    _In_opt_ WDI_TASK_CLOSE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskClose(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_CLOSE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskClose( _In_ WDI_TASK_CLOSE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_CLOSE_PARAMETERS*>(pParsedMessage)->~WDI_TASK_CLOSE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_CLOSE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetHostDetectError(
    _In_opt_ WDI_SET_HOST_DETECT_ERROR_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetHostDetectError(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_HOST_DETECT_ERROR_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetHostDetectError( _In_ WDI_SET_HOST_DETECT_ERROR_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_HOST_DETECT_ERROR_PARAMETERS*>(pParsedMessage)->~WDI_SET_HOST_DETECT_ERROR_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_HOST_DETECT_ERROR_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskScanToIhv(
    _In_ WDI_SCAN_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SCAN),
        WDI_TLV::CONTAINERS::WDI_SCAN_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskScanToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SCAN_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SCAN),
        WDI_TLV::CONTAINERS::WDI_SCAN_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskScanToIhv( _In_ WDI_SCAN_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SCAN_PARAMETERS*>(pParsedMessage)->~WDI_SCAN_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SCAN_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskScanFromIhv(
    _In_opt_ WDI_SCAN_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskScanFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SCAN_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskScanFromIhv( _In_ WDI_SCAN_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SCAN_RESULTS*>(pParsedMessage)->~WDI_SCAN_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SCAN_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskP2pDiscoverToIhv(
    _In_ WDI_TASK_P2P_DISCOVER_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_P2P_DISCOVER),
        WDI_TLV::CONTAINERS::WDI_TASK_P2P_DISCOVER_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskP2pDiscoverToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_P2P_DISCOVER_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_P2P_DISCOVER),
        WDI_TLV::CONTAINERS::WDI_TASK_P2P_DISCOVER_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskP2pDiscoverToIhv( _In_ WDI_TASK_P2P_DISCOVER_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_P2P_DISCOVER_PARAMETERS*>(pParsedMessage)->~WDI_TASK_P2P_DISCOVER_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_P2P_DISCOVER_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskP2pDiscoverFromIhv(
    _In_opt_ WDI_TASK_P2P_DISCOVER_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskP2pDiscoverFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_P2P_DISCOVER_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskP2pDiscoverFromIhv( _In_ WDI_TASK_P2P_DISCOVER_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_P2P_DISCOVER_RESULTS*>(pParsedMessage)->~WDI_TASK_P2P_DISCOVER_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_P2P_DISCOVER_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetP2pStartBackgroundDiscoveryToIhv(
    _In_ WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_P2P_START_BACKGROUND_DISCOVERY),
        WDI_TLV::CONTAINERS::WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetP2pStartBackgroundDiscoveryToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_P2P_START_BACKGROUND_DISCOVERY),
        WDI_TLV::CONTAINERS::WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetP2pStartBackgroundDiscoveryToIhv( _In_ WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS*>(pParsedMessage)->~WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetP2pStartBackgroundDiscoveryFromIhv(
    _In_opt_ WDI_SET_P2P_START_BACKGROUND_DISCOVERY_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetP2pStartBackgroundDiscoveryFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_P2P_START_BACKGROUND_DISCOVERY_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetP2pStartBackgroundDiscoveryFromIhv( _In_ WDI_SET_P2P_START_BACKGROUND_DISCOVERY_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_P2P_START_BACKGROUND_DISCOVERY_RESULTS*>(pParsedMessage)->~WDI_SET_P2P_START_BACKGROUND_DISCOVERY_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_P2P_START_BACKGROUND_DISCOVERY_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetP2pStopBackgroundDiscovery(
    _In_opt_ WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetP2pStopBackgroundDiscovery(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetP2pStopBackgroundDiscovery( _In_ WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS*>(pParsedMessage)->~WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskConnectToIhv(
    _In_ WDI_TASK_CONNECT_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_CONNECT),
        WDI_TLV::CONTAINERS::WDI_TASK_CONNECT_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskConnectToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_CONNECT_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_CONNECT),
        WDI_TLV::CONTAINERS::WDI_TASK_CONNECT_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskConnectToIhv( _In_ WDI_TASK_CONNECT_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_CONNECT_PARAMETERS*>(pParsedMessage)->~WDI_TASK_CONNECT_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_CONNECT_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskConnectFromIhv(
    _In_opt_ WDI_TASK_CONNECT_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskConnectFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_CONNECT_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskConnectFromIhv( _In_ WDI_TASK_CONNECT_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_CONNECT_RESULTS*>(pParsedMessage)->~WDI_TASK_CONNECT_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_CONNECT_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskDot11ResetToIhv(
    _In_ WDI_TASK_DOT11_RESET_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_DOT11_RESET),
        WDI_TLV::CONTAINERS::WDI_TASK_DOT11_RESET_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskDot11ResetToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_DOT11_RESET_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_DOT11_RESET),
        WDI_TLV::CONTAINERS::WDI_TASK_DOT11_RESET_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskDot11ResetToIhv( _In_ WDI_TASK_DOT11_RESET_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_DOT11_RESET_PARAMETERS*>(pParsedMessage)->~WDI_TASK_DOT11_RESET_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_DOT11_RESET_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskDot11ResetFromIhv(
    _In_opt_ WDI_TASK_DOT11_RESET_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskDot11ResetFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_DOT11_RESET_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskDot11ResetFromIhv( _In_ WDI_TASK_DOT11_RESET_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_DOT11_RESET_RESULTS*>(pParsedMessage)->~WDI_TASK_DOT11_RESET_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_DOT11_RESET_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskDisconnectToIhv(
    _In_ WDI_TASK_DISCONNECT_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_DISCONNECT),
        WDI_TLV::CONTAINERS::WDI_TASK_DISCONNECT_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskDisconnectToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_DISCONNECT_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_DISCONNECT),
        WDI_TLV::CONTAINERS::WDI_TASK_DISCONNECT_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskDisconnectToIhv( _In_ WDI_TASK_DISCONNECT_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_DISCONNECT_PARAMETERS*>(pParsedMessage)->~WDI_TASK_DISCONNECT_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_DISCONNECT_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskDisconnectFromIhv(
    _In_opt_ WDI_TASK_DISCONNECT_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskDisconnectFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_DISCONNECT_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskDisconnectFromIhv( _In_ WDI_TASK_DISCONNECT_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_DISCONNECT_RESULTS*>(pParsedMessage)->~WDI_TASK_DISCONNECT_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_DISCONNECT_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskP2pSendRequestActionFrameToIhv(
    _In_ WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME),
        WDI_TLV::CONTAINERS::WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskP2pSendRequestActionFrameToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME),
        WDI_TLV::CONTAINERS::WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskP2pSendRequestActionFrameToIhv( _In_ WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS*>(pParsedMessage)->~WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskP2pSendRequestActionFrameFromIhv(
    _In_opt_ WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskP2pSendRequestActionFrameFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskP2pSendRequestActionFrameFromIhv( _In_ WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_RESULTS*>(pParsedMessage)->~WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskP2pSendResponseActionFrameToIhv(
    _In_ WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME),
        WDI_TLV::CONTAINERS::WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskP2pSendResponseActionFrameToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME),
        WDI_TLV::CONTAINERS::WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskP2pSendResponseActionFrameToIhv( _In_ WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS*>(pParsedMessage)->~WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskP2pSendResponseActionFrameFromIhv(
    _In_opt_ WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskP2pSendResponseActionFrameFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskP2pSendResponseActionFrameFromIhv( _In_ WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_RESULTS*>(pParsedMessage)->~WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSetRadioStateToIhv(
    _In_ WDI_SET_RADIO_STATE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SET_RADIO_STATE),
        WDI_TLV::CONTAINERS::WDI_SET_RADIO_STATE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSetRadioStateToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_RADIO_STATE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SET_RADIO_STATE),
        WDI_TLV::CONTAINERS::WDI_SET_RADIO_STATE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSetRadioStateToIhv( _In_ WDI_SET_RADIO_STATE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_RADIO_STATE_PARAMETERS*>(pParsedMessage)->~WDI_SET_RADIO_STATE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_RADIO_STATE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSetRadioStateFromIhv(
    _In_opt_ WDI_SET_RADIO_STATE_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSetRadioStateFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_RADIO_STATE_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSetRadioStateFromIhv( _In_ WDI_SET_RADIO_STATE_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_RADIO_STATE_RESULTS*>(pParsedMessage)->~WDI_SET_RADIO_STATE_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_RADIO_STATE_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskCreatePortToIhv(
    _In_ WDI_TASK_CREATE_PORT_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_CREATE_PORT),
        WDI_TLV::CONTAINERS::WDI_TASK_CREATE_PORT_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskCreatePortToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_CREATE_PORT_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_CREATE_PORT),
        WDI_TLV::CONTAINERS::WDI_TASK_CREATE_PORT_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskCreatePortToIhv( _In_ WDI_TASK_CREATE_PORT_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_CREATE_PORT_PARAMETERS*>(pParsedMessage)->~WDI_TASK_CREATE_PORT_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_CREATE_PORT_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskCreatePortFromIhv(
    _In_opt_ WDI_TASK_CREATE_PORT_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskCreatePortFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_CREATE_PORT_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskCreatePortFromIhv( _In_ WDI_TASK_CREATE_PORT_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_CREATE_PORT_RESULTS*>(pParsedMessage)->~WDI_TASK_CREATE_PORT_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_CREATE_PORT_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskDeletePortToIhv(
    _In_ WDI_TASK_DELETE_PORT_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_DELETE_PORT),
        WDI_TLV::CONTAINERS::WDI_TASK_DELETE_PORT_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskDeletePortToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_DELETE_PORT_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_DELETE_PORT),
        WDI_TLV::CONTAINERS::WDI_TASK_DELETE_PORT_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskDeletePortToIhv( _In_ WDI_TASK_DELETE_PORT_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_DELETE_PORT_PARAMETERS*>(pParsedMessage)->~WDI_TASK_DELETE_PORT_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_DELETE_PORT_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskDeletePortFromIhv(
    _In_opt_ WDI_TASK_DELETE_PORT_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskDeletePortFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_DELETE_PORT_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskDeletePortFromIhv( _In_ WDI_TASK_DELETE_PORT_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_DELETE_PORT_RESULTS*>(pParsedMessage)->~WDI_TASK_DELETE_PORT_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_DELETE_PORT_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskStartApToIhv(
    _In_ WDI_TASK_START_AP_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_START_AP),
        WDI_TLV::CONTAINERS::WDI_TASK_START_AP_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskStartApToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_START_AP_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_START_AP),
        WDI_TLV::CONTAINERS::WDI_TASK_START_AP_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskStartApToIhv( _In_ WDI_TASK_START_AP_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_START_AP_PARAMETERS*>(pParsedMessage)->~WDI_TASK_START_AP_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_START_AP_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskStartApFromIhv(
    _In_opt_ WDI_TASK_START_AP_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskStartApFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_START_AP_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskStartApFromIhv( _In_ WDI_TASK_START_AP_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_START_AP_RESULTS*>(pParsedMessage)->~WDI_TASK_START_AP_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_START_AP_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskStopAp(
    _In_opt_ WDI_TASK_STOP_AP_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskStopAp(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_STOP_AP_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskStopAp( _In_ WDI_TASK_STOP_AP_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_STOP_AP_PARAMETERS*>(pParsedMessage)->~WDI_TASK_STOP_AP_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_STOP_AP_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSendApAssociationResponseToIhv(
    _In_ WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE),
        WDI_TLV::CONTAINERS::WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSendApAssociationResponseToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE),
        WDI_TLV::CONTAINERS::WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSendApAssociationResponseToIhv( _In_ WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS*>(pParsedMessage)->~WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSendApAssociationResponseFromIhv(
    _In_opt_ WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSendApAssociationResponseFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSendApAssociationResponseFromIhv( _In_ WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_RESULTS*>(pParsedMessage)->~WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSetReadyToReceiveIndications(
    _In_opt_ WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSetReadyToReceiveIndications(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSetReadyToReceiveIndications( _In_ WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS*>(pParsedMessage)->~WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetPowerStateToIhv(
    _In_ WDI_SET_POWER_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_POWER_STATE),
        WDI_TLV::CONTAINERS::WDI_SET_POWER_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetPowerStateToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_POWER_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_POWER_STATE),
        WDI_TLV::CONTAINERS::WDI_SET_POWER_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetPowerStateToIhv( _In_ WDI_SET_POWER_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_POWER_PARAMETERS*>(pParsedMessage)->~WDI_SET_POWER_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_POWER_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetPowerStateFromIhv(
    _In_ WDI_SET_POWER_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_POWER_STATE),
        WDI_TLV::CONTAINERS::WDI_SET_POWER_RESULTS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetPowerStateFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_POWER_RESULTS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_POWER_STATE),
        WDI_TLV::CONTAINERS::WDI_SET_POWER_RESULTS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetPowerStateFromIhv( _In_ WDI_SET_POWER_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_POWER_RESULTS*>(pParsedMessage)->~WDI_SET_POWER_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_POWER_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationDisconnectCompleteFromIhv(
    _In_opt_ WDI_INDICATION_DISCONNECT_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationDisconnectCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_DISCONNECT_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationDisconnectCompleteFromIhv( _In_ WDI_INDICATION_DISCONNECT_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_DISCONNECT_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_DISCONNECT_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_DISCONNECT_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationSetRadioStateCompleteFromIhv(
    _In_opt_ WDI_INDICATION_SET_RADIO_STATE_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationSetRadioStateCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_SET_RADIO_STATE_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationSetRadioStateCompleteFromIhv( _In_ WDI_INDICATION_SET_RADIO_STATE_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_SET_RADIO_STATE_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_SET_RADIO_STATE_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_SET_RADIO_STATE_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationSetReadyToReceiveIndicationsCompleteFromIhv(
    _In_opt_ WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationSetReadyToReceiveIndicationsCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationSetReadyToReceiveIndicationsCompleteFromIhv( _In_ WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetOperationMode(
    _In_opt_ WDI_SET_OPERATION_MODE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetOperationMode(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_OPERATION_MODE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetOperationMode( _In_ WDI_SET_OPERATION_MODE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_OPERATION_MODE_PARAMETERS*>(pParsedMessage)->~WDI_SET_OPERATION_MODE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_OPERATION_MODE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetEndDwellTime(
    _In_opt_ WDI_SET_END_DWELL_TIME_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetEndDwellTime(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_END_DWELL_TIME_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetEndDwellTime( _In_ WDI_SET_END_DWELL_TIME_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_END_DWELL_TIME_PARAMETERS*>(pParsedMessage)->~WDI_SET_END_DWELL_TIME_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_END_DWELL_TIME_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetP2pListenStateToIhv(
    _In_ WDI_SET_P2P_LISTEN_STATE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_P2P_LISTEN_STATE),
        WDI_TLV::CONTAINERS::WDI_SET_P2P_LISTEN_STATE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetP2pListenStateToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_P2P_LISTEN_STATE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_P2P_LISTEN_STATE),
        WDI_TLV::CONTAINERS::WDI_SET_P2P_LISTEN_STATE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetP2pListenStateToIhv( _In_ WDI_SET_P2P_LISTEN_STATE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_P2P_LISTEN_STATE_PARAMETERS*>(pParsedMessage)->~WDI_SET_P2P_LISTEN_STATE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_P2P_LISTEN_STATE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetP2pListenStateFromIhv(
    _In_opt_ WDI_SET_P2P_LISTEN_STATE_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetP2pListenStateFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_P2P_LISTEN_STATE_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetP2pListenStateFromIhv( _In_ WDI_SET_P2P_LISTEN_STATE_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_P2P_LISTEN_STATE_RESULTS*>(pParsedMessage)->~WDI_SET_P2P_LISTEN_STATE_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_P2P_LISTEN_STATE_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetPrivacyExemptionListToIhv(
    _In_ WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_PRIVACY_EXEMPTION_LIST),
        WDI_TLV::CONTAINERS::WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetPrivacyExemptionListToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_PRIVACY_EXEMPTION_LIST),
        WDI_TLV::CONTAINERS::WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetPrivacyExemptionListToIhv( _In_ WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS*>(pParsedMessage)->~WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetPrivacyExemptionListFromIhv(
    _In_opt_ WDI_SET_PRIVACY_EXEMPTION_LIST_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetPrivacyExemptionListFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_PRIVACY_EXEMPTION_LIST_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetPrivacyExemptionListFromIhv( _In_ WDI_SET_PRIVACY_EXEMPTION_LIST_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_PRIVACY_EXEMPTION_LIST_RESULTS*>(pParsedMessage)->~WDI_SET_PRIVACY_EXEMPTION_LIST_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_PRIVACY_EXEMPTION_LIST_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAddCipherKeysToIhv(
    _In_ WDI_SET_ADD_CIPHER_KEYS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADD_CIPHER_KEYS),
        WDI_TLV::CONTAINERS::WDI_SET_ADD_CIPHER_KEYS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAddCipherKeysToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_ADD_CIPHER_KEYS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADD_CIPHER_KEYS),
        WDI_TLV::CONTAINERS::WDI_SET_ADD_CIPHER_KEYS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAddCipherKeysToIhv( _In_ WDI_SET_ADD_CIPHER_KEYS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ADD_CIPHER_KEYS_PARAMETERS*>(pParsedMessage)->~WDI_SET_ADD_CIPHER_KEYS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ADD_CIPHER_KEYS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAddCipherKeysFromIhv(
    _In_opt_ WDI_SET_ADD_CIPHER_KEYS_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAddCipherKeysFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_ADD_CIPHER_KEYS_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAddCipherKeysFromIhv( _In_ WDI_SET_ADD_CIPHER_KEYS_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ADD_CIPHER_KEYS_RESULTS*>(pParsedMessage)->~WDI_SET_ADD_CIPHER_KEYS_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ADD_CIPHER_KEYS_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetDeleteCipherKeysToIhv(
    _In_ WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_DELETE_CIPHER_KEYS),
        WDI_TLV::CONTAINERS::WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetDeleteCipherKeysToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_DELETE_CIPHER_KEYS),
        WDI_TLV::CONTAINERS::WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetDeleteCipherKeysToIhv( _In_ WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS*>(pParsedMessage)->~WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetDeleteCipherKeysFromIhv(
    _In_opt_ WDI_SET_DELETE_CIPHER_KEYS_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetDeleteCipherKeysFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_DELETE_CIPHER_KEYS_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetDeleteCipherKeysFromIhv( _In_ WDI_SET_DELETE_CIPHER_KEYS_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_DELETE_CIPHER_KEYS_RESULTS*>(pParsedMessage)->~WDI_SET_DELETE_CIPHER_KEYS_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_DELETE_CIPHER_KEYS_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetDefaultKeyIdToIhv(
    _In_ WDI_SET_DEFAULT_KEY_ID_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_DEFAULT_KEY_ID),
        WDI_TLV::CONTAINERS::WDI_SET_DEFAULT_KEY_ID_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetDefaultKeyIdToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_DEFAULT_KEY_ID_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_DEFAULT_KEY_ID),
        WDI_TLV::CONTAINERS::WDI_SET_DEFAULT_KEY_ID_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetDefaultKeyIdToIhv( _In_ WDI_SET_DEFAULT_KEY_ID_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_DEFAULT_KEY_ID_PARAMETERS*>(pParsedMessage)->~WDI_SET_DEFAULT_KEY_ID_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_DEFAULT_KEY_ID_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetDefaultKeyIdFromIhv(
    _In_opt_ WDI_SET_DEFAULT_KEY_ID_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetDefaultKeyIdFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_DEFAULT_KEY_ID_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetDefaultKeyIdFromIhv( _In_ WDI_SET_DEFAULT_KEY_ID_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_DEFAULT_KEY_ID_RESULTS*>(pParsedMessage)->~WDI_SET_DEFAULT_KEY_ID_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_DEFAULT_KEY_ID_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetConnectionQualityToIhv(
    _In_ WDI_SET_CONNECTION_QUALITY_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_CONNECTION_QUALITY),
        WDI_TLV::CONTAINERS::WDI_SET_CONNECTION_QUALITY_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetConnectionQualityToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_CONNECTION_QUALITY_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_CONNECTION_QUALITY),
        WDI_TLV::CONTAINERS::WDI_SET_CONNECTION_QUALITY_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetConnectionQualityToIhv( _In_ WDI_SET_CONNECTION_QUALITY_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_CONNECTION_QUALITY_PARAMETERS*>(pParsedMessage)->~WDI_SET_CONNECTION_QUALITY_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_CONNECTION_QUALITY_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetConnectionQualityFromIhv(
    _In_opt_ WDI_SET_CONNECTION_QUALITY_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetConnectionQualityFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_CONNECTION_QUALITY_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetConnectionQualityFromIhv( _In_ WDI_SET_CONNECTION_QUALITY_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_CONNECTION_QUALITY_RESULTS*>(pParsedMessage)->~WDI_SET_CONNECTION_QUALITY_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_CONNECTION_QUALITY_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetStatisticsToIhv(
    _In_opt_ WDI_GET_STATISTICS_INPUTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetStatisticsToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_GET_STATISTICS_INPUTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiGetStatisticsToIhv( _In_ WDI_GET_STATISTICS_INPUTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_STATISTICS_INPUTS*>(pParsedMessage)->~WDI_GET_STATISTICS_INPUTS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_STATISTICS_INPUTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetStatisticsFromIhv(
    _In_ WDI_GET_STATISTICS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_STATISTICS),
        WDI_TLV::CONTAINERS::WDI_GET_STATISTICS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetStatisticsFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_GET_STATISTICS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_STATISTICS),
        WDI_TLV::CONTAINERS::WDI_GET_STATISTICS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiGetStatisticsFromIhv( _In_ WDI_GET_STATISTICS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_STATISTICS_PARAMETERS*>(pParsedMessage)->~WDI_GET_STATISTICS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_STATISTICS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetReceivePacketFilterToIhv(
    _In_ WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_RECEIVE_PACKET_FILTER),
        WDI_TLV::CONTAINERS::WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetReceivePacketFilterToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_RECEIVE_PACKET_FILTER),
        WDI_TLV::CONTAINERS::WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetReceivePacketFilterToIhv( _In_ WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS*>(pParsedMessage)->~WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetReceivePacketFilterFromIhv(
    _In_opt_ WDI_SET_RECEIVE_PACKET_FILTER_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetReceivePacketFilterFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_RECEIVE_PACKET_FILTER_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetReceivePacketFilterFromIhv( _In_ WDI_SET_RECEIVE_PACKET_FILTER_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_RECEIVE_PACKET_FILTER_RESULTS*>(pParsedMessage)->~WDI_SET_RECEIVE_PACKET_FILTER_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_RECEIVE_PACKET_FILTER_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetAdapterCapabilitiesToIhv(
    _In_opt_ WDI_GET_ADAPTER_CAPABILITIES_INPUTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetAdapterCapabilitiesToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_GET_ADAPTER_CAPABILITIES_INPUTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiGetAdapterCapabilitiesToIhv( _In_ WDI_GET_ADAPTER_CAPABILITIES_INPUTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_ADAPTER_CAPABILITIES_INPUTS*>(pParsedMessage)->~WDI_GET_ADAPTER_CAPABILITIES_INPUTS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_ADAPTER_CAPABILITIES_INPUTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetAdapterCapabilitiesFromIhv(
    _In_ WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_ADAPTER_CAPABILITIES),
        WDI_TLV::CONTAINERS::WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetAdapterCapabilitiesFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_ADAPTER_CAPABILITIES),
        WDI_TLV::CONTAINERS::WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiGetAdapterCapabilitiesFromIhv( _In_ WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS*>(pParsedMessage)->~WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetNetworkListOffloadToIhv(
    _In_ WDI_NETWORK_LIST_OFFLOAD_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_NETWORK_LIST_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_NETWORK_LIST_OFFLOAD_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetNetworkListOffloadToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_NETWORK_LIST_OFFLOAD_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_NETWORK_LIST_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_NETWORK_LIST_OFFLOAD_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetNetworkListOffloadToIhv( _In_ WDI_NETWORK_LIST_OFFLOAD_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_NETWORK_LIST_OFFLOAD_PARAMETERS*>(pParsedMessage)->~WDI_NETWORK_LIST_OFFLOAD_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_NETWORK_LIST_OFFLOAD_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetNetworkListOffloadFromIhv(
    _In_opt_ WDI_NETWORK_LIST_OFFLOAD_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetNetworkListOffloadFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_NETWORK_LIST_OFFLOAD_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetNetworkListOffloadFromIhv( _In_ WDI_NETWORK_LIST_OFFLOAD_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_NETWORK_LIST_OFFLOAD_RESULTS*>(pParsedMessage)->~WDI_NETWORK_LIST_OFFLOAD_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_NETWORK_LIST_OFFLOAD_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetReceiveCoalescingToIhv(
    _In_ WDI_SET_RECEIVE_COALESCING_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_RECEIVE_COALESCING),
        WDI_TLV::CONTAINERS::WDI_SET_RECEIVE_COALESCING_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetReceiveCoalescingToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_RECEIVE_COALESCING_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_RECEIVE_COALESCING),
        WDI_TLV::CONTAINERS::WDI_SET_RECEIVE_COALESCING_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetReceiveCoalescingToIhv( _In_ WDI_SET_RECEIVE_COALESCING_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_RECEIVE_COALESCING_PARAMETERS*>(pParsedMessage)->~WDI_SET_RECEIVE_COALESCING_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_RECEIVE_COALESCING_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetReceiveCoalescingFromIhv(
    _In_opt_ WDI_SET_RECEIVE_COALESCING_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetReceiveCoalescingFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_RECEIVE_COALESCING_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetReceiveCoalescingFromIhv( _In_ WDI_SET_RECEIVE_COALESCING_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_RECEIVE_COALESCING_RESULTS*>(pParsedMessage)->~WDI_SET_RECEIVE_COALESCING_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_RECEIVE_COALESCING_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetBssEntryListToIhv(
    _In_ WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_BSS_ENTRY_LIST),
        WDI_TLV::CONTAINERS::WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetBssEntryListToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_BSS_ENTRY_LIST),
        WDI_TLV::CONTAINERS::WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiGetBssEntryListToIhv( _In_ WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS*>(pParsedMessage)->~WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetBssEntryListFromIhv(
    _In_opt_ WDI_GET_BSS_ENTRY_LIST_UPDATE_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetBssEntryListFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_GET_BSS_ENTRY_LIST_UPDATE_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiGetBssEntryListFromIhv( _In_ WDI_GET_BSS_ENTRY_LIST_UPDATE_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_BSS_ENTRY_LIST_UPDATE_RESULTS*>(pParsedMessage)->~WDI_GET_BSS_ENTRY_LIST_UPDATE_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_BSS_ENTRY_LIST_UPDATE_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationDisassociationFromIhv(
    _In_ WDI_INDICATION_DISASSOCIATION_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_DISASSOCIATION),
        WDI_TLV::CONTAINERS::WDI_INDICATION_DISASSOCIATION_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationDisassociationFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_DISASSOCIATION_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_DISASSOCIATION),
        WDI_TLV::CONTAINERS::WDI_INDICATION_DISASSOCIATION_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationDisassociationFromIhv( _In_ WDI_INDICATION_DISASSOCIATION_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_DISASSOCIATION_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_DISASSOCIATION_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_DISASSOCIATION_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationRoamingNeededFromIhv(
    _In_ WDI_INDICATION_ROAMING_NEEDED_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_ROAMING_NEEDED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_ROAMING_NEEDED_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationRoamingNeededFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_ROAMING_NEEDED_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_ROAMING_NEEDED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_ROAMING_NEEDED_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationRoamingNeededFromIhv( _In_ WDI_INDICATION_ROAMING_NEEDED_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_ROAMING_NEEDED_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_ROAMING_NEEDED_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_ROAMING_NEEDED_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationLinkStateChangeFromIhv(
    _In_ WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_LINK_STATE_CHANGE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationLinkStateChangeFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_LINK_STATE_CHANGE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationLinkStateChangeFromIhv( _In_ WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationP2pActionFrameReceivedFromIhv(
    _In_ WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationP2pActionFrameReceivedFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationP2pActionFrameReceivedFromIhv( _In_ WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationApAssociationRequestReceivedFromIhv(
    _In_ WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_AP_ASSOCIATION_REQUEST_RECEIVED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationApAssociationRequestReceivedFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_AP_ASSOCIATION_REQUEST_RECEIVED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationApAssociationRequestReceivedFromIhv( _In_ WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationNloDiscoveryFromIhv(
    _In_ WDI_INDICATION_NLO_DISCOVERY_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_NLO_DISCOVERY),
        WDI_TLV::CONTAINERS::WDI_INDICATION_NLO_DISCOVERY_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationNloDiscoveryFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_NLO_DISCOVERY_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_NLO_DISCOVERY),
        WDI_TLV::CONTAINERS::WDI_INDICATION_NLO_DISCOVERY_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationNloDiscoveryFromIhv( _In_ WDI_INDICATION_NLO_DISCOVERY_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_NLO_DISCOVERY_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_NLO_DISCOVERY_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_NLO_DISCOVERY_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationWakeReasonFromIhv(
    _In_ WDI_INDICATION_WAKE_REASON_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_WAKE_REASON),
        WDI_TLV::CONTAINERS::WDI_INDICATION_WAKE_REASON_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationWakeReasonFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_WAKE_REASON_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_WAKE_REASON),
        WDI_TLV::CONTAINERS::WDI_INDICATION_WAKE_REASON_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationWakeReasonFromIhv( _In_ WDI_INDICATION_WAKE_REASON_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_WAKE_REASON_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_WAKE_REASON_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_WAKE_REASON_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationTkipMicFailureFromIhv(
    _In_ WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_TKIP_MIC_FAILURE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationTkipMicFailureFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_TKIP_MIC_FAILURE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationTkipMicFailureFromIhv( _In_ WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationScanCompleteFromIhv(
    _In_opt_ WDI_INDICATION_SCAN_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationScanCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_SCAN_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationScanCompleteFromIhv( _In_ WDI_INDICATION_SCAN_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_SCAN_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_SCAN_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_SCAN_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationP2pDiscoveryCompleteFromIhv(
    _In_opt_ WDI_INDICATION_P2P_DISCOVERY_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationP2pDiscoveryCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_P2P_DISCOVERY_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationP2pDiscoveryCompleteFromIhv( _In_ WDI_INDICATION_P2P_DISCOVERY_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_P2P_DISCOVERY_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_P2P_DISCOVERY_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_P2P_DISCOVERY_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationBssEntryListFromIhv(
    _In_ WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_BSS_ENTRY_LIST),
        WDI_TLV::CONTAINERS::WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationBssEntryListFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_BSS_ENTRY_LIST),
        WDI_TLV::CONTAINERS::WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationBssEntryListFromIhv( _In_ WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationDot11ResetCompleteFromIhv(
    _In_opt_ WDI_INDICATION_DOT11_RESET_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationDot11ResetCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_DOT11_RESET_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationDot11ResetCompleteFromIhv( _In_ WDI_INDICATION_DOT11_RESET_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_DOT11_RESET_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_DOT11_RESET_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_DOT11_RESET_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationConnectCompleteFromIhv(
    _In_opt_ WDI_INDICATION_CONNECT_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationConnectCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_CONNECT_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationConnectCompleteFromIhv( _In_ WDI_INDICATION_CONNECT_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_CONNECT_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_CONNECT_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_CONNECT_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationP2pSendRequestActionFrameCompleteFromIhv(
    _In_ WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationP2pSendRequestActionFrameCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationP2pSendRequestActionFrameCompleteFromIhv( _In_ WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationP2pSendResponseActionFrameCompleteFromIhv(
    _In_ WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationP2pSendResponseActionFrameCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationP2pSendResponseActionFrameCompleteFromIhv( _In_ WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationRadioStatusFromIhv(
    _In_ WDI_INDICATION_RADIO_STATUS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_RADIO_STATUS),
        WDI_TLV::CONTAINERS::WDI_INDICATION_RADIO_STATUS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationRadioStatusFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_RADIO_STATUS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_RADIO_STATUS),
        WDI_TLV::CONTAINERS::WDI_INDICATION_RADIO_STATUS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationRadioStatusFromIhv( _In_ WDI_INDICATION_RADIO_STATUS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_RADIO_STATUS_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_RADIO_STATUS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_RADIO_STATUS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationCreatePortCompleteFromIhv(
    _In_ WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_CREATE_PORT_COMPLETE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationCreatePortCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_CREATE_PORT_COMPLETE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationCreatePortCompleteFromIhv( _In_ WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationDeletePortCompleteFromIhv(
    _In_opt_ WDI_INDICATION_DELETE_PORT_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationDeletePortCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_DELETE_PORT_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationDeletePortCompleteFromIhv( _In_ WDI_INDICATION_DELETE_PORT_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_DELETE_PORT_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_DELETE_PORT_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_DELETE_PORT_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationStartApCompleteFromIhv(
    _In_opt_ WDI_INDICATION_START_AP_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationStartApCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_START_AP_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationStartApCompleteFromIhv( _In_ WDI_INDICATION_START_AP_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_START_AP_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_START_AP_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_START_AP_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationStopApCompleteFromIhv(
    _In_opt_ WDI_INDICATION_STOP_AP_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationStopApCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_STOP_AP_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationStopApCompleteFromIhv( _In_ WDI_INDICATION_STOP_AP_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_STOP_AP_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_STOP_AP_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_STOP_AP_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationStopApFromIhv(
    _In_ WDI_INDICATION_STOP_AP_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_STOP_AP),
        WDI_TLV::CONTAINERS::WDI_INDICATION_STOP_AP_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationStopApFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_STOP_AP_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_STOP_AP),
        WDI_TLV::CONTAINERS::WDI_INDICATION_STOP_AP_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationStopApFromIhv( _In_ WDI_INDICATION_STOP_AP_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_STOP_AP_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_STOP_AP_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_STOP_AP_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationCanSustainApFromIhv(
    _In_ WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_CAN_SUSTAIN_AP),
        WDI_TLV::CONTAINERS::WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationCanSustainApFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_CAN_SUSTAIN_AP),
        WDI_TLV::CONTAINERS::WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationCanSustainApFromIhv( _In_ WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationSendApAssociationResponseCompleteFromIhv(
    _In_ WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationSendApAssociationResponseCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE),
        WDI_TLV::CONTAINERS::WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationSendApAssociationResponseCompleteFromIhv( _In_ WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationAssociationResultFromIhv(
    _In_ WDI_INDICATION_ASSOCIATION_RESULT_LIST const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_ASSOCIATION_RESULT),
        WDI_TLV::CONTAINERS::WDI_INDICATION_ASSOCIATION_RESULT_LIST_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationAssociationResultFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_ASSOCIATION_RESULT_LIST* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_ASSOCIATION_RESULT),
        WDI_TLV::CONTAINERS::WDI_INDICATION_ASSOCIATION_RESULT_LIST_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationAssociationResultFromIhv( _In_ WDI_INDICATION_ASSOCIATION_RESULT_LIST* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_ASSOCIATION_RESULT_LIST*>(pParsedMessage)->~WDI_INDICATION_ASSOCIATION_RESULT_LIST();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_ASSOCIATION_RESULT_LIST ) );
}

NDIS_STATUS __stdcall GenerateWdiGetAutoPowerSaveToIhv(
    _In_opt_ WDI_GET_AUTO_POWER_SAVE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetAutoPowerSaveToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_GET_AUTO_POWER_SAVE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiGetAutoPowerSaveToIhv( _In_ WDI_GET_AUTO_POWER_SAVE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_AUTO_POWER_SAVE_PARAMETERS*>(pParsedMessage)->~WDI_GET_AUTO_POWER_SAVE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_AUTO_POWER_SAVE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetAutoPowerSaveFromIhv(
    _In_ WDI_GET_AUTO_POWER_SAVE_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_AUTO_POWER_SAVE),
        WDI_TLV::CONTAINERS::WDI_GET_AUTO_POWER_SAVE_RESULTS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetAutoPowerSaveFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_GET_AUTO_POWER_SAVE_RESULTS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_AUTO_POWER_SAVE),
        WDI_TLV::CONTAINERS::WDI_GET_AUTO_POWER_SAVE_RESULTS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiGetAutoPowerSaveFromIhv( _In_ WDI_GET_AUTO_POWER_SAVE_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_AUTO_POWER_SAVE_RESULTS*>(pParsedMessage)->~WDI_GET_AUTO_POWER_SAVE_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_AUTO_POWER_SAVE_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAddWolPatternToIhv(
    _In_ WDI_SET_ADD_WOL_PATTERN_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADD_WOL_PATTERN),
        WDI_TLV::CONTAINERS::WDI_SET_ADD_WOL_PATTERN_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAddWolPatternToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_ADD_WOL_PATTERN_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADD_WOL_PATTERN),
        WDI_TLV::CONTAINERS::WDI_SET_ADD_WOL_PATTERN_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAddWolPatternToIhv( _In_ WDI_SET_ADD_WOL_PATTERN_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ADD_WOL_PATTERN_PARAMETERS*>(pParsedMessage)->~WDI_SET_ADD_WOL_PATTERN_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ADD_WOL_PATTERN_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAddWolPatternFromIhv(
    _In_opt_ WDI_SET_ADD_WOL_PATTERN_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAddWolPatternFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_ADD_WOL_PATTERN_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAddWolPatternFromIhv( _In_ WDI_SET_ADD_WOL_PATTERN_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ADD_WOL_PATTERN_RESULTS*>(pParsedMessage)->~WDI_SET_ADD_WOL_PATTERN_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ADD_WOL_PATTERN_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetRemoveWolPatternToIhv(
    _In_ WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_REMOVE_WOL_PATTERN),
        WDI_TLV::CONTAINERS::WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetRemoveWolPatternToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_REMOVE_WOL_PATTERN),
        WDI_TLV::CONTAINERS::WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetRemoveWolPatternToIhv( _In_ WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS*>(pParsedMessage)->~WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetRemoveWolPatternFromIhv(
    _In_opt_ WDI_SET_REMOVE_WOL_PATTERN_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetRemoveWolPatternFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_REMOVE_WOL_PATTERN_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetRemoveWolPatternFromIhv( _In_ WDI_SET_REMOVE_WOL_PATTERN_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_REMOVE_WOL_PATTERN_RESULTS*>(pParsedMessage)->~WDI_SET_REMOVE_WOL_PATTERN_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_REMOVE_WOL_PATTERN_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetMulticastListToIhv(
    _In_ WDI_SET_MULTICAST_LIST_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_MULTICAST_LIST),
        WDI_TLV::CONTAINERS::WDI_SET_MULTICAST_LIST_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetMulticastListToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_MULTICAST_LIST_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_MULTICAST_LIST),
        WDI_TLV::CONTAINERS::WDI_SET_MULTICAST_LIST_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetMulticastListToIhv( _In_ WDI_SET_MULTICAST_LIST_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_MULTICAST_LIST_PARAMETERS*>(pParsedMessage)->~WDI_SET_MULTICAST_LIST_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_MULTICAST_LIST_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetMulticastListFromIhv(
    _In_opt_ WDI_SET_MULTICAST_LIST_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetMulticastListFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_MULTICAST_LIST_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetMulticastListFromIhv( _In_ WDI_SET_MULTICAST_LIST_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_MULTICAST_LIST_RESULTS*>(pParsedMessage)->~WDI_SET_MULTICAST_LIST_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_MULTICAST_LIST_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAddPmProtocolOffloadToIhv(
    _In_ WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADD_PM_PROTOCOL_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAddPmProtocolOffloadToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADD_PM_PROTOCOL_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAddPmProtocolOffloadToIhv( _In_ WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS*>(pParsedMessage)->~WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAddPmProtocolOffloadFromIhv(
    _In_opt_ WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAddPmProtocolOffloadFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAddPmProtocolOffloadFromIhv( _In_ WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_RESULTS*>(pParsedMessage)->~WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetRemovePmProtocolOffloadToIhv(
    _In_ WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetRemovePmProtocolOffloadToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetRemovePmProtocolOffloadToIhv( _In_ WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS*>(pParsedMessage)->~WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetRemovePmProtocolOffloadFromIhv(
    _In_opt_ WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetRemovePmProtocolOffloadFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetRemovePmProtocolOffloadFromIhv( _In_ WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_RESULTS*>(pParsedMessage)->~WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationP2pGroupOperatingChannelFromIhv(
    _In_ WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationP2pGroupOperatingChannelFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationP2pGroupOperatingChannelFromIhv( _In_ WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationP2pOperatingChannelAttributesFromIhv(
    _In_ WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationP2pOperatingChannelAttributesFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES),
        WDI_TLV::CONTAINERS::WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationP2pOperatingChannelAttributesFromIhv( _In_ WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAdapterConfigurationToIhv(
    _In_ WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADAPTER_CONFIGURATION),
        WDI_TLV::CONTAINERS::WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAdapterConfigurationToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADAPTER_CONFIGURATION),
        WDI_TLV::CONTAINERS::WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAdapterConfigurationToIhv( _In_ WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS*>(pParsedMessage)->~WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAdapterConfigurationFromIhv(
    _In_opt_ WDI_SET_FIRMWARE_CONFIGURATION_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAdapterConfigurationFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_FIRMWARE_CONFIGURATION_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAdapterConfigurationFromIhv( _In_ WDI_SET_FIRMWARE_CONFIGURATION_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_FIRMWARE_CONFIGURATION_RESULTS*>(pParsedMessage)->~WDI_SET_FIRMWARE_CONFIGURATION_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_FIRMWARE_CONFIGURATION_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetReceiveCoalescingMatchCountToIhv(
    _In_opt_ WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_INPUTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetReceiveCoalescingMatchCountToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_INPUTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiGetReceiveCoalescingMatchCountToIhv( _In_ WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_INPUTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_INPUTS*>(pParsedMessage)->~WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_INPUTS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_INPUTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetReceiveCoalescingMatchCountFromIhv(
    _In_ WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_RECEIVE_COALESCING_MATCH_COUNT),
        WDI_TLV::CONTAINERS::WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetReceiveCoalescingMatchCountFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_RECEIVE_COALESCING_MATCH_COUNT),
        WDI_TLV::CONTAINERS::WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiGetReceiveCoalescingMatchCountFromIhv( _In_ WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS*>(pParsedMessage)->~WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetClearReceiveCoalescingToIhv(
    _In_ WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_CLEAR_RECEIVE_COALESCING),
        WDI_TLV::CONTAINERS::WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetClearReceiveCoalescingToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_CLEAR_RECEIVE_COALESCING),
        WDI_TLV::CONTAINERS::WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetClearReceiveCoalescingToIhv( _In_ WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS*>(pParsedMessage)->~WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetClearReceiveCoalescingFromIhv(
    _In_opt_ WDI_SET_CLEAR_RECEIVE_COALESCING_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetClearReceiveCoalescingFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_CLEAR_RECEIVE_COALESCING_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetClearReceiveCoalescingFromIhv( _In_ WDI_SET_CLEAR_RECEIVE_COALESCING_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_CLEAR_RECEIVE_COALESCING_RESULTS*>(pParsedMessage)->~WDI_SET_CLEAR_RECEIVE_COALESCING_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_CLEAR_RECEIVE_COALESCING_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetPmProtocolOffloadToIhv(
    _In_ WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_PM_PROTOCOL_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetPmProtocolOffloadToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_PM_PROTOCOL_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiGetPmProtocolOffloadToIhv( _In_ WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS*>(pParsedMessage)->~WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetPmProtocolOffloadFromIhv(
    _In_ WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_PM_PROTOCOL_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetPmProtocolOffloadFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_PM_PROTOCOL_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiGetPmProtocolOffloadFromIhv( _In_ WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS*>(pParsedMessage)->~WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAdvertisementInformationToIhv(
    _In_ WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADVERTISEMENT_INFORMATION),
        WDI_TLV::CONTAINERS::WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAdvertisementInformationToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ADVERTISEMENT_INFORMATION),
        WDI_TLV::CONTAINERS::WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAdvertisementInformationToIhv( _In_ WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS*>(pParsedMessage)->~WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAdvertisementInformationFromIhv(
    _In_opt_ WDI_SET_ADVERTISEMENT_INFORMATION_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAdvertisementInformationFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_ADVERTISEMENT_INFORMATION_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAdvertisementInformationFromIhv( _In_ WDI_SET_ADVERTISEMENT_INFORMATION_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ADVERTISEMENT_INFORMATION_RESULTS*>(pParsedMessage)->~WDI_SET_ADVERTISEMENT_INFORMATION_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ADVERTISEMENT_INFORMATION_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskChangeOperationModeToIhv(
    _In_ WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_CHANGE_OPERATION_MODE),
        WDI_TLV::CONTAINERS::WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskChangeOperationModeToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_CHANGE_OPERATION_MODE),
        WDI_TLV::CONTAINERS::WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskChangeOperationModeToIhv( _In_ WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS*>(pParsedMessage)->~WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskChangeOperationModeFromIhv(
    _In_opt_ WDI_TASK_CHANGE_OPERATION_MODE_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskChangeOperationModeFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_CHANGE_OPERATION_MODE_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskChangeOperationModeFromIhv( _In_ WDI_TASK_CHANGE_OPERATION_MODE_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_CHANGE_OPERATION_MODE_RESULTS*>(pParsedMessage)->~WDI_TASK_CHANGE_OPERATION_MODE_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_CHANGE_OPERATION_MODE_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationChangeOperationModeCompleteFromIhv(
    _In_opt_ WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationChangeOperationModeCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationChangeOperationModeCompleteFromIhv( _In_ WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIhvRequest(
    _In_ WDI_IHV_REQUEST_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_IHV_REQUEST),
        WDI_TLV::CONTAINERS::WDI_IHV_REQUEST_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIhvRequest(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_IHV_REQUEST_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_IHV_REQUEST),
        WDI_TLV::CONTAINERS::WDI_IHV_REQUEST_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIhvRequest( _In_ WDI_IHV_REQUEST_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_IHV_REQUEST_PARAMETERS*>(pParsedMessage)->~WDI_IHV_REQUEST_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_IHV_REQUEST_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationIhvEventFromIhv(
    _In_ WDI_INDICATION_IHV_EVENT_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_IHV_EVENT),
        WDI_TLV::CONTAINERS::WDI_INDICATION_IHV_EVENT_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationIhvEventFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_IHV_EVENT_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_IHV_EVENT),
        WDI_TLV::CONTAINERS::WDI_INDICATION_IHV_EVENT_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationIhvEventFromIhv( _In_ WDI_INDICATION_IHV_EVENT_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_IHV_EVENT_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_IHV_EVENT_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_IHV_EVENT_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationOpenCompleteFromIhv(
    _In_opt_ WDI_INDICATION_OPEN_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationOpenCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_OPEN_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationOpenCompleteFromIhv( _In_ WDI_INDICATION_OPEN_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_OPEN_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_OPEN_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_OPEN_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationCloseCompleteFromIhv(
    _In_opt_ WDI_INDICATION_CLOSE_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationCloseCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_CLOSE_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationCloseCompleteFromIhv( _In_ WDI_INDICATION_CLOSE_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_CLOSE_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_CLOSE_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_CLOSE_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetFlushBssEntry(
    _In_opt_ WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetFlushBssEntry(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetFlushBssEntry( _In_ WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS*>(pParsedMessage)->~WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationAssociationParametersRequestFromIhv(
    _In_ WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_ASSOCIATION_PARAMETERS_REQUEST),
        WDI_TLV::CONTAINERS::WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationAssociationParametersRequestFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_ASSOCIATION_PARAMETERS_REQUEST),
        WDI_TLV::CONTAINERS::WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationAssociationParametersRequestFromIhv( _In_ WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAssociationParametersToIhv(
    _In_ WDI_SET_ASSOCIATION_PARAMS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ASSOCIATION_PARAMETERS),
        WDI_TLV::CONTAINERS::WDI_SET_ASSOCIATION_PARAMS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAssociationParametersToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_ASSOCIATION_PARAMS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ASSOCIATION_PARAMETERS),
        WDI_TLV::CONTAINERS::WDI_SET_ASSOCIATION_PARAMS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAssociationParametersToIhv( _In_ WDI_SET_ASSOCIATION_PARAMS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ASSOCIATION_PARAMS_PARAMETERS*>(pParsedMessage)->~WDI_SET_ASSOCIATION_PARAMS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ASSOCIATION_PARAMS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetAssociationParametersFromIhv(
    _In_opt_ WDI_SET_ASSOCIATION_PARAMS_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetAssociationParametersFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_ASSOCIATION_PARAMS_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetAssociationParametersFromIhv( _In_ WDI_SET_ASSOCIATION_PARAMS_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ASSOCIATION_PARAMS_RESULTS*>(pParsedMessage)->~WDI_SET_ASSOCIATION_PARAMS_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ASSOCIATION_PARAMS_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskRoamToIhv(
    _In_ WDI_TASK_ROAM_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_ROAM),
        WDI_TLV::CONTAINERS::WDI_TASK_ROAM_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskRoamToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_ROAM_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_ROAM),
        WDI_TLV::CONTAINERS::WDI_TASK_ROAM_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskRoamToIhv( _In_ WDI_TASK_ROAM_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_ROAM_PARAMETERS*>(pParsedMessage)->~WDI_TASK_ROAM_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_ROAM_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskRoamFromIhv(
    _In_opt_ WDI_TASK_ROAM_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskRoamFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_ROAM_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskRoamFromIhv( _In_ WDI_TASK_ROAM_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_ROAM_RESULTS*>(pParsedMessage)->~WDI_TASK_ROAM_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_ROAM_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationRoamCompleteFromIhv(
    _In_opt_ WDI_INDICATION_ROAM_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationRoamCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_ROAM_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationRoamCompleteFromIhv( _In_ WDI_INDICATION_ROAM_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_ROAM_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_ROAM_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_ROAM_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSendRequestActionFrameToIhv(
    _In_ WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SEND_REQUEST_ACTION_FRAME),
        WDI_TLV::CONTAINERS::WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSendRequestActionFrameToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SEND_REQUEST_ACTION_FRAME),
        WDI_TLV::CONTAINERS::WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSendRequestActionFrameToIhv( _In_ WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS*>(pParsedMessage)->~WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSendRequestActionFrameFromIhv(
    _In_opt_ WDI_TASK_SEND_REQUEST_ACTION_FRAME_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSendRequestActionFrameFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_SEND_REQUEST_ACTION_FRAME_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSendRequestActionFrameFromIhv( _In_ WDI_TASK_SEND_REQUEST_ACTION_FRAME_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_SEND_REQUEST_ACTION_FRAME_RESULTS*>(pParsedMessage)->~WDI_TASK_SEND_REQUEST_ACTION_FRAME_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_SEND_REQUEST_ACTION_FRAME_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationActionFrameReceivedFromIhv(
    _In_ WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_ACTION_FRAME_RECEIVED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationActionFrameReceivedFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_ACTION_FRAME_RECEIVED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationActionFrameReceivedFromIhv( _In_ WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationTaskOffloadCurrentConfigFromIhv(
    _In_ WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG),
        WDI_TLV::CONTAINERS::WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationTaskOffloadCurrentConfigFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG),
        WDI_TLV::CONTAINERS::WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationTaskOffloadCurrentConfigFromIhv( _In_ WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSendResponseActionFrameToIhv(
    _In_ WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SEND_RESPONSE_ACTION_FRAME),
        WDI_TLV::CONTAINERS::WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSendResponseActionFrameToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_SEND_RESPONSE_ACTION_FRAME),
        WDI_TLV::CONTAINERS::WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSendResponseActionFrameToIhv( _In_ WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS*>(pParsedMessage)->~WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskSendResponseActionFrameFromIhv(
    _In_opt_ WDI_TASK_SEND_RESPONSE_ACTION_FRAME_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskSendResponseActionFrameFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_SEND_RESPONSE_ACTION_FRAME_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskSendResponseActionFrameFromIhv( _In_ WDI_TASK_SEND_RESPONSE_ACTION_FRAME_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_SEND_RESPONSE_ACTION_FRAME_RESULTS*>(pParsedMessage)->~WDI_TASK_SEND_RESPONSE_ACTION_FRAME_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_SEND_RESPONSE_ACTION_FRAME_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationSendRequestActionFrameCompleteFromIhv(
    _In_opt_ WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationSendRequestActionFrameCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationSendRequestActionFrameCompleteFromIhv( _In_ WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationSendResponseActionFrameCompleteFromIhv(
    _In_opt_ WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationSendResponseActionFrameCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationSendResponseActionFrameCompleteFromIhv( _In_ WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetNextActionFrameDialogTokenToIhv(
    _In_opt_ WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_INPUTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetNextActionFrameDialogTokenToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_INPUTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiGetNextActionFrameDialogTokenToIhv( _In_ WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_INPUTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_INPUTS*>(pParsedMessage)->~WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_INPUTS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_INPUTS ) );
}

NDIS_STATUS __stdcall GenerateWdiGetNextActionFrameDialogTokenFromIhv(
    _In_ WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN),
        WDI_TLV::CONTAINERS::WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiGetNextActionFrameDialogTokenFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN),
        WDI_TLV::CONTAINERS::WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiGetNextActionFrameDialogTokenFromIhv( _In_ WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS*>(pParsedMessage)->~WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetP2pWpsEnabledToIhv(
    _In_ WDI_SET_P2P_WPS_ENABLED_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_P2P_WPS_ENABLED),
        WDI_TLV::CONTAINERS::WDI_SET_P2P_WPS_ENABLED_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetP2pWpsEnabledToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_P2P_WPS_ENABLED_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_P2P_WPS_ENABLED),
        WDI_TLV::CONTAINERS::WDI_SET_P2P_WPS_ENABLED_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetP2pWpsEnabledToIhv( _In_ WDI_SET_P2P_WPS_ENABLED_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_P2P_WPS_ENABLED_PARAMETERS*>(pParsedMessage)->~WDI_SET_P2P_WPS_ENABLED_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_P2P_WPS_ENABLED_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetP2pWpsEnabledFromIhv(
    _In_opt_ WDI_SET_P2P_WPS_ENABLED_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetP2pWpsEnabledFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_P2P_WPS_ENABLED_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetP2pWpsEnabledFromIhv( _In_ WDI_SET_P2P_WPS_ENABLED_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_P2P_WPS_ENABLED_RESULTS*>(pParsedMessage)->~WDI_SET_P2P_WPS_ENABLED_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_P2P_WPS_ENABLED_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskIhvToIhv(
    _In_ WDI_TASK_IHV_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_IHV),
        WDI_TLV::CONTAINERS::WDI_TASK_IHV_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskIhvToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_IHV_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TASK_IHV),
        WDI_TLV::CONTAINERS::WDI_TASK_IHV_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskIhvToIhv( _In_ WDI_TASK_IHV_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_IHV_PARAMETERS*>(pParsedMessage)->~WDI_TASK_IHV_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_IHV_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiTaskIhvFromIhv(
    _In_opt_ WDI_TASK_IHV_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTaskIhvFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_IHV_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTaskIhvFromIhv( _In_ WDI_TASK_IHV_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_IHV_RESULTS*>(pParsedMessage)->~WDI_TASK_IHV_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_IHV_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationIhvTaskRequestFromIhv(
    _In_ WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_IHV_TASK_REQUEST),
        WDI_TLV::CONTAINERS::WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationIhvTaskRequestFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_IHV_TASK_REQUEST),
        WDI_TLV::CONTAINERS::WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationIhvTaskRequestFromIhv( _In_ WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationIhvTaskCompleteFromIhv(
    _In_opt_ WDI_INDICATION_IHV_TASK_COMPLETE_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationIhvTaskCompleteFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_IHV_TASK_COMPLETE_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationIhvTaskCompleteFromIhv( _In_ WDI_INDICATION_IHV_TASK_COMPLETE_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_IHV_TASK_COMPLETE_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_IHV_TASK_COMPLETE_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_IHV_TASK_COMPLETE_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiAbortTaskToIhv(
    _In_ WDI_TASK_ABORT_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_ABORT_TASK),
        WDI_TLV::CONTAINERS::WDI_TASK_ABORT_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiAbortTaskToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_ABORT_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_ABORT_TASK),
        WDI_TLV::CONTAINERS::WDI_TASK_ABORT_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiAbortTaskToIhv( _In_ WDI_TASK_ABORT_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_ABORT_PARAMETERS*>(pParsedMessage)->~WDI_TASK_ABORT_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_ABORT_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiAbortTaskFromIhv(
    _In_opt_ WDI_TASK_ABORT_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiAbortTaskFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TASK_ABORT_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiAbortTaskFromIhv( _In_ WDI_TASK_ABORT_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_ABORT_RESULTS*>(pParsedMessage)->~WDI_TASK_ABORT_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_ABORT_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetTcpOffloadParametersToIhv(
    _In_ WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_TCP_OFFLOAD_PARAMETERS),
        WDI_TLV::CONTAINERS::WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetTcpOffloadParametersToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_TCP_OFFLOAD_PARAMETERS),
        WDI_TLV::CONTAINERS::WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetTcpOffloadParametersToIhv( _In_ WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS*>(pParsedMessage)->~WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetTcpOffloadParametersFromIhv(
    _In_opt_ WDI_SET_TCP_OFFLOAD_PARAMS_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetTcpOffloadParametersFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_TCP_OFFLOAD_PARAMS_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetTcpOffloadParametersFromIhv( _In_ WDI_SET_TCP_OFFLOAD_PARAMS_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_TCP_OFFLOAD_PARAMS_RESULTS*>(pParsedMessage)->~WDI_SET_TCP_OFFLOAD_PARAMS_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_TCP_OFFLOAD_PARAMS_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTcpRscStatisticsToIhv(
    _In_opt_ WDI_TCP_RSC_STATISTICS_INPUTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTcpRscStatisticsToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_TCP_RSC_STATISTICS_INPUTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiTcpRscStatisticsToIhv( _In_ WDI_TCP_RSC_STATISTICS_INPUTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TCP_RSC_STATISTICS_INPUTS*>(pParsedMessage)->~WDI_TCP_RSC_STATISTICS_INPUTS();
    memset( pParsedMessage, 0, sizeof( WDI_TCP_RSC_STATISTICS_INPUTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTcpRscStatisticsFromIhv(
    _In_ WDI_TCP_RSC_STATISTICS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TCP_RSC_STATISTICS),
        WDI_TLV::CONTAINERS::WDI_TCP_RSC_STATISTICS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTcpRscStatisticsFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TCP_RSC_STATISTICS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TCP_RSC_STATISTICS),
        WDI_TLV::CONTAINERS::WDI_TCP_RSC_STATISTICS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTcpRscStatisticsFromIhv( _In_ WDI_TCP_RSC_STATISTICS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TCP_RSC_STATISTICS_PARAMETERS*>(pParsedMessage)->~WDI_TCP_RSC_STATISTICS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TCP_RSC_STATISTICS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetEncapsulationOffloadToIhv(
    _In_ WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ENCAPSULATION_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetEncapsulationOffloadToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_ENCAPSULATION_OFFLOAD),
        WDI_TLV::CONTAINERS::WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetEncapsulationOffloadToIhv( _In_ WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS*>(pParsedMessage)->~WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetEncapsulationOffloadFromIhv(
    _In_opt_ WDI_SET_ENCAPSULATION_OFFLOAD_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetEncapsulationOffloadFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_ENCAPSULATION_OFFLOAD_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetEncapsulationOffloadFromIhv( _In_ WDI_SET_ENCAPSULATION_OFFLOAD_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_ENCAPSULATION_OFFLOAD_RESULTS*>(pParsedMessage)->~WDI_SET_ENCAPSULATION_OFFLOAD_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_ENCAPSULATION_OFFLOAD_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationFtAssocParamsNeededFromIhv(
    _In_ WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationFtAssocParamsNeededFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED),
        WDI_TLV::CONTAINERS::WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationFtAssocParamsNeededFromIhv( _In_ WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetFastBssTransitionParametersToIhv(
    _In_ WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_FAST_BSS_TRANSITION_PARAMETERS),
        WDI_TLV::CONTAINERS::WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetFastBssTransitionParametersToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_FAST_BSS_TRANSITION_PARAMETERS),
        WDI_TLV::CONTAINERS::WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetFastBssTransitionParametersToIhv( _In_ WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND*>(pParsedMessage)->~WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND();
    memset( pParsedMessage, 0, sizeof( WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND ) );
}

NDIS_STATUS __stdcall GenerateWdiSetFastBssTransitionParametersFromIhv(
    _In_opt_ WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetFastBssTransitionParametersFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetFastBssTransitionParametersFromIhv( _In_ WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_RESULTS*>(pParsedMessage)->~WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiIndicationFirmwareStalledFromIhv(
    _In_opt_ WDI_INDICATION_FIRMWARE_STALLED_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiIndicationFirmwareStalledFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_INDICATION_FIRMWARE_STALLED_PARAMETERS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiIndicationFirmwareStalledFromIhv( _In_ WDI_INDICATION_FIRMWARE_STALLED_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_INDICATION_FIRMWARE_STALLED_PARAMETERS*>(pParsedMessage)->~WDI_INDICATION_FIRMWARE_STALLED_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_INDICATION_FIRMWARE_STALLED_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetNeighborReportEntriesToIhv(
    _In_ WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_NEIGHBOR_REPORT_ENTRIES),
        WDI_TLV::CONTAINERS::WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetNeighborReportEntriesToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_SET_NEIGHBOR_REPORT_ENTRIES),
        WDI_TLV::CONTAINERS::WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiSetNeighborReportEntriesToIhv( _In_ WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS*>(pParsedMessage)->~WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS ) );
}

NDIS_STATUS __stdcall GenerateWdiSetNeighborReportEntriesFromIhv(
    _In_opt_ WDI_SET_NEIGHBOR_REPORT_ENTRIES_RESULTS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateEmptyMessage( pInput, ReservedHeaderLength, Context, pBufferLength, ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiSetNeighborReportEntriesFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_opt_ WDI_SET_NEIGHBOR_REPORT_ENTRIES_RESULTS* pParsedMessage )
{
    return WDI_TLV::PARSER::ParseEmptyMessage( BufferLength, pBuffer, Context, pParsedMessage );
}
void __stdcall CleanupParsedWdiSetNeighborReportEntriesFromIhv( _In_ WDI_SET_NEIGHBOR_REPORT_ENTRIES_RESULTS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_SET_NEIGHBOR_REPORT_ENTRIES_RESULTS*>(pParsedMessage)->~WDI_SET_NEIGHBOR_REPORT_ENTRIES_RESULTS();
    memset( pParsedMessage, 0, sizeof( WDI_SET_NEIGHBOR_REPORT_ENTRIES_RESULTS ) );
}

NDIS_STATUS __stdcall GenerateWdiTestTask(
    _In_ WDI_TASK_TEST_PARAMETERS const * pInput,
    _In_ ULONG ReservedHeaderLength,
    _In_ PCTLV_CONTEXT Context,
    _Out_ ULONG* pBufferLength,
    _Outptr_result_buffer_( *pBufferLength ) UINT8** ppBuffer )
{
    return WDI_TLV::GENERATOR::GenerateMessage(
        sizeof( *pInput ), pInput,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TEST_TASK),
        WDI_TLV::CONTAINERS::WDI_TASK_TEST_PARAMETERS_HELPER::s_Container,
        ReservedHeaderLength,
        Context,
        pBufferLength,
        ppBuffer );
}

NDIS_STATUS __stdcall ParseWdiTestTask(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ PCTLV_CONTEXT Context,
    _Out_ WDI_TASK_TEST_PARAMETERS* pParsedMessage )
{

    return WDI_TLV::PARSER::ParseMessage(
        BufferLength,
        pBuffer,
        WDI_TLV::ENUMS::MESSAGE_ID(WDI_TEST_TASK),
        WDI_TLV::CONTAINERS::WDI_TASK_TEST_PARAMETERS_HELPER::s_Container,
        Context,
        sizeof( *pParsedMessage ), pParsedMessage );
}
void __stdcall CleanupParsedWdiTestTask( _In_ WDI_TASK_TEST_PARAMETERS* pParsedMessage )
{
    // Cast from the 'C' type to the 'C++' type of the same name and call the destructor
    // which will trigger any nested freeing required
    reinterpret_cast<WDI_TASK_TEST_PARAMETERS*>(pParsedMessage)->~WDI_TASK_TEST_PARAMETERS();
    memset( pParsedMessage, 0, sizeof( WDI_TASK_TEST_PARAMETERS ) );
}

static const EmptyMessageStructureType s_empty = { 0 } ;

extern "C" NDIS_STATUS __stdcall ParseToIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ USHORT MessageId,
    _In_ PCTLV_CONTEXT Context,
    _Outptr_result_nullonfailure_ PVOID* ppParsedOutput )
{
    NDIS_STATUS ndisStatus = NDIS_STATUS_SUCCESS;
    *ppParsedOutput = NULL;

    if ((Context == NULL) || (Context->PeerVersion < WDI_VERSION_MIN_SUPPORTED))
    {
        return NDIS_STATUS_UNSUPPORTED_REVISION;
    }

    switch (MessageId)
    {
    case WDI_TASK_OPEN:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskOpen( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_OPEN_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_CLOSE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskClose( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_CLOSE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_HOST_DETECT_ERROR:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetHostDetectError( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_HOST_DETECT_ERROR_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_SCAN:
    {
        WDI_SCAN_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SCAN_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskScanToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_P2P_DISCOVER:
    {
        WDI_TASK_P2P_DISCOVER_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_P2P_DISCOVER_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskP2pDiscoverToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_P2P_START_BACKGROUND_DISCOVERY:
    {
        WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetP2pStartBackgroundDiscoveryToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetP2pStopBackgroundDiscovery( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_CONNECT:
    {
        WDI_TASK_CONNECT_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_CONNECT_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskConnectToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_DOT11_RESET:
    {
        WDI_TASK_DOT11_RESET_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_DOT11_RESET_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskDot11ResetToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_DISCONNECT:
    {
        WDI_TASK_DISCONNECT_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_DISCONNECT_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskDisconnectToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME:
    {
        WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskP2pSendRequestActionFrameToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME:
    {
        WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskP2pSendResponseActionFrameToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_SET_RADIO_STATE:
    {
        WDI_SET_RADIO_STATE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_RADIO_STATE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskSetRadioStateToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_CREATE_PORT:
    {
        WDI_TASK_CREATE_PORT_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_CREATE_PORT_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskCreatePortToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_DELETE_PORT:
    {
        WDI_TASK_DELETE_PORT_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_DELETE_PORT_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskDeletePortToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_START_AP:
    {
        WDI_TASK_START_AP_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_START_AP_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskStartApToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_STOP_AP:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskStopAp( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_STOP_AP_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case 16:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE:
    {
        WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskSendApAssociationResponseToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskSetReadyToReceiveIndications( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_POWER_STATE:
    {
        WDI_SET_POWER_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_POWER_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetPowerStateToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_OPERATION_MODE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetOperationMode( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_OPERATION_MODE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_END_DWELL_TIME:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetEndDwellTime( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_END_DWELL_TIME_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_P2P_ADDITIONAL_IE:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_SET_P2P_LISTEN_STATE:
    {
        WDI_SET_P2P_LISTEN_STATE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_P2P_LISTEN_STATE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetP2pListenStateToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case 27:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_SET_PRIVACY_EXEMPTION_LIST:
    {
        WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetPrivacyExemptionListToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ADD_CIPHER_KEYS:
    {
        WDI_SET_ADD_CIPHER_KEYS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_ADD_CIPHER_KEYS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetAddCipherKeysToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_DELETE_CIPHER_KEYS:
    {
        WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetDeleteCipherKeysToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_DEFAULT_KEY_ID:
    {
        WDI_SET_DEFAULT_KEY_ID_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_DEFAULT_KEY_ID_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetDefaultKeyIdToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_CONNECTION_QUALITY:
    {
        WDI_SET_CONNECTION_QUALITY_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_CONNECTION_QUALITY_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetConnectionQualityToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_GET_STATISTICS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiGetStatisticsToIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_GET_STATISTICS_INPUTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_RECEIVE_PACKET_FILTER:
    {
        WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetReceivePacketFilterToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_GET_ADAPTER_CAPABILITIES:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiGetAdapterCapabilitiesToIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_GET_ADAPTER_CAPABILITIES_INPUTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_NETWORK_LIST_OFFLOAD:
    {
        WDI_NETWORK_LIST_OFFLOAD_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_NETWORK_LIST_OFFLOAD_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetNetworkListOffloadToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_RECEIVE_COALESCING:
    {
        WDI_SET_RECEIVE_COALESCING_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_RECEIVE_COALESCING_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetReceiveCoalescingToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_GET_BSS_ENTRY_LIST:
    {
        WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiGetBssEntryListToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case 49:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case 74:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_GET_AUTO_POWER_SAVE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiGetAutoPowerSaveToIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_GET_AUTO_POWER_SAVE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_ADD_WOL_PATTERN:
    {
        WDI_SET_ADD_WOL_PATTERN_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_ADD_WOL_PATTERN_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetAddWolPatternToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_REMOVE_WOL_PATTERN:
    {
        WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetRemoveWolPatternToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_MULTICAST_LIST:
    {
        WDI_SET_MULTICAST_LIST_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_MULTICAST_LIST_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetMulticastListToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ADD_PM_PROTOCOL_OFFLOAD:
    {
        WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetAddPmProtocolOffloadToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD:
    {
        WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetRemovePmProtocolOffloadToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ADAPTER_CONFIGURATION:
    {
        WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetAdapterConfigurationToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_GET_RECEIVE_COALESCING_MATCH_COUNT:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiGetReceiveCoalescingMatchCountToIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_INPUTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_CLEAR_RECEIVE_COALESCING:
    {
        WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetClearReceiveCoalescingToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_GET_PM_PROTOCOL_OFFLOAD:
    {
        WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiGetPmProtocolOffloadToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ADVERTISEMENT_INFORMATION:
    {
        WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetAdvertisementInformationToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_CHANGE_OPERATION_MODE:
    {
        WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskChangeOperationModeToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_DELETE_PEER_STATE:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_IHV_REQUEST:
    {
        WDI_IHV_REQUEST_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_IHV_REQUEST_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIhvRequest( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_FLUSH_BSS_ENTRY:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetFlushBssEntry( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_ASSOCIATION_PARAMETERS:
    {
        WDI_SET_ASSOCIATION_PARAMS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_ASSOCIATION_PARAMS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetAssociationParametersToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_ROAM:
    {
        WDI_TASK_ROAM_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_ROAM_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskRoamToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_SEND_REQUEST_ACTION_FRAME:
    {
        WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskSendRequestActionFrameToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_SEND_RESPONSE_ACTION_FRAME:
    {
        WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskSendResponseActionFrameToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiGetNextActionFrameDialogTokenToIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_INPUTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_P2P_WPS_ENABLED:
    {
        WDI_SET_P2P_WPS_ENABLED_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_P2P_WPS_ENABLED_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetP2pWpsEnabledToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_IHV:
    {
        WDI_TASK_IHV_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_IHV_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTaskIhvToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_ABORT_TASK:
    {
        WDI_TASK_ABORT_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TASK_ABORT_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiAbortTaskToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_TCP_OFFLOAD_PARAMETERS:
    {
        WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetTcpOffloadParametersToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TCP_RSC_STATISTICS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTcpRscStatisticsToIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TCP_RSC_STATISTICS_INPUTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_ENCAPSULATION_OFFLOAD:
    {
        WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetEncapsulationOffloadToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_FAST_BSS_TRANSITION_PARAMETERS:
    {
        WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND * pOutput = new (Context->AllocationContext) WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetFastBssTransitionParametersToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_NEIGHBOR_REPORT_ENTRIES:
    {
        WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetNeighborReportEntriesToIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    default:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    if (!NT_SUCCESS( ndisStatus ) && (NULL != *ppParsedOutput))
    {
        delete *ppParsedOutput;
        *ppParsedOutput = NULL;
    }
    return ndisStatus;
}

extern "C" NDIS_STATUS __stdcall FreeParsedToIhv(
    _In_ USHORT MessageId,
    _In_opt_ PVOID pParsedOutput )
{
    NDIS_STATUS ndisStatus = NDIS_STATUS_SUCCESS;

    switch (MessageId)
    {
    case WDI_TASK_OPEN:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_OPEN_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_TASK_CLOSE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_CLOSE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_HOST_DETECT_ERROR:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_HOST_DETECT_ERROR_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_TASK_SCAN:
        delete ((WDI_SCAN_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_P2P_DISCOVER:
        delete ((WDI_TASK_P2P_DISCOVER_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_P2P_START_BACKGROUND_DISCOVERY:
        delete ((WDI_SET_P2P_START_BACKGROUND_DISCOVERY_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_TASK_CONNECT:
        delete ((WDI_TASK_CONNECT_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_DOT11_RESET:
        delete ((WDI_TASK_DOT11_RESET_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_DISCONNECT:
        delete ((WDI_TASK_DISCONNECT_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME:
        delete ((WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME:
        delete ((WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_SET_RADIO_STATE:
        delete ((WDI_SET_RADIO_STATE_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_CREATE_PORT:
        delete ((WDI_TASK_CREATE_PORT_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_DELETE_PORT:
        delete ((WDI_TASK_DELETE_PORT_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_START_AP:
        delete ((WDI_TASK_START_AP_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_STOP_AP:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_STOP_AP_PARAMETERS*)pParsedOutput);
        }
        break;

    case 16:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE:
        delete ((WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_POWER_STATE:
        delete ((WDI_SET_POWER_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_OPERATION_MODE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_OPERATION_MODE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_END_DWELL_TIME:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_END_DWELL_TIME_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_P2P_ADDITIONAL_IE:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_SET_P2P_LISTEN_STATE:
        delete ((WDI_SET_P2P_LISTEN_STATE_PARAMETERS*)pParsedOutput);
        break;

    case 27:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_SET_PRIVACY_EXEMPTION_LIST:
        delete ((WDI_SET_PRIVACY_EXEMPTION_LIST_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_ADD_CIPHER_KEYS:
        delete ((WDI_SET_ADD_CIPHER_KEYS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_DELETE_CIPHER_KEYS:
        delete ((WDI_SET_DELETE_CIPHER_KEYS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_DEFAULT_KEY_ID:
        delete ((WDI_SET_DEFAULT_KEY_ID_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_CONNECTION_QUALITY:
        delete ((WDI_SET_CONNECTION_QUALITY_PARAMETERS*)pParsedOutput);
        break;

    case WDI_GET_STATISTICS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_GET_STATISTICS_INPUTS*)pParsedOutput);
        }
        break;

    case WDI_SET_RECEIVE_PACKET_FILTER:
        delete ((WDI_SET_RECEIVE_PACKET_FILTER_PARAMETERS*)pParsedOutput);
        break;

    case WDI_GET_ADAPTER_CAPABILITIES:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_GET_ADAPTER_CAPABILITIES_INPUTS*)pParsedOutput);
        }
        break;

    case WDI_SET_NETWORK_LIST_OFFLOAD:
        delete ((WDI_NETWORK_LIST_OFFLOAD_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_RECEIVE_COALESCING:
        delete ((WDI_SET_RECEIVE_COALESCING_PARAMETERS*)pParsedOutput);
        break;

    case WDI_GET_BSS_ENTRY_LIST:
        delete ((WDI_GET_BSS_ENTRY_LIST_UPDATE_PARAMETERS*)pParsedOutput);
        break;

    case 49:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case 74:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_GET_AUTO_POWER_SAVE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_GET_AUTO_POWER_SAVE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_ADD_WOL_PATTERN:
        delete ((WDI_SET_ADD_WOL_PATTERN_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_REMOVE_WOL_PATTERN:
        delete ((WDI_SET_REMOVE_WOL_PATTERN_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_MULTICAST_LIST:
        delete ((WDI_SET_MULTICAST_LIST_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_ADD_PM_PROTOCOL_OFFLOAD:
        delete ((WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD:
        delete ((WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_ADAPTER_CONFIGURATION:
        delete ((WDI_SET_FIRMWARE_CONFIGURATION_PARAMETERS*)pParsedOutput);
        break;

    case WDI_GET_RECEIVE_COALESCING_MATCH_COUNT:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_INPUTS*)pParsedOutput);
        }
        break;

    case WDI_SET_CLEAR_RECEIVE_COALESCING:
        delete ((WDI_SET_CLEAR_RECEIVE_COALESCING_PARAMETERS*)pParsedOutput);
        break;

    case WDI_GET_PM_PROTOCOL_OFFLOAD:
        delete ((WDI_GET_PM_PROTOCOL_OFFLOAD_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_ADVERTISEMENT_INFORMATION:
        delete ((WDI_SET_ADVERTISEMENT_INFORMATION_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_CHANGE_OPERATION_MODE:
        delete ((WDI_TASK_CHANGE_OPERATION_MODE_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_DELETE_PEER_STATE:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_IHV_REQUEST:
        delete ((WDI_IHV_REQUEST_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_FLUSH_BSS_ENTRY:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_ASSOCIATION_PARAMETERS:
        delete ((WDI_SET_ASSOCIATION_PARAMS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_ROAM:
        delete ((WDI_TASK_ROAM_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_SEND_REQUEST_ACTION_FRAME:
        delete ((WDI_TASK_SEND_REQUEST_ACTION_FRAME_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_SEND_RESPONSE_ACTION_FRAME:
        delete ((WDI_TASK_SEND_RESPONSE_ACTION_FRAME_PARAMETERS*)pParsedOutput);
        break;

    case WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_INPUTS*)pParsedOutput);
        }
        break;

    case WDI_SET_P2P_WPS_ENABLED:
        delete ((WDI_SET_P2P_WPS_ENABLED_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_IHV:
        delete ((WDI_TASK_IHV_PARAMETERS*)pParsedOutput);
        break;

    case WDI_ABORT_TASK:
        delete ((WDI_TASK_ABORT_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_TCP_OFFLOAD_PARAMETERS:
        delete ((WDI_SET_TCP_OFFLOAD_PARAMS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TCP_RSC_STATISTICS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TCP_RSC_STATISTICS_INPUTS*)pParsedOutput);
        }
        break;

    case WDI_SET_ENCAPSULATION_OFFLOAD:
        delete ((WDI_SET_ENCAPSULATION_OFFLOAD_PARAMS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_FAST_BSS_TRANSITION_PARAMETERS:
        delete ((WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_COMMAND*)pParsedOutput);
        break;

    case WDI_SET_NEIGHBOR_REPORT_ENTRIES:
        delete ((WDI_SET_NEIGHBOR_REPORT_ENTRIES_PARAMETERS*)pParsedOutput);
        break;

    default:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }
    return ndisStatus;
}

extern "C" NDIS_STATUS __stdcall ParseFromIhv(
    _In_ ULONG BufferLength,
    _In_reads_bytes_( BufferLength ) UINT8 const * pBuffer,
    _In_ USHORT MessageId,
    _In_ PCTLV_CONTEXT Context,
    _Outptr_result_nullonfailure_ PVOID* ppParsedOutput )
{
    NDIS_STATUS ndisStatus = NDIS_STATUS_SUCCESS;
    *ppParsedOutput = NULL;

    if ((Context == NULL) || (Context->PeerVersion < WDI_VERSION_MIN_SUPPORTED))
    {
        return NDIS_STATUS_UNSUPPORTED_REVISION;
    }

    switch (MessageId)
    {
    case WDI_TASK_OPEN:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskOpen( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_OPEN_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_CLOSE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskClose( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_CLOSE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_HOST_DETECT_ERROR:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetHostDetectError( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_HOST_DETECT_ERROR_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_SCAN:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskScanFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SCAN_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_P2P_DISCOVER:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskP2pDiscoverFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_P2P_DISCOVER_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_P2P_START_BACKGROUND_DISCOVERY:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetP2pStartBackgroundDiscoveryFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_P2P_START_BACKGROUND_DISCOVERY_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetP2pStopBackgroundDiscovery( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_CONNECT:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskConnectFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_CONNECT_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_DOT11_RESET:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskDot11ResetFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_DOT11_RESET_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_DISCONNECT:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskDisconnectFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_DISCONNECT_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskP2pSendRequestActionFrameFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskP2pSendResponseActionFrameFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_SET_RADIO_STATE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskSetRadioStateFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_RADIO_STATE_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_CREATE_PORT:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskCreatePortFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_CREATE_PORT_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_DELETE_PORT:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskDeletePortFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_DELETE_PORT_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_START_AP:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskStartApFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_START_AP_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_STOP_AP:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskStopAp( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_STOP_AP_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case 16:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskSendApAssociationResponseFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskSetReadyToReceiveIndications( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_POWER_STATE:
    {
        WDI_SET_POWER_RESULTS * pOutput = new (Context->AllocationContext) WDI_SET_POWER_RESULTS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiSetPowerStateFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_DISCONNECT_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationDisconnectCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_DISCONNECT_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_SET_RADIO_STATE_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationSetRadioStateCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_SET_RADIO_STATE_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationSetReadyToReceiveIndicationsCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_OPERATION_MODE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetOperationMode( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_OPERATION_MODE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_END_DWELL_TIME:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetEndDwellTime( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_END_DWELL_TIME_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_P2P_ADDITIONAL_IE:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_SET_P2P_LISTEN_STATE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetP2pListenStateFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_P2P_LISTEN_STATE_RESULTS * >( &s_empty );
        }
        break;
    }

    case 27:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_SET_PRIVACY_EXEMPTION_LIST:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetPrivacyExemptionListFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_PRIVACY_EXEMPTION_LIST_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_ADD_CIPHER_KEYS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetAddCipherKeysFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_ADD_CIPHER_KEYS_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_DELETE_CIPHER_KEYS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetDeleteCipherKeysFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_DELETE_CIPHER_KEYS_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_DEFAULT_KEY_ID:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetDefaultKeyIdFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_DEFAULT_KEY_ID_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_CONNECTION_QUALITY:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetConnectionQualityFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_CONNECTION_QUALITY_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_GET_STATISTICS:
    {
        WDI_GET_STATISTICS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_GET_STATISTICS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiGetStatisticsFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_RECEIVE_PACKET_FILTER:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetReceivePacketFilterFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_RECEIVE_PACKET_FILTER_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_GET_ADAPTER_CAPABILITIES:
    {
        WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiGetAdapterCapabilitiesFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_NETWORK_LIST_OFFLOAD:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetNetworkListOffloadFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_NETWORK_LIST_OFFLOAD_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_RECEIVE_COALESCING:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetReceiveCoalescingFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_RECEIVE_COALESCING_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_GET_BSS_ENTRY_LIST:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiGetBssEntryListFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_GET_BSS_ENTRY_LIST_UPDATE_RESULTS * >( &s_empty );
        }
        break;
    }

    case 49:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_INDICATION_DISASSOCIATION:
    {
        WDI_INDICATION_DISASSOCIATION_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_DISASSOCIATION_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationDisassociationFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_ROAMING_NEEDED:
    {
        WDI_INDICATION_ROAMING_NEEDED_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_ROAMING_NEEDED_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationRoamingNeededFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_LINK_STATE_CHANGE:
    {
        WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationLinkStateChangeFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED:
    {
        WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationP2pActionFrameReceivedFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_AP_ASSOCIATION_REQUEST_RECEIVED:
    {
        WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationApAssociationRequestReceivedFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_NLO_DISCOVERY:
    {
        WDI_INDICATION_NLO_DISCOVERY_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_NLO_DISCOVERY_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationNloDiscoveryFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_WAKE_REASON:
    {
        WDI_INDICATION_WAKE_REASON_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_WAKE_REASON_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationWakeReasonFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_PMKID_CANDIDATE_LIST_UPDATE:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_INDICATION_TKIP_MIC_FAILURE:
    {
        WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationTkipMicFailureFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_SCAN_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationScanCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_SCAN_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_P2P_DISCOVERY_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationP2pDiscoveryCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_P2P_DISCOVERY_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_BSS_ENTRY_LIST:
    {
        WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationBssEntryListFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_DOT11_RESET_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationDot11ResetCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_DOT11_RESET_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_CONNECT_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationConnectCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_CONNECT_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE:
    {
        WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationP2pSendRequestActionFrameCompleteFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE:
    {
        WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationP2pSendResponseActionFrameCompleteFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_RADIO_STATUS:
    {
        WDI_INDICATION_RADIO_STATUS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_RADIO_STATUS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationRadioStatusFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_CREATE_PORT_COMPLETE:
    {
        WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationCreatePortCompleteFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_DELETE_PORT_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationDeletePortCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_DELETE_PORT_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_START_AP_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationStartApCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_START_AP_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_STOP_AP_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationStopApCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_STOP_AP_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_STOP_AP:
    {
        WDI_INDICATION_STOP_AP_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_STOP_AP_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationStopApFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_CAN_SUSTAIN_AP:
    {
        WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationCanSustainApFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE:
    {
        WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationSendApAssociationResponseCompleteFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case 74:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_INDICATION_ASSOCIATION_RESULT:
    {
        WDI_INDICATION_ASSOCIATION_RESULT_LIST * pOutput = new (Context->AllocationContext) WDI_INDICATION_ASSOCIATION_RESULT_LIST();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationAssociationResultFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_GET_AUTO_POWER_SAVE:
    {
        WDI_GET_AUTO_POWER_SAVE_RESULTS * pOutput = new (Context->AllocationContext) WDI_GET_AUTO_POWER_SAVE_RESULTS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiGetAutoPowerSaveFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ADD_WOL_PATTERN:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetAddWolPatternFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_ADD_WOL_PATTERN_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_REMOVE_WOL_PATTERN:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetRemoveWolPatternFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_REMOVE_WOL_PATTERN_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_MULTICAST_LIST:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetMulticastListFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_MULTICAST_LIST_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_ADD_PM_PROTOCOL_OFFLOAD:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetAddPmProtocolOffloadFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetRemovePmProtocolOffloadFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL:
    {
        WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationP2pGroupOperatingChannelFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES:
    {
        WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationP2pOperatingChannelAttributesFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ADAPTER_CONFIGURATION:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetAdapterConfigurationFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_FIRMWARE_CONFIGURATION_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_GET_RECEIVE_COALESCING_MATCH_COUNT:
    {
        WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiGetReceiveCoalescingMatchCountFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_CLEAR_RECEIVE_COALESCING:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetClearReceiveCoalescingFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_CLEAR_RECEIVE_COALESCING_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_GET_PM_PROTOCOL_OFFLOAD:
    {
        WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS * pOutput = new (Context->AllocationContext) WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiGetPmProtocolOffloadFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ADVERTISEMENT_INFORMATION:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetAdvertisementInformationFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_ADVERTISEMENT_INFORMATION_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_CHANGE_OPERATION_MODE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskChangeOperationModeFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_CHANGE_OPERATION_MODE_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationChangeOperationModeCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_DELETE_PEER_STATE:
    {
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    case WDI_IHV_REQUEST:
    {
        WDI_IHV_REQUEST_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_IHV_REQUEST_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIhvRequest( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_IHV_EVENT:
    {
        WDI_INDICATION_IHV_EVENT_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_IHV_EVENT_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationIhvEventFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_OPEN_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationOpenCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_OPEN_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_CLOSE_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationCloseCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_CLOSE_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_FLUSH_BSS_ENTRY:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetFlushBssEntry( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_ASSOCIATION_PARAMETERS_REQUEST:
    {
        WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationAssociationParametersRequestFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ASSOCIATION_PARAMETERS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetAssociationParametersFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_ASSOCIATION_PARAMS_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_ROAM:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskRoamFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_ROAM_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_ROAM_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationRoamCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_ROAM_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_SEND_REQUEST_ACTION_FRAME:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskSendRequestActionFrameFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_SEND_REQUEST_ACTION_FRAME_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_ACTION_FRAME_RECEIVED:
    {
        WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationActionFrameReceivedFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG:
    {
        WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationTaskOffloadCurrentConfigFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_TASK_SEND_RESPONSE_ACTION_FRAME:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskSendResponseActionFrameFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_SEND_RESPONSE_ACTION_FRAME_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationSendRequestActionFrameCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationSendResponseActionFrameCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN:
    {
        WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiGetNextActionFrameDialogTokenFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_P2P_WPS_ENABLED:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetP2pWpsEnabledFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_P2P_WPS_ENABLED_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TASK_IHV:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiTaskIhvFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_IHV_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_IHV_TASK_REQUEST:
    {
        WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationIhvTaskRequestFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_INDICATION_IHV_TASK_COMPLETE:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationIhvTaskCompleteFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_IHV_TASK_COMPLETE_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_ABORT_TASK:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiAbortTaskFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_TASK_ABORT_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_TCP_OFFLOAD_PARAMETERS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetTcpOffloadParametersFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_TCP_OFFLOAD_PARAMS_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_TCP_RSC_STATISTICS:
    {
        WDI_TCP_RSC_STATISTICS_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_TCP_RSC_STATISTICS_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiTcpRscStatisticsFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_ENCAPSULATION_OFFLOAD:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetEncapsulationOffloadFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_ENCAPSULATION_OFFLOAD_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED:
    {
        WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS * pOutput = new (Context->AllocationContext) WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS();
        if (NULL == pOutput)
        {
            ndisStatus = NDIS_STATUS_RESOURCES;
            break;
        }
        ndisStatus = ParseWdiIndicationFtAssocParamsNeededFromIhv( BufferLength, pBuffer, Context, pOutput );
        *ppParsedOutput = pOutput;
        break;
    }

    case WDI_SET_FAST_BSS_TRANSITION_PARAMETERS:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetFastBssTransitionParametersFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_RESULTS * >( &s_empty );
        }
        break;
    }

    case WDI_INDICATION_FIRMWARE_STALLED:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiIndicationFirmwareStalledFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_INDICATION_FIRMWARE_STALLED_PARAMETERS * >( &s_empty );
        }
        break;
    }

    case WDI_SET_NEIGHBOR_REPORT_ENTRIES:
    {
        // Empty message needs no data, or allocation, just validate the message structure
        // and return the singleton empty type.
        ndisStatus = ParseWdiSetNeighborReportEntriesFromIhv( BufferLength, pBuffer, Context, NULL );
        if (NT_SUCCESS( ndisStatus ))
        {
            *ppParsedOutput = const_cast< WDI_SET_NEIGHBOR_REPORT_ENTRIES_RESULTS * >( &s_empty );
        }
        break;
    }

    default:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }

    if (!NT_SUCCESS( ndisStatus ) && (NULL != *ppParsedOutput))
    {
        delete *ppParsedOutput;
        *ppParsedOutput = NULL;
    }
    return ndisStatus;
}

extern "C" NDIS_STATUS __stdcall FreeParsedFromIhv(
    _In_ USHORT MessageId,
    _In_opt_ PVOID pParsedOutput )
{
    NDIS_STATUS ndisStatus = NDIS_STATUS_SUCCESS;

    switch (MessageId)
    {
    case WDI_TASK_OPEN:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_OPEN_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_TASK_CLOSE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_CLOSE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_HOST_DETECT_ERROR:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_HOST_DETECT_ERROR_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_TASK_SCAN:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SCAN_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_P2P_DISCOVER:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_P2P_DISCOVER_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_P2P_START_BACKGROUND_DISCOVERY:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_P2P_START_BACKGROUND_DISCOVERY_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_P2P_STOP_BACKGROUND_DISCOVERY_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_TASK_CONNECT:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_CONNECT_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_DOT11_RESET:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_DOT11_RESET_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_DISCONNECT:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_DISCONNECT_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_P2P_SEND_REQUEST_ACTION_FRAME_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_P2P_SEND_RESPONSE_ACTION_FRAME_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_SET_RADIO_STATE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_RADIO_STATE_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_CREATE_PORT:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_CREATE_PORT_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_DELETE_PORT:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_DELETE_PORT_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_START_AP:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_START_AP_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_STOP_AP:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_STOP_AP_PARAMETERS*)pParsedOutput);
        }
        break;

    case 16:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_SEND_AP_ASSOCIATION_RESPONSE_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_SET_READY_TO_RECEIVE_INDICATIONS_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_POWER_STATE:
        delete ((WDI_SET_POWER_RESULTS*)pParsedOutput);
        break;

    case WDI_INDICATION_DISCONNECT_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_DISCONNECT_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_SET_RADIO_STATE_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_SET_RADIO_STATE_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_SET_READY_TO_RECEIVE_INDICATIONS_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_OPERATION_MODE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_OPERATION_MODE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_END_DWELL_TIME:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_END_DWELL_TIME_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_P2P_ADDITIONAL_IE:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_SET_P2P_LISTEN_STATE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_P2P_LISTEN_STATE_RESULTS*)pParsedOutput);
        }
        break;

    case 27:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_SET_PRIVACY_EXEMPTION_LIST:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_PRIVACY_EXEMPTION_LIST_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_ADD_CIPHER_KEYS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_ADD_CIPHER_KEYS_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_DELETE_CIPHER_KEYS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_DELETE_CIPHER_KEYS_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_DEFAULT_KEY_ID:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_DEFAULT_KEY_ID_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_CONNECTION_QUALITY:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_CONNECTION_QUALITY_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_GET_STATISTICS:
        delete ((WDI_GET_STATISTICS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_RECEIVE_PACKET_FILTER:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_RECEIVE_PACKET_FILTER_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_GET_ADAPTER_CAPABILITIES:
        delete ((WDI_GET_ADAPTER_CAPABILITIES_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_NETWORK_LIST_OFFLOAD:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_NETWORK_LIST_OFFLOAD_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_RECEIVE_COALESCING:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_RECEIVE_COALESCING_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_GET_BSS_ENTRY_LIST:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_GET_BSS_ENTRY_LIST_UPDATE_RESULTS*)pParsedOutput);
        }
        break;

    case 49:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_INDICATION_DISASSOCIATION:
        delete ((WDI_INDICATION_DISASSOCIATION_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_ROAMING_NEEDED:
        delete ((WDI_INDICATION_ROAMING_NEEDED_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_LINK_STATE_CHANGE:
        delete ((WDI_INDICATION_LINK_STATE_CHANGE_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED:
        delete ((WDI_INDICATION_P2P_ACTION_FRAME_RECEIVED_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_AP_ASSOCIATION_REQUEST_RECEIVED:
        delete ((WDI_INDICATION_AP_ASSOCIATION_REQUEST_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_NLO_DISCOVERY:
        delete ((WDI_INDICATION_NLO_DISCOVERY_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_WAKE_REASON:
        delete ((WDI_INDICATION_WAKE_REASON_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_PMKID_CANDIDATE_LIST_UPDATE:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_INDICATION_TKIP_MIC_FAILURE:
        delete ((WDI_INDICATION_TKIP_MIC_FAILURE_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_SCAN_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_SCAN_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_P2P_DISCOVERY_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_P2P_DISCOVERY_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_BSS_ENTRY_LIST:
        delete ((WDI_INDICATION_BSS_ENTRY_LIST_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_DOT11_RESET_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_DOT11_RESET_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_CONNECT_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_CONNECT_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE:
        delete ((WDI_INDICATION_P2P_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE:
        delete ((WDI_INDICATION_P2P_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_RADIO_STATUS:
        delete ((WDI_INDICATION_RADIO_STATUS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_CREATE_PORT_COMPLETE:
        delete ((WDI_INDICATION_CREATE_PORT_COMPLETE_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_DELETE_PORT_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_DELETE_PORT_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_START_AP_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_START_AP_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_STOP_AP_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_STOP_AP_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_STOP_AP:
        delete ((WDI_INDICATION_STOP_AP_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_CAN_SUSTAIN_AP:
        delete ((WDI_INDICATION_CAN_SUSTAIN_AP_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE:
        delete ((WDI_INDICATION_SEND_AP_ASSOCIATION_RESPONSE_COMPLETE_PARAMETERS*)pParsedOutput);
        break;

    case 74:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_INDICATION_ASSOCIATION_RESULT:
        delete ((WDI_INDICATION_ASSOCIATION_RESULT_LIST*)pParsedOutput);
        break;

    case WDI_GET_AUTO_POWER_SAVE:
        delete ((WDI_GET_AUTO_POWER_SAVE_RESULTS*)pParsedOutput);
        break;

    case WDI_SET_ADD_WOL_PATTERN:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_ADD_WOL_PATTERN_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_REMOVE_WOL_PATTERN:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_REMOVE_WOL_PATTERN_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_MULTICAST_LIST:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_MULTICAST_LIST_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_ADD_PM_PROTOCOL_OFFLOAD:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_ADD_PM_PROTOCOL_OFFLOAD_PARAMETERS_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_REMOVE_PM_PROTOCOL_OFFLOAD_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL:
        delete ((WDI_INDICATION_P2P_GROUP_OPERATING_CHANNEL_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES:
        delete ((WDI_INDICATION_P2P_OPERATING_CHANNEL_ATTRIBUTES_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_ADAPTER_CONFIGURATION:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_FIRMWARE_CONFIGURATION_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_GET_RECEIVE_COALESCING_MATCH_COUNT:
        delete ((WDI_GET_RECEIVE_COALESCING_MATCH_COUNT_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_CLEAR_RECEIVE_COALESCING:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_CLEAR_RECEIVE_COALESCING_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_GET_PM_PROTOCOL_OFFLOAD:
        delete ((WDI_GET_PM_PROTOCOL_OFFLOAD_RESULTS*)pParsedOutput);
        break;

    case WDI_SET_ADVERTISEMENT_INFORMATION:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_ADVERTISEMENT_INFORMATION_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_CHANGE_OPERATION_MODE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_CHANGE_OPERATION_MODE_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_CHANGE_OPERATION_MODE_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_TASK_DELETE_PEER_STATE:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;

    case WDI_IHV_REQUEST:
        delete ((WDI_IHV_REQUEST_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_IHV_EVENT:
        delete ((WDI_INDICATION_IHV_EVENT_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_OPEN_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_OPEN_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_CLOSE_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_CLOSE_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_FLUSH_BSS_ENTRY:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_FLUSH_BSS_ENTRY_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_ASSOCIATION_PARAMETERS_REQUEST:
        delete ((WDI_INDICATION_ASSOCIATION_PARAMS_REQUEST_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_ASSOCIATION_PARAMETERS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_ASSOCIATION_PARAMS_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_ROAM:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_ROAM_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_ROAM_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_ROAM_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_TASK_SEND_REQUEST_ACTION_FRAME:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_SEND_REQUEST_ACTION_FRAME_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_ACTION_FRAME_RECEIVED:
        delete ((WDI_INDICATION_ACTION_FRAME_RECEIVED_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG:
        delete ((WDI_INDICATION_TASK_OFFLOAD_CURRENT_CONFIG_PARAMETERS*)pParsedOutput);
        break;

    case WDI_TASK_SEND_RESPONSE_ACTION_FRAME:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_SEND_RESPONSE_ACTION_FRAME_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_SEND_REQUEST_ACTION_FRAME_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_SEND_RESPONSE_ACTION_FRAME_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN:
        delete ((WDI_GET_NEXT_ACTION_FRAME_DIALOG_TOKEN_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_P2P_WPS_ENABLED:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_P2P_WPS_ENABLED_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TASK_IHV:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_IHV_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_IHV_TASK_REQUEST:
        delete ((WDI_INDICATION_IHV_TASK_REQUEST_PARAMETERS*)pParsedOutput);
        break;

    case WDI_INDICATION_IHV_TASK_COMPLETE:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_IHV_TASK_COMPLETE_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_ABORT_TASK:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_TASK_ABORT_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_SET_TCP_OFFLOAD_PARAMETERS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_TCP_OFFLOAD_PARAMS_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_TCP_RSC_STATISTICS:
        delete ((WDI_TCP_RSC_STATISTICS_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_ENCAPSULATION_OFFLOAD:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_ENCAPSULATION_OFFLOAD_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED:
        delete ((WDI_INDICATION_FT_ASSOC_PARAMS_NEEDED_PARAMETERS*)pParsedOutput);
        break;

    case WDI_SET_FAST_BSS_TRANSITION_PARAMETERS:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_FAST_BSS_TRANSITION_PARAMETERS_RESULTS*)pParsedOutput);
        }
        break;

    case WDI_INDICATION_FIRMWARE_STALLED:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_INDICATION_FIRMWARE_STALLED_PARAMETERS*)pParsedOutput);
        }
        break;

    case WDI_SET_NEIGHBOR_REPORT_ENTRIES:
        // Empty message needs no data, or allocation, so this should be the singleton empty type.
        if (pParsedOutput != &s_empty)
        {
            delete ((WDI_SET_NEIGHBOR_REPORT_ENTRIES_RESULTS*)pParsedOutput);
        }
        break;

    default:
        ndisStatus = NDIS_STATUS_INVALID_PARAMETER;
        break;
    }
    return ndisStatus;
}
