types_generated_handling.h

Go to the documentation of this file.

 
 
#ifndef TYPES_GENERATED_HANDLING_H_
#define TYPES_GENERATED_HANDLING_H_
 
#include "types_generated.h"
 
_UA_BEGIN_DECLS
 
#if defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
# pragma GCC diagnostic ignored "-Wmissing-braces"
#endif
 
 
/** Boolean */
static void
UA_Boolean_init(UA_Boolean *p) {
    memset(p, 0, sizeof(UA_Boolean));
}
 
static UA_Boolean *
UA_Boolean_new(void) {
    return (UA_Boolean*)UA_new(&UA_TYPES[UA_TYPES_BOOLEAN]);
}
 
static UA_StatusCode
UA_Boolean_copy(const UA_Boolean *src, UA_Boolean *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BOOLEAN]);
}
 
UA_DEPRECATED static void
UA_Boolean_deleteMembers(UA_Boolean *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BOOLEAN]);
}
 
static void
UA_Boolean_clear(UA_Boolean *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BOOLEAN]);
}
 
static void
UA_Boolean_delete(UA_Boolean *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BOOLEAN]);
}
 
/** SByte */
static void
UA_SByte_init(UA_SByte *p) {
    memset(p, 0, sizeof(UA_SByte));
}
 
static UA_SByte *
UA_SByte_new(void) {
    return (UA_SByte*)UA_new(&UA_TYPES[UA_TYPES_SBYTE]);
}
 
static UA_StatusCode
UA_SByte_copy(const UA_SByte *src, UA_SByte *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SBYTE]);
}
 
UA_DEPRECATED static void
UA_SByte_deleteMembers(UA_SByte *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SBYTE]);
}
 
static void
UA_SByte_clear(UA_SByte *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SBYTE]);
}
 
static void
UA_SByte_delete(UA_SByte *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SBYTE]);
}
 
/** Byte */
static void
UA_Byte_init(UA_Byte *p) {
    memset(p, 0, sizeof(UA_Byte));
}
 
static UA_Byte *
UA_Byte_new(void) {
    return (UA_Byte*)UA_new(&UA_TYPES[UA_TYPES_BYTE]);
}
 
static UA_StatusCode
UA_Byte_copy(const UA_Byte *src, UA_Byte *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BYTE]);
}
 
UA_DEPRECATED static void
UA_Byte_deleteMembers(UA_Byte *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BYTE]);
}
 
static void
UA_Byte_clear(UA_Byte *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BYTE]);
}
 
static void
UA_Byte_delete(UA_Byte *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BYTE]);
}
 
/** Int16 */
static void
UA_Int16_init(UA_Int16 *p) {
    memset(p, 0, sizeof(UA_Int16));
}
 
static UA_Int16 *
UA_Int16_new(void) {
    return (UA_Int16*)UA_new(&UA_TYPES[UA_TYPES_INT16]);
}
 
static UA_StatusCode
UA_Int16_copy(const UA_Int16 *src, UA_Int16 *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT16]);
}
 
UA_DEPRECATED static void
UA_Int16_deleteMembers(UA_Int16 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT16]);
}
 
static void
UA_Int16_clear(UA_Int16 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT16]);
}
 
static void
UA_Int16_delete(UA_Int16 *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_INT16]);
}
 
/** UInt16 */
static void
UA_UInt16_init(UA_UInt16 *p) {
    memset(p, 0, sizeof(UA_UInt16));
}
 
static UA_UInt16 *
UA_UInt16_new(void) {
    return (UA_UInt16*)UA_new(&UA_TYPES[UA_TYPES_UINT16]);
}
 
static UA_StatusCode
UA_UInt16_copy(const UA_UInt16 *src, UA_UInt16 *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT16]);
}
 
UA_DEPRECATED static void
UA_UInt16_deleteMembers(UA_UInt16 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT16]);
}
 
static void
UA_UInt16_clear(UA_UInt16 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT16]);
}
 
static void
UA_UInt16_delete(UA_UInt16 *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_UINT16]);
}
 
/** Int32 */
static void
UA_Int32_init(UA_Int32 *p) {
    memset(p, 0, sizeof(UA_Int32));
}
 
static UA_Int32 *
UA_Int32_new(void) {
    return (UA_Int32*)UA_new(&UA_TYPES[UA_TYPES_INT32]);
}
 
static UA_StatusCode
UA_Int32_copy(const UA_Int32 *src, UA_Int32 *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT32]);
}
 
UA_DEPRECATED static void
UA_Int32_deleteMembers(UA_Int32 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT32]);
}
 
static void
UA_Int32_clear(UA_Int32 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT32]);
}
 
static void
UA_Int32_delete(UA_Int32 *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_INT32]);
}
 
/** UInt32 */
static void
UA_UInt32_init(UA_UInt32 *p) {
    memset(p, 0, sizeof(UA_UInt32));
}
 
static UA_UInt32 *
UA_UInt32_new(void) {
    return (UA_UInt32*)UA_new(&UA_TYPES[UA_TYPES_UINT32]);
}
 
static UA_StatusCode
UA_UInt32_copy(const UA_UInt32 *src, UA_UInt32 *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT32]);
}
 
UA_DEPRECATED static void
UA_UInt32_deleteMembers(UA_UInt32 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT32]);
}
 
static void
UA_UInt32_clear(UA_UInt32 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT32]);
}
 
static void
UA_UInt32_delete(UA_UInt32 *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_UINT32]);
}
 
/** Int64 */
static void
UA_Int64_init(UA_Int64 *p) {
    memset(p, 0, sizeof(UA_Int64));
}
 
static UA_Int64 *
UA_Int64_new(void) {
    return (UA_Int64*)UA_new(&UA_TYPES[UA_TYPES_INT64]);
}
 
static UA_StatusCode
UA_Int64_copy(const UA_Int64 *src, UA_Int64 *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT64]);
}
 
UA_DEPRECATED static void
UA_Int64_deleteMembers(UA_Int64 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT64]);
}
 
static void
UA_Int64_clear(UA_Int64 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT64]);
}
 
static void
UA_Int64_delete(UA_Int64 *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_INT64]);
}
 
/** UInt64 */
static void
UA_UInt64_init(UA_UInt64 *p) {
    memset(p, 0, sizeof(UA_UInt64));
}
 
static UA_UInt64 *
UA_UInt64_new(void) {
    return (UA_UInt64*)UA_new(&UA_TYPES[UA_TYPES_UINT64]);
}
 
static UA_StatusCode
UA_UInt64_copy(const UA_UInt64 *src, UA_UInt64 *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT64]);
}
 
UA_DEPRECATED static void
UA_UInt64_deleteMembers(UA_UInt64 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT64]);
}
 
static void
UA_UInt64_clear(UA_UInt64 *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT64]);
}
 
static void
UA_UInt64_delete(UA_UInt64 *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_UINT64]);
}
 
/** Float */
static void
UA_Float_init(UA_Float *p) {
    memset(p, 0, sizeof(UA_Float));
}
 
static UA_Float *
UA_Float_new(void) {
    return (UA_Float*)UA_new(&UA_TYPES[UA_TYPES_FLOAT]);
}
 
static UA_StatusCode
UA_Float_copy(const UA_Float *src, UA_Float *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FLOAT]);
}
 
UA_DEPRECATED static void
UA_Float_deleteMembers(UA_Float *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_FLOAT]);
}
 
static void
UA_Float_clear(UA_Float *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_FLOAT]);
}
 
static void
UA_Float_delete(UA_Float *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_FLOAT]);
}
 
/** Double */
static void
UA_Double_init(UA_Double *p) {
    memset(p, 0, sizeof(UA_Double));
}
 
static UA_Double *
UA_Double_new(void) {
    return (UA_Double*)UA_new(&UA_TYPES[UA_TYPES_DOUBLE]);
}
 
static UA_StatusCode
UA_Double_copy(const UA_Double *src, UA_Double *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DOUBLE]);
}
 
UA_DEPRECATED static void
UA_Double_deleteMembers(UA_Double *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLE]);
}
 
static void
UA_Double_clear(UA_Double *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLE]);
}
 
static void
UA_Double_delete(UA_Double *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DOUBLE]);
}
 
/** String */
static void
UA_String_init(UA_String *p) {
    memset(p, 0, sizeof(UA_String));
}
 
static UA_String *
UA_String_new(void) {
    return (UA_String*)UA_new(&UA_TYPES[UA_TYPES_STRING]);
}
 
static UA_StatusCode
UA_String_copy(const UA_String *src, UA_String *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRING]);
}
 
UA_DEPRECATED static void
UA_String_deleteMembers(UA_String *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRING]);
}
 
static void
UA_String_clear(UA_String *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRING]);
}
 
static void
UA_String_delete(UA_String *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRING]);
}
 
/** DateTime */
static void
UA_DateTime_init(UA_DateTime *p) {
    memset(p, 0, sizeof(UA_DateTime));
}
 
static UA_DateTime *
UA_DateTime_new(void) {
    return (UA_DateTime*)UA_new(&UA_TYPES[UA_TYPES_DATETIME]);
}
 
static UA_StatusCode
UA_DateTime_copy(const UA_DateTime *src, UA_DateTime *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATETIME]);
}
 
UA_DEPRECATED static void
UA_DateTime_deleteMembers(UA_DateTime *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATETIME]);
}
 
static void
UA_DateTime_clear(UA_DateTime *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATETIME]);
}
 
static void
UA_DateTime_delete(UA_DateTime *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATETIME]);
}
 
/** Guid */
static void
UA_Guid_init(UA_Guid *p) {
    memset(p, 0, sizeof(UA_Guid));
}
 
static UA_Guid *
UA_Guid_new(void) {
    return (UA_Guid*)UA_new(&UA_TYPES[UA_TYPES_GUID]);
}
 
static UA_StatusCode
UA_Guid_copy(const UA_Guid *src, UA_Guid *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GUID]);
}
 
UA_DEPRECATED static void
UA_Guid_deleteMembers(UA_Guid *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_GUID]);
}
 
static void
UA_Guid_clear(UA_Guid *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_GUID]);
}
 
static void
UA_Guid_delete(UA_Guid *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_GUID]);
}
 
/** ByteString */
static void
UA_ByteString_init(UA_ByteString *p) {
    memset(p, 0, sizeof(UA_ByteString));
}
 
static UA_ByteString *
UA_ByteString_new(void) {
    return (UA_ByteString*)UA_new(&UA_TYPES[UA_TYPES_BYTESTRING]);
}
 
static UA_StatusCode
UA_ByteString_copy(const UA_ByteString *src, UA_ByteString *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BYTESTRING]);
}
 
UA_DEPRECATED static void
UA_ByteString_deleteMembers(UA_ByteString *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BYTESTRING]);
}
 
static void
UA_ByteString_clear(UA_ByteString *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BYTESTRING]);
}
 
static void
UA_ByteString_delete(UA_ByteString *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BYTESTRING]);
}
 
/** XmlElement */
static void
UA_XmlElement_init(UA_XmlElement *p) {
    memset(p, 0, sizeof(UA_XmlElement));
}
 
static UA_XmlElement *
UA_XmlElement_new(void) {
    return (UA_XmlElement*)UA_new(&UA_TYPES[UA_TYPES_XMLELEMENT]);
}
 
static UA_StatusCode
UA_XmlElement_copy(const UA_XmlElement *src, UA_XmlElement *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_XMLELEMENT]);
}
 
UA_DEPRECATED static void
UA_XmlElement_deleteMembers(UA_XmlElement *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_XMLELEMENT]);
}
 
static void
UA_XmlElement_clear(UA_XmlElement *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_XMLELEMENT]);
}
 
static void
UA_XmlElement_delete(UA_XmlElement *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_XMLELEMENT]);
}
 
/** NodeId */
static void
UA_NodeId_init(UA_NodeId *p) {
    memset(p, 0, sizeof(UA_NodeId));
}
 
static UA_NodeId *
UA_NodeId_new(void) {
    return (UA_NodeId*)UA_new(&UA_TYPES[UA_TYPES_NODEID]);
}
 
static UA_StatusCode
UA_NodeId_copy(const UA_NodeId *src, UA_NodeId *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEID]);
}
 
UA_DEPRECATED static void
UA_NodeId_deleteMembers(UA_NodeId *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEID]);
}
 
static void
UA_NodeId_clear(UA_NodeId *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEID]);
}
 
static void
UA_NodeId_delete(UA_NodeId *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODEID]);
}
 
/** ExpandedNodeId */
static void
UA_ExpandedNodeId_init(UA_ExpandedNodeId *p) {
    memset(p, 0, sizeof(UA_ExpandedNodeId));
}
 
static UA_ExpandedNodeId *
UA_ExpandedNodeId_new(void) {
    return (UA_ExpandedNodeId*)UA_new(&UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
}
 
static UA_StatusCode
UA_ExpandedNodeId_copy(const UA_ExpandedNodeId *src, UA_ExpandedNodeId *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
}
 
UA_DEPRECATED static void
UA_ExpandedNodeId_deleteMembers(UA_ExpandedNodeId *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
}
 
static void
UA_ExpandedNodeId_clear(UA_ExpandedNodeId *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
}
 
static void
UA_ExpandedNodeId_delete(UA_ExpandedNodeId *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
}
 
/** StatusCode */
static void
UA_StatusCode_init(UA_StatusCode *p) {
    memset(p, 0, sizeof(UA_StatusCode));
}
 
static UA_StatusCode *
UA_StatusCode_new(void) {
    return (UA_StatusCode*)UA_new(&UA_TYPES[UA_TYPES_STATUSCODE]);
}
 
static UA_StatusCode
UA_StatusCode_copy(const UA_StatusCode *src, UA_StatusCode *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STATUSCODE]);
}
 
UA_DEPRECATED static void
UA_StatusCode_deleteMembers(UA_StatusCode *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCODE]);
}
 
static void
UA_StatusCode_clear(UA_StatusCode *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCODE]);
}
 
static void
UA_StatusCode_delete(UA_StatusCode *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_STATUSCODE]);
}
 
/** QualifiedName */
static void
UA_QualifiedName_init(UA_QualifiedName *p) {
    memset(p, 0, sizeof(UA_QualifiedName));
}
 
static UA_QualifiedName *
UA_QualifiedName_new(void) {
    return (UA_QualifiedName*)UA_new(&UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
}
 
static UA_StatusCode
UA_QualifiedName_copy(const UA_QualifiedName *src, UA_QualifiedName *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
}
 
UA_DEPRECATED static void
UA_QualifiedName_deleteMembers(UA_QualifiedName *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
}
 
static void
UA_QualifiedName_clear(UA_QualifiedName *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
}
 
static void
UA_QualifiedName_delete(UA_QualifiedName *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
}
 
/** LocalizedText */
static void
UA_LocalizedText_init(UA_LocalizedText *p) {
    memset(p, 0, sizeof(UA_LocalizedText));
}
 
static UA_LocalizedText *
UA_LocalizedText_new(void) {
    return (UA_LocalizedText*)UA_new(&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
}
 
static UA_StatusCode
UA_LocalizedText_copy(const UA_LocalizedText *src, UA_LocalizedText *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
}
 
UA_DEPRECATED static void
UA_LocalizedText_deleteMembers(UA_LocalizedText *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
}
 
static void
UA_LocalizedText_clear(UA_LocalizedText *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
}
 
static void
UA_LocalizedText_delete(UA_LocalizedText *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
}
 
/** ExtensionObject */
static void
UA_ExtensionObject_init(UA_ExtensionObject *p) {
    memset(p, 0, sizeof(UA_ExtensionObject));
}
 
static UA_ExtensionObject *
UA_ExtensionObject_new(void) {
    return (UA_ExtensionObject*)UA_new(&UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
}
 
static UA_StatusCode
UA_ExtensionObject_copy(const UA_ExtensionObject *src, UA_ExtensionObject *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
}
 
UA_DEPRECATED static void
UA_ExtensionObject_deleteMembers(UA_ExtensionObject *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
}
 
static void
UA_ExtensionObject_clear(UA_ExtensionObject *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
}
 
static void
UA_ExtensionObject_delete(UA_ExtensionObject *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
}
 
/** DataValue */
static void
UA_DataValue_init(UA_DataValue *p) {
    memset(p, 0, sizeof(UA_DataValue));
}
 
static UA_DataValue *
UA_DataValue_new(void) {
    return (UA_DataValue*)UA_new(&UA_TYPES[UA_TYPES_DATAVALUE]);
}
 
static UA_StatusCode
UA_DataValue_copy(const UA_DataValue *src, UA_DataValue *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAVALUE]);
}
 
UA_DEPRECATED static void
UA_DataValue_deleteMembers(UA_DataValue *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATAVALUE]);
}
 
static void
UA_DataValue_clear(UA_DataValue *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATAVALUE]);
}
 
static void
UA_DataValue_delete(UA_DataValue *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATAVALUE]);
}
 
/** Variant */
static void
UA_Variant_init(UA_Variant *p) {
    memset(p, 0, sizeof(UA_Variant));
}
 
static UA_Variant *
UA_Variant_new(void) {
    return (UA_Variant*)UA_new(&UA_TYPES[UA_TYPES_VARIANT]);
}
 
static UA_StatusCode
UA_Variant_copy(const UA_Variant *src, UA_Variant *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIANT]);
}
 
UA_DEPRECATED static void
UA_Variant_deleteMembers(UA_Variant *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIANT]);
}
 
static void
UA_Variant_clear(UA_Variant *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIANT]);
}
 
static void
UA_Variant_delete(UA_Variant *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_VARIANT]);
}
 
/** DiagnosticInfo */
static void
UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) {
    memset(p, 0, sizeof(UA_DiagnosticInfo));
}
 
static UA_DiagnosticInfo *
UA_DiagnosticInfo_new(void) {
    return (UA_DiagnosticInfo*)UA_new(&UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
}
 
static UA_StatusCode
UA_DiagnosticInfo_copy(const UA_DiagnosticInfo *src, UA_DiagnosticInfo *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
}
 
UA_DEPRECATED static void
UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
}
 
static void
UA_DiagnosticInfo_clear(UA_DiagnosticInfo *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
}
 
static void
UA_DiagnosticInfo_delete(UA_DiagnosticInfo *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
}
 
/** KeyValuePair */
static void
UA_KeyValuePair_init(UA_KeyValuePair *p) {
    memset(p, 0, sizeof(UA_KeyValuePair));
}
 
static UA_KeyValuePair *
UA_KeyValuePair_new(void) {
    return (UA_KeyValuePair*)UA_new(&UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
}
 
static UA_StatusCode
UA_KeyValuePair_copy(const UA_KeyValuePair *src, UA_KeyValuePair *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
}
 
UA_DEPRECATED static void
UA_KeyValuePair_deleteMembers(UA_KeyValuePair *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
}
 
static void
UA_KeyValuePair_clear(UA_KeyValuePair *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
}
 
static void
UA_KeyValuePair_delete(UA_KeyValuePair *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
}
 
/** NodeClass */
static void
UA_NodeClass_init(UA_NodeClass *p) {
    memset(p, 0, sizeof(UA_NodeClass));
}
 
static UA_NodeClass *
UA_NodeClass_new(void) {
    return (UA_NodeClass*)UA_new(&UA_TYPES[UA_TYPES_NODECLASS]);
}
 
static UA_StatusCode
UA_NodeClass_copy(const UA_NodeClass *src, UA_NodeClass *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODECLASS]);
}
 
UA_DEPRECATED static void
UA_NodeClass_deleteMembers(UA_NodeClass *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODECLASS]);
}
 
static void
UA_NodeClass_clear(UA_NodeClass *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODECLASS]);
}
 
static void
UA_NodeClass_delete(UA_NodeClass *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODECLASS]);
}
 
/** StructureType */
static void
UA_StructureType_init(UA_StructureType *p) {
    memset(p, 0, sizeof(UA_StructureType));
}
 
static UA_StructureType *
UA_StructureType_new(void) {
    return (UA_StructureType*)UA_new(&UA_TYPES[UA_TYPES_STRUCTURETYPE]);
}
 
static UA_StatusCode
UA_StructureType_copy(const UA_StructureType *src, UA_StructureType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTURETYPE]);
}
 
UA_DEPRECATED static void
UA_StructureType_deleteMembers(UA_StructureType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTURETYPE]);
}
 
static void
UA_StructureType_clear(UA_StructureType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTURETYPE]);
}
 
static void
UA_StructureType_delete(UA_StructureType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTURETYPE]);
}
 
/** StructureField */
static void
UA_StructureField_init(UA_StructureField *p) {
    memset(p, 0, sizeof(UA_StructureField));
}
 
static UA_StructureField *
UA_StructureField_new(void) {
    return (UA_StructureField*)UA_new(&UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
}
 
static UA_StatusCode
UA_StructureField_copy(const UA_StructureField *src, UA_StructureField *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
}
 
UA_DEPRECATED static void
UA_StructureField_deleteMembers(UA_StructureField *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
}
 
static void
UA_StructureField_clear(UA_StructureField *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
}
 
static void
UA_StructureField_delete(UA_StructureField *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
}
 
/** StructureDefinition */
static void
UA_StructureDefinition_init(UA_StructureDefinition *p) {
    memset(p, 0, sizeof(UA_StructureDefinition));
}
 
static UA_StructureDefinition *
UA_StructureDefinition_new(void) {
    return (UA_StructureDefinition*)UA_new(&UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
}
 
static UA_StatusCode
UA_StructureDefinition_copy(const UA_StructureDefinition *src, UA_StructureDefinition *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
}
 
UA_DEPRECATED static void
UA_StructureDefinition_deleteMembers(UA_StructureDefinition *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
}
 
static void
UA_StructureDefinition_clear(UA_StructureDefinition *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
}
 
static void
UA_StructureDefinition_delete(UA_StructureDefinition *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
}
 
/** Argument */
static void
UA_Argument_init(UA_Argument *p) {
    memset(p, 0, sizeof(UA_Argument));
}
 
static UA_Argument *
UA_Argument_new(void) {
    return (UA_Argument*)UA_new(&UA_TYPES[UA_TYPES_ARGUMENT]);
}
 
static UA_StatusCode
UA_Argument_copy(const UA_Argument *src, UA_Argument *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ARGUMENT]);
}
 
UA_DEPRECATED static void
UA_Argument_deleteMembers(UA_Argument *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ARGUMENT]);
}
 
static void
UA_Argument_clear(UA_Argument *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ARGUMENT]);
}
 
static void
UA_Argument_delete(UA_Argument *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ARGUMENT]);
}
 
/** EnumValueType */
static void
UA_EnumValueType_init(UA_EnumValueType *p) {
    memset(p, 0, sizeof(UA_EnumValueType));
}
 
static UA_EnumValueType *
UA_EnumValueType_new(void) {
    return (UA_EnumValueType*)UA_new(&UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
}
 
static UA_StatusCode
UA_EnumValueType_copy(const UA_EnumValueType *src, UA_EnumValueType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
}
 
UA_DEPRECATED static void
UA_EnumValueType_deleteMembers(UA_EnumValueType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
}
 
static void
UA_EnumValueType_clear(UA_EnumValueType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
}
 
static void
UA_EnumValueType_delete(UA_EnumValueType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
}
 
/** EnumField */
static void
UA_EnumField_init(UA_EnumField *p) {
    memset(p, 0, sizeof(UA_EnumField));
}
 
static UA_EnumField *
UA_EnumField_new(void) {
    return (UA_EnumField*)UA_new(&UA_TYPES[UA_TYPES_ENUMFIELD]);
}
 
static UA_StatusCode
UA_EnumField_copy(const UA_EnumField *src, UA_EnumField *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMFIELD]);
}
 
UA_DEPRECATED static void
UA_EnumField_deleteMembers(UA_EnumField *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMFIELD]);
}
 
static void
UA_EnumField_clear(UA_EnumField *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMFIELD]);
}
 
static void
UA_EnumField_delete(UA_EnumField *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENUMFIELD]);
}
 
/** Duration */
static void
UA_Duration_init(UA_Duration *p) {
    memset(p, 0, sizeof(UA_Duration));
}
 
static UA_Duration *
UA_Duration_new(void) {
    return (UA_Duration*)UA_new(&UA_TYPES[UA_TYPES_DURATION]);
}
 
static UA_StatusCode
UA_Duration_copy(const UA_Duration *src, UA_Duration *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DURATION]);
}
 
UA_DEPRECATED static void
UA_Duration_deleteMembers(UA_Duration *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DURATION]);
}
 
static void
UA_Duration_clear(UA_Duration *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DURATION]);
}
 
static void
UA_Duration_delete(UA_Duration *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DURATION]);
}
 
/** UtcTime */
static void
UA_UtcTime_init(UA_UtcTime *p) {
    memset(p, 0, sizeof(UA_UtcTime));
}
 
static UA_UtcTime *
UA_UtcTime_new(void) {
    return (UA_UtcTime*)UA_new(&UA_TYPES[UA_TYPES_UTCTIME]);
}
 
static UA_StatusCode
UA_UtcTime_copy(const UA_UtcTime *src, UA_UtcTime *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UTCTIME]);
}
 
UA_DEPRECATED static void
UA_UtcTime_deleteMembers(UA_UtcTime *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UTCTIME]);
}
 
static void
UA_UtcTime_clear(UA_UtcTime *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UTCTIME]);
}
 
static void
UA_UtcTime_delete(UA_UtcTime *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_UTCTIME]);
}
 
/** LocaleId */
static void
UA_LocaleId_init(UA_LocaleId *p) {
    memset(p, 0, sizeof(UA_LocaleId));
}
 
static UA_LocaleId *
UA_LocaleId_new(void) {
    return (UA_LocaleId*)UA_new(&UA_TYPES[UA_TYPES_LOCALEID]);
}
 
static UA_StatusCode
UA_LocaleId_copy(const UA_LocaleId *src, UA_LocaleId *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOCALEID]);
}
 
UA_DEPRECATED static void
UA_LocaleId_deleteMembers(UA_LocaleId *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOCALEID]);
}
 
static void
UA_LocaleId_clear(UA_LocaleId *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOCALEID]);
}
 
static void
UA_LocaleId_delete(UA_LocaleId *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_LOCALEID]);
}
 
/** TimeZoneDataType */
static void
UA_TimeZoneDataType_init(UA_TimeZoneDataType *p) {
    memset(p, 0, sizeof(UA_TimeZoneDataType));
}
 
static UA_TimeZoneDataType *
UA_TimeZoneDataType_new(void) {
    return (UA_TimeZoneDataType*)UA_new(&UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
}
 
static UA_StatusCode
UA_TimeZoneDataType_copy(const UA_TimeZoneDataType *src, UA_TimeZoneDataType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
}
 
UA_DEPRECATED static void
UA_TimeZoneDataType_deleteMembers(UA_TimeZoneDataType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
}
 
static void
UA_TimeZoneDataType_clear(UA_TimeZoneDataType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
}
 
static void
UA_TimeZoneDataType_delete(UA_TimeZoneDataType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
}
 
/** ApplicationType */
static void
UA_ApplicationType_init(UA_ApplicationType *p) {
    memset(p, 0, sizeof(UA_ApplicationType));
}
 
static UA_ApplicationType *
UA_ApplicationType_new(void) {
    return (UA_ApplicationType*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
}
 
static UA_StatusCode
UA_ApplicationType_copy(const UA_ApplicationType *src, UA_ApplicationType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
}
 
UA_DEPRECATED static void
UA_ApplicationType_deleteMembers(UA_ApplicationType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
}
 
static void
UA_ApplicationType_clear(UA_ApplicationType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
}
 
static void
UA_ApplicationType_delete(UA_ApplicationType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
}
 
/** ApplicationDescription */
static void
UA_ApplicationDescription_init(UA_ApplicationDescription *p) {
    memset(p, 0, sizeof(UA_ApplicationDescription));
}
 
static UA_ApplicationDescription *
UA_ApplicationDescription_new(void) {
    return (UA_ApplicationDescription*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
}
 
static UA_StatusCode
UA_ApplicationDescription_copy(const UA_ApplicationDescription *src, UA_ApplicationDescription *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
}
 
UA_DEPRECATED static void
UA_ApplicationDescription_deleteMembers(UA_ApplicationDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
}
 
static void
UA_ApplicationDescription_clear(UA_ApplicationDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
}
 
static void
UA_ApplicationDescription_delete(UA_ApplicationDescription *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
}
 
/** RequestHeader */
static void
UA_RequestHeader_init(UA_RequestHeader *p) {
    memset(p, 0, sizeof(UA_RequestHeader));
}
 
static UA_RequestHeader *
UA_RequestHeader_new(void) {
    return (UA_RequestHeader*)UA_new(&UA_TYPES[UA_TYPES_REQUESTHEADER]);
}
 
static UA_StatusCode
UA_RequestHeader_copy(const UA_RequestHeader *src, UA_RequestHeader *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REQUESTHEADER]);
}
 
UA_DEPRECATED static void
UA_RequestHeader_deleteMembers(UA_RequestHeader *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REQUESTHEADER]);
}
 
static void
UA_RequestHeader_clear(UA_RequestHeader *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REQUESTHEADER]);
}
 
static void
UA_RequestHeader_delete(UA_RequestHeader *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_REQUESTHEADER]);
}
 
/** ResponseHeader */
static void
UA_ResponseHeader_init(UA_ResponseHeader *p) {
    memset(p, 0, sizeof(UA_ResponseHeader));
}
 
static UA_ResponseHeader *
UA_ResponseHeader_new(void) {
    return (UA_ResponseHeader*)UA_new(&UA_TYPES[UA_TYPES_RESPONSEHEADER]);
}
 
static UA_StatusCode
UA_ResponseHeader_copy(const UA_ResponseHeader *src, UA_ResponseHeader *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
}
 
UA_DEPRECATED static void
UA_ResponseHeader_deleteMembers(UA_ResponseHeader *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
}
 
static void
UA_ResponseHeader_clear(UA_ResponseHeader *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
}
 
static void
UA_ResponseHeader_delete(UA_ResponseHeader *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
}
 
/** ServiceFault */
static void
UA_ServiceFault_init(UA_ServiceFault *p) {
    memset(p, 0, sizeof(UA_ServiceFault));
}
 
static UA_ServiceFault *
UA_ServiceFault_new(void) {
    return (UA_ServiceFault*)UA_new(&UA_TYPES[UA_TYPES_SERVICEFAULT]);
}
 
static UA_StatusCode
UA_ServiceFault_copy(const UA_ServiceFault *src, UA_ServiceFault *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
}
 
UA_DEPRECATED static void
UA_ServiceFault_deleteMembers(UA_ServiceFault *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
}
 
static void
UA_ServiceFault_clear(UA_ServiceFault *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
}
 
static void
UA_ServiceFault_delete(UA_ServiceFault *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
}
 
/** FindServersRequest */
static void
UA_FindServersRequest_init(UA_FindServersRequest *p) {
    memset(p, 0, sizeof(UA_FindServersRequest));
}
 
static UA_FindServersRequest *
UA_FindServersRequest_new(void) {
    return (UA_FindServersRequest*)UA_new(&UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
}
 
static UA_StatusCode
UA_FindServersRequest_copy(const UA_FindServersRequest *src, UA_FindServersRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
}
 
UA_DEPRECATED static void
UA_FindServersRequest_deleteMembers(UA_FindServersRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
}
 
static void
UA_FindServersRequest_clear(UA_FindServersRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
}
 
static void
UA_FindServersRequest_delete(UA_FindServersRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
}
 
/** FindServersResponse */
static void
UA_FindServersResponse_init(UA_FindServersResponse *p) {
    memset(p, 0, sizeof(UA_FindServersResponse));
}
 
static UA_FindServersResponse *
UA_FindServersResponse_new(void) {
    return (UA_FindServersResponse*)UA_new(&UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
}
 
static UA_StatusCode
UA_FindServersResponse_copy(const UA_FindServersResponse *src, UA_FindServersResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
}
 
UA_DEPRECATED static void
UA_FindServersResponse_deleteMembers(UA_FindServersResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
}
 
static void
UA_FindServersResponse_clear(UA_FindServersResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
}
 
static void
UA_FindServersResponse_delete(UA_FindServersResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
}
 
/** MessageSecurityMode */
static void
UA_MessageSecurityMode_init(UA_MessageSecurityMode *p) {
    memset(p, 0, sizeof(UA_MessageSecurityMode));
}
 
static UA_MessageSecurityMode *
UA_MessageSecurityMode_new(void) {
    return (UA_MessageSecurityMode*)UA_new(&UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
}
 
static UA_StatusCode
UA_MessageSecurityMode_copy(const UA_MessageSecurityMode *src, UA_MessageSecurityMode *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
}
 
UA_DEPRECATED static void
UA_MessageSecurityMode_deleteMembers(UA_MessageSecurityMode *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
}
 
static void
UA_MessageSecurityMode_clear(UA_MessageSecurityMode *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
}
 
static void
UA_MessageSecurityMode_delete(UA_MessageSecurityMode *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
}
 
/** UserTokenType */
static void
UA_UserTokenType_init(UA_UserTokenType *p) {
    memset(p, 0, sizeof(UA_UserTokenType));
}
 
static UA_UserTokenType *
UA_UserTokenType_new(void) {
    return (UA_UserTokenType*)UA_new(&UA_TYPES[UA_TYPES_USERTOKENTYPE]);
}
 
static UA_StatusCode
UA_UserTokenType_copy(const UA_UserTokenType *src, UA_UserTokenType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERTOKENTYPE]);
}
 
UA_DEPRECATED static void
UA_UserTokenType_deleteMembers(UA_UserTokenType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENTYPE]);
}
 
static void
UA_UserTokenType_clear(UA_UserTokenType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENTYPE]);
}
 
static void
UA_UserTokenType_delete(UA_UserTokenType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERTOKENTYPE]);
}
 
/** UserTokenPolicy */
static void
UA_UserTokenPolicy_init(UA_UserTokenPolicy *p) {
    memset(p, 0, sizeof(UA_UserTokenPolicy));
}
 
static UA_UserTokenPolicy *
UA_UserTokenPolicy_new(void) {
    return (UA_UserTokenPolicy*)UA_new(&UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
}
 
static UA_StatusCode
UA_UserTokenPolicy_copy(const UA_UserTokenPolicy *src, UA_UserTokenPolicy *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
}
 
UA_DEPRECATED static void
UA_UserTokenPolicy_deleteMembers(UA_UserTokenPolicy *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
}
 
static void
UA_UserTokenPolicy_clear(UA_UserTokenPolicy *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
}
 
static void
UA_UserTokenPolicy_delete(UA_UserTokenPolicy *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
}
 
/** EndpointDescription */
static void
UA_EndpointDescription_init(UA_EndpointDescription *p) {
    memset(p, 0, sizeof(UA_EndpointDescription));
}
 
static UA_EndpointDescription *
UA_EndpointDescription_new(void) {
    return (UA_EndpointDescription*)UA_new(&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
}
 
static UA_StatusCode
UA_EndpointDescription_copy(const UA_EndpointDescription *src, UA_EndpointDescription *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
}
 
UA_DEPRECATED static void
UA_EndpointDescription_deleteMembers(UA_EndpointDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
}
 
static void
UA_EndpointDescription_clear(UA_EndpointDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
}
 
static void
UA_EndpointDescription_delete(UA_EndpointDescription *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
}
 
/** GetEndpointsRequest */
static void
UA_GetEndpointsRequest_init(UA_GetEndpointsRequest *p) {
    memset(p, 0, sizeof(UA_GetEndpointsRequest));
}
 
static UA_GetEndpointsRequest *
UA_GetEndpointsRequest_new(void) {
    return (UA_GetEndpointsRequest*)UA_new(&UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
}
 
static UA_StatusCode
UA_GetEndpointsRequest_copy(const UA_GetEndpointsRequest *src, UA_GetEndpointsRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
}
 
UA_DEPRECATED static void
UA_GetEndpointsRequest_deleteMembers(UA_GetEndpointsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
}
 
static void
UA_GetEndpointsRequest_clear(UA_GetEndpointsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
}
 
static void
UA_GetEndpointsRequest_delete(UA_GetEndpointsRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
}
 
/** GetEndpointsResponse */
static void
UA_GetEndpointsResponse_init(UA_GetEndpointsResponse *p) {
    memset(p, 0, sizeof(UA_GetEndpointsResponse));
}
 
static UA_GetEndpointsResponse *
UA_GetEndpointsResponse_new(void) {
    return (UA_GetEndpointsResponse*)UA_new(&UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
}
 
static UA_StatusCode
UA_GetEndpointsResponse_copy(const UA_GetEndpointsResponse *src, UA_GetEndpointsResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
}
 
UA_DEPRECATED static void
UA_GetEndpointsResponse_deleteMembers(UA_GetEndpointsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
}
 
static void
UA_GetEndpointsResponse_clear(UA_GetEndpointsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
}
 
static void
UA_GetEndpointsResponse_delete(UA_GetEndpointsResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
}
 
/** SecurityTokenRequestType */
static void
UA_SecurityTokenRequestType_init(UA_SecurityTokenRequestType *p) {
    memset(p, 0, sizeof(UA_SecurityTokenRequestType));
}
 
static UA_SecurityTokenRequestType *
UA_SecurityTokenRequestType_new(void) {
    return (UA_SecurityTokenRequestType*)UA_new(&UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
}
 
static UA_StatusCode
UA_SecurityTokenRequestType_copy(const UA_SecurityTokenRequestType *src, UA_SecurityTokenRequestType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
}
 
UA_DEPRECATED static void
UA_SecurityTokenRequestType_deleteMembers(UA_SecurityTokenRequestType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
}
 
static void
UA_SecurityTokenRequestType_clear(UA_SecurityTokenRequestType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
}
 
static void
UA_SecurityTokenRequestType_delete(UA_SecurityTokenRequestType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
}
 
/** ChannelSecurityToken */
static void
UA_ChannelSecurityToken_init(UA_ChannelSecurityToken *p) {
    memset(p, 0, sizeof(UA_ChannelSecurityToken));
}
 
static UA_ChannelSecurityToken *
UA_ChannelSecurityToken_new(void) {
    return (UA_ChannelSecurityToken*)UA_new(&UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
}
 
static UA_StatusCode
UA_ChannelSecurityToken_copy(const UA_ChannelSecurityToken *src, UA_ChannelSecurityToken *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
}
 
UA_DEPRECATED static void
UA_ChannelSecurityToken_deleteMembers(UA_ChannelSecurityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
}
 
static void
UA_ChannelSecurityToken_clear(UA_ChannelSecurityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
}
 
static void
UA_ChannelSecurityToken_delete(UA_ChannelSecurityToken *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
}
 
/** OpenSecureChannelRequest */
static void
UA_OpenSecureChannelRequest_init(UA_OpenSecureChannelRequest *p) {
    memset(p, 0, sizeof(UA_OpenSecureChannelRequest));
}
 
static UA_OpenSecureChannelRequest *
UA_OpenSecureChannelRequest_new(void) {
    return (UA_OpenSecureChannelRequest*)UA_new(&UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
}
 
static UA_StatusCode
UA_OpenSecureChannelRequest_copy(const UA_OpenSecureChannelRequest *src, UA_OpenSecureChannelRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
}
 
UA_DEPRECATED static void
UA_OpenSecureChannelRequest_deleteMembers(UA_OpenSecureChannelRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
}
 
static void
UA_OpenSecureChannelRequest_clear(UA_OpenSecureChannelRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
}
 
static void
UA_OpenSecureChannelRequest_delete(UA_OpenSecureChannelRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
}
 
/** OpenSecureChannelResponse */
static void
UA_OpenSecureChannelResponse_init(UA_OpenSecureChannelResponse *p) {
    memset(p, 0, sizeof(UA_OpenSecureChannelResponse));
}
 
static UA_OpenSecureChannelResponse *
UA_OpenSecureChannelResponse_new(void) {
    return (UA_OpenSecureChannelResponse*)UA_new(&UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
}
 
static UA_StatusCode
UA_OpenSecureChannelResponse_copy(const UA_OpenSecureChannelResponse *src, UA_OpenSecureChannelResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
}
 
UA_DEPRECATED static void
UA_OpenSecureChannelResponse_deleteMembers(UA_OpenSecureChannelResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
}
 
static void
UA_OpenSecureChannelResponse_clear(UA_OpenSecureChannelResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
}
 
static void
UA_OpenSecureChannelResponse_delete(UA_OpenSecureChannelResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
}
 
/** CloseSecureChannelRequest */
static void
UA_CloseSecureChannelRequest_init(UA_CloseSecureChannelRequest *p) {
    memset(p, 0, sizeof(UA_CloseSecureChannelRequest));
}
 
static UA_CloseSecureChannelRequest *
UA_CloseSecureChannelRequest_new(void) {
    return (UA_CloseSecureChannelRequest*)UA_new(&UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
}
 
static UA_StatusCode
UA_CloseSecureChannelRequest_copy(const UA_CloseSecureChannelRequest *src, UA_CloseSecureChannelRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
}
 
UA_DEPRECATED static void
UA_CloseSecureChannelRequest_deleteMembers(UA_CloseSecureChannelRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
}
 
static void
UA_CloseSecureChannelRequest_clear(UA_CloseSecureChannelRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
}
 
static void
UA_CloseSecureChannelRequest_delete(UA_CloseSecureChannelRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
}
 
/** CloseSecureChannelResponse */
static void
UA_CloseSecureChannelResponse_init(UA_CloseSecureChannelResponse *p) {
    memset(p, 0, sizeof(UA_CloseSecureChannelResponse));
}
 
static UA_CloseSecureChannelResponse *
UA_CloseSecureChannelResponse_new(void) {
    return (UA_CloseSecureChannelResponse*)UA_new(&UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
}
 
static UA_StatusCode
UA_CloseSecureChannelResponse_copy(const UA_CloseSecureChannelResponse *src, UA_CloseSecureChannelResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
}
 
UA_DEPRECATED static void
UA_CloseSecureChannelResponse_deleteMembers(UA_CloseSecureChannelResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
}
 
static void
UA_CloseSecureChannelResponse_clear(UA_CloseSecureChannelResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
}
 
static void
UA_CloseSecureChannelResponse_delete(UA_CloseSecureChannelResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
}
 
/** SignedSoftwareCertificate */
static void
UA_SignedSoftwareCertificate_init(UA_SignedSoftwareCertificate *p) {
    memset(p, 0, sizeof(UA_SignedSoftwareCertificate));
}
 
static UA_SignedSoftwareCertificate *
UA_SignedSoftwareCertificate_new(void) {
    return (UA_SignedSoftwareCertificate*)UA_new(&UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
}
 
static UA_StatusCode
UA_SignedSoftwareCertificate_copy(const UA_SignedSoftwareCertificate *src, UA_SignedSoftwareCertificate *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
}
 
UA_DEPRECATED static void
UA_SignedSoftwareCertificate_deleteMembers(UA_SignedSoftwareCertificate *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
}
 
static void
UA_SignedSoftwareCertificate_clear(UA_SignedSoftwareCertificate *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
}
 
static void
UA_SignedSoftwareCertificate_delete(UA_SignedSoftwareCertificate *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
}
 
/** SignatureData */
static void
UA_SignatureData_init(UA_SignatureData *p) {
    memset(p, 0, sizeof(UA_SignatureData));
}
 
static UA_SignatureData *
UA_SignatureData_new(void) {
    return (UA_SignatureData*)UA_new(&UA_TYPES[UA_TYPES_SIGNATUREDATA]);
}
 
static UA_StatusCode
UA_SignatureData_copy(const UA_SignatureData *src, UA_SignatureData *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIGNATUREDATA]);
}
 
UA_DEPRECATED static void
UA_SignatureData_deleteMembers(UA_SignatureData *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIGNATUREDATA]);
}
 
static void
UA_SignatureData_clear(UA_SignatureData *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIGNATUREDATA]);
}
 
static void
UA_SignatureData_delete(UA_SignatureData *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SIGNATUREDATA]);
}
 
/** CreateSessionRequest */
static void
UA_CreateSessionRequest_init(UA_CreateSessionRequest *p) {
    memset(p, 0, sizeof(UA_CreateSessionRequest));
}
 
static UA_CreateSessionRequest *
UA_CreateSessionRequest_new(void) {
    return (UA_CreateSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
}
 
static UA_StatusCode
UA_CreateSessionRequest_copy(const UA_CreateSessionRequest *src, UA_CreateSessionRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
}
 
UA_DEPRECATED static void
UA_CreateSessionRequest_deleteMembers(UA_CreateSessionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
}
 
static void
UA_CreateSessionRequest_clear(UA_CreateSessionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
}
 
static void
UA_CreateSessionRequest_delete(UA_CreateSessionRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
}
 
/** CreateSessionResponse */
static void
UA_CreateSessionResponse_init(UA_CreateSessionResponse *p) {
    memset(p, 0, sizeof(UA_CreateSessionResponse));
}
 
static UA_CreateSessionResponse *
UA_CreateSessionResponse_new(void) {
    return (UA_CreateSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
}
 
static UA_StatusCode
UA_CreateSessionResponse_copy(const UA_CreateSessionResponse *src, UA_CreateSessionResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
}
 
UA_DEPRECATED static void
UA_CreateSessionResponse_deleteMembers(UA_CreateSessionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
}
 
static void
UA_CreateSessionResponse_clear(UA_CreateSessionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
}
 
static void
UA_CreateSessionResponse_delete(UA_CreateSessionResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
}
 
/** UserIdentityToken */
static void
UA_UserIdentityToken_init(UA_UserIdentityToken *p) {
    memset(p, 0, sizeof(UA_UserIdentityToken));
}
 
static UA_UserIdentityToken *
UA_UserIdentityToken_new(void) {
    return (UA_UserIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
}
 
static UA_StatusCode
UA_UserIdentityToken_copy(const UA_UserIdentityToken *src, UA_UserIdentityToken *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
}
 
UA_DEPRECATED static void
UA_UserIdentityToken_deleteMembers(UA_UserIdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
}
 
static void
UA_UserIdentityToken_clear(UA_UserIdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
}
 
static void
UA_UserIdentityToken_delete(UA_UserIdentityToken *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
}
 
/** AnonymousIdentityToken */
static void
UA_AnonymousIdentityToken_init(UA_AnonymousIdentityToken *p) {
    memset(p, 0, sizeof(UA_AnonymousIdentityToken));
}
 
static UA_AnonymousIdentityToken *
UA_AnonymousIdentityToken_new(void) {
    return (UA_AnonymousIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
}
 
static UA_StatusCode
UA_AnonymousIdentityToken_copy(const UA_AnonymousIdentityToken *src, UA_AnonymousIdentityToken *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
}
 
UA_DEPRECATED static void
UA_AnonymousIdentityToken_deleteMembers(UA_AnonymousIdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
}
 
static void
UA_AnonymousIdentityToken_clear(UA_AnonymousIdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
}
 
static void
UA_AnonymousIdentityToken_delete(UA_AnonymousIdentityToken *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
}
 
/** UserNameIdentityToken */
static void
UA_UserNameIdentityToken_init(UA_UserNameIdentityToken *p) {
    memset(p, 0, sizeof(UA_UserNameIdentityToken));
}
 
static UA_UserNameIdentityToken *
UA_UserNameIdentityToken_new(void) {
    return (UA_UserNameIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
}
 
static UA_StatusCode
UA_UserNameIdentityToken_copy(const UA_UserNameIdentityToken *src, UA_UserNameIdentityToken *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
}
 
UA_DEPRECATED static void
UA_UserNameIdentityToken_deleteMembers(UA_UserNameIdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
}
 
static void
UA_UserNameIdentityToken_clear(UA_UserNameIdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
}
 
static void
UA_UserNameIdentityToken_delete(UA_UserNameIdentityToken *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
}
 
/** X509IdentityToken */
static void
UA_X509IdentityToken_init(UA_X509IdentityToken *p) {
    memset(p, 0, sizeof(UA_X509IdentityToken));
}
 
static UA_X509IdentityToken *
UA_X509IdentityToken_new(void) {
    return (UA_X509IdentityToken*)UA_new(&UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
}
 
static UA_StatusCode
UA_X509IdentityToken_copy(const UA_X509IdentityToken *src, UA_X509IdentityToken *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
}
 
UA_DEPRECATED static void
UA_X509IdentityToken_deleteMembers(UA_X509IdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
}
 
static void
UA_X509IdentityToken_clear(UA_X509IdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
}
 
static void
UA_X509IdentityToken_delete(UA_X509IdentityToken *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
}
 
/** IssuedIdentityToken */
static void
UA_IssuedIdentityToken_init(UA_IssuedIdentityToken *p) {
    memset(p, 0, sizeof(UA_IssuedIdentityToken));
}
 
static UA_IssuedIdentityToken *
UA_IssuedIdentityToken_new(void) {
    return (UA_IssuedIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
}
 
static UA_StatusCode
UA_IssuedIdentityToken_copy(const UA_IssuedIdentityToken *src, UA_IssuedIdentityToken *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
}
 
UA_DEPRECATED static void
UA_IssuedIdentityToken_deleteMembers(UA_IssuedIdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
}
 
static void
UA_IssuedIdentityToken_clear(UA_IssuedIdentityToken *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
}
 
static void
UA_IssuedIdentityToken_delete(UA_IssuedIdentityToken *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
}
 
/** ActivateSessionRequest */
static void
UA_ActivateSessionRequest_init(UA_ActivateSessionRequest *p) {
    memset(p, 0, sizeof(UA_ActivateSessionRequest));
}
 
static UA_ActivateSessionRequest *
UA_ActivateSessionRequest_new(void) {
    return (UA_ActivateSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
}
 
static UA_StatusCode
UA_ActivateSessionRequest_copy(const UA_ActivateSessionRequest *src, UA_ActivateSessionRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
}
 
UA_DEPRECATED static void
UA_ActivateSessionRequest_deleteMembers(UA_ActivateSessionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
}
 
static void
UA_ActivateSessionRequest_clear(UA_ActivateSessionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
}
 
static void
UA_ActivateSessionRequest_delete(UA_ActivateSessionRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
}
 
/** ActivateSessionResponse */
static void
UA_ActivateSessionResponse_init(UA_ActivateSessionResponse *p) {
    memset(p, 0, sizeof(UA_ActivateSessionResponse));
}
 
static UA_ActivateSessionResponse *
UA_ActivateSessionResponse_new(void) {
    return (UA_ActivateSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
}
 
static UA_StatusCode
UA_ActivateSessionResponse_copy(const UA_ActivateSessionResponse *src, UA_ActivateSessionResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
}
 
UA_DEPRECATED static void
UA_ActivateSessionResponse_deleteMembers(UA_ActivateSessionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
}
 
static void
UA_ActivateSessionResponse_clear(UA_ActivateSessionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
}
 
static void
UA_ActivateSessionResponse_delete(UA_ActivateSessionResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
}
 
/** CloseSessionRequest */
static void
UA_CloseSessionRequest_init(UA_CloseSessionRequest *p) {
    memset(p, 0, sizeof(UA_CloseSessionRequest));
}
 
static UA_CloseSessionRequest *
UA_CloseSessionRequest_new(void) {
    return (UA_CloseSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
}
 
static UA_StatusCode
UA_CloseSessionRequest_copy(const UA_CloseSessionRequest *src, UA_CloseSessionRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
}
 
UA_DEPRECATED static void
UA_CloseSessionRequest_deleteMembers(UA_CloseSessionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
}
 
static void
UA_CloseSessionRequest_clear(UA_CloseSessionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
}
 
static void
UA_CloseSessionRequest_delete(UA_CloseSessionRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
}
 
/** CloseSessionResponse */
static void
UA_CloseSessionResponse_init(UA_CloseSessionResponse *p) {
    memset(p, 0, sizeof(UA_CloseSessionResponse));
}
 
static UA_CloseSessionResponse *
UA_CloseSessionResponse_new(void) {
    return (UA_CloseSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
}
 
static UA_StatusCode
UA_CloseSessionResponse_copy(const UA_CloseSessionResponse *src, UA_CloseSessionResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
}
 
UA_DEPRECATED static void
UA_CloseSessionResponse_deleteMembers(UA_CloseSessionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
}
 
static void
UA_CloseSessionResponse_clear(UA_CloseSessionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
}
 
static void
UA_CloseSessionResponse_delete(UA_CloseSessionResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
}
 
/** NodeAttributesMask */
static void
UA_NodeAttributesMask_init(UA_NodeAttributesMask *p) {
    memset(p, 0, sizeof(UA_NodeAttributesMask));
}
 
static UA_NodeAttributesMask *
UA_NodeAttributesMask_new(void) {
    return (UA_NodeAttributesMask*)UA_new(&UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
}
 
static UA_StatusCode
UA_NodeAttributesMask_copy(const UA_NodeAttributesMask *src, UA_NodeAttributesMask *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
}
 
UA_DEPRECATED static void
UA_NodeAttributesMask_deleteMembers(UA_NodeAttributesMask *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
}
 
static void
UA_NodeAttributesMask_clear(UA_NodeAttributesMask *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
}
 
static void
UA_NodeAttributesMask_delete(UA_NodeAttributesMask *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
}
 
/** NodeAttributes */
static void
UA_NodeAttributes_init(UA_NodeAttributes *p) {
    memset(p, 0, sizeof(UA_NodeAttributes));
}
 
static UA_NodeAttributes *
UA_NodeAttributes_new(void) {
    return (UA_NodeAttributes*)UA_new(&UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
}
 
static UA_StatusCode
UA_NodeAttributes_copy(const UA_NodeAttributes *src, UA_NodeAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_NodeAttributes_deleteMembers(UA_NodeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
}
 
static void
UA_NodeAttributes_clear(UA_NodeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
}
 
static void
UA_NodeAttributes_delete(UA_NodeAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
}
 
/** ObjectAttributes */
static void
UA_ObjectAttributes_init(UA_ObjectAttributes *p) {
    memset(p, 0, sizeof(UA_ObjectAttributes));
}
 
static UA_ObjectAttributes *
UA_ObjectAttributes_new(void) {
    return (UA_ObjectAttributes*)UA_new(&UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
}
 
static UA_StatusCode
UA_ObjectAttributes_copy(const UA_ObjectAttributes *src, UA_ObjectAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_ObjectAttributes_deleteMembers(UA_ObjectAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
}
 
static void
UA_ObjectAttributes_clear(UA_ObjectAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
}
 
static void
UA_ObjectAttributes_delete(UA_ObjectAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
}
 
/** VariableAttributes */
static void
UA_VariableAttributes_init(UA_VariableAttributes *p) {
    memset(p, 0, sizeof(UA_VariableAttributes));
}
 
static UA_VariableAttributes *
UA_VariableAttributes_new(void) {
    return (UA_VariableAttributes*)UA_new(&UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
}
 
static UA_StatusCode
UA_VariableAttributes_copy(const UA_VariableAttributes *src, UA_VariableAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_VariableAttributes_deleteMembers(UA_VariableAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
}
 
static void
UA_VariableAttributes_clear(UA_VariableAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
}
 
static void
UA_VariableAttributes_delete(UA_VariableAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
}
 
/** MethodAttributes */
static void
UA_MethodAttributes_init(UA_MethodAttributes *p) {
    memset(p, 0, sizeof(UA_MethodAttributes));
}
 
static UA_MethodAttributes *
UA_MethodAttributes_new(void) {
    return (UA_MethodAttributes*)UA_new(&UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
}
 
static UA_StatusCode
UA_MethodAttributes_copy(const UA_MethodAttributes *src, UA_MethodAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_MethodAttributes_deleteMembers(UA_MethodAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
}
 
static void
UA_MethodAttributes_clear(UA_MethodAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
}
 
static void
UA_MethodAttributes_delete(UA_MethodAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
}
 
/** ObjectTypeAttributes */
static void
UA_ObjectTypeAttributes_init(UA_ObjectTypeAttributes *p) {
    memset(p, 0, sizeof(UA_ObjectTypeAttributes));
}
 
static UA_ObjectTypeAttributes *
UA_ObjectTypeAttributes_new(void) {
    return (UA_ObjectTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
}
 
static UA_StatusCode
UA_ObjectTypeAttributes_copy(const UA_ObjectTypeAttributes *src, UA_ObjectTypeAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_ObjectTypeAttributes_deleteMembers(UA_ObjectTypeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
}
 
static void
UA_ObjectTypeAttributes_clear(UA_ObjectTypeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
}
 
static void
UA_ObjectTypeAttributes_delete(UA_ObjectTypeAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
}
 
/** VariableTypeAttributes */
static void
UA_VariableTypeAttributes_init(UA_VariableTypeAttributes *p) {
    memset(p, 0, sizeof(UA_VariableTypeAttributes));
}
 
static UA_VariableTypeAttributes *
UA_VariableTypeAttributes_new(void) {
    return (UA_VariableTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
}
 
static UA_StatusCode
UA_VariableTypeAttributes_copy(const UA_VariableTypeAttributes *src, UA_VariableTypeAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_VariableTypeAttributes_deleteMembers(UA_VariableTypeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
}
 
static void
UA_VariableTypeAttributes_clear(UA_VariableTypeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
}
 
static void
UA_VariableTypeAttributes_delete(UA_VariableTypeAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
}
 
/** ReferenceTypeAttributes */
static void
UA_ReferenceTypeAttributes_init(UA_ReferenceTypeAttributes *p) {
    memset(p, 0, sizeof(UA_ReferenceTypeAttributes));
}
 
static UA_ReferenceTypeAttributes *
UA_ReferenceTypeAttributes_new(void) {
    return (UA_ReferenceTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
}
 
static UA_StatusCode
UA_ReferenceTypeAttributes_copy(const UA_ReferenceTypeAttributes *src, UA_ReferenceTypeAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_ReferenceTypeAttributes_deleteMembers(UA_ReferenceTypeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
}
 
static void
UA_ReferenceTypeAttributes_clear(UA_ReferenceTypeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
}
 
static void
UA_ReferenceTypeAttributes_delete(UA_ReferenceTypeAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
}
 
/** DataTypeAttributes */
static void
UA_DataTypeAttributes_init(UA_DataTypeAttributes *p) {
    memset(p, 0, sizeof(UA_DataTypeAttributes));
}
 
static UA_DataTypeAttributes *
UA_DataTypeAttributes_new(void) {
    return (UA_DataTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
}
 
static UA_StatusCode
UA_DataTypeAttributes_copy(const UA_DataTypeAttributes *src, UA_DataTypeAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_DataTypeAttributes_deleteMembers(UA_DataTypeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
}
 
static void
UA_DataTypeAttributes_clear(UA_DataTypeAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
}
 
static void
UA_DataTypeAttributes_delete(UA_DataTypeAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
}
 
/** ViewAttributes */
static void
UA_ViewAttributes_init(UA_ViewAttributes *p) {
    memset(p, 0, sizeof(UA_ViewAttributes));
}
 
static UA_ViewAttributes *
UA_ViewAttributes_new(void) {
    return (UA_ViewAttributes*)UA_new(&UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
}
 
static UA_StatusCode
UA_ViewAttributes_copy(const UA_ViewAttributes *src, UA_ViewAttributes *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
}
 
UA_DEPRECATED static void
UA_ViewAttributes_deleteMembers(UA_ViewAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
}
 
static void
UA_ViewAttributes_clear(UA_ViewAttributes *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
}
 
static void
UA_ViewAttributes_delete(UA_ViewAttributes *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
}
 
/** AddNodesItem */
static void
UA_AddNodesItem_init(UA_AddNodesItem *p) {
    memset(p, 0, sizeof(UA_AddNodesItem));
}
 
static UA_AddNodesItem *
UA_AddNodesItem_new(void) {
    return (UA_AddNodesItem*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESITEM]);
}
 
static UA_StatusCode
UA_AddNodesItem_copy(const UA_AddNodesItem *src, UA_AddNodesItem *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESITEM]);
}
 
UA_DEPRECATED static void
UA_AddNodesItem_deleteMembers(UA_AddNodesItem *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESITEM]);
}
 
static void
UA_AddNodesItem_clear(UA_AddNodesItem *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESITEM]);
}
 
static void
UA_AddNodesItem_delete(UA_AddNodesItem *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESITEM]);
}
 
/** AddNodesResult */
static void
UA_AddNodesResult_init(UA_AddNodesResult *p) {
    memset(p, 0, sizeof(UA_AddNodesResult));
}
 
static UA_AddNodesResult *
UA_AddNodesResult_new(void) {
    return (UA_AddNodesResult*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESRESULT]);
}
 
static UA_StatusCode
UA_AddNodesResult_copy(const UA_AddNodesResult *src, UA_AddNodesResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESRESULT]);
}
 
UA_DEPRECATED static void
UA_AddNodesResult_deleteMembers(UA_AddNodesResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESULT]);
}
 
static void
UA_AddNodesResult_clear(UA_AddNodesResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESULT]);
}
 
static void
UA_AddNodesResult_delete(UA_AddNodesResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESRESULT]);
}
 
/** AddNodesRequest */
static void
UA_AddNodesRequest_init(UA_AddNodesRequest *p) {
    memset(p, 0, sizeof(UA_AddNodesRequest));
}
 
static UA_AddNodesRequest *
UA_AddNodesRequest_new(void) {
    return (UA_AddNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
}
 
static UA_StatusCode
UA_AddNodesRequest_copy(const UA_AddNodesRequest *src, UA_AddNodesRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
}
 
UA_DEPRECATED static void
UA_AddNodesRequest_deleteMembers(UA_AddNodesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
}
 
static void
UA_AddNodesRequest_clear(UA_AddNodesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
}
 
static void
UA_AddNodesRequest_delete(UA_AddNodesRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
}
 
/** AddNodesResponse */
static void
UA_AddNodesResponse_init(UA_AddNodesResponse *p) {
    memset(p, 0, sizeof(UA_AddNodesResponse));
}
 
static UA_AddNodesResponse *
UA_AddNodesResponse_new(void) {
    return (UA_AddNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
}
 
static UA_StatusCode
UA_AddNodesResponse_copy(const UA_AddNodesResponse *src, UA_AddNodesResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
}
 
UA_DEPRECATED static void
UA_AddNodesResponse_deleteMembers(UA_AddNodesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
}
 
static void
UA_AddNodesResponse_clear(UA_AddNodesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
}
 
static void
UA_AddNodesResponse_delete(UA_AddNodesResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
}
 
/** AddReferencesItem */
static void
UA_AddReferencesItem_init(UA_AddReferencesItem *p) {
    memset(p, 0, sizeof(UA_AddReferencesItem));
}
 
static UA_AddReferencesItem *
UA_AddReferencesItem_new(void) {
    return (UA_AddReferencesItem*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
}
 
static UA_StatusCode
UA_AddReferencesItem_copy(const UA_AddReferencesItem *src, UA_AddReferencesItem *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
}
 
UA_DEPRECATED static void
UA_AddReferencesItem_deleteMembers(UA_AddReferencesItem *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
}
 
static void
UA_AddReferencesItem_clear(UA_AddReferencesItem *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
}
 
static void
UA_AddReferencesItem_delete(UA_AddReferencesItem *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
}
 
/** AddReferencesRequest */
static void
UA_AddReferencesRequest_init(UA_AddReferencesRequest *p) {
    memset(p, 0, sizeof(UA_AddReferencesRequest));
}
 
static UA_AddReferencesRequest *
UA_AddReferencesRequest_new(void) {
    return (UA_AddReferencesRequest*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
}
 
static UA_StatusCode
UA_AddReferencesRequest_copy(const UA_AddReferencesRequest *src, UA_AddReferencesRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
}
 
UA_DEPRECATED static void
UA_AddReferencesRequest_deleteMembers(UA_AddReferencesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
}
 
static void
UA_AddReferencesRequest_clear(UA_AddReferencesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
}
 
static void
UA_AddReferencesRequest_delete(UA_AddReferencesRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
}
 
/** AddReferencesResponse */
static void
UA_AddReferencesResponse_init(UA_AddReferencesResponse *p) {
    memset(p, 0, sizeof(UA_AddReferencesResponse));
}
 
static UA_AddReferencesResponse *
UA_AddReferencesResponse_new(void) {
    return (UA_AddReferencesResponse*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
}
 
static UA_StatusCode
UA_AddReferencesResponse_copy(const UA_AddReferencesResponse *src, UA_AddReferencesResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
}
 
UA_DEPRECATED static void
UA_AddReferencesResponse_deleteMembers(UA_AddReferencesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
}
 
static void
UA_AddReferencesResponse_clear(UA_AddReferencesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
}
 
static void
UA_AddReferencesResponse_delete(UA_AddReferencesResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
}
 
/** DeleteNodesItem */
static void
UA_DeleteNodesItem_init(UA_DeleteNodesItem *p) {
    memset(p, 0, sizeof(UA_DeleteNodesItem));
}
 
static UA_DeleteNodesItem *
UA_DeleteNodesItem_new(void) {
    return (UA_DeleteNodesItem*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESITEM]);
}
 
static UA_StatusCode
UA_DeleteNodesItem_copy(const UA_DeleteNodesItem *src, UA_DeleteNodesItem *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESITEM]);
}
 
UA_DEPRECATED static void
UA_DeleteNodesItem_deleteMembers(UA_DeleteNodesItem *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESITEM]);
}
 
static void
UA_DeleteNodesItem_clear(UA_DeleteNodesItem *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESITEM]);
}
 
static void
UA_DeleteNodesItem_delete(UA_DeleteNodesItem *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESITEM]);
}
 
/** DeleteNodesRequest */
static void
UA_DeleteNodesRequest_init(UA_DeleteNodesRequest *p) {
    memset(p, 0, sizeof(UA_DeleteNodesRequest));
}
 
static UA_DeleteNodesRequest *
UA_DeleteNodesRequest_new(void) {
    return (UA_DeleteNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
}
 
static UA_StatusCode
UA_DeleteNodesRequest_copy(const UA_DeleteNodesRequest *src, UA_DeleteNodesRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
}
 
UA_DEPRECATED static void
UA_DeleteNodesRequest_deleteMembers(UA_DeleteNodesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
}
 
static void
UA_DeleteNodesRequest_clear(UA_DeleteNodesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
}
 
static void
UA_DeleteNodesRequest_delete(UA_DeleteNodesRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
}
 
/** DeleteNodesResponse */
static void
UA_DeleteNodesResponse_init(UA_DeleteNodesResponse *p) {
    memset(p, 0, sizeof(UA_DeleteNodesResponse));
}
 
static UA_DeleteNodesResponse *
UA_DeleteNodesResponse_new(void) {
    return (UA_DeleteNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
}
 
static UA_StatusCode
UA_DeleteNodesResponse_copy(const UA_DeleteNodesResponse *src, UA_DeleteNodesResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
}
 
UA_DEPRECATED static void
UA_DeleteNodesResponse_deleteMembers(UA_DeleteNodesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
}
 
static void
UA_DeleteNodesResponse_clear(UA_DeleteNodesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
}
 
static void
UA_DeleteNodesResponse_delete(UA_DeleteNodesResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
}
 
/** DeleteReferencesItem */
static void
UA_DeleteReferencesItem_init(UA_DeleteReferencesItem *p) {
    memset(p, 0, sizeof(UA_DeleteReferencesItem));
}
 
static UA_DeleteReferencesItem *
UA_DeleteReferencesItem_new(void) {
    return (UA_DeleteReferencesItem*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
}
 
static UA_StatusCode
UA_DeleteReferencesItem_copy(const UA_DeleteReferencesItem *src, UA_DeleteReferencesItem *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
}
 
UA_DEPRECATED static void
UA_DeleteReferencesItem_deleteMembers(UA_DeleteReferencesItem *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
}
 
static void
UA_DeleteReferencesItem_clear(UA_DeleteReferencesItem *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
}
 
static void
UA_DeleteReferencesItem_delete(UA_DeleteReferencesItem *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
}
 
/** DeleteReferencesRequest */
static void
UA_DeleteReferencesRequest_init(UA_DeleteReferencesRequest *p) {
    memset(p, 0, sizeof(UA_DeleteReferencesRequest));
}
 
static UA_DeleteReferencesRequest *
UA_DeleteReferencesRequest_new(void) {
    return (UA_DeleteReferencesRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
}
 
static UA_StatusCode
UA_DeleteReferencesRequest_copy(const UA_DeleteReferencesRequest *src, UA_DeleteReferencesRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
}
 
UA_DEPRECATED static void
UA_DeleteReferencesRequest_deleteMembers(UA_DeleteReferencesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
}
 
static void
UA_DeleteReferencesRequest_clear(UA_DeleteReferencesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
}
 
static void
UA_DeleteReferencesRequest_delete(UA_DeleteReferencesRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
}
 
/** DeleteReferencesResponse */
static void
UA_DeleteReferencesResponse_init(UA_DeleteReferencesResponse *p) {
    memset(p, 0, sizeof(UA_DeleteReferencesResponse));
}
 
static UA_DeleteReferencesResponse *
UA_DeleteReferencesResponse_new(void) {
    return (UA_DeleteReferencesResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
}
 
static UA_StatusCode
UA_DeleteReferencesResponse_copy(const UA_DeleteReferencesResponse *src, UA_DeleteReferencesResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
}
 
UA_DEPRECATED static void
UA_DeleteReferencesResponse_deleteMembers(UA_DeleteReferencesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
}
 
static void
UA_DeleteReferencesResponse_clear(UA_DeleteReferencesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
}
 
static void
UA_DeleteReferencesResponse_delete(UA_DeleteReferencesResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
}
 
/** BrowseDirection */
static void
UA_BrowseDirection_init(UA_BrowseDirection *p) {
    memset(p, 0, sizeof(UA_BrowseDirection));
}
 
static UA_BrowseDirection *
UA_BrowseDirection_new(void) {
    return (UA_BrowseDirection*)UA_new(&UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
}
 
static UA_StatusCode
UA_BrowseDirection_copy(const UA_BrowseDirection *src, UA_BrowseDirection *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
}
 
UA_DEPRECATED static void
UA_BrowseDirection_deleteMembers(UA_BrowseDirection *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
}
 
static void
UA_BrowseDirection_clear(UA_BrowseDirection *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
}
 
static void
UA_BrowseDirection_delete(UA_BrowseDirection *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
}
 
/** ViewDescription */
static void
UA_ViewDescription_init(UA_ViewDescription *p) {
    memset(p, 0, sizeof(UA_ViewDescription));
}
 
static UA_ViewDescription *
UA_ViewDescription_new(void) {
    return (UA_ViewDescription*)UA_new(&UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
}
 
static UA_StatusCode
UA_ViewDescription_copy(const UA_ViewDescription *src, UA_ViewDescription *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
}
 
UA_DEPRECATED static void
UA_ViewDescription_deleteMembers(UA_ViewDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
}
 
static void
UA_ViewDescription_clear(UA_ViewDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
}
 
static void
UA_ViewDescription_delete(UA_ViewDescription *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
}
 
/** BrowseDescription */
static void
UA_BrowseDescription_init(UA_BrowseDescription *p) {
    memset(p, 0, sizeof(UA_BrowseDescription));
}
 
static UA_BrowseDescription *
UA_BrowseDescription_new(void) {
    return (UA_BrowseDescription*)UA_new(&UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
}
 
static UA_StatusCode
UA_BrowseDescription_copy(const UA_BrowseDescription *src, UA_BrowseDescription *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
}
 
UA_DEPRECATED static void
UA_BrowseDescription_deleteMembers(UA_BrowseDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
}
 
static void
UA_BrowseDescription_clear(UA_BrowseDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
}
 
static void
UA_BrowseDescription_delete(UA_BrowseDescription *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
}
 
/** BrowseResultMask */
static void
UA_BrowseResultMask_init(UA_BrowseResultMask *p) {
    memset(p, 0, sizeof(UA_BrowseResultMask));
}
 
static UA_BrowseResultMask *
UA_BrowseResultMask_new(void) {
    return (UA_BrowseResultMask*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
}
 
static UA_StatusCode
UA_BrowseResultMask_copy(const UA_BrowseResultMask *src, UA_BrowseResultMask *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
}
 
UA_DEPRECATED static void
UA_BrowseResultMask_deleteMembers(UA_BrowseResultMask *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
}
 
static void
UA_BrowseResultMask_clear(UA_BrowseResultMask *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
}
 
static void
UA_BrowseResultMask_delete(UA_BrowseResultMask *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
}
 
/** ReferenceDescription */
static void
UA_ReferenceDescription_init(UA_ReferenceDescription *p) {
    memset(p, 0, sizeof(UA_ReferenceDescription));
}
 
static UA_ReferenceDescription *
UA_ReferenceDescription_new(void) {
    return (UA_ReferenceDescription*)UA_new(&UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
}
 
static UA_StatusCode
UA_ReferenceDescription_copy(const UA_ReferenceDescription *src, UA_ReferenceDescription *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
}
 
UA_DEPRECATED static void
UA_ReferenceDescription_deleteMembers(UA_ReferenceDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
}
 
static void
UA_ReferenceDescription_clear(UA_ReferenceDescription *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
}
 
static void
UA_ReferenceDescription_delete(UA_ReferenceDescription *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
}
 
/** BrowseResult */
static void
UA_BrowseResult_init(UA_BrowseResult *p) {
    memset(p, 0, sizeof(UA_BrowseResult));
}
 
static UA_BrowseResult *
UA_BrowseResult_new(void) {
    return (UA_BrowseResult*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESULT]);
}
 
static UA_StatusCode
UA_BrowseResult_copy(const UA_BrowseResult *src, UA_BrowseResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESULT]);
}
 
UA_DEPRECATED static void
UA_BrowseResult_deleteMembers(UA_BrowseResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULT]);
}
 
static void
UA_BrowseResult_clear(UA_BrowseResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULT]);
}
 
static void
UA_BrowseResult_delete(UA_BrowseResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESULT]);
}
 
/** BrowseRequest */
static void
UA_BrowseRequest_init(UA_BrowseRequest *p) {
    memset(p, 0, sizeof(UA_BrowseRequest));
}
 
static UA_BrowseRequest *
UA_BrowseRequest_new(void) {
    return (UA_BrowseRequest*)UA_new(&UA_TYPES[UA_TYPES_BROWSEREQUEST]);
}
 
static UA_StatusCode
UA_BrowseRequest_copy(const UA_BrowseRequest *src, UA_BrowseRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEREQUEST]);
}
 
UA_DEPRECATED static void
UA_BrowseRequest_deleteMembers(UA_BrowseRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEREQUEST]);
}
 
static void
UA_BrowseRequest_clear(UA_BrowseRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEREQUEST]);
}
 
static void
UA_BrowseRequest_delete(UA_BrowseRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEREQUEST]);
}
 
/** BrowseResponse */
static void
UA_BrowseResponse_init(UA_BrowseResponse *p) {
    memset(p, 0, sizeof(UA_BrowseResponse));
}
 
static UA_BrowseResponse *
UA_BrowseResponse_new(void) {
    return (UA_BrowseResponse*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESPONSE]);
}
 
static UA_StatusCode
UA_BrowseResponse_copy(const UA_BrowseResponse *src, UA_BrowseResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESPONSE]);
}
 
UA_DEPRECATED static void
UA_BrowseResponse_deleteMembers(UA_BrowseResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESPONSE]);
}
 
static void
UA_BrowseResponse_clear(UA_BrowseResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESPONSE]);
}
 
static void
UA_BrowseResponse_delete(UA_BrowseResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESPONSE]);
}
 
/** BrowseNextRequest */
static void
UA_BrowseNextRequest_init(UA_BrowseNextRequest *p) {
    memset(p, 0, sizeof(UA_BrowseNextRequest));
}
 
static UA_BrowseNextRequest *
UA_BrowseNextRequest_new(void) {
    return (UA_BrowseNextRequest*)UA_new(&UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
}
 
static UA_StatusCode
UA_BrowseNextRequest_copy(const UA_BrowseNextRequest *src, UA_BrowseNextRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
}
 
UA_DEPRECATED static void
UA_BrowseNextRequest_deleteMembers(UA_BrowseNextRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
}
 
static void
UA_BrowseNextRequest_clear(UA_BrowseNextRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
}
 
static void
UA_BrowseNextRequest_delete(UA_BrowseNextRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
}
 
/** BrowseNextResponse */
static void
UA_BrowseNextResponse_init(UA_BrowseNextResponse *p) {
    memset(p, 0, sizeof(UA_BrowseNextResponse));
}
 
static UA_BrowseNextResponse *
UA_BrowseNextResponse_new(void) {
    return (UA_BrowseNextResponse*)UA_new(&UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
}
 
static UA_StatusCode
UA_BrowseNextResponse_copy(const UA_BrowseNextResponse *src, UA_BrowseNextResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
}
 
UA_DEPRECATED static void
UA_BrowseNextResponse_deleteMembers(UA_BrowseNextResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
}
 
static void
UA_BrowseNextResponse_clear(UA_BrowseNextResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
}
 
static void
UA_BrowseNextResponse_delete(UA_BrowseNextResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
}
 
/** RelativePathElement */
static void
UA_RelativePathElement_init(UA_RelativePathElement *p) {
    memset(p, 0, sizeof(UA_RelativePathElement));
}
 
static UA_RelativePathElement *
UA_RelativePathElement_new(void) {
    return (UA_RelativePathElement*)UA_new(&UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
}
 
static UA_StatusCode
UA_RelativePathElement_copy(const UA_RelativePathElement *src, UA_RelativePathElement *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
}
 
UA_DEPRECATED static void
UA_RelativePathElement_deleteMembers(UA_RelativePathElement *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
}
 
static void
UA_RelativePathElement_clear(UA_RelativePathElement *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
}
 
static void
UA_RelativePathElement_delete(UA_RelativePathElement *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
}
 
/** RelativePath */
static void
UA_RelativePath_init(UA_RelativePath *p) {
    memset(p, 0, sizeof(UA_RelativePath));
}
 
static UA_RelativePath *
UA_RelativePath_new(void) {
    return (UA_RelativePath*)UA_new(&UA_TYPES[UA_TYPES_RELATIVEPATH]);
}
 
static UA_StatusCode
UA_RelativePath_copy(const UA_RelativePath *src, UA_RelativePath *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RELATIVEPATH]);
}
 
UA_DEPRECATED static void
UA_RelativePath_deleteMembers(UA_RelativePath *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATH]);
}
 
static void
UA_RelativePath_clear(UA_RelativePath *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATH]);
}
 
static void
UA_RelativePath_delete(UA_RelativePath *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_RELATIVEPATH]);
}
 
/** BrowsePath */
static void
UA_BrowsePath_init(UA_BrowsePath *p) {
    memset(p, 0, sizeof(UA_BrowsePath));
}
 
static UA_BrowsePath *
UA_BrowsePath_new(void) {
    return (UA_BrowsePath*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATH]);
}
 
static UA_StatusCode
UA_BrowsePath_copy(const UA_BrowsePath *src, UA_BrowsePath *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATH]);
}
 
UA_DEPRECATED static void
UA_BrowsePath_deleteMembers(UA_BrowsePath *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATH]);
}
 
static void
UA_BrowsePath_clear(UA_BrowsePath *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATH]);
}
 
static void
UA_BrowsePath_delete(UA_BrowsePath *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATH]);
}
 
/** BrowsePathTarget */
static void
UA_BrowsePathTarget_init(UA_BrowsePathTarget *p) {
    memset(p, 0, sizeof(UA_BrowsePathTarget));
}
 
static UA_BrowsePathTarget *
UA_BrowsePathTarget_new(void) {
    return (UA_BrowsePathTarget*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
}
 
static UA_StatusCode
UA_BrowsePathTarget_copy(const UA_BrowsePathTarget *src, UA_BrowsePathTarget *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
}
 
UA_DEPRECATED static void
UA_BrowsePathTarget_deleteMembers(UA_BrowsePathTarget *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
}
 
static void
UA_BrowsePathTarget_clear(UA_BrowsePathTarget *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
}
 
static void
UA_BrowsePathTarget_delete(UA_BrowsePathTarget *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
}
 
/** BrowsePathResult */
static void
UA_BrowsePathResult_init(UA_BrowsePathResult *p) {
    memset(p, 0, sizeof(UA_BrowsePathResult));
}
 
static UA_BrowsePathResult *
UA_BrowsePathResult_new(void) {
    return (UA_BrowsePathResult*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
}
 
static UA_StatusCode
UA_BrowsePathResult_copy(const UA_BrowsePathResult *src, UA_BrowsePathResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
}
 
UA_DEPRECATED static void
UA_BrowsePathResult_deleteMembers(UA_BrowsePathResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
}
 
static void
UA_BrowsePathResult_clear(UA_BrowsePathResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
}
 
static void
UA_BrowsePathResult_delete(UA_BrowsePathResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
}
 
/** TranslateBrowsePathsToNodeIdsRequest */
static void
UA_TranslateBrowsePathsToNodeIdsRequest_init(UA_TranslateBrowsePathsToNodeIdsRequest *p) {
    memset(p, 0, sizeof(UA_TranslateBrowsePathsToNodeIdsRequest));
}
 
static UA_TranslateBrowsePathsToNodeIdsRequest *
UA_TranslateBrowsePathsToNodeIdsRequest_new(void) {
    return (UA_TranslateBrowsePathsToNodeIdsRequest*)UA_new(&UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
}
 
static UA_StatusCode
UA_TranslateBrowsePathsToNodeIdsRequest_copy(const UA_TranslateBrowsePathsToNodeIdsRequest *src, UA_TranslateBrowsePathsToNodeIdsRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
}
 
UA_DEPRECATED static void
UA_TranslateBrowsePathsToNodeIdsRequest_deleteMembers(UA_TranslateBrowsePathsToNodeIdsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
}
 
static void
UA_TranslateBrowsePathsToNodeIdsRequest_clear(UA_TranslateBrowsePathsToNodeIdsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
}
 
static void
UA_TranslateBrowsePathsToNodeIdsRequest_delete(UA_TranslateBrowsePathsToNodeIdsRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
}
 
/** TranslateBrowsePathsToNodeIdsResponse */
static void
UA_TranslateBrowsePathsToNodeIdsResponse_init(UA_TranslateBrowsePathsToNodeIdsResponse *p) {
    memset(p, 0, sizeof(UA_TranslateBrowsePathsToNodeIdsResponse));
}
 
static UA_TranslateBrowsePathsToNodeIdsResponse *
UA_TranslateBrowsePathsToNodeIdsResponse_new(void) {
    return (UA_TranslateBrowsePathsToNodeIdsResponse*)UA_new(&UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
}
 
static UA_StatusCode
UA_TranslateBrowsePathsToNodeIdsResponse_copy(const UA_TranslateBrowsePathsToNodeIdsResponse *src, UA_TranslateBrowsePathsToNodeIdsResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
}
 
UA_DEPRECATED static void
UA_TranslateBrowsePathsToNodeIdsResponse_deleteMembers(UA_TranslateBrowsePathsToNodeIdsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
}
 
static void
UA_TranslateBrowsePathsToNodeIdsResponse_clear(UA_TranslateBrowsePathsToNodeIdsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
}
 
static void
UA_TranslateBrowsePathsToNodeIdsResponse_delete(UA_TranslateBrowsePathsToNodeIdsResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
}
 
/** RegisterNodesRequest */
static void
UA_RegisterNodesRequest_init(UA_RegisterNodesRequest *p) {
    memset(p, 0, sizeof(UA_RegisterNodesRequest));
}
 
static UA_RegisterNodesRequest *
UA_RegisterNodesRequest_new(void) {
    return (UA_RegisterNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
}
 
static UA_StatusCode
UA_RegisterNodesRequest_copy(const UA_RegisterNodesRequest *src, UA_RegisterNodesRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
}
 
UA_DEPRECATED static void
UA_RegisterNodesRequest_deleteMembers(UA_RegisterNodesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
}
 
static void
UA_RegisterNodesRequest_clear(UA_RegisterNodesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
}
 
static void
UA_RegisterNodesRequest_delete(UA_RegisterNodesRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
}
 
/** RegisterNodesResponse */
static void
UA_RegisterNodesResponse_init(UA_RegisterNodesResponse *p) {
    memset(p, 0, sizeof(UA_RegisterNodesResponse));
}
 
static UA_RegisterNodesResponse *
UA_RegisterNodesResponse_new(void) {
    return (UA_RegisterNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
}
 
static UA_StatusCode
UA_RegisterNodesResponse_copy(const UA_RegisterNodesResponse *src, UA_RegisterNodesResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
}
 
UA_DEPRECATED static void
UA_RegisterNodesResponse_deleteMembers(UA_RegisterNodesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
}
 
static void
UA_RegisterNodesResponse_clear(UA_RegisterNodesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
}
 
static void
UA_RegisterNodesResponse_delete(UA_RegisterNodesResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
}
 
/** UnregisterNodesRequest */
static void
UA_UnregisterNodesRequest_init(UA_UnregisterNodesRequest *p) {
    memset(p, 0, sizeof(UA_UnregisterNodesRequest));
}
 
static UA_UnregisterNodesRequest *
UA_UnregisterNodesRequest_new(void) {
    return (UA_UnregisterNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
}
 
static UA_StatusCode
UA_UnregisterNodesRequest_copy(const UA_UnregisterNodesRequest *src, UA_UnregisterNodesRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
}
 
UA_DEPRECATED static void
UA_UnregisterNodesRequest_deleteMembers(UA_UnregisterNodesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
}
 
static void
UA_UnregisterNodesRequest_clear(UA_UnregisterNodesRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
}
 
static void
UA_UnregisterNodesRequest_delete(UA_UnregisterNodesRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
}
 
/** UnregisterNodesResponse */
static void
UA_UnregisterNodesResponse_init(UA_UnregisterNodesResponse *p) {
    memset(p, 0, sizeof(UA_UnregisterNodesResponse));
}
 
static UA_UnregisterNodesResponse *
UA_UnregisterNodesResponse_new(void) {
    return (UA_UnregisterNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
}
 
static UA_StatusCode
UA_UnregisterNodesResponse_copy(const UA_UnregisterNodesResponse *src, UA_UnregisterNodesResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
}
 
UA_DEPRECATED static void
UA_UnregisterNodesResponse_deleteMembers(UA_UnregisterNodesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
}
 
static void
UA_UnregisterNodesResponse_clear(UA_UnregisterNodesResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
}
 
static void
UA_UnregisterNodesResponse_delete(UA_UnregisterNodesResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
}
 
/** FilterOperator */
static void
UA_FilterOperator_init(UA_FilterOperator *p) {
    memset(p, 0, sizeof(UA_FilterOperator));
}
 
static UA_FilterOperator *
UA_FilterOperator_new(void) {
    return (UA_FilterOperator*)UA_new(&UA_TYPES[UA_TYPES_FILTEROPERATOR]);
}
 
static UA_StatusCode
UA_FilterOperator_copy(const UA_FilterOperator *src, UA_FilterOperator *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FILTEROPERATOR]);
}
 
UA_DEPRECATED static void
UA_FilterOperator_deleteMembers(UA_FilterOperator *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_FILTEROPERATOR]);
}
 
static void
UA_FilterOperator_clear(UA_FilterOperator *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_FILTEROPERATOR]);
}
 
static void
UA_FilterOperator_delete(UA_FilterOperator *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_FILTEROPERATOR]);
}
 
/** ContentFilterElement */
static void
UA_ContentFilterElement_init(UA_ContentFilterElement *p) {
    memset(p, 0, sizeof(UA_ContentFilterElement));
}
 
static UA_ContentFilterElement *
UA_ContentFilterElement_new(void) {
    return (UA_ContentFilterElement*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
}
 
static UA_StatusCode
UA_ContentFilterElement_copy(const UA_ContentFilterElement *src, UA_ContentFilterElement *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
}
 
UA_DEPRECATED static void
UA_ContentFilterElement_deleteMembers(UA_ContentFilterElement *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
}
 
static void
UA_ContentFilterElement_clear(UA_ContentFilterElement *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
}
 
static void
UA_ContentFilterElement_delete(UA_ContentFilterElement *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
}
 
/** ContentFilter */
static void
UA_ContentFilter_init(UA_ContentFilter *p) {
    memset(p, 0, sizeof(UA_ContentFilter));
}
 
static UA_ContentFilter *
UA_ContentFilter_new(void) {
    return (UA_ContentFilter*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTER]);
}
 
static UA_StatusCode
UA_ContentFilter_copy(const UA_ContentFilter *src, UA_ContentFilter *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTER]);
}
 
UA_DEPRECATED static void
UA_ContentFilter_deleteMembers(UA_ContentFilter *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTER]);
}
 
static void
UA_ContentFilter_clear(UA_ContentFilter *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTER]);
}
 
static void
UA_ContentFilter_delete(UA_ContentFilter *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTER]);
}
 
/** ElementOperand */
static void
UA_ElementOperand_init(UA_ElementOperand *p) {
    memset(p, 0, sizeof(UA_ElementOperand));
}
 
static UA_ElementOperand *
UA_ElementOperand_new(void) {
    return (UA_ElementOperand*)UA_new(&UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
}
 
static UA_StatusCode
UA_ElementOperand_copy(const UA_ElementOperand *src, UA_ElementOperand *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
}
 
UA_DEPRECATED static void
UA_ElementOperand_deleteMembers(UA_ElementOperand *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
}
 
static void
UA_ElementOperand_clear(UA_ElementOperand *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
}
 
static void
UA_ElementOperand_delete(UA_ElementOperand *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
}
 
/** LiteralOperand */
static void
UA_LiteralOperand_init(UA_LiteralOperand *p) {
    memset(p, 0, sizeof(UA_LiteralOperand));
}
 
static UA_LiteralOperand *
UA_LiteralOperand_new(void) {
    return (UA_LiteralOperand*)UA_new(&UA_TYPES[UA_TYPES_LITERALOPERAND]);
}
 
static UA_StatusCode
UA_LiteralOperand_copy(const UA_LiteralOperand *src, UA_LiteralOperand *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LITERALOPERAND]);
}
 
UA_DEPRECATED static void
UA_LiteralOperand_deleteMembers(UA_LiteralOperand *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_LITERALOPERAND]);
}
 
static void
UA_LiteralOperand_clear(UA_LiteralOperand *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_LITERALOPERAND]);
}
 
static void
UA_LiteralOperand_delete(UA_LiteralOperand *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_LITERALOPERAND]);
}
 
/** AttributeOperand */
static void
UA_AttributeOperand_init(UA_AttributeOperand *p) {
    memset(p, 0, sizeof(UA_AttributeOperand));
}
 
static UA_AttributeOperand *
UA_AttributeOperand_new(void) {
    return (UA_AttributeOperand*)UA_new(&UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
}
 
static UA_StatusCode
UA_AttributeOperand_copy(const UA_AttributeOperand *src, UA_AttributeOperand *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
}
 
UA_DEPRECATED static void
UA_AttributeOperand_deleteMembers(UA_AttributeOperand *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
}
 
static void
UA_AttributeOperand_clear(UA_AttributeOperand *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
}
 
static void
UA_AttributeOperand_delete(UA_AttributeOperand *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
}
 
/** SimpleAttributeOperand */
static void
UA_SimpleAttributeOperand_init(UA_SimpleAttributeOperand *p) {
    memset(p, 0, sizeof(UA_SimpleAttributeOperand));
}
 
static UA_SimpleAttributeOperand *
UA_SimpleAttributeOperand_new(void) {
    return (UA_SimpleAttributeOperand*)UA_new(&UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
}
 
static UA_StatusCode
UA_SimpleAttributeOperand_copy(const UA_SimpleAttributeOperand *src, UA_SimpleAttributeOperand *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
}
 
UA_DEPRECATED static void
UA_SimpleAttributeOperand_deleteMembers(UA_SimpleAttributeOperand *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
}
 
static void
UA_SimpleAttributeOperand_clear(UA_SimpleAttributeOperand *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
}
 
static void
UA_SimpleAttributeOperand_delete(UA_SimpleAttributeOperand *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
}
 
/** ContentFilterElementResult */
static void
UA_ContentFilterElementResult_init(UA_ContentFilterElementResult *p) {
    memset(p, 0, sizeof(UA_ContentFilterElementResult));
}
 
static UA_ContentFilterElementResult *
UA_ContentFilterElementResult_new(void) {
    return (UA_ContentFilterElementResult*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
}
 
static UA_StatusCode
UA_ContentFilterElementResult_copy(const UA_ContentFilterElementResult *src, UA_ContentFilterElementResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
}
 
UA_DEPRECATED static void
UA_ContentFilterElementResult_deleteMembers(UA_ContentFilterElementResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
}
 
static void
UA_ContentFilterElementResult_clear(UA_ContentFilterElementResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
}
 
static void
UA_ContentFilterElementResult_delete(UA_ContentFilterElementResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
}
 
/** ContentFilterResult */
static void
UA_ContentFilterResult_init(UA_ContentFilterResult *p) {
    memset(p, 0, sizeof(UA_ContentFilterResult));
}
 
static UA_ContentFilterResult *
UA_ContentFilterResult_new(void) {
    return (UA_ContentFilterResult*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
}
 
static UA_StatusCode
UA_ContentFilterResult_copy(const UA_ContentFilterResult *src, UA_ContentFilterResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
}
 
UA_DEPRECATED static void
UA_ContentFilterResult_deleteMembers(UA_ContentFilterResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
}
 
static void
UA_ContentFilterResult_clear(UA_ContentFilterResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
}
 
static void
UA_ContentFilterResult_delete(UA_ContentFilterResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
}
 
/** TimestampsToReturn */
static void
UA_TimestampsToReturn_init(UA_TimestampsToReturn *p) {
    memset(p, 0, sizeof(UA_TimestampsToReturn));
}
 
static UA_TimestampsToReturn *
UA_TimestampsToReturn_new(void) {
    return (UA_TimestampsToReturn*)UA_new(&UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
}
 
static UA_StatusCode
UA_TimestampsToReturn_copy(const UA_TimestampsToReturn *src, UA_TimestampsToReturn *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
}
 
UA_DEPRECATED static void
UA_TimestampsToReturn_deleteMembers(UA_TimestampsToReturn *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
}
 
static void
UA_TimestampsToReturn_clear(UA_TimestampsToReturn *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
}
 
static void
UA_TimestampsToReturn_delete(UA_TimestampsToReturn *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
}
 
/** ReadValueId */
static void
UA_ReadValueId_init(UA_ReadValueId *p) {
    memset(p, 0, sizeof(UA_ReadValueId));
}
 
static UA_ReadValueId *
UA_ReadValueId_new(void) {
    return (UA_ReadValueId*)UA_new(&UA_TYPES[UA_TYPES_READVALUEID]);
}
 
static UA_StatusCode
UA_ReadValueId_copy(const UA_ReadValueId *src, UA_ReadValueId *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READVALUEID]);
}
 
UA_DEPRECATED static void
UA_ReadValueId_deleteMembers(UA_ReadValueId *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_READVALUEID]);
}
 
static void
UA_ReadValueId_clear(UA_ReadValueId *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_READVALUEID]);
}
 
static void
UA_ReadValueId_delete(UA_ReadValueId *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_READVALUEID]);
}
 
/** ReadRequest */
static void
UA_ReadRequest_init(UA_ReadRequest *p) {
    memset(p, 0, sizeof(UA_ReadRequest));
}
 
static UA_ReadRequest *
UA_ReadRequest_new(void) {
    return (UA_ReadRequest*)UA_new(&UA_TYPES[UA_TYPES_READREQUEST]);
}
 
static UA_StatusCode
UA_ReadRequest_copy(const UA_ReadRequest *src, UA_ReadRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READREQUEST]);
}
 
UA_DEPRECATED static void
UA_ReadRequest_deleteMembers(UA_ReadRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_READREQUEST]);
}
 
static void
UA_ReadRequest_clear(UA_ReadRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_READREQUEST]);
}
 
static void
UA_ReadRequest_delete(UA_ReadRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_READREQUEST]);
}
 
/** ReadResponse */
static void
UA_ReadResponse_init(UA_ReadResponse *p) {
    memset(p, 0, sizeof(UA_ReadResponse));
}
 
static UA_ReadResponse *
UA_ReadResponse_new(void) {
    return (UA_ReadResponse*)UA_new(&UA_TYPES[UA_TYPES_READRESPONSE]);
}
 
static UA_StatusCode
UA_ReadResponse_copy(const UA_ReadResponse *src, UA_ReadResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READRESPONSE]);
}
 
UA_DEPRECATED static void
UA_ReadResponse_deleteMembers(UA_ReadResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_READRESPONSE]);
}
 
static void
UA_ReadResponse_clear(UA_ReadResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_READRESPONSE]);
}
 
static void
UA_ReadResponse_delete(UA_ReadResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_READRESPONSE]);
}
 
/** WriteValue */
static void
UA_WriteValue_init(UA_WriteValue *p) {
    memset(p, 0, sizeof(UA_WriteValue));
}
 
static UA_WriteValue *
UA_WriteValue_new(void) {
    return (UA_WriteValue*)UA_new(&UA_TYPES[UA_TYPES_WRITEVALUE]);
}
 
static UA_StatusCode
UA_WriteValue_copy(const UA_WriteValue *src, UA_WriteValue *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITEVALUE]);
}
 
UA_DEPRECATED static void
UA_WriteValue_deleteMembers(UA_WriteValue *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITEVALUE]);
}
 
static void
UA_WriteValue_clear(UA_WriteValue *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITEVALUE]);
}
 
static void
UA_WriteValue_delete(UA_WriteValue *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_WRITEVALUE]);
}
 
/** WriteRequest */
static void
UA_WriteRequest_init(UA_WriteRequest *p) {
    memset(p, 0, sizeof(UA_WriteRequest));
}
 
static UA_WriteRequest *
UA_WriteRequest_new(void) {
    return (UA_WriteRequest*)UA_new(&UA_TYPES[UA_TYPES_WRITEREQUEST]);
}
 
static UA_StatusCode
UA_WriteRequest_copy(const UA_WriteRequest *src, UA_WriteRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITEREQUEST]);
}
 
UA_DEPRECATED static void
UA_WriteRequest_deleteMembers(UA_WriteRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITEREQUEST]);
}
 
static void
UA_WriteRequest_clear(UA_WriteRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITEREQUEST]);
}
 
static void
UA_WriteRequest_delete(UA_WriteRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_WRITEREQUEST]);
}
 
/** WriteResponse */
static void
UA_WriteResponse_init(UA_WriteResponse *p) {
    memset(p, 0, sizeof(UA_WriteResponse));
}
 
static UA_WriteResponse *
UA_WriteResponse_new(void) {
    return (UA_WriteResponse*)UA_new(&UA_TYPES[UA_TYPES_WRITERESPONSE]);
}
 
static UA_StatusCode
UA_WriteResponse_copy(const UA_WriteResponse *src, UA_WriteResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITERESPONSE]);
}
 
UA_DEPRECATED static void
UA_WriteResponse_deleteMembers(UA_WriteResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITERESPONSE]);
}
 
static void
UA_WriteResponse_clear(UA_WriteResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITERESPONSE]);
}
 
static void
UA_WriteResponse_delete(UA_WriteResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_WRITERESPONSE]);
}
 
/** CallMethodRequest */
static void
UA_CallMethodRequest_init(UA_CallMethodRequest *p) {
    memset(p, 0, sizeof(UA_CallMethodRequest));
}
 
static UA_CallMethodRequest *
UA_CallMethodRequest_new(void) {
    return (UA_CallMethodRequest*)UA_new(&UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
}
 
static UA_StatusCode
UA_CallMethodRequest_copy(const UA_CallMethodRequest *src, UA_CallMethodRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
}
 
UA_DEPRECATED static void
UA_CallMethodRequest_deleteMembers(UA_CallMethodRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
}
 
static void
UA_CallMethodRequest_clear(UA_CallMethodRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
}
 
static void
UA_CallMethodRequest_delete(UA_CallMethodRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
}
 
/** CallMethodResult */
static void
UA_CallMethodResult_init(UA_CallMethodResult *p) {
    memset(p, 0, sizeof(UA_CallMethodResult));
}
 
static UA_CallMethodResult *
UA_CallMethodResult_new(void) {
    return (UA_CallMethodResult*)UA_new(&UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
}
 
static UA_StatusCode
UA_CallMethodResult_copy(const UA_CallMethodResult *src, UA_CallMethodResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
}
 
UA_DEPRECATED static void
UA_CallMethodResult_deleteMembers(UA_CallMethodResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
}
 
static void
UA_CallMethodResult_clear(UA_CallMethodResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
}
 
static void
UA_CallMethodResult_delete(UA_CallMethodResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
}
 
/** CallRequest */
static void
UA_CallRequest_init(UA_CallRequest *p) {
    memset(p, 0, sizeof(UA_CallRequest));
}
 
static UA_CallRequest *
UA_CallRequest_new(void) {
    return (UA_CallRequest*)UA_new(&UA_TYPES[UA_TYPES_CALLREQUEST]);
}
 
static UA_StatusCode
UA_CallRequest_copy(const UA_CallRequest *src, UA_CallRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLREQUEST]);
}
 
UA_DEPRECATED static void
UA_CallRequest_deleteMembers(UA_CallRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLREQUEST]);
}
 
static void
UA_CallRequest_clear(UA_CallRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLREQUEST]);
}
 
static void
UA_CallRequest_delete(UA_CallRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CALLREQUEST]);
}
 
/** CallResponse */
static void
UA_CallResponse_init(UA_CallResponse *p) {
    memset(p, 0, sizeof(UA_CallResponse));
}
 
static UA_CallResponse *
UA_CallResponse_new(void) {
    return (UA_CallResponse*)UA_new(&UA_TYPES[UA_TYPES_CALLRESPONSE]);
}
 
static UA_StatusCode
UA_CallResponse_copy(const UA_CallResponse *src, UA_CallResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLRESPONSE]);
}
 
UA_DEPRECATED static void
UA_CallResponse_deleteMembers(UA_CallResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLRESPONSE]);
}
 
static void
UA_CallResponse_clear(UA_CallResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLRESPONSE]);
}
 
static void
UA_CallResponse_delete(UA_CallResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CALLRESPONSE]);
}
 
/** MonitoringMode */
static void
UA_MonitoringMode_init(UA_MonitoringMode *p) {
    memset(p, 0, sizeof(UA_MonitoringMode));
}
 
static UA_MonitoringMode *
UA_MonitoringMode_new(void) {
    return (UA_MonitoringMode*)UA_new(&UA_TYPES[UA_TYPES_MONITORINGMODE]);
}
 
static UA_StatusCode
UA_MonitoringMode_copy(const UA_MonitoringMode *src, UA_MonitoringMode *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITORINGMODE]);
}
 
UA_DEPRECATED static void
UA_MonitoringMode_deleteMembers(UA_MonitoringMode *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGMODE]);
}
 
static void
UA_MonitoringMode_clear(UA_MonitoringMode *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGMODE]);
}
 
static void
UA_MonitoringMode_delete(UA_MonitoringMode *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITORINGMODE]);
}
 
/** DataChangeTrigger */
static void
UA_DataChangeTrigger_init(UA_DataChangeTrigger *p) {
    memset(p, 0, sizeof(UA_DataChangeTrigger));
}
 
static UA_DataChangeTrigger *
UA_DataChangeTrigger_new(void) {
    return (UA_DataChangeTrigger*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
}
 
static UA_StatusCode
UA_DataChangeTrigger_copy(const UA_DataChangeTrigger *src, UA_DataChangeTrigger *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
}
 
UA_DEPRECATED static void
UA_DataChangeTrigger_deleteMembers(UA_DataChangeTrigger *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
}
 
static void
UA_DataChangeTrigger_clear(UA_DataChangeTrigger *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
}
 
static void
UA_DataChangeTrigger_delete(UA_DataChangeTrigger *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
}
 
/** DeadbandType */
static void
UA_DeadbandType_init(UA_DeadbandType *p) {
    memset(p, 0, sizeof(UA_DeadbandType));
}
 
static UA_DeadbandType *
UA_DeadbandType_new(void) {
    return (UA_DeadbandType*)UA_new(&UA_TYPES[UA_TYPES_DEADBANDTYPE]);
}
 
static UA_StatusCode
UA_DeadbandType_copy(const UA_DeadbandType *src, UA_DeadbandType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DEADBANDTYPE]);
}
 
UA_DEPRECATED static void
UA_DeadbandType_deleteMembers(UA_DeadbandType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DEADBANDTYPE]);
}
 
static void
UA_DeadbandType_clear(UA_DeadbandType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DEADBANDTYPE]);
}
 
static void
UA_DeadbandType_delete(UA_DeadbandType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DEADBANDTYPE]);
}
 
/** DataChangeFilter */
static void
UA_DataChangeFilter_init(UA_DataChangeFilter *p) {
    memset(p, 0, sizeof(UA_DataChangeFilter));
}
 
static UA_DataChangeFilter *
UA_DataChangeFilter_new(void) {
    return (UA_DataChangeFilter*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
}
 
static UA_StatusCode
UA_DataChangeFilter_copy(const UA_DataChangeFilter *src, UA_DataChangeFilter *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
}
 
UA_DEPRECATED static void
UA_DataChangeFilter_deleteMembers(UA_DataChangeFilter *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
}
 
static void
UA_DataChangeFilter_clear(UA_DataChangeFilter *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
}
 
static void
UA_DataChangeFilter_delete(UA_DataChangeFilter *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
}
 
/** EventFilter */
static void
UA_EventFilter_init(UA_EventFilter *p) {
    memset(p, 0, sizeof(UA_EventFilter));
}
 
static UA_EventFilter *
UA_EventFilter_new(void) {
    return (UA_EventFilter*)UA_new(&UA_TYPES[UA_TYPES_EVENTFILTER]);
}
 
static UA_StatusCode
UA_EventFilter_copy(const UA_EventFilter *src, UA_EventFilter *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFILTER]);
}
 
UA_DEPRECATED static void
UA_EventFilter_deleteMembers(UA_EventFilter *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTER]);
}
 
static void
UA_EventFilter_clear(UA_EventFilter *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTER]);
}
 
static void
UA_EventFilter_delete(UA_EventFilter *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFILTER]);
}
 
/** AggregateConfiguration */
static void
UA_AggregateConfiguration_init(UA_AggregateConfiguration *p) {
    memset(p, 0, sizeof(UA_AggregateConfiguration));
}
 
static UA_AggregateConfiguration *
UA_AggregateConfiguration_new(void) {
    return (UA_AggregateConfiguration*)UA_new(&UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
}
 
static UA_StatusCode
UA_AggregateConfiguration_copy(const UA_AggregateConfiguration *src, UA_AggregateConfiguration *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
}
 
UA_DEPRECATED static void
UA_AggregateConfiguration_deleteMembers(UA_AggregateConfiguration *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
}
 
static void
UA_AggregateConfiguration_clear(UA_AggregateConfiguration *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
}
 
static void
UA_AggregateConfiguration_delete(UA_AggregateConfiguration *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
}
 
/** AggregateFilter */
static void
UA_AggregateFilter_init(UA_AggregateFilter *p) {
    memset(p, 0, sizeof(UA_AggregateFilter));
}
 
static UA_AggregateFilter *
UA_AggregateFilter_new(void) {
    return (UA_AggregateFilter*)UA_new(&UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
}
 
static UA_StatusCode
UA_AggregateFilter_copy(const UA_AggregateFilter *src, UA_AggregateFilter *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
}
 
UA_DEPRECATED static void
UA_AggregateFilter_deleteMembers(UA_AggregateFilter *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
}
 
static void
UA_AggregateFilter_clear(UA_AggregateFilter *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
}
 
static void
UA_AggregateFilter_delete(UA_AggregateFilter *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
}
 
/** EventFilterResult */
static void
UA_EventFilterResult_init(UA_EventFilterResult *p) {
    memset(p, 0, sizeof(UA_EventFilterResult));
}
 
static UA_EventFilterResult *
UA_EventFilterResult_new(void) {
    return (UA_EventFilterResult*)UA_new(&UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
}
 
static UA_StatusCode
UA_EventFilterResult_copy(const UA_EventFilterResult *src, UA_EventFilterResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
}
 
UA_DEPRECATED static void
UA_EventFilterResult_deleteMembers(UA_EventFilterResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
}
 
static void
UA_EventFilterResult_clear(UA_EventFilterResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
}
 
static void
UA_EventFilterResult_delete(UA_EventFilterResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
}
 
/** MonitoringParameters */
static void
UA_MonitoringParameters_init(UA_MonitoringParameters *p) {
    memset(p, 0, sizeof(UA_MonitoringParameters));
}
 
static UA_MonitoringParameters *
UA_MonitoringParameters_new(void) {
    return (UA_MonitoringParameters*)UA_new(&UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
}
 
static UA_StatusCode
UA_MonitoringParameters_copy(const UA_MonitoringParameters *src, UA_MonitoringParameters *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
}
 
UA_DEPRECATED static void
UA_MonitoringParameters_deleteMembers(UA_MonitoringParameters *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
}
 
static void
UA_MonitoringParameters_clear(UA_MonitoringParameters *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
}
 
static void
UA_MonitoringParameters_delete(UA_MonitoringParameters *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
}
 
/** MonitoredItemCreateRequest */
static void
UA_MonitoredItemCreateRequest_init(UA_MonitoredItemCreateRequest *p) {
    memset(p, 0, sizeof(UA_MonitoredItemCreateRequest));
}
 
static UA_MonitoredItemCreateRequest *
UA_MonitoredItemCreateRequest_new(void) {
    return (UA_MonitoredItemCreateRequest*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
}
 
static UA_StatusCode
UA_MonitoredItemCreateRequest_copy(const UA_MonitoredItemCreateRequest *src, UA_MonitoredItemCreateRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
}
 
UA_DEPRECATED static void
UA_MonitoredItemCreateRequest_deleteMembers(UA_MonitoredItemCreateRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
}
 
static void
UA_MonitoredItemCreateRequest_clear(UA_MonitoredItemCreateRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
}
 
static void
UA_MonitoredItemCreateRequest_delete(UA_MonitoredItemCreateRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
}
 
/** MonitoredItemCreateResult */
static void
UA_MonitoredItemCreateResult_init(UA_MonitoredItemCreateResult *p) {
    memset(p, 0, sizeof(UA_MonitoredItemCreateResult));
}
 
static UA_MonitoredItemCreateResult *
UA_MonitoredItemCreateResult_new(void) {
    return (UA_MonitoredItemCreateResult*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
}
 
static UA_StatusCode
UA_MonitoredItemCreateResult_copy(const UA_MonitoredItemCreateResult *src, UA_MonitoredItemCreateResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
}
 
UA_DEPRECATED static void
UA_MonitoredItemCreateResult_deleteMembers(UA_MonitoredItemCreateResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
}
 
static void
UA_MonitoredItemCreateResult_clear(UA_MonitoredItemCreateResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
}
 
static void
UA_MonitoredItemCreateResult_delete(UA_MonitoredItemCreateResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
}
 
/** CreateMonitoredItemsRequest */
static void
UA_CreateMonitoredItemsRequest_init(UA_CreateMonitoredItemsRequest *p) {
    memset(p, 0, sizeof(UA_CreateMonitoredItemsRequest));
}
 
static UA_CreateMonitoredItemsRequest *
UA_CreateMonitoredItemsRequest_new(void) {
    return (UA_CreateMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
}
 
static UA_StatusCode
UA_CreateMonitoredItemsRequest_copy(const UA_CreateMonitoredItemsRequest *src, UA_CreateMonitoredItemsRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
}
 
UA_DEPRECATED static void
UA_CreateMonitoredItemsRequest_deleteMembers(UA_CreateMonitoredItemsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
}
 
static void
UA_CreateMonitoredItemsRequest_clear(UA_CreateMonitoredItemsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
}
 
static void
UA_CreateMonitoredItemsRequest_delete(UA_CreateMonitoredItemsRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
}
 
/** CreateMonitoredItemsResponse */
static void
UA_CreateMonitoredItemsResponse_init(UA_CreateMonitoredItemsResponse *p) {
    memset(p, 0, sizeof(UA_CreateMonitoredItemsResponse));
}
 
static UA_CreateMonitoredItemsResponse *
UA_CreateMonitoredItemsResponse_new(void) {
    return (UA_CreateMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
}
 
static UA_StatusCode
UA_CreateMonitoredItemsResponse_copy(const UA_CreateMonitoredItemsResponse *src, UA_CreateMonitoredItemsResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
}
 
UA_DEPRECATED static void
UA_CreateMonitoredItemsResponse_deleteMembers(UA_CreateMonitoredItemsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
}
 
static void
UA_CreateMonitoredItemsResponse_clear(UA_CreateMonitoredItemsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
}
 
static void
UA_CreateMonitoredItemsResponse_delete(UA_CreateMonitoredItemsResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
}
 
/** MonitoredItemModifyRequest */
static void
UA_MonitoredItemModifyRequest_init(UA_MonitoredItemModifyRequest *p) {
    memset(p, 0, sizeof(UA_MonitoredItemModifyRequest));
}
 
static UA_MonitoredItemModifyRequest *
UA_MonitoredItemModifyRequest_new(void) {
    return (UA_MonitoredItemModifyRequest*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
}
 
static UA_StatusCode
UA_MonitoredItemModifyRequest_copy(const UA_MonitoredItemModifyRequest *src, UA_MonitoredItemModifyRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
}
 
UA_DEPRECATED static void
UA_MonitoredItemModifyRequest_deleteMembers(UA_MonitoredItemModifyRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
}
 
static void
UA_MonitoredItemModifyRequest_clear(UA_MonitoredItemModifyRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
}
 
static void
UA_MonitoredItemModifyRequest_delete(UA_MonitoredItemModifyRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
}
 
/** MonitoredItemModifyResult */
static void
UA_MonitoredItemModifyResult_init(UA_MonitoredItemModifyResult *p) {
    memset(p, 0, sizeof(UA_MonitoredItemModifyResult));
}
 
static UA_MonitoredItemModifyResult *
UA_MonitoredItemModifyResult_new(void) {
    return (UA_MonitoredItemModifyResult*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
}
 
static UA_StatusCode
UA_MonitoredItemModifyResult_copy(const UA_MonitoredItemModifyResult *src, UA_MonitoredItemModifyResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
}
 
UA_DEPRECATED static void
UA_MonitoredItemModifyResult_deleteMembers(UA_MonitoredItemModifyResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
}
 
static void
UA_MonitoredItemModifyResult_clear(UA_MonitoredItemModifyResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
}
 
static void
UA_MonitoredItemModifyResult_delete(UA_MonitoredItemModifyResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
}
 
/** ModifyMonitoredItemsRequest */
static void
UA_ModifyMonitoredItemsRequest_init(UA_ModifyMonitoredItemsRequest *p) {
    memset(p, 0, sizeof(UA_ModifyMonitoredItemsRequest));
}
 
static UA_ModifyMonitoredItemsRequest *
UA_ModifyMonitoredItemsRequest_new(void) {
    return (UA_ModifyMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
}
 
static UA_StatusCode
UA_ModifyMonitoredItemsRequest_copy(const UA_ModifyMonitoredItemsRequest *src, UA_ModifyMonitoredItemsRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
}
 
UA_DEPRECATED static void
UA_ModifyMonitoredItemsRequest_deleteMembers(UA_ModifyMonitoredItemsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
}
 
static void
UA_ModifyMonitoredItemsRequest_clear(UA_ModifyMonitoredItemsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
}
 
static void
UA_ModifyMonitoredItemsRequest_delete(UA_ModifyMonitoredItemsRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
}
 
/** ModifyMonitoredItemsResponse */
static void
UA_ModifyMonitoredItemsResponse_init(UA_ModifyMonitoredItemsResponse *p) {
    memset(p, 0, sizeof(UA_ModifyMonitoredItemsResponse));
}
 
static UA_ModifyMonitoredItemsResponse *
UA_ModifyMonitoredItemsResponse_new(void) {
    return (UA_ModifyMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
}
 
static UA_StatusCode
UA_ModifyMonitoredItemsResponse_copy(const UA_ModifyMonitoredItemsResponse *src, UA_ModifyMonitoredItemsResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
}
 
UA_DEPRECATED static void
UA_ModifyMonitoredItemsResponse_deleteMembers(UA_ModifyMonitoredItemsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
}
 
static void
UA_ModifyMonitoredItemsResponse_clear(UA_ModifyMonitoredItemsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
}
 
static void
UA_ModifyMonitoredItemsResponse_delete(UA_ModifyMonitoredItemsResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
}
 
/** SetMonitoringModeRequest */
static void
UA_SetMonitoringModeRequest_init(UA_SetMonitoringModeRequest *p) {
    memset(p, 0, sizeof(UA_SetMonitoringModeRequest));
}
 
static UA_SetMonitoringModeRequest *
UA_SetMonitoringModeRequest_new(void) {
    return (UA_SetMonitoringModeRequest*)UA_new(&UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
}
 
static UA_StatusCode
UA_SetMonitoringModeRequest_copy(const UA_SetMonitoringModeRequest *src, UA_SetMonitoringModeRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
}
 
UA_DEPRECATED static void
UA_SetMonitoringModeRequest_deleteMembers(UA_SetMonitoringModeRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
}
 
static void
UA_SetMonitoringModeRequest_clear(UA_SetMonitoringModeRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
}
 
static void
UA_SetMonitoringModeRequest_delete(UA_SetMonitoringModeRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
}
 
/** SetMonitoringModeResponse */
static void
UA_SetMonitoringModeResponse_init(UA_SetMonitoringModeResponse *p) {
    memset(p, 0, sizeof(UA_SetMonitoringModeResponse));
}
 
static UA_SetMonitoringModeResponse *
UA_SetMonitoringModeResponse_new(void) {
    return (UA_SetMonitoringModeResponse*)UA_new(&UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
}
 
static UA_StatusCode
UA_SetMonitoringModeResponse_copy(const UA_SetMonitoringModeResponse *src, UA_SetMonitoringModeResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
}
 
UA_DEPRECATED static void
UA_SetMonitoringModeResponse_deleteMembers(UA_SetMonitoringModeResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
}
 
static void
UA_SetMonitoringModeResponse_clear(UA_SetMonitoringModeResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
}
 
static void
UA_SetMonitoringModeResponse_delete(UA_SetMonitoringModeResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
}
 
/** SetTriggeringRequest */
static void
UA_SetTriggeringRequest_init(UA_SetTriggeringRequest *p) {
    memset(p, 0, sizeof(UA_SetTriggeringRequest));
}
 
static UA_SetTriggeringRequest *
UA_SetTriggeringRequest_new(void) {
    return (UA_SetTriggeringRequest*)UA_new(&UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
}
 
static UA_StatusCode
UA_SetTriggeringRequest_copy(const UA_SetTriggeringRequest *src, UA_SetTriggeringRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
}
 
UA_DEPRECATED static void
UA_SetTriggeringRequest_deleteMembers(UA_SetTriggeringRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
}
 
static void
UA_SetTriggeringRequest_clear(UA_SetTriggeringRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
}
 
static void
UA_SetTriggeringRequest_delete(UA_SetTriggeringRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
}
 
/** SetTriggeringResponse */
static void
UA_SetTriggeringResponse_init(UA_SetTriggeringResponse *p) {
    memset(p, 0, sizeof(UA_SetTriggeringResponse));
}
 
static UA_SetTriggeringResponse *
UA_SetTriggeringResponse_new(void) {
    return (UA_SetTriggeringResponse*)UA_new(&UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
}
 
static UA_StatusCode
UA_SetTriggeringResponse_copy(const UA_SetTriggeringResponse *src, UA_SetTriggeringResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
}
 
UA_DEPRECATED static void
UA_SetTriggeringResponse_deleteMembers(UA_SetTriggeringResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
}
 
static void
UA_SetTriggeringResponse_clear(UA_SetTriggeringResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
}
 
static void
UA_SetTriggeringResponse_delete(UA_SetTriggeringResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
}
 
/** DeleteMonitoredItemsRequest */
static void
UA_DeleteMonitoredItemsRequest_init(UA_DeleteMonitoredItemsRequest *p) {
    memset(p, 0, sizeof(UA_DeleteMonitoredItemsRequest));
}
 
static UA_DeleteMonitoredItemsRequest *
UA_DeleteMonitoredItemsRequest_new(void) {
    return (UA_DeleteMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
}
 
static UA_StatusCode
UA_DeleteMonitoredItemsRequest_copy(const UA_DeleteMonitoredItemsRequest *src, UA_DeleteMonitoredItemsRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
}
 
UA_DEPRECATED static void
UA_DeleteMonitoredItemsRequest_deleteMembers(UA_DeleteMonitoredItemsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
}
 
static void
UA_DeleteMonitoredItemsRequest_clear(UA_DeleteMonitoredItemsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
}
 
static void
UA_DeleteMonitoredItemsRequest_delete(UA_DeleteMonitoredItemsRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
}
 
/** DeleteMonitoredItemsResponse */
static void
UA_DeleteMonitoredItemsResponse_init(UA_DeleteMonitoredItemsResponse *p) {
    memset(p, 0, sizeof(UA_DeleteMonitoredItemsResponse));
}
 
static UA_DeleteMonitoredItemsResponse *
UA_DeleteMonitoredItemsResponse_new(void) {
    return (UA_DeleteMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
}
 
static UA_StatusCode
UA_DeleteMonitoredItemsResponse_copy(const UA_DeleteMonitoredItemsResponse *src, UA_DeleteMonitoredItemsResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
}
 
UA_DEPRECATED static void
UA_DeleteMonitoredItemsResponse_deleteMembers(UA_DeleteMonitoredItemsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
}
 
static void
UA_DeleteMonitoredItemsResponse_clear(UA_DeleteMonitoredItemsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
}
 
static void
UA_DeleteMonitoredItemsResponse_delete(UA_DeleteMonitoredItemsResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
}
 
/** CreateSubscriptionRequest */
static void
UA_CreateSubscriptionRequest_init(UA_CreateSubscriptionRequest *p) {
    memset(p, 0, sizeof(UA_CreateSubscriptionRequest));
}
 
static UA_CreateSubscriptionRequest *
UA_CreateSubscriptionRequest_new(void) {
    return (UA_CreateSubscriptionRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
}
 
static UA_StatusCode
UA_CreateSubscriptionRequest_copy(const UA_CreateSubscriptionRequest *src, UA_CreateSubscriptionRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
}
 
UA_DEPRECATED static void
UA_CreateSubscriptionRequest_deleteMembers(UA_CreateSubscriptionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
}
 
static void
UA_CreateSubscriptionRequest_clear(UA_CreateSubscriptionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
}
 
static void
UA_CreateSubscriptionRequest_delete(UA_CreateSubscriptionRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
}
 
/** CreateSubscriptionResponse */
static void
UA_CreateSubscriptionResponse_init(UA_CreateSubscriptionResponse *p) {
    memset(p, 0, sizeof(UA_CreateSubscriptionResponse));
}
 
static UA_CreateSubscriptionResponse *
UA_CreateSubscriptionResponse_new(void) {
    return (UA_CreateSubscriptionResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
}
 
static UA_StatusCode
UA_CreateSubscriptionResponse_copy(const UA_CreateSubscriptionResponse *src, UA_CreateSubscriptionResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
}
 
UA_DEPRECATED static void
UA_CreateSubscriptionResponse_deleteMembers(UA_CreateSubscriptionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
}
 
static void
UA_CreateSubscriptionResponse_clear(UA_CreateSubscriptionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
}
 
static void
UA_CreateSubscriptionResponse_delete(UA_CreateSubscriptionResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
}
 
/** ModifySubscriptionRequest */
static void
UA_ModifySubscriptionRequest_init(UA_ModifySubscriptionRequest *p) {
    memset(p, 0, sizeof(UA_ModifySubscriptionRequest));
}
 
static UA_ModifySubscriptionRequest *
UA_ModifySubscriptionRequest_new(void) {
    return (UA_ModifySubscriptionRequest*)UA_new(&UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
}
 
static UA_StatusCode
UA_ModifySubscriptionRequest_copy(const UA_ModifySubscriptionRequest *src, UA_ModifySubscriptionRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
}
 
UA_DEPRECATED static void
UA_ModifySubscriptionRequest_deleteMembers(UA_ModifySubscriptionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
}
 
static void
UA_ModifySubscriptionRequest_clear(UA_ModifySubscriptionRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
}
 
static void
UA_ModifySubscriptionRequest_delete(UA_ModifySubscriptionRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
}
 
/** ModifySubscriptionResponse */
static void
UA_ModifySubscriptionResponse_init(UA_ModifySubscriptionResponse *p) {
    memset(p, 0, sizeof(UA_ModifySubscriptionResponse));
}
 
static UA_ModifySubscriptionResponse *
UA_ModifySubscriptionResponse_new(void) {
    return (UA_ModifySubscriptionResponse*)UA_new(&UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
}
 
static UA_StatusCode
UA_ModifySubscriptionResponse_copy(const UA_ModifySubscriptionResponse *src, UA_ModifySubscriptionResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
}
 
UA_DEPRECATED static void
UA_ModifySubscriptionResponse_deleteMembers(UA_ModifySubscriptionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
}
 
static void
UA_ModifySubscriptionResponse_clear(UA_ModifySubscriptionResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
}
 
static void
UA_ModifySubscriptionResponse_delete(UA_ModifySubscriptionResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
}
 
/** SetPublishingModeRequest */
static void
UA_SetPublishingModeRequest_init(UA_SetPublishingModeRequest *p) {
    memset(p, 0, sizeof(UA_SetPublishingModeRequest));
}
 
static UA_SetPublishingModeRequest *
UA_SetPublishingModeRequest_new(void) {
    return (UA_SetPublishingModeRequest*)UA_new(&UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
}
 
static UA_StatusCode
UA_SetPublishingModeRequest_copy(const UA_SetPublishingModeRequest *src, UA_SetPublishingModeRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
}
 
UA_DEPRECATED static void
UA_SetPublishingModeRequest_deleteMembers(UA_SetPublishingModeRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
}
 
static void
UA_SetPublishingModeRequest_clear(UA_SetPublishingModeRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
}
 
static void
UA_SetPublishingModeRequest_delete(UA_SetPublishingModeRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
}
 
/** SetPublishingModeResponse */
static void
UA_SetPublishingModeResponse_init(UA_SetPublishingModeResponse *p) {
    memset(p, 0, sizeof(UA_SetPublishingModeResponse));
}
 
static UA_SetPublishingModeResponse *
UA_SetPublishingModeResponse_new(void) {
    return (UA_SetPublishingModeResponse*)UA_new(&UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
}
 
static UA_StatusCode
UA_SetPublishingModeResponse_copy(const UA_SetPublishingModeResponse *src, UA_SetPublishingModeResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
}
 
UA_DEPRECATED static void
UA_SetPublishingModeResponse_deleteMembers(UA_SetPublishingModeResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
}
 
static void
UA_SetPublishingModeResponse_clear(UA_SetPublishingModeResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
}
 
static void
UA_SetPublishingModeResponse_delete(UA_SetPublishingModeResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
}
 
/** NotificationMessage */
static void
UA_NotificationMessage_init(UA_NotificationMessage *p) {
    memset(p, 0, sizeof(UA_NotificationMessage));
}
 
static UA_NotificationMessage *
UA_NotificationMessage_new(void) {
    return (UA_NotificationMessage*)UA_new(&UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
}
 
static UA_StatusCode
UA_NotificationMessage_copy(const UA_NotificationMessage *src, UA_NotificationMessage *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
}
 
UA_DEPRECATED static void
UA_NotificationMessage_deleteMembers(UA_NotificationMessage *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
}
 
static void
UA_NotificationMessage_clear(UA_NotificationMessage *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
}
 
static void
UA_NotificationMessage_delete(UA_NotificationMessage *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
}
 
/** MonitoredItemNotification */
static void
UA_MonitoredItemNotification_init(UA_MonitoredItemNotification *p) {
    memset(p, 0, sizeof(UA_MonitoredItemNotification));
}
 
static UA_MonitoredItemNotification *
UA_MonitoredItemNotification_new(void) {
    return (UA_MonitoredItemNotification*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
}
 
static UA_StatusCode
UA_MonitoredItemNotification_copy(const UA_MonitoredItemNotification *src, UA_MonitoredItemNotification *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
}
 
UA_DEPRECATED static void
UA_MonitoredItemNotification_deleteMembers(UA_MonitoredItemNotification *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
}
 
static void
UA_MonitoredItemNotification_clear(UA_MonitoredItemNotification *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
}
 
static void
UA_MonitoredItemNotification_delete(UA_MonitoredItemNotification *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
}
 
/** EventFieldList */
static void
UA_EventFieldList_init(UA_EventFieldList *p) {
    memset(p, 0, sizeof(UA_EventFieldList));
}
 
static UA_EventFieldList *
UA_EventFieldList_new(void) {
    return (UA_EventFieldList*)UA_new(&UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
}
 
static UA_StatusCode
UA_EventFieldList_copy(const UA_EventFieldList *src, UA_EventFieldList *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
}
 
UA_DEPRECATED static void
UA_EventFieldList_deleteMembers(UA_EventFieldList *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
}
 
static void
UA_EventFieldList_clear(UA_EventFieldList *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
}
 
static void
UA_EventFieldList_delete(UA_EventFieldList *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
}
 
/** StatusChangeNotification */
static void
UA_StatusChangeNotification_init(UA_StatusChangeNotification *p) {
    memset(p, 0, sizeof(UA_StatusChangeNotification));
}
 
static UA_StatusChangeNotification *
UA_StatusChangeNotification_new(void) {
    return (UA_StatusChangeNotification*)UA_new(&UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
}
 
static UA_StatusCode
UA_StatusChangeNotification_copy(const UA_StatusChangeNotification *src, UA_StatusChangeNotification *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
}
 
UA_DEPRECATED static void
UA_StatusChangeNotification_deleteMembers(UA_StatusChangeNotification *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
}
 
static void
UA_StatusChangeNotification_clear(UA_StatusChangeNotification *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
}
 
static void
UA_StatusChangeNotification_delete(UA_StatusChangeNotification *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
}
 
/** SubscriptionAcknowledgement */
static void
UA_SubscriptionAcknowledgement_init(UA_SubscriptionAcknowledgement *p) {
    memset(p, 0, sizeof(UA_SubscriptionAcknowledgement));
}
 
static UA_SubscriptionAcknowledgement *
UA_SubscriptionAcknowledgement_new(void) {
    return (UA_SubscriptionAcknowledgement*)UA_new(&UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
}
 
static UA_StatusCode
UA_SubscriptionAcknowledgement_copy(const UA_SubscriptionAcknowledgement *src, UA_SubscriptionAcknowledgement *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
}
 
UA_DEPRECATED static void
UA_SubscriptionAcknowledgement_deleteMembers(UA_SubscriptionAcknowledgement *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
}
 
static void
UA_SubscriptionAcknowledgement_clear(UA_SubscriptionAcknowledgement *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
}
 
static void
UA_SubscriptionAcknowledgement_delete(UA_SubscriptionAcknowledgement *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
}
 
/** PublishRequest */
static void
UA_PublishRequest_init(UA_PublishRequest *p) {
    memset(p, 0, sizeof(UA_PublishRequest));
}
 
static UA_PublishRequest *
UA_PublishRequest_new(void) {
    return (UA_PublishRequest*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
}
 
static UA_StatusCode
UA_PublishRequest_copy(const UA_PublishRequest *src, UA_PublishRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
}
 
UA_DEPRECATED static void
UA_PublishRequest_deleteMembers(UA_PublishRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
}
 
static void
UA_PublishRequest_clear(UA_PublishRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
}
 
static void
UA_PublishRequest_delete(UA_PublishRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
}
 
/** PublishResponse */
static void
UA_PublishResponse_init(UA_PublishResponse *p) {
    memset(p, 0, sizeof(UA_PublishResponse));
}
 
static UA_PublishResponse *
UA_PublishResponse_new(void) {
    return (UA_PublishResponse*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
}
 
static UA_StatusCode
UA_PublishResponse_copy(const UA_PublishResponse *src, UA_PublishResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
}
 
UA_DEPRECATED static void
UA_PublishResponse_deleteMembers(UA_PublishResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
}
 
static void
UA_PublishResponse_clear(UA_PublishResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
}
 
static void
UA_PublishResponse_delete(UA_PublishResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
}
 
/** RepublishRequest */
static void
UA_RepublishRequest_init(UA_RepublishRequest *p) {
    memset(p, 0, sizeof(UA_RepublishRequest));
}
 
static UA_RepublishRequest *
UA_RepublishRequest_new(void) {
    return (UA_RepublishRequest*)UA_new(&UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
}
 
static UA_StatusCode
UA_RepublishRequest_copy(const UA_RepublishRequest *src, UA_RepublishRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
}
 
UA_DEPRECATED static void
UA_RepublishRequest_deleteMembers(UA_RepublishRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
}
 
static void
UA_RepublishRequest_clear(UA_RepublishRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
}
 
static void
UA_RepublishRequest_delete(UA_RepublishRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
}
 
/** RepublishResponse */
static void
UA_RepublishResponse_init(UA_RepublishResponse *p) {
    memset(p, 0, sizeof(UA_RepublishResponse));
}
 
static UA_RepublishResponse *
UA_RepublishResponse_new(void) {
    return (UA_RepublishResponse*)UA_new(&UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
}
 
static UA_StatusCode
UA_RepublishResponse_copy(const UA_RepublishResponse *src, UA_RepublishResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
}
 
UA_DEPRECATED static void
UA_RepublishResponse_deleteMembers(UA_RepublishResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
}
 
static void
UA_RepublishResponse_clear(UA_RepublishResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
}
 
static void
UA_RepublishResponse_delete(UA_RepublishResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
}
 
/** TransferResult */
static void
UA_TransferResult_init(UA_TransferResult *p) {
    memset(p, 0, sizeof(UA_TransferResult));
}
 
static UA_TransferResult *
UA_TransferResult_new(void) {
    return (UA_TransferResult*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERRESULT]);
}
 
static UA_StatusCode
UA_TransferResult_copy(const UA_TransferResult *src, UA_TransferResult *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERRESULT]);
}
 
UA_DEPRECATED static void
UA_TransferResult_deleteMembers(UA_TransferResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERRESULT]);
}
 
static void
UA_TransferResult_clear(UA_TransferResult *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERRESULT]);
}
 
static void
UA_TransferResult_delete(UA_TransferResult *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERRESULT]);
}
 
/** TransferSubscriptionsRequest */
static void
UA_TransferSubscriptionsRequest_init(UA_TransferSubscriptionsRequest *p) {
    memset(p, 0, sizeof(UA_TransferSubscriptionsRequest));
}
 
static UA_TransferSubscriptionsRequest *
UA_TransferSubscriptionsRequest_new(void) {
    return (UA_TransferSubscriptionsRequest*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
}
 
static UA_StatusCode
UA_TransferSubscriptionsRequest_copy(const UA_TransferSubscriptionsRequest *src, UA_TransferSubscriptionsRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
}
 
UA_DEPRECATED static void
UA_TransferSubscriptionsRequest_deleteMembers(UA_TransferSubscriptionsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
}
 
static void
UA_TransferSubscriptionsRequest_clear(UA_TransferSubscriptionsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
}
 
static void
UA_TransferSubscriptionsRequest_delete(UA_TransferSubscriptionsRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
}
 
/** TransferSubscriptionsResponse */
static void
UA_TransferSubscriptionsResponse_init(UA_TransferSubscriptionsResponse *p) {
    memset(p, 0, sizeof(UA_TransferSubscriptionsResponse));
}
 
static UA_TransferSubscriptionsResponse *
UA_TransferSubscriptionsResponse_new(void) {
    return (UA_TransferSubscriptionsResponse*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
}
 
static UA_StatusCode
UA_TransferSubscriptionsResponse_copy(const UA_TransferSubscriptionsResponse *src, UA_TransferSubscriptionsResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
}
 
UA_DEPRECATED static void
UA_TransferSubscriptionsResponse_deleteMembers(UA_TransferSubscriptionsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
}
 
static void
UA_TransferSubscriptionsResponse_clear(UA_TransferSubscriptionsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
}
 
static void
UA_TransferSubscriptionsResponse_delete(UA_TransferSubscriptionsResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
}
 
/** DeleteSubscriptionsRequest */
static void
UA_DeleteSubscriptionsRequest_init(UA_DeleteSubscriptionsRequest *p) {
    memset(p, 0, sizeof(UA_DeleteSubscriptionsRequest));
}
 
static UA_DeleteSubscriptionsRequest *
UA_DeleteSubscriptionsRequest_new(void) {
    return (UA_DeleteSubscriptionsRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
}
 
static UA_StatusCode
UA_DeleteSubscriptionsRequest_copy(const UA_DeleteSubscriptionsRequest *src, UA_DeleteSubscriptionsRequest *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
}
 
UA_DEPRECATED static void
UA_DeleteSubscriptionsRequest_deleteMembers(UA_DeleteSubscriptionsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
}
 
static void
UA_DeleteSubscriptionsRequest_clear(UA_DeleteSubscriptionsRequest *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
}
 
static void
UA_DeleteSubscriptionsRequest_delete(UA_DeleteSubscriptionsRequest *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
}
 
/** DeleteSubscriptionsResponse */
static void
UA_DeleteSubscriptionsResponse_init(UA_DeleteSubscriptionsResponse *p) {
    memset(p, 0, sizeof(UA_DeleteSubscriptionsResponse));
}
 
static UA_DeleteSubscriptionsResponse *
UA_DeleteSubscriptionsResponse_new(void) {
    return (UA_DeleteSubscriptionsResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
}
 
static UA_StatusCode
UA_DeleteSubscriptionsResponse_copy(const UA_DeleteSubscriptionsResponse *src, UA_DeleteSubscriptionsResponse *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
}
 
UA_DEPRECATED static void
UA_DeleteSubscriptionsResponse_deleteMembers(UA_DeleteSubscriptionsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
}
 
static void
UA_DeleteSubscriptionsResponse_clear(UA_DeleteSubscriptionsResponse *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
}
 
static void
UA_DeleteSubscriptionsResponse_delete(UA_DeleteSubscriptionsResponse *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
}
 
/** BuildInfo */
static void
UA_BuildInfo_init(UA_BuildInfo *p) {
    memset(p, 0, sizeof(UA_BuildInfo));
}
 
static UA_BuildInfo *
UA_BuildInfo_new(void) {
    return (UA_BuildInfo*)UA_new(&UA_TYPES[UA_TYPES_BUILDINFO]);
}
 
static UA_StatusCode
UA_BuildInfo_copy(const UA_BuildInfo *src, UA_BuildInfo *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BUILDINFO]);
}
 
UA_DEPRECATED static void
UA_BuildInfo_deleteMembers(UA_BuildInfo *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BUILDINFO]);
}
 
static void
UA_BuildInfo_clear(UA_BuildInfo *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_BUILDINFO]);
}
 
static void
UA_BuildInfo_delete(UA_BuildInfo *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_BUILDINFO]);
}
 
/** RedundancySupport */
static void
UA_RedundancySupport_init(UA_RedundancySupport *p) {
    memset(p, 0, sizeof(UA_RedundancySupport));
}
 
static UA_RedundancySupport *
UA_RedundancySupport_new(void) {
    return (UA_RedundancySupport*)UA_new(&UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
}
 
static UA_StatusCode
UA_RedundancySupport_copy(const UA_RedundancySupport *src, UA_RedundancySupport *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
}
 
UA_DEPRECATED static void
UA_RedundancySupport_deleteMembers(UA_RedundancySupport *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
}
 
static void
UA_RedundancySupport_clear(UA_RedundancySupport *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
}
 
static void
UA_RedundancySupport_delete(UA_RedundancySupport *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
}
 
/** ServerState */
static void
UA_ServerState_init(UA_ServerState *p) {
    memset(p, 0, sizeof(UA_ServerState));
}
 
static UA_ServerState *
UA_ServerState_new(void) {
    return (UA_ServerState*)UA_new(&UA_TYPES[UA_TYPES_SERVERSTATE]);
}
 
static UA_StatusCode
UA_ServerState_copy(const UA_ServerState *src, UA_ServerState *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERSTATE]);
}
 
UA_DEPRECATED static void
UA_ServerState_deleteMembers(UA_ServerState *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATE]);
}
 
static void
UA_ServerState_clear(UA_ServerState *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATE]);
}
 
static void
UA_ServerState_delete(UA_ServerState *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVERSTATE]);
}
 
/** ServerDiagnosticsSummaryDataType */
static void
UA_ServerDiagnosticsSummaryDataType_init(UA_ServerDiagnosticsSummaryDataType *p) {
    memset(p, 0, sizeof(UA_ServerDiagnosticsSummaryDataType));
}
 
static UA_ServerDiagnosticsSummaryDataType *
UA_ServerDiagnosticsSummaryDataType_new(void) {
    return (UA_ServerDiagnosticsSummaryDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
}
 
static UA_StatusCode
UA_ServerDiagnosticsSummaryDataType_copy(const UA_ServerDiagnosticsSummaryDataType *src, UA_ServerDiagnosticsSummaryDataType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
}
 
UA_DEPRECATED static void
UA_ServerDiagnosticsSummaryDataType_deleteMembers(UA_ServerDiagnosticsSummaryDataType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
}
 
static void
UA_ServerDiagnosticsSummaryDataType_clear(UA_ServerDiagnosticsSummaryDataType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
}
 
static void
UA_ServerDiagnosticsSummaryDataType_delete(UA_ServerDiagnosticsSummaryDataType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
}
 
/** ServerStatusDataType */
static void
UA_ServerStatusDataType_init(UA_ServerStatusDataType *p) {
    memset(p, 0, sizeof(UA_ServerStatusDataType));
}
 
static UA_ServerStatusDataType *
UA_ServerStatusDataType_new(void) {
    return (UA_ServerStatusDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
}
 
static UA_StatusCode
UA_ServerStatusDataType_copy(const UA_ServerStatusDataType *src, UA_ServerStatusDataType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
}
 
UA_DEPRECATED static void
UA_ServerStatusDataType_deleteMembers(UA_ServerStatusDataType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
}
 
static void
UA_ServerStatusDataType_clear(UA_ServerStatusDataType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
}
 
static void
UA_ServerStatusDataType_delete(UA_ServerStatusDataType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
}
 
/** Range */
static void
UA_Range_init(UA_Range *p) {
    memset(p, 0, sizeof(UA_Range));
}
 
static UA_Range *
UA_Range_new(void) {
    return (UA_Range*)UA_new(&UA_TYPES[UA_TYPES_RANGE]);
}
 
static UA_StatusCode
UA_Range_copy(const UA_Range *src, UA_Range *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RANGE]);
}
 
UA_DEPRECATED static void
UA_Range_deleteMembers(UA_Range *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_RANGE]);
}
 
static void
UA_Range_clear(UA_Range *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_RANGE]);
}
 
static void
UA_Range_delete(UA_Range *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_RANGE]);
}
 
/** EUInformation */
static void
UA_EUInformation_init(UA_EUInformation *p) {
    memset(p, 0, sizeof(UA_EUInformation));
}
 
static UA_EUInformation *
UA_EUInformation_new(void) {
    return (UA_EUInformation*)UA_new(&UA_TYPES[UA_TYPES_EUINFORMATION]);
}
 
static UA_StatusCode
UA_EUInformation_copy(const UA_EUInformation *src, UA_EUInformation *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EUINFORMATION]);
}
 
UA_DEPRECATED static void
UA_EUInformation_deleteMembers(UA_EUInformation *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EUINFORMATION]);
}
 
static void
UA_EUInformation_clear(UA_EUInformation *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EUINFORMATION]);
}
 
static void
UA_EUInformation_delete(UA_EUInformation *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_EUINFORMATION]);
}
 
/** AxisScaleEnumeration */
static void
UA_AxisScaleEnumeration_init(UA_AxisScaleEnumeration *p) {
    memset(p, 0, sizeof(UA_AxisScaleEnumeration));
}
 
static UA_AxisScaleEnumeration *
UA_AxisScaleEnumeration_new(void) {
    return (UA_AxisScaleEnumeration*)UA_new(&UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
}
 
static UA_StatusCode
UA_AxisScaleEnumeration_copy(const UA_AxisScaleEnumeration *src, UA_AxisScaleEnumeration *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
}
 
UA_DEPRECATED static void
UA_AxisScaleEnumeration_deleteMembers(UA_AxisScaleEnumeration *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
}
 
static void
UA_AxisScaleEnumeration_clear(UA_AxisScaleEnumeration *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
}
 
static void
UA_AxisScaleEnumeration_delete(UA_AxisScaleEnumeration *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
}
 
/** ComplexNumberType */
static void
UA_ComplexNumberType_init(UA_ComplexNumberType *p) {
    memset(p, 0, sizeof(UA_ComplexNumberType));
}
 
static UA_ComplexNumberType *
UA_ComplexNumberType_new(void) {
    return (UA_ComplexNumberType*)UA_new(&UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
}
 
static UA_StatusCode
UA_ComplexNumberType_copy(const UA_ComplexNumberType *src, UA_ComplexNumberType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
}
 
UA_DEPRECATED static void
UA_ComplexNumberType_deleteMembers(UA_ComplexNumberType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
}
 
static void
UA_ComplexNumberType_clear(UA_ComplexNumberType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
}
 
static void
UA_ComplexNumberType_delete(UA_ComplexNumberType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
}
 
/** DoubleComplexNumberType */
static void
UA_DoubleComplexNumberType_init(UA_DoubleComplexNumberType *p) {
    memset(p, 0, sizeof(UA_DoubleComplexNumberType));
}
 
static UA_DoubleComplexNumberType *
UA_DoubleComplexNumberType_new(void) {
    return (UA_DoubleComplexNumberType*)UA_new(&UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
}
 
static UA_StatusCode
UA_DoubleComplexNumberType_copy(const UA_DoubleComplexNumberType *src, UA_DoubleComplexNumberType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
}
 
UA_DEPRECATED static void
UA_DoubleComplexNumberType_deleteMembers(UA_DoubleComplexNumberType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
}
 
static void
UA_DoubleComplexNumberType_clear(UA_DoubleComplexNumberType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
}
 
static void
UA_DoubleComplexNumberType_delete(UA_DoubleComplexNumberType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
}
 
/** AxisInformation */
static void
UA_AxisInformation_init(UA_AxisInformation *p) {
    memset(p, 0, sizeof(UA_AxisInformation));
}
 
static UA_AxisInformation *
UA_AxisInformation_new(void) {
    return (UA_AxisInformation*)UA_new(&UA_TYPES[UA_TYPES_AXISINFORMATION]);
}
 
static UA_StatusCode
UA_AxisInformation_copy(const UA_AxisInformation *src, UA_AxisInformation *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AXISINFORMATION]);
}
 
UA_DEPRECATED static void
UA_AxisInformation_deleteMembers(UA_AxisInformation *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_AXISINFORMATION]);
}
 
static void
UA_AxisInformation_clear(UA_AxisInformation *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_AXISINFORMATION]);
}
 
static void
UA_AxisInformation_delete(UA_AxisInformation *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_AXISINFORMATION]);
}
 
/** XVType */
static void
UA_XVType_init(UA_XVType *p) {
    memset(p, 0, sizeof(UA_XVType));
}
 
static UA_XVType *
UA_XVType_new(void) {
    return (UA_XVType*)UA_new(&UA_TYPES[UA_TYPES_XVTYPE]);
}
 
static UA_StatusCode
UA_XVType_copy(const UA_XVType *src, UA_XVType *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_XVTYPE]);
}
 
UA_DEPRECATED static void
UA_XVType_deleteMembers(UA_XVType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_XVTYPE]);
}
 
static void
UA_XVType_clear(UA_XVType *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_XVTYPE]);
}
 
static void
UA_XVType_delete(UA_XVType *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_XVTYPE]);
}
 
/** EnumDefinition */
static void
UA_EnumDefinition_init(UA_EnumDefinition *p) {
    memset(p, 0, sizeof(UA_EnumDefinition));
}
 
static UA_EnumDefinition *
UA_EnumDefinition_new(void) {
    return (UA_EnumDefinition*)UA_new(&UA_TYPES[UA_TYPES_ENUMDEFINITION]);
}
 
static UA_StatusCode
UA_EnumDefinition_copy(const UA_EnumDefinition *src, UA_EnumDefinition *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMDEFINITION]);
}
 
UA_DEPRECATED static void
UA_EnumDefinition_deleteMembers(UA_EnumDefinition *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMDEFINITION]);
}
 
static void
UA_EnumDefinition_clear(UA_EnumDefinition *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMDEFINITION]);
}
 
static void
UA_EnumDefinition_delete(UA_EnumDefinition *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENUMDEFINITION]);
}
 
/** DataChangeNotification */
static void
UA_DataChangeNotification_init(UA_DataChangeNotification *p) {
    memset(p, 0, sizeof(UA_DataChangeNotification));
}
 
static UA_DataChangeNotification *
UA_DataChangeNotification_new(void) {
    return (UA_DataChangeNotification*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
}
 
static UA_StatusCode
UA_DataChangeNotification_copy(const UA_DataChangeNotification *src, UA_DataChangeNotification *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
}
 
UA_DEPRECATED static void
UA_DataChangeNotification_deleteMembers(UA_DataChangeNotification *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
}
 
static void
UA_DataChangeNotification_clear(UA_DataChangeNotification *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
}
 
static void
UA_DataChangeNotification_delete(UA_DataChangeNotification *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
}
 
/** EventNotificationList */
static void
UA_EventNotificationList_init(UA_EventNotificationList *p) {
    memset(p, 0, sizeof(UA_EventNotificationList));
}
 
static UA_EventNotificationList *
UA_EventNotificationList_new(void) {
    return (UA_EventNotificationList*)UA_new(&UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
}
 
static UA_StatusCode
UA_EventNotificationList_copy(const UA_EventNotificationList *src, UA_EventNotificationList *dst) {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
}
 
UA_DEPRECATED static void
UA_EventNotificationList_deleteMembers(UA_EventNotificationList *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
}
 
static void
UA_EventNotificationList_clear(UA_EventNotificationList *p) {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
}
 
static void
UA_EventNotificationList_delete(UA_EventNotificationList *p) {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
}
 
#if defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 6
# pragma GCC diagnostic pop
#endif
 
_UA_END_DECLS
 
#endif /* TYPES_GENERATED_HANDLING_H_ */