/**********************************
 * Autogenerated -- do not modify *
 **********************************/

#include <open62541/types.h>

#ifndef TYPES_GENERATED_H_
#define TYPES_GENERATED_H_


_UA_BEGIN_DECLS

/**
 * Every type is assigned an index in an array containing the type descriptions.
 * These descriptions are used during type handling (copying, deletion,
 * binary encoding, ...). */
#define UA_TYPES_COUNT 448
extern UA_EXPORT UA_DataType UA_TYPES[UA_TYPES_COUNT];

/* Boolean */
#define UA_TYPES_BOOLEAN 0

UA_INLINABLE( void
UA_Boolean_init(UA_Boolean *p), {
    memset(p, 0, sizeof(UA_Boolean));
})

UA_INLINABLE( UA_Boolean *
UA_Boolean_new(void), {
    return (UA_Boolean*)UA_new(&UA_TYPES[UA_TYPES_BOOLEAN]);
})

UA_INLINABLE( UA_StatusCode
UA_Boolean_copy(const UA_Boolean *src, UA_Boolean *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BOOLEAN]);
})

UA_INLINABLE( void
UA_Boolean_clear(UA_Boolean *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BOOLEAN]);
})

UA_INLINABLE( void
UA_Boolean_delete(UA_Boolean *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BOOLEAN]);
})

UA_INLINABLE( UA_Boolean
UA_Boolean_equal(const UA_Boolean *p1, const UA_Boolean *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BOOLEAN]) == UA_ORDER_EQ);
})


/* SByte */
#define UA_TYPES_SBYTE 1

UA_INLINABLE( void
UA_SByte_init(UA_SByte *p), {
    memset(p, 0, sizeof(UA_SByte));
})

UA_INLINABLE( UA_SByte *
UA_SByte_new(void), {
    return (UA_SByte*)UA_new(&UA_TYPES[UA_TYPES_SBYTE]);
})

UA_INLINABLE( UA_StatusCode
UA_SByte_copy(const UA_SByte *src, UA_SByte *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SBYTE]);
})

UA_INLINABLE( void
UA_SByte_clear(UA_SByte *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SBYTE]);
})

UA_INLINABLE( void
UA_SByte_delete(UA_SByte *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SBYTE]);
})

UA_INLINABLE( UA_Boolean
UA_SByte_equal(const UA_SByte *p1, const UA_SByte *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SBYTE]) == UA_ORDER_EQ);
})


/* Byte */
#define UA_TYPES_BYTE 2

UA_INLINABLE( void
UA_Byte_init(UA_Byte *p), {
    memset(p, 0, sizeof(UA_Byte));
})

UA_INLINABLE( UA_Byte *
UA_Byte_new(void), {
    return (UA_Byte*)UA_new(&UA_TYPES[UA_TYPES_BYTE]);
})

UA_INLINABLE( UA_StatusCode
UA_Byte_copy(const UA_Byte *src, UA_Byte *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BYTE]);
})

UA_INLINABLE( void
UA_Byte_clear(UA_Byte *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BYTE]);
})

UA_INLINABLE( void
UA_Byte_delete(UA_Byte *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BYTE]);
})

UA_INLINABLE( UA_Boolean
UA_Byte_equal(const UA_Byte *p1, const UA_Byte *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BYTE]) == UA_ORDER_EQ);
})


/* Int16 */
#define UA_TYPES_INT16 3

UA_INLINABLE( void
UA_Int16_init(UA_Int16 *p), {
    memset(p, 0, sizeof(UA_Int16));
})

UA_INLINABLE( UA_Int16 *
UA_Int16_new(void), {
    return (UA_Int16*)UA_new(&UA_TYPES[UA_TYPES_INT16]);
})

UA_INLINABLE( UA_StatusCode
UA_Int16_copy(const UA_Int16 *src, UA_Int16 *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT16]);
})

UA_INLINABLE( void
UA_Int16_clear(UA_Int16 *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT16]);
})

UA_INLINABLE( void
UA_Int16_delete(UA_Int16 *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_INT16]);
})

UA_INLINABLE( UA_Boolean
UA_Int16_equal(const UA_Int16 *p1, const UA_Int16 *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_INT16]) == UA_ORDER_EQ);
})


/* UInt16 */
#define UA_TYPES_UINT16 4

UA_INLINABLE( void
UA_UInt16_init(UA_UInt16 *p), {
    memset(p, 0, sizeof(UA_UInt16));
})

UA_INLINABLE( UA_UInt16 *
UA_UInt16_new(void), {
    return (UA_UInt16*)UA_new(&UA_TYPES[UA_TYPES_UINT16]);
})

UA_INLINABLE( UA_StatusCode
UA_UInt16_copy(const UA_UInt16 *src, UA_UInt16 *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT16]);
})

UA_INLINABLE( void
UA_UInt16_clear(UA_UInt16 *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT16]);
})

UA_INLINABLE( void
UA_UInt16_delete(UA_UInt16 *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UINT16]);
})

UA_INLINABLE( UA_Boolean
UA_UInt16_equal(const UA_UInt16 *p1, const UA_UInt16 *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UINT16]) == UA_ORDER_EQ);
})


/* Int32 */
#define UA_TYPES_INT32 5

UA_INLINABLE( void
UA_Int32_init(UA_Int32 *p), {
    memset(p, 0, sizeof(UA_Int32));
})

UA_INLINABLE( UA_Int32 *
UA_Int32_new(void), {
    return (UA_Int32*)UA_new(&UA_TYPES[UA_TYPES_INT32]);
})

UA_INLINABLE( UA_StatusCode
UA_Int32_copy(const UA_Int32 *src, UA_Int32 *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT32]);
})

UA_INLINABLE( void
UA_Int32_clear(UA_Int32 *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT32]);
})

UA_INLINABLE( void
UA_Int32_delete(UA_Int32 *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_INT32]);
})

UA_INLINABLE( UA_Boolean
UA_Int32_equal(const UA_Int32 *p1, const UA_Int32 *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_INT32]) == UA_ORDER_EQ);
})


/* UInt32 */
#define UA_TYPES_UINT32 6

UA_INLINABLE( void
UA_UInt32_init(UA_UInt32 *p), {
    memset(p, 0, sizeof(UA_UInt32));
})

UA_INLINABLE( UA_UInt32 *
UA_UInt32_new(void), {
    return (UA_UInt32*)UA_new(&UA_TYPES[UA_TYPES_UINT32]);
})

UA_INLINABLE( UA_StatusCode
UA_UInt32_copy(const UA_UInt32 *src, UA_UInt32 *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT32]);
})

UA_INLINABLE( void
UA_UInt32_clear(UA_UInt32 *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT32]);
})

UA_INLINABLE( void
UA_UInt32_delete(UA_UInt32 *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UINT32]);
})

UA_INLINABLE( UA_Boolean
UA_UInt32_equal(const UA_UInt32 *p1, const UA_UInt32 *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UINT32]) == UA_ORDER_EQ);
})


/* Int64 */
#define UA_TYPES_INT64 7

UA_INLINABLE( void
UA_Int64_init(UA_Int64 *p), {
    memset(p, 0, sizeof(UA_Int64));
})

UA_INLINABLE( UA_Int64 *
UA_Int64_new(void), {
    return (UA_Int64*)UA_new(&UA_TYPES[UA_TYPES_INT64]);
})

UA_INLINABLE( UA_StatusCode
UA_Int64_copy(const UA_Int64 *src, UA_Int64 *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT64]);
})

UA_INLINABLE( void
UA_Int64_clear(UA_Int64 *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_INT64]);
})

UA_INLINABLE( void
UA_Int64_delete(UA_Int64 *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_INT64]);
})

UA_INLINABLE( UA_Boolean
UA_Int64_equal(const UA_Int64 *p1, const UA_Int64 *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_INT64]) == UA_ORDER_EQ);
})


/* UInt64 */
#define UA_TYPES_UINT64 8

UA_INLINABLE( void
UA_UInt64_init(UA_UInt64 *p), {
    memset(p, 0, sizeof(UA_UInt64));
})

UA_INLINABLE( UA_UInt64 *
UA_UInt64_new(void), {
    return (UA_UInt64*)UA_new(&UA_TYPES[UA_TYPES_UINT64]);
})

UA_INLINABLE( UA_StatusCode
UA_UInt64_copy(const UA_UInt64 *src, UA_UInt64 *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT64]);
})

UA_INLINABLE( void
UA_UInt64_clear(UA_UInt64 *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UINT64]);
})

UA_INLINABLE( void
UA_UInt64_delete(UA_UInt64 *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UINT64]);
})

UA_INLINABLE( UA_Boolean
UA_UInt64_equal(const UA_UInt64 *p1, const UA_UInt64 *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UINT64]) == UA_ORDER_EQ);
})


/* Float */
#define UA_TYPES_FLOAT 9

UA_INLINABLE( void
UA_Float_init(UA_Float *p), {
    memset(p, 0, sizeof(UA_Float));
})

UA_INLINABLE( UA_Float *
UA_Float_new(void), {
    return (UA_Float*)UA_new(&UA_TYPES[UA_TYPES_FLOAT]);
})

UA_INLINABLE( UA_StatusCode
UA_Float_copy(const UA_Float *src, UA_Float *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FLOAT]);
})

UA_INLINABLE( void
UA_Float_clear(UA_Float *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_FLOAT]);
})

UA_INLINABLE( void
UA_Float_delete(UA_Float *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_FLOAT]);
})

UA_INLINABLE( UA_Boolean
UA_Float_equal(const UA_Float *p1, const UA_Float *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_FLOAT]) == UA_ORDER_EQ);
})


/* Double */
#define UA_TYPES_DOUBLE 10

UA_INLINABLE( void
UA_Double_init(UA_Double *p), {
    memset(p, 0, sizeof(UA_Double));
})

UA_INLINABLE( UA_Double *
UA_Double_new(void), {
    return (UA_Double*)UA_new(&UA_TYPES[UA_TYPES_DOUBLE]);
})

UA_INLINABLE( UA_StatusCode
UA_Double_copy(const UA_Double *src, UA_Double *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DOUBLE]);
})

UA_INLINABLE( void
UA_Double_clear(UA_Double *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLE]);
})

UA_INLINABLE( void
UA_Double_delete(UA_Double *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DOUBLE]);
})

UA_INLINABLE( UA_Boolean
UA_Double_equal(const UA_Double *p1, const UA_Double *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DOUBLE]) == UA_ORDER_EQ);
})


/* String */
#define UA_TYPES_STRING 11

UA_INLINABLE( void
UA_String_init(UA_String *p), {
    memset(p, 0, sizeof(UA_String));
})

UA_INLINABLE( UA_String *
UA_String_new(void), {
    return (UA_String*)UA_new(&UA_TYPES[UA_TYPES_STRING]);
})

UA_INLINABLE( UA_StatusCode
UA_String_copy(const UA_String *src, UA_String *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRING]);
})

UA_INLINABLE( void
UA_String_clear(UA_String *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRING]);
})

UA_INLINABLE( void
UA_String_delete(UA_String *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRING]);
})

UA_INLINABLE( UA_Boolean
UA_String_equal(const UA_String *p1, const UA_String *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STRING]) == UA_ORDER_EQ);
})


/* DateTime */
#define UA_TYPES_DATETIME 12

UA_INLINABLE( void
UA_DateTime_init(UA_DateTime *p), {
    memset(p, 0, sizeof(UA_DateTime));
})

UA_INLINABLE( UA_DateTime *
UA_DateTime_new(void), {
    return (UA_DateTime*)UA_new(&UA_TYPES[UA_TYPES_DATETIME]);
})

UA_INLINABLE( UA_StatusCode
UA_DateTime_copy(const UA_DateTime *src, UA_DateTime *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATETIME]);
})

UA_INLINABLE( void
UA_DateTime_clear(UA_DateTime *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATETIME]);
})

UA_INLINABLE( void
UA_DateTime_delete(UA_DateTime *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATETIME]);
})

UA_INLINABLE( UA_Boolean
UA_DateTime_equal(const UA_DateTime *p1, const UA_DateTime *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATETIME]) == UA_ORDER_EQ);
})


/* Guid */
#define UA_TYPES_GUID 13

UA_INLINABLE( void
UA_Guid_init(UA_Guid *p), {
    memset(p, 0, sizeof(UA_Guid));
})

UA_INLINABLE( UA_Guid *
UA_Guid_new(void), {
    return (UA_Guid*)UA_new(&UA_TYPES[UA_TYPES_GUID]);
})

UA_INLINABLE( UA_StatusCode
UA_Guid_copy(const UA_Guid *src, UA_Guid *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GUID]);
})

UA_INLINABLE( void
UA_Guid_clear(UA_Guid *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_GUID]);
})

UA_INLINABLE( void
UA_Guid_delete(UA_Guid *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_GUID]);
})

UA_INLINABLE( UA_Boolean
UA_Guid_equal(const UA_Guid *p1, const UA_Guid *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_GUID]) == UA_ORDER_EQ);
})


/* ByteString */
#define UA_TYPES_BYTESTRING 14

UA_INLINABLE( void
UA_ByteString_init(UA_ByteString *p), {
    memset(p, 0, sizeof(UA_ByteString));
})

UA_INLINABLE( UA_ByteString *
UA_ByteString_new(void), {
    return (UA_ByteString*)UA_new(&UA_TYPES[UA_TYPES_BYTESTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_ByteString_copy(const UA_ByteString *src, UA_ByteString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BYTESTRING]);
})

UA_INLINABLE( void
UA_ByteString_clear(UA_ByteString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BYTESTRING]);
})

UA_INLINABLE( void
UA_ByteString_delete(UA_ByteString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BYTESTRING]);
})

UA_INLINABLE( UA_Boolean
UA_ByteString_equal(const UA_ByteString *p1, const UA_ByteString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BYTESTRING]) == UA_ORDER_EQ);
})


/* XmlElement */
#define UA_TYPES_XMLELEMENT 15

UA_INLINABLE( void
UA_XmlElement_init(UA_XmlElement *p), {
    memset(p, 0, sizeof(UA_XmlElement));
})

UA_INLINABLE( UA_XmlElement *
UA_XmlElement_new(void), {
    return (UA_XmlElement*)UA_new(&UA_TYPES[UA_TYPES_XMLELEMENT]);
})

UA_INLINABLE( UA_StatusCode
UA_XmlElement_copy(const UA_XmlElement *src, UA_XmlElement *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_XMLELEMENT]);
})

UA_INLINABLE( void
UA_XmlElement_clear(UA_XmlElement *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_XMLELEMENT]);
})

UA_INLINABLE( void
UA_XmlElement_delete(UA_XmlElement *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_XMLELEMENT]);
})

UA_INLINABLE( UA_Boolean
UA_XmlElement_equal(const UA_XmlElement *p1, const UA_XmlElement *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_XMLELEMENT]) == UA_ORDER_EQ);
})


/* NodeId */
#define UA_TYPES_NODEID 16

UA_INLINABLE( void
UA_NodeId_init(UA_NodeId *p), {
    memset(p, 0, sizeof(UA_NodeId));
})

UA_INLINABLE( UA_NodeId *
UA_NodeId_new(void), {
    return (UA_NodeId*)UA_new(&UA_TYPES[UA_TYPES_NODEID]);
})

UA_INLINABLE( UA_StatusCode
UA_NodeId_copy(const UA_NodeId *src, UA_NodeId *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEID]);
})

UA_INLINABLE( void
UA_NodeId_clear(UA_NodeId *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEID]);
})

UA_INLINABLE( void
UA_NodeId_delete(UA_NodeId *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODEID]);
})

UA_INLINABLE( UA_Boolean
UA_NodeId_equal(const UA_NodeId *p1, const UA_NodeId *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NODEID]) == UA_ORDER_EQ);
})


/* ExpandedNodeId */
#define UA_TYPES_EXPANDEDNODEID 17

UA_INLINABLE( void
UA_ExpandedNodeId_init(UA_ExpandedNodeId *p), {
    memset(p, 0, sizeof(UA_ExpandedNodeId));
})

UA_INLINABLE( UA_ExpandedNodeId *
UA_ExpandedNodeId_new(void), {
    return (UA_ExpandedNodeId*)UA_new(&UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
})

UA_INLINABLE( UA_StatusCode
UA_ExpandedNodeId_copy(const UA_ExpandedNodeId *src, UA_ExpandedNodeId *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
})

UA_INLINABLE( void
UA_ExpandedNodeId_clear(UA_ExpandedNodeId *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
})

UA_INLINABLE( void
UA_ExpandedNodeId_delete(UA_ExpandedNodeId *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]);
})

UA_INLINABLE( UA_Boolean
UA_ExpandedNodeId_equal(const UA_ExpandedNodeId *p1, const UA_ExpandedNodeId *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]) == UA_ORDER_EQ);
})


/* StatusCode */
#define UA_TYPES_STATUSCODE 18

UA_INLINABLE( void
UA_StatusCode_init(UA_StatusCode *p), {
    memset(p, 0, sizeof(UA_StatusCode));
})

UA_INLINABLE( UA_StatusCode *
UA_StatusCode_new(void), {
    return (UA_StatusCode*)UA_new(&UA_TYPES[UA_TYPES_STATUSCODE]);
})

UA_INLINABLE( UA_StatusCode
UA_StatusCode_copy(const UA_StatusCode *src, UA_StatusCode *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STATUSCODE]);
})

UA_INLINABLE( void
UA_StatusCode_clear(UA_StatusCode *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCODE]);
})

UA_INLINABLE( void
UA_StatusCode_delete(UA_StatusCode *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STATUSCODE]);
})

UA_INLINABLE( UA_Boolean
UA_StatusCode_equal(const UA_StatusCode *p1, const UA_StatusCode *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STATUSCODE]) == UA_ORDER_EQ);
})


/* QualifiedName */
#define UA_TYPES_QUALIFIEDNAME 19

UA_INLINABLE( void
UA_QualifiedName_init(UA_QualifiedName *p), {
    memset(p, 0, sizeof(UA_QualifiedName));
})

UA_INLINABLE( UA_QualifiedName *
UA_QualifiedName_new(void), {
    return (UA_QualifiedName*)UA_new(&UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
})

UA_INLINABLE( UA_StatusCode
UA_QualifiedName_copy(const UA_QualifiedName *src, UA_QualifiedName *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
})

UA_INLINABLE( void
UA_QualifiedName_clear(UA_QualifiedName *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
})

UA_INLINABLE( void
UA_QualifiedName_delete(UA_QualifiedName *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
})

UA_INLINABLE( UA_Boolean
UA_QualifiedName_equal(const UA_QualifiedName *p1, const UA_QualifiedName *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]) == UA_ORDER_EQ);
})


/* LocalizedText */
#define UA_TYPES_LOCALIZEDTEXT 20

UA_INLINABLE( void
UA_LocalizedText_init(UA_LocalizedText *p), {
    memset(p, 0, sizeof(UA_LocalizedText));
})

UA_INLINABLE( UA_LocalizedText *
UA_LocalizedText_new(void), {
    return (UA_LocalizedText*)UA_new(&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
})

UA_INLINABLE( UA_StatusCode
UA_LocalizedText_copy(const UA_LocalizedText *src, UA_LocalizedText *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
})

UA_INLINABLE( void
UA_LocalizedText_clear(UA_LocalizedText *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
})

UA_INLINABLE( void
UA_LocalizedText_delete(UA_LocalizedText *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
})

UA_INLINABLE( UA_Boolean
UA_LocalizedText_equal(const UA_LocalizedText *p1, const UA_LocalizedText *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]) == UA_ORDER_EQ);
})


/* ExtensionObject */
#define UA_TYPES_EXTENSIONOBJECT 21

UA_INLINABLE( void
UA_ExtensionObject_init(UA_ExtensionObject *p), {
    memset(p, 0, sizeof(UA_ExtensionObject));
})

UA_INLINABLE( UA_ExtensionObject *
UA_ExtensionObject_new(void), {
    return (UA_ExtensionObject*)UA_new(&UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
})

UA_INLINABLE( UA_StatusCode
UA_ExtensionObject_copy(const UA_ExtensionObject *src, UA_ExtensionObject *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
})

UA_INLINABLE( void
UA_ExtensionObject_clear(UA_ExtensionObject *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
})

UA_INLINABLE( void
UA_ExtensionObject_delete(UA_ExtensionObject *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]);
})

UA_INLINABLE( UA_Boolean
UA_ExtensionObject_equal(const UA_ExtensionObject *p1, const UA_ExtensionObject *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]) == UA_ORDER_EQ);
})


/* DataValue */
#define UA_TYPES_DATAVALUE 22

UA_INLINABLE( void
UA_DataValue_init(UA_DataValue *p), {
    memset(p, 0, sizeof(UA_DataValue));
})

UA_INLINABLE( UA_DataValue *
UA_DataValue_new(void), {
    return (UA_DataValue*)UA_new(&UA_TYPES[UA_TYPES_DATAVALUE]);
})

UA_INLINABLE( UA_StatusCode
UA_DataValue_copy(const UA_DataValue *src, UA_DataValue *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAVALUE]);
})

UA_INLINABLE( void
UA_DataValue_clear(UA_DataValue *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATAVALUE]);
})

UA_INLINABLE( void
UA_DataValue_delete(UA_DataValue *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATAVALUE]);
})

UA_INLINABLE( UA_Boolean
UA_DataValue_equal(const UA_DataValue *p1, const UA_DataValue *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATAVALUE]) == UA_ORDER_EQ);
})


/* Variant */
#define UA_TYPES_VARIANT 23

UA_INLINABLE( void
UA_Variant_init(UA_Variant *p), {
    memset(p, 0, sizeof(UA_Variant));
})

UA_INLINABLE( UA_Variant *
UA_Variant_new(void), {
    return (UA_Variant*)UA_new(&UA_TYPES[UA_TYPES_VARIANT]);
})

UA_INLINABLE( UA_StatusCode
UA_Variant_copy(const UA_Variant *src, UA_Variant *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIANT]);
})

UA_INLINABLE( void
UA_Variant_clear(UA_Variant *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIANT]);
})

UA_INLINABLE( void
UA_Variant_delete(UA_Variant *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_VARIANT]);
})

UA_INLINABLE( UA_Boolean
UA_Variant_equal(const UA_Variant *p1, const UA_Variant *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_VARIANT]) == UA_ORDER_EQ);
})


/* DiagnosticInfo */
#define UA_TYPES_DIAGNOSTICINFO 24

UA_INLINABLE( void
UA_DiagnosticInfo_init(UA_DiagnosticInfo *p), {
    memset(p, 0, sizeof(UA_DiagnosticInfo));
})

UA_INLINABLE( UA_DiagnosticInfo *
UA_DiagnosticInfo_new(void), {
    return (UA_DiagnosticInfo*)UA_new(&UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
})

UA_INLINABLE( UA_StatusCode
UA_DiagnosticInfo_copy(const UA_DiagnosticInfo *src, UA_DiagnosticInfo *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
})

UA_INLINABLE( void
UA_DiagnosticInfo_clear(UA_DiagnosticInfo *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
})

UA_INLINABLE( void
UA_DiagnosticInfo_delete(UA_DiagnosticInfo *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]);
})

UA_INLINABLE( UA_Boolean
UA_DiagnosticInfo_equal(const UA_DiagnosticInfo *p1, const UA_DiagnosticInfo *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]) == UA_ORDER_EQ);
})


/* NamingRuleType */
typedef enum {
    UA_NAMINGRULETYPE_MANDATORY = 1,
    UA_NAMINGRULETYPE_OPTIONAL = 2,
    UA_NAMINGRULETYPE_CONSTRAINT = 3,
    __UA_NAMINGRULETYPE_FORCE32BIT = 0x7fffffff
} UA_NamingRuleType;

UA_STATIC_ASSERT(sizeof(UA_NamingRuleType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_NAMINGRULETYPE 25

UA_INLINABLE( void
UA_NamingRuleType_init(UA_NamingRuleType *p), {
    memset(p, 0, sizeof(UA_NamingRuleType));
})

UA_INLINABLE( UA_NamingRuleType *
UA_NamingRuleType_new(void), {
    return (UA_NamingRuleType*)UA_new(&UA_TYPES[UA_TYPES_NAMINGRULETYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_NamingRuleType_copy(const UA_NamingRuleType *src, UA_NamingRuleType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NAMINGRULETYPE]);
})

UA_INLINABLE( void
UA_NamingRuleType_clear(UA_NamingRuleType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NAMINGRULETYPE]);
})

UA_INLINABLE( void
UA_NamingRuleType_delete(UA_NamingRuleType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NAMINGRULETYPE]);
})

UA_INLINABLE( UA_Boolean
UA_NamingRuleType_equal(const UA_NamingRuleType *p1, const UA_NamingRuleType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NAMINGRULETYPE]) == UA_ORDER_EQ);
})


/* Enumeration */
typedef enum {
    __UA_ENUMERATION_FORCE32BIT = 0x7fffffff
} UA_Enumeration;

UA_STATIC_ASSERT(sizeof(UA_Enumeration) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_ENUMERATION 26

UA_INLINABLE( void
UA_Enumeration_init(UA_Enumeration *p), {
    memset(p, 0, sizeof(UA_Enumeration));
})

UA_INLINABLE( UA_Enumeration *
UA_Enumeration_new(void), {
    return (UA_Enumeration*)UA_new(&UA_TYPES[UA_TYPES_ENUMERATION]);
})

UA_INLINABLE( UA_StatusCode
UA_Enumeration_copy(const UA_Enumeration *src, UA_Enumeration *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMERATION]);
})

UA_INLINABLE( void
UA_Enumeration_clear(UA_Enumeration *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMERATION]);
})

UA_INLINABLE( void
UA_Enumeration_delete(UA_Enumeration *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENUMERATION]);
})

UA_INLINABLE( UA_Boolean
UA_Enumeration_equal(const UA_Enumeration *p1, const UA_Enumeration *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENUMERATION]) == UA_ORDER_EQ);
})


/* ImageBMP */
typedef UA_ByteString UA_ImageBMP;

#define UA_TYPES_IMAGEBMP 27

UA_INLINABLE( void
UA_ImageBMP_init(UA_ImageBMP *p), {
    memset(p, 0, sizeof(UA_ImageBMP));
})

UA_INLINABLE( UA_ImageBMP *
UA_ImageBMP_new(void), {
    return (UA_ImageBMP*)UA_new(&UA_TYPES[UA_TYPES_IMAGEBMP]);
})

UA_INLINABLE( UA_StatusCode
UA_ImageBMP_copy(const UA_ImageBMP *src, UA_ImageBMP *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_IMAGEBMP]);
})

UA_INLINABLE( void
UA_ImageBMP_clear(UA_ImageBMP *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_IMAGEBMP]);
})

UA_INLINABLE( void
UA_ImageBMP_delete(UA_ImageBMP *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_IMAGEBMP]);
})

UA_INLINABLE( UA_Boolean
UA_ImageBMP_equal(const UA_ImageBMP *p1, const UA_ImageBMP *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_IMAGEBMP]) == UA_ORDER_EQ);
})


/* ImageGIF */
typedef UA_ByteString UA_ImageGIF;

#define UA_TYPES_IMAGEGIF 28

UA_INLINABLE( void
UA_ImageGIF_init(UA_ImageGIF *p), {
    memset(p, 0, sizeof(UA_ImageGIF));
})

UA_INLINABLE( UA_ImageGIF *
UA_ImageGIF_new(void), {
    return (UA_ImageGIF*)UA_new(&UA_TYPES[UA_TYPES_IMAGEGIF]);
})

UA_INLINABLE( UA_StatusCode
UA_ImageGIF_copy(const UA_ImageGIF *src, UA_ImageGIF *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_IMAGEGIF]);
})

UA_INLINABLE( void
UA_ImageGIF_clear(UA_ImageGIF *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_IMAGEGIF]);
})

UA_INLINABLE( void
UA_ImageGIF_delete(UA_ImageGIF *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_IMAGEGIF]);
})

UA_INLINABLE( UA_Boolean
UA_ImageGIF_equal(const UA_ImageGIF *p1, const UA_ImageGIF *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_IMAGEGIF]) == UA_ORDER_EQ);
})


/* ImageJPG */
typedef UA_ByteString UA_ImageJPG;

#define UA_TYPES_IMAGEJPG 29

UA_INLINABLE( void
UA_ImageJPG_init(UA_ImageJPG *p), {
    memset(p, 0, sizeof(UA_ImageJPG));
})

UA_INLINABLE( UA_ImageJPG *
UA_ImageJPG_new(void), {
    return (UA_ImageJPG*)UA_new(&UA_TYPES[UA_TYPES_IMAGEJPG]);
})

UA_INLINABLE( UA_StatusCode
UA_ImageJPG_copy(const UA_ImageJPG *src, UA_ImageJPG *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_IMAGEJPG]);
})

UA_INLINABLE( void
UA_ImageJPG_clear(UA_ImageJPG *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_IMAGEJPG]);
})

UA_INLINABLE( void
UA_ImageJPG_delete(UA_ImageJPG *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_IMAGEJPG]);
})

UA_INLINABLE( UA_Boolean
UA_ImageJPG_equal(const UA_ImageJPG *p1, const UA_ImageJPG *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_IMAGEJPG]) == UA_ORDER_EQ);
})


/* ImagePNG */
typedef UA_ByteString UA_ImagePNG;

#define UA_TYPES_IMAGEPNG 30

UA_INLINABLE( void
UA_ImagePNG_init(UA_ImagePNG *p), {
    memset(p, 0, sizeof(UA_ImagePNG));
})

UA_INLINABLE( UA_ImagePNG *
UA_ImagePNG_new(void), {
    return (UA_ImagePNG*)UA_new(&UA_TYPES[UA_TYPES_IMAGEPNG]);
})

UA_INLINABLE( UA_StatusCode
UA_ImagePNG_copy(const UA_ImagePNG *src, UA_ImagePNG *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_IMAGEPNG]);
})

UA_INLINABLE( void
UA_ImagePNG_clear(UA_ImagePNG *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_IMAGEPNG]);
})

UA_INLINABLE( void
UA_ImagePNG_delete(UA_ImagePNG *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_IMAGEPNG]);
})

UA_INLINABLE( UA_Boolean
UA_ImagePNG_equal(const UA_ImagePNG *p1, const UA_ImagePNG *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_IMAGEPNG]) == UA_ORDER_EQ);
})


/* AudioDataType */
typedef UA_ByteString UA_AudioDataType;

#define UA_TYPES_AUDIODATATYPE 31

UA_INLINABLE( void
UA_AudioDataType_init(UA_AudioDataType *p), {
    memset(p, 0, sizeof(UA_AudioDataType));
})

UA_INLINABLE( UA_AudioDataType *
UA_AudioDataType_new(void), {
    return (UA_AudioDataType*)UA_new(&UA_TYPES[UA_TYPES_AUDIODATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_AudioDataType_copy(const UA_AudioDataType *src, UA_AudioDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AUDIODATATYPE]);
})

UA_INLINABLE( void
UA_AudioDataType_clear(UA_AudioDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_AUDIODATATYPE]);
})

UA_INLINABLE( void
UA_AudioDataType_delete(UA_AudioDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_AUDIODATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_AudioDataType_equal(const UA_AudioDataType *p1, const UA_AudioDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_AUDIODATATYPE]) == UA_ORDER_EQ);
})


/* UriString */
typedef UA_String UA_UriString;

#define UA_TYPES_URISTRING 32

UA_INLINABLE( void
UA_UriString_init(UA_UriString *p), {
    memset(p, 0, sizeof(UA_UriString));
})

UA_INLINABLE( UA_UriString *
UA_UriString_new(void), {
    return (UA_UriString*)UA_new(&UA_TYPES[UA_TYPES_URISTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_UriString_copy(const UA_UriString *src, UA_UriString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_URISTRING]);
})

UA_INLINABLE( void
UA_UriString_clear(UA_UriString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_URISTRING]);
})

UA_INLINABLE( void
UA_UriString_delete(UA_UriString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_URISTRING]);
})

UA_INLINABLE( UA_Boolean
UA_UriString_equal(const UA_UriString *p1, const UA_UriString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_URISTRING]) == UA_ORDER_EQ);
})


/* RedundantServerMode */
typedef enum {
    UA_REDUNDANTSERVERMODE_PRIMARYWITHBACKUP = 0,
    UA_REDUNDANTSERVERMODE_PRIMARYONLY = 1,
    UA_REDUNDANTSERVERMODE_BACKUPREADY = 2,
    UA_REDUNDANTSERVERMODE_BACKUPNOTREADY = 3,
    __UA_REDUNDANTSERVERMODE_FORCE32BIT = 0x7fffffff
} UA_RedundantServerMode;

UA_STATIC_ASSERT(sizeof(UA_RedundantServerMode) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_REDUNDANTSERVERMODE 33

UA_INLINABLE( void
UA_RedundantServerMode_init(UA_RedundantServerMode *p), {
    memset(p, 0, sizeof(UA_RedundantServerMode));
})

UA_INLINABLE( UA_RedundantServerMode *
UA_RedundantServerMode_new(void), {
    return (UA_RedundantServerMode*)UA_new(&UA_TYPES[UA_TYPES_REDUNDANTSERVERMODE]);
})

UA_INLINABLE( UA_StatusCode
UA_RedundantServerMode_copy(const UA_RedundantServerMode *src, UA_RedundantServerMode *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REDUNDANTSERVERMODE]);
})

UA_INLINABLE( void
UA_RedundantServerMode_clear(UA_RedundantServerMode *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REDUNDANTSERVERMODE]);
})

UA_INLINABLE( void
UA_RedundantServerMode_delete(UA_RedundantServerMode *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REDUNDANTSERVERMODE]);
})

UA_INLINABLE( UA_Boolean
UA_RedundantServerMode_equal(const UA_RedundantServerMode *p1, const UA_RedundantServerMode *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REDUNDANTSERVERMODE]) == UA_ORDER_EQ);
})


/* BitFieldMaskDataType */
typedef UA_UInt64 UA_BitFieldMaskDataType;

#define UA_TYPES_BITFIELDMASKDATATYPE 34

UA_INLINABLE( void
UA_BitFieldMaskDataType_init(UA_BitFieldMaskDataType *p), {
    memset(p, 0, sizeof(UA_BitFieldMaskDataType));
})

UA_INLINABLE( UA_BitFieldMaskDataType *
UA_BitFieldMaskDataType_new(void), {
    return (UA_BitFieldMaskDataType*)UA_new(&UA_TYPES[UA_TYPES_BITFIELDMASKDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_BitFieldMaskDataType_copy(const UA_BitFieldMaskDataType *src, UA_BitFieldMaskDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BITFIELDMASKDATATYPE]);
})

UA_INLINABLE( void
UA_BitFieldMaskDataType_clear(UA_BitFieldMaskDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BITFIELDMASKDATATYPE]);
})

UA_INLINABLE( void
UA_BitFieldMaskDataType_delete(UA_BitFieldMaskDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BITFIELDMASKDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_BitFieldMaskDataType_equal(const UA_BitFieldMaskDataType *p1, const UA_BitFieldMaskDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BITFIELDMASKDATATYPE]) == UA_ORDER_EQ);
})


/* SemanticVersionString */
typedef UA_String UA_SemanticVersionString;

#define UA_TYPES_SEMANTICVERSIONSTRING 35

UA_INLINABLE( void
UA_SemanticVersionString_init(UA_SemanticVersionString *p), {
    memset(p, 0, sizeof(UA_SemanticVersionString));
})

UA_INLINABLE( UA_SemanticVersionString *
UA_SemanticVersionString_new(void), {
    return (UA_SemanticVersionString*)UA_new(&UA_TYPES[UA_TYPES_SEMANTICVERSIONSTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_SemanticVersionString_copy(const UA_SemanticVersionString *src, UA_SemanticVersionString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SEMANTICVERSIONSTRING]);
})

UA_INLINABLE( void
UA_SemanticVersionString_clear(UA_SemanticVersionString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SEMANTICVERSIONSTRING]);
})

UA_INLINABLE( void
UA_SemanticVersionString_delete(UA_SemanticVersionString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SEMANTICVERSIONSTRING]);
})

UA_INLINABLE( UA_Boolean
UA_SemanticVersionString_equal(const UA_SemanticVersionString *p1, const UA_SemanticVersionString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SEMANTICVERSIONSTRING]) == UA_ORDER_EQ);
})


/* KeyValuePair */
typedef struct {
    UA_QualifiedName key;
    UA_Variant value;
} UA_KeyValuePair;

#define UA_TYPES_KEYVALUEPAIR 36

UA_INLINABLE( void
UA_KeyValuePair_init(UA_KeyValuePair *p), {
    memset(p, 0, sizeof(UA_KeyValuePair));
})

UA_INLINABLE( UA_KeyValuePair *
UA_KeyValuePair_new(void), {
    return (UA_KeyValuePair*)UA_new(&UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
})

UA_INLINABLE( UA_StatusCode
UA_KeyValuePair_copy(const UA_KeyValuePair *src, UA_KeyValuePair *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
})

UA_INLINABLE( void
UA_KeyValuePair_clear(UA_KeyValuePair *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
})

UA_INLINABLE( void
UA_KeyValuePair_delete(UA_KeyValuePair *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]);
})

UA_INLINABLE( UA_Boolean
UA_KeyValuePair_equal(const UA_KeyValuePair *p1, const UA_KeyValuePair *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]) == UA_ORDER_EQ);
})


/* AdditionalParametersType */
typedef struct {
    size_t parametersSize;
    UA_KeyValuePair *parameters;
} UA_AdditionalParametersType;

#define UA_TYPES_ADDITIONALPARAMETERSTYPE 37

UA_INLINABLE( void
UA_AdditionalParametersType_init(UA_AdditionalParametersType *p), {
    memset(p, 0, sizeof(UA_AdditionalParametersType));
})

UA_INLINABLE( UA_AdditionalParametersType *
UA_AdditionalParametersType_new(void), {
    return (UA_AdditionalParametersType*)UA_new(&UA_TYPES[UA_TYPES_ADDITIONALPARAMETERSTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_AdditionalParametersType_copy(const UA_AdditionalParametersType *src, UA_AdditionalParametersType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDITIONALPARAMETERSTYPE]);
})

UA_INLINABLE( void
UA_AdditionalParametersType_clear(UA_AdditionalParametersType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDITIONALPARAMETERSTYPE]);
})

UA_INLINABLE( void
UA_AdditionalParametersType_delete(UA_AdditionalParametersType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDITIONALPARAMETERSTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_AdditionalParametersType_equal(const UA_AdditionalParametersType *p1, const UA_AdditionalParametersType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ADDITIONALPARAMETERSTYPE]) == UA_ORDER_EQ);
})


/* EphemeralKeyType */
typedef struct {
    UA_ByteString publicKey;
    UA_ByteString signature;
} UA_EphemeralKeyType;

#define UA_TYPES_EPHEMERALKEYTYPE 38

UA_INLINABLE( void
UA_EphemeralKeyType_init(UA_EphemeralKeyType *p), {
    memset(p, 0, sizeof(UA_EphemeralKeyType));
})

UA_INLINABLE( UA_EphemeralKeyType *
UA_EphemeralKeyType_new(void), {
    return (UA_EphemeralKeyType*)UA_new(&UA_TYPES[UA_TYPES_EPHEMERALKEYTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_EphemeralKeyType_copy(const UA_EphemeralKeyType *src, UA_EphemeralKeyType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EPHEMERALKEYTYPE]);
})

UA_INLINABLE( void
UA_EphemeralKeyType_clear(UA_EphemeralKeyType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EPHEMERALKEYTYPE]);
})

UA_INLINABLE( void
UA_EphemeralKeyType_delete(UA_EphemeralKeyType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EPHEMERALKEYTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_EphemeralKeyType_equal(const UA_EphemeralKeyType *p1, const UA_EphemeralKeyType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EPHEMERALKEYTYPE]) == UA_ORDER_EQ);
})


/* Handle */
typedef UA_ByteString UA_Handle;

#define UA_TYPES_HANDLE 39

UA_INLINABLE( void
UA_Handle_init(UA_Handle *p), {
    memset(p, 0, sizeof(UA_Handle));
})

UA_INLINABLE( UA_Handle *
UA_Handle_new(void), {
    return (UA_Handle*)UA_new(&UA_TYPES[UA_TYPES_HANDLE]);
})

UA_INLINABLE( UA_StatusCode
UA_Handle_copy(const UA_Handle *src, UA_Handle *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HANDLE]);
})

UA_INLINABLE( void
UA_Handle_clear(UA_Handle *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HANDLE]);
})

UA_INLINABLE( void
UA_Handle_delete(UA_Handle *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HANDLE]);
})

UA_INLINABLE( UA_Boolean
UA_Handle_equal(const UA_Handle *p1, const UA_Handle *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HANDLE]) == UA_ORDER_EQ);
})


/* TrimmedString */
typedef UA_ByteString UA_TrimmedString;

#define UA_TYPES_TRIMMEDSTRING 40

UA_INLINABLE( void
UA_TrimmedString_init(UA_TrimmedString *p), {
    memset(p, 0, sizeof(UA_TrimmedString));
})

UA_INLINABLE( UA_TrimmedString *
UA_TrimmedString_new(void), {
    return (UA_TrimmedString*)UA_new(&UA_TYPES[UA_TYPES_TRIMMEDSTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_TrimmedString_copy(const UA_TrimmedString *src, UA_TrimmedString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRIMMEDSTRING]);
})

UA_INLINABLE( void
UA_TrimmedString_clear(UA_TrimmedString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRIMMEDSTRING]);
})

UA_INLINABLE( void
UA_TrimmedString_delete(UA_TrimmedString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRIMMEDSTRING]);
})

UA_INLINABLE( UA_Boolean
UA_TrimmedString_equal(const UA_TrimmedString *p1, const UA_TrimmedString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRIMMEDSTRING]) == UA_ORDER_EQ);
})


/* BitFieldDefinition */
typedef struct {
    UA_String name;
    UA_LocalizedText description;
    UA_Boolean reserved;
    UA_UInt32 startingBitPosition;
    UA_UInt32 endingBitPosition;
} UA_BitFieldDefinition;

#define UA_TYPES_BITFIELDDEFINITION 41

UA_INLINABLE( void
UA_BitFieldDefinition_init(UA_BitFieldDefinition *p), {
    memset(p, 0, sizeof(UA_BitFieldDefinition));
})

UA_INLINABLE( UA_BitFieldDefinition *
UA_BitFieldDefinition_new(void), {
    return (UA_BitFieldDefinition*)UA_new(&UA_TYPES[UA_TYPES_BITFIELDDEFINITION]);
})

UA_INLINABLE( UA_StatusCode
UA_BitFieldDefinition_copy(const UA_BitFieldDefinition *src, UA_BitFieldDefinition *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BITFIELDDEFINITION]);
})

UA_INLINABLE( void
UA_BitFieldDefinition_clear(UA_BitFieldDefinition *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BITFIELDDEFINITION]);
})

UA_INLINABLE( void
UA_BitFieldDefinition_delete(UA_BitFieldDefinition *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BITFIELDDEFINITION]);
})

UA_INLINABLE( UA_Boolean
UA_BitFieldDefinition_equal(const UA_BitFieldDefinition *p1, const UA_BitFieldDefinition *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BITFIELDDEFINITION]) == UA_ORDER_EQ);
})


/* RationalNumber */
typedef struct {
    UA_Int32 numerator;
    UA_UInt32 denominator;
} UA_RationalNumber;

#define UA_TYPES_RATIONALNUMBER 42

UA_INLINABLE( void
UA_RationalNumber_init(UA_RationalNumber *p), {
    memset(p, 0, sizeof(UA_RationalNumber));
})

UA_INLINABLE( UA_RationalNumber *
UA_RationalNumber_new(void), {
    return (UA_RationalNumber*)UA_new(&UA_TYPES[UA_TYPES_RATIONALNUMBER]);
})

UA_INLINABLE( UA_StatusCode
UA_RationalNumber_copy(const UA_RationalNumber *src, UA_RationalNumber *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RATIONALNUMBER]);
})

UA_INLINABLE( void
UA_RationalNumber_clear(UA_RationalNumber *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_RATIONALNUMBER]);
})

UA_INLINABLE( void
UA_RationalNumber_delete(UA_RationalNumber *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_RATIONALNUMBER]);
})

UA_INLINABLE( UA_Boolean
UA_RationalNumber_equal(const UA_RationalNumber *p1, const UA_RationalNumber *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_RATIONALNUMBER]) == UA_ORDER_EQ);
})


/* ThreeDVector */
typedef struct {
    UA_Double x;
    UA_Double y;
    UA_Double z;
} UA_ThreeDVector;

#define UA_TYPES_THREEDVECTOR 43

UA_INLINABLE( void
UA_ThreeDVector_init(UA_ThreeDVector *p), {
    memset(p, 0, sizeof(UA_ThreeDVector));
})

UA_INLINABLE( UA_ThreeDVector *
UA_ThreeDVector_new(void), {
    return (UA_ThreeDVector*)UA_new(&UA_TYPES[UA_TYPES_THREEDVECTOR]);
})

UA_INLINABLE( UA_StatusCode
UA_ThreeDVector_copy(const UA_ThreeDVector *src, UA_ThreeDVector *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_THREEDVECTOR]);
})

UA_INLINABLE( void
UA_ThreeDVector_clear(UA_ThreeDVector *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_THREEDVECTOR]);
})

UA_INLINABLE( void
UA_ThreeDVector_delete(UA_ThreeDVector *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_THREEDVECTOR]);
})

UA_INLINABLE( UA_Boolean
UA_ThreeDVector_equal(const UA_ThreeDVector *p1, const UA_ThreeDVector *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_THREEDVECTOR]) == UA_ORDER_EQ);
})


/* ThreeDCartesianCoordinates */
typedef struct {
    UA_Double x;
    UA_Double y;
    UA_Double z;
} UA_ThreeDCartesianCoordinates;

#define UA_TYPES_THREEDCARTESIANCOORDINATES 44

UA_INLINABLE( void
UA_ThreeDCartesianCoordinates_init(UA_ThreeDCartesianCoordinates *p), {
    memset(p, 0, sizeof(UA_ThreeDCartesianCoordinates));
})

UA_INLINABLE( UA_ThreeDCartesianCoordinates *
UA_ThreeDCartesianCoordinates_new(void), {
    return (UA_ThreeDCartesianCoordinates*)UA_new(&UA_TYPES[UA_TYPES_THREEDCARTESIANCOORDINATES]);
})

UA_INLINABLE( UA_StatusCode
UA_ThreeDCartesianCoordinates_copy(const UA_ThreeDCartesianCoordinates *src, UA_ThreeDCartesianCoordinates *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_THREEDCARTESIANCOORDINATES]);
})

UA_INLINABLE( void
UA_ThreeDCartesianCoordinates_clear(UA_ThreeDCartesianCoordinates *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_THREEDCARTESIANCOORDINATES]);
})

UA_INLINABLE( void
UA_ThreeDCartesianCoordinates_delete(UA_ThreeDCartesianCoordinates *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_THREEDCARTESIANCOORDINATES]);
})

UA_INLINABLE( UA_Boolean
UA_ThreeDCartesianCoordinates_equal(const UA_ThreeDCartesianCoordinates *p1, const UA_ThreeDCartesianCoordinates *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_THREEDCARTESIANCOORDINATES]) == UA_ORDER_EQ);
})


/* ThreeDOrientation */
typedef struct {
    UA_Double a;
    UA_Double b;
    UA_Double c;
} UA_ThreeDOrientation;

#define UA_TYPES_THREEDORIENTATION 45

UA_INLINABLE( void
UA_ThreeDOrientation_init(UA_ThreeDOrientation *p), {
    memset(p, 0, sizeof(UA_ThreeDOrientation));
})

UA_INLINABLE( UA_ThreeDOrientation *
UA_ThreeDOrientation_new(void), {
    return (UA_ThreeDOrientation*)UA_new(&UA_TYPES[UA_TYPES_THREEDORIENTATION]);
})

UA_INLINABLE( UA_StatusCode
UA_ThreeDOrientation_copy(const UA_ThreeDOrientation *src, UA_ThreeDOrientation *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_THREEDORIENTATION]);
})

UA_INLINABLE( void
UA_ThreeDOrientation_clear(UA_ThreeDOrientation *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_THREEDORIENTATION]);
})

UA_INLINABLE( void
UA_ThreeDOrientation_delete(UA_ThreeDOrientation *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_THREEDORIENTATION]);
})

UA_INLINABLE( UA_Boolean
UA_ThreeDOrientation_equal(const UA_ThreeDOrientation *p1, const UA_ThreeDOrientation *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_THREEDORIENTATION]) == UA_ORDER_EQ);
})


/* ThreeDFrame */
typedef struct {
    UA_ThreeDCartesianCoordinates cartesianCoordinates;
    UA_ThreeDOrientation orientation;
} UA_ThreeDFrame;

#define UA_TYPES_THREEDFRAME 46

UA_INLINABLE( void
UA_ThreeDFrame_init(UA_ThreeDFrame *p), {
    memset(p, 0, sizeof(UA_ThreeDFrame));
})

UA_INLINABLE( UA_ThreeDFrame *
UA_ThreeDFrame_new(void), {
    return (UA_ThreeDFrame*)UA_new(&UA_TYPES[UA_TYPES_THREEDFRAME]);
})

UA_INLINABLE( UA_StatusCode
UA_ThreeDFrame_copy(const UA_ThreeDFrame *src, UA_ThreeDFrame *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_THREEDFRAME]);
})

UA_INLINABLE( void
UA_ThreeDFrame_clear(UA_ThreeDFrame *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_THREEDFRAME]);
})

UA_INLINABLE( void
UA_ThreeDFrame_delete(UA_ThreeDFrame *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_THREEDFRAME]);
})

UA_INLINABLE( UA_Boolean
UA_ThreeDFrame_equal(const UA_ThreeDFrame *p1, const UA_ThreeDFrame *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_THREEDFRAME]) == UA_ORDER_EQ);
})


/* OpenFileMode */
typedef enum {
    UA_OPENFILEMODE_READ = 1,
    UA_OPENFILEMODE_WRITE = 2,
    UA_OPENFILEMODE_ERASEEXISTING = 4,
    UA_OPENFILEMODE_APPEND = 8,
    __UA_OPENFILEMODE_FORCE32BIT = 0x7fffffff
} UA_OpenFileMode;

UA_STATIC_ASSERT(sizeof(UA_OpenFileMode) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_OPENFILEMODE 47

UA_INLINABLE( void
UA_OpenFileMode_init(UA_OpenFileMode *p), {
    memset(p, 0, sizeof(UA_OpenFileMode));
})

UA_INLINABLE( UA_OpenFileMode *
UA_OpenFileMode_new(void), {
    return (UA_OpenFileMode*)UA_new(&UA_TYPES[UA_TYPES_OPENFILEMODE]);
})

UA_INLINABLE( UA_StatusCode
UA_OpenFileMode_copy(const UA_OpenFileMode *src, UA_OpenFileMode *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPENFILEMODE]);
})

UA_INLINABLE( void
UA_OpenFileMode_clear(UA_OpenFileMode *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPENFILEMODE]);
})

UA_INLINABLE( void
UA_OpenFileMode_delete(UA_OpenFileMode *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_OPENFILEMODE]);
})

UA_INLINABLE( UA_Boolean
UA_OpenFileMode_equal(const UA_OpenFileMode *p1, const UA_OpenFileMode *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_OPENFILEMODE]) == UA_ORDER_EQ);
})


/* IdentityCriteriaType */
typedef enum {
    UA_IDENTITYCRITERIATYPE_USERNAME = 1,
    UA_IDENTITYCRITERIATYPE_THUMBPRINT = 2,
    UA_IDENTITYCRITERIATYPE_ROLE = 3,
    UA_IDENTITYCRITERIATYPE_GROUPID = 4,
    UA_IDENTITYCRITERIATYPE_ANONYMOUS = 5,
    UA_IDENTITYCRITERIATYPE_AUTHENTICATEDUSER = 6,
    UA_IDENTITYCRITERIATYPE_APPLICATION = 7,
    UA_IDENTITYCRITERIATYPE_X509SUBJECT = 8,
    UA_IDENTITYCRITERIATYPE_TRUSTEDAPPLICATION = 9,
    __UA_IDENTITYCRITERIATYPE_FORCE32BIT = 0x7fffffff
} UA_IdentityCriteriaType;

UA_STATIC_ASSERT(sizeof(UA_IdentityCriteriaType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_IDENTITYCRITERIATYPE 48

UA_INLINABLE( void
UA_IdentityCriteriaType_init(UA_IdentityCriteriaType *p), {
    memset(p, 0, sizeof(UA_IdentityCriteriaType));
})

UA_INLINABLE( UA_IdentityCriteriaType *
UA_IdentityCriteriaType_new(void), {
    return (UA_IdentityCriteriaType*)UA_new(&UA_TYPES[UA_TYPES_IDENTITYCRITERIATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_IdentityCriteriaType_copy(const UA_IdentityCriteriaType *src, UA_IdentityCriteriaType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_IDENTITYCRITERIATYPE]);
})

UA_INLINABLE( void
UA_IdentityCriteriaType_clear(UA_IdentityCriteriaType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_IDENTITYCRITERIATYPE]);
})

UA_INLINABLE( void
UA_IdentityCriteriaType_delete(UA_IdentityCriteriaType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_IDENTITYCRITERIATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_IdentityCriteriaType_equal(const UA_IdentityCriteriaType *p1, const UA_IdentityCriteriaType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_IDENTITYCRITERIATYPE]) == UA_ORDER_EQ);
})


/* IdentityMappingRuleType */
typedef struct {
    UA_IdentityCriteriaType criteriaType;
    UA_String criteria;
} UA_IdentityMappingRuleType;

#define UA_TYPES_IDENTITYMAPPINGRULETYPE 49

UA_INLINABLE( void
UA_IdentityMappingRuleType_init(UA_IdentityMappingRuleType *p), {
    memset(p, 0, sizeof(UA_IdentityMappingRuleType));
})

UA_INLINABLE( UA_IdentityMappingRuleType *
UA_IdentityMappingRuleType_new(void), {
    return (UA_IdentityMappingRuleType*)UA_new(&UA_TYPES[UA_TYPES_IDENTITYMAPPINGRULETYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_IdentityMappingRuleType_copy(const UA_IdentityMappingRuleType *src, UA_IdentityMappingRuleType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_IDENTITYMAPPINGRULETYPE]);
})

UA_INLINABLE( void
UA_IdentityMappingRuleType_clear(UA_IdentityMappingRuleType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_IDENTITYMAPPINGRULETYPE]);
})

UA_INLINABLE( void
UA_IdentityMappingRuleType_delete(UA_IdentityMappingRuleType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_IDENTITYMAPPINGRULETYPE]);
})

UA_INLINABLE( UA_Boolean
UA_IdentityMappingRuleType_equal(const UA_IdentityMappingRuleType *p1, const UA_IdentityMappingRuleType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_IDENTITYMAPPINGRULETYPE]) == UA_ORDER_EQ);
})


/* CurrencyUnitType */
typedef struct {
    UA_Int16 numericCode;
    UA_SByte exponent;
    UA_String alphabeticCode;
    UA_LocalizedText currency;
} UA_CurrencyUnitType;

#define UA_TYPES_CURRENCYUNITTYPE 50

UA_INLINABLE( void
UA_CurrencyUnitType_init(UA_CurrencyUnitType *p), {
    memset(p, 0, sizeof(UA_CurrencyUnitType));
})

UA_INLINABLE( UA_CurrencyUnitType *
UA_CurrencyUnitType_new(void), {
    return (UA_CurrencyUnitType*)UA_new(&UA_TYPES[UA_TYPES_CURRENCYUNITTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_CurrencyUnitType_copy(const UA_CurrencyUnitType *src, UA_CurrencyUnitType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CURRENCYUNITTYPE]);
})

UA_INLINABLE( void
UA_CurrencyUnitType_clear(UA_CurrencyUnitType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CURRENCYUNITTYPE]);
})

UA_INLINABLE( void
UA_CurrencyUnitType_delete(UA_CurrencyUnitType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CURRENCYUNITTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_CurrencyUnitType_equal(const UA_CurrencyUnitType *p1, const UA_CurrencyUnitType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CURRENCYUNITTYPE]) == UA_ORDER_EQ);
})


/* AnnotationDataType */
typedef struct {
    UA_String annotation;
    UA_String discipline;
    UA_String uri;
} UA_AnnotationDataType;

#define UA_TYPES_ANNOTATIONDATATYPE 51

UA_INLINABLE( void
UA_AnnotationDataType_init(UA_AnnotationDataType *p), {
    memset(p, 0, sizeof(UA_AnnotationDataType));
})

UA_INLINABLE( UA_AnnotationDataType *
UA_AnnotationDataType_new(void), {
    return (UA_AnnotationDataType*)UA_new(&UA_TYPES[UA_TYPES_ANNOTATIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_AnnotationDataType_copy(const UA_AnnotationDataType *src, UA_AnnotationDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ANNOTATIONDATATYPE]);
})

UA_INLINABLE( void
UA_AnnotationDataType_clear(UA_AnnotationDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ANNOTATIONDATATYPE]);
})

UA_INLINABLE( void
UA_AnnotationDataType_delete(UA_AnnotationDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ANNOTATIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_AnnotationDataType_equal(const UA_AnnotationDataType *p1, const UA_AnnotationDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ANNOTATIONDATATYPE]) == UA_ORDER_EQ);
})


/* LinearConversionDataType */
typedef struct {
    UA_Float initialAddend;
    UA_Float multiplicand;
    UA_Float divisor;
    UA_Float finalAddend;
} UA_LinearConversionDataType;

#define UA_TYPES_LINEARCONVERSIONDATATYPE 52

UA_INLINABLE( void
UA_LinearConversionDataType_init(UA_LinearConversionDataType *p), {
    memset(p, 0, sizeof(UA_LinearConversionDataType));
})

UA_INLINABLE( UA_LinearConversionDataType *
UA_LinearConversionDataType_new(void), {
    return (UA_LinearConversionDataType*)UA_new(&UA_TYPES[UA_TYPES_LINEARCONVERSIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_LinearConversionDataType_copy(const UA_LinearConversionDataType *src, UA_LinearConversionDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LINEARCONVERSIONDATATYPE]);
})

UA_INLINABLE( void
UA_LinearConversionDataType_clear(UA_LinearConversionDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LINEARCONVERSIONDATATYPE]);
})

UA_INLINABLE( void
UA_LinearConversionDataType_delete(UA_LinearConversionDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LINEARCONVERSIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_LinearConversionDataType_equal(const UA_LinearConversionDataType *p1, const UA_LinearConversionDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LINEARCONVERSIONDATATYPE]) == UA_ORDER_EQ);
})


/* ConversionLimitEnum */
typedef enum {
    UA_CONVERSIONLIMITENUM_NOCONVERSION = 0,
    UA_CONVERSIONLIMITENUM_LIMITED = 1,
    UA_CONVERSIONLIMITENUM_UNLIMITED = 2,
    __UA_CONVERSIONLIMITENUM_FORCE32BIT = 0x7fffffff
} UA_ConversionLimitEnum;

UA_STATIC_ASSERT(sizeof(UA_ConversionLimitEnum) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_CONVERSIONLIMITENUM 53

UA_INLINABLE( void
UA_ConversionLimitEnum_init(UA_ConversionLimitEnum *p), {
    memset(p, 0, sizeof(UA_ConversionLimitEnum));
})

UA_INLINABLE( UA_ConversionLimitEnum *
UA_ConversionLimitEnum_new(void), {
    return (UA_ConversionLimitEnum*)UA_new(&UA_TYPES[UA_TYPES_CONVERSIONLIMITENUM]);
})

UA_INLINABLE( UA_StatusCode
UA_ConversionLimitEnum_copy(const UA_ConversionLimitEnum *src, UA_ConversionLimitEnum *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONVERSIONLIMITENUM]);
})

UA_INLINABLE( void
UA_ConversionLimitEnum_clear(UA_ConversionLimitEnum *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONVERSIONLIMITENUM]);
})

UA_INLINABLE( void
UA_ConversionLimitEnum_delete(UA_ConversionLimitEnum *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONVERSIONLIMITENUM]);
})

UA_INLINABLE( UA_Boolean
UA_ConversionLimitEnum_equal(const UA_ConversionLimitEnum *p1, const UA_ConversionLimitEnum *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONVERSIONLIMITENUM]) == UA_ORDER_EQ);
})


/* QuantityDimension */
typedef struct {
    UA_SByte massExponent;
    UA_SByte lengthExponent;
    UA_SByte timeExponent;
    UA_SByte electricCurrentExponent;
    UA_SByte amountOfSubstanceExponent;
    UA_SByte luminousIntensityExponent;
    UA_SByte absoluteTemperatureExponent;
    UA_SByte dimensionlessExponent;
} UA_QuantityDimension;

#define UA_TYPES_QUANTITYDIMENSION 54

UA_INLINABLE( void
UA_QuantityDimension_init(UA_QuantityDimension *p), {
    memset(p, 0, sizeof(UA_QuantityDimension));
})

UA_INLINABLE( UA_QuantityDimension *
UA_QuantityDimension_new(void), {
    return (UA_QuantityDimension*)UA_new(&UA_TYPES[UA_TYPES_QUANTITYDIMENSION]);
})

UA_INLINABLE( UA_StatusCode
UA_QuantityDimension_copy(const UA_QuantityDimension *src, UA_QuantityDimension *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUANTITYDIMENSION]);
})

UA_INLINABLE( void
UA_QuantityDimension_clear(UA_QuantityDimension *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUANTITYDIMENSION]);
})

UA_INLINABLE( void
UA_QuantityDimension_delete(UA_QuantityDimension *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUANTITYDIMENSION]);
})

UA_INLINABLE( UA_Boolean
UA_QuantityDimension_equal(const UA_QuantityDimension *p1, const UA_QuantityDimension *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_QUANTITYDIMENSION]) == UA_ORDER_EQ);
})


/* AlarmMask */
typedef UA_UInt16 UA_AlarmMask;

#define UA_ALARMMASK_NONE 0
#define UA_ALARMMASK_ACTIVE 1
#define UA_ALARMMASK_UNACKNOWLEDGED 2
#define UA_ALARMMASK_UNCONFIRMED 4

#define UA_TYPES_ALARMMASK 55

UA_INLINABLE( void
UA_AlarmMask_init(UA_AlarmMask *p), {
    memset(p, 0, sizeof(UA_AlarmMask));
})

UA_INLINABLE( UA_AlarmMask *
UA_AlarmMask_new(void), {
    return (UA_AlarmMask*)UA_new(&UA_TYPES[UA_TYPES_ALARMMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_AlarmMask_copy(const UA_AlarmMask *src, UA_AlarmMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ALARMMASK]);
})

UA_INLINABLE( void
UA_AlarmMask_clear(UA_AlarmMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ALARMMASK]);
})

UA_INLINABLE( void
UA_AlarmMask_delete(UA_AlarmMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ALARMMASK]);
})

UA_INLINABLE( UA_Boolean
UA_AlarmMask_equal(const UA_AlarmMask *p1, const UA_AlarmMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ALARMMASK]) == UA_ORDER_EQ);
})


/* TrustListValidationOptions */
typedef UA_UInt32 UA_TrustListValidationOptions;

#define UA_TRUSTLISTVALIDATIONOPTIONS_NONE 0
#define UA_TRUSTLISTVALIDATIONOPTIONS_SUPPRESSCERTIFICATEEXPIRED 1
#define UA_TRUSTLISTVALIDATIONOPTIONS_SUPPRESSHOSTNAMEINVALID 2
#define UA_TRUSTLISTVALIDATIONOPTIONS_SUPPRESSREVOCATIONSTATUSUNKNOWN 4
#define UA_TRUSTLISTVALIDATIONOPTIONS_SUPPRESSISSUERCERTIFICATEEXPIRED 8
#define UA_TRUSTLISTVALIDATIONOPTIONS_SUPPRESSISSUERREVOCATIONSTATUSUNKNOWN 16
#define UA_TRUSTLISTVALIDATIONOPTIONS_CHECKREVOCATIONSTATUSONLINE 32
#define UA_TRUSTLISTVALIDATIONOPTIONS_CHECKREVOCATIONSTATUSOFFLINE 64

#define UA_TYPES_TRUSTLISTVALIDATIONOPTIONS 56

UA_INLINABLE( void
UA_TrustListValidationOptions_init(UA_TrustListValidationOptions *p), {
    memset(p, 0, sizeof(UA_TrustListValidationOptions));
})

UA_INLINABLE( UA_TrustListValidationOptions *
UA_TrustListValidationOptions_new(void), {
    return (UA_TrustListValidationOptions*)UA_new(&UA_TYPES[UA_TYPES_TRUSTLISTVALIDATIONOPTIONS]);
})

UA_INLINABLE( UA_StatusCode
UA_TrustListValidationOptions_copy(const UA_TrustListValidationOptions *src, UA_TrustListValidationOptions *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRUSTLISTVALIDATIONOPTIONS]);
})

UA_INLINABLE( void
UA_TrustListValidationOptions_clear(UA_TrustListValidationOptions *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRUSTLISTVALIDATIONOPTIONS]);
})

UA_INLINABLE( void
UA_TrustListValidationOptions_delete(UA_TrustListValidationOptions *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRUSTLISTVALIDATIONOPTIONS]);
})

UA_INLINABLE( UA_Boolean
UA_TrustListValidationOptions_equal(const UA_TrustListValidationOptions *p1, const UA_TrustListValidationOptions *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRUSTLISTVALIDATIONOPTIONS]) == UA_ORDER_EQ);
})


/* TrustListMasks */
typedef enum {
    UA_TRUSTLISTMASKS_NONE = 0,
    UA_TRUSTLISTMASKS_TRUSTEDCERTIFICATES = 1,
    UA_TRUSTLISTMASKS_TRUSTEDCRLS = 2,
    UA_TRUSTLISTMASKS_ISSUERCERTIFICATES = 4,
    UA_TRUSTLISTMASKS_ISSUERCRLS = 8,
    UA_TRUSTLISTMASKS_ALL = 15,
    __UA_TRUSTLISTMASKS_FORCE32BIT = 0x7fffffff
} UA_TrustListMasks;

UA_STATIC_ASSERT(sizeof(UA_TrustListMasks) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_TRUSTLISTMASKS 57

UA_INLINABLE( void
UA_TrustListMasks_init(UA_TrustListMasks *p), {
    memset(p, 0, sizeof(UA_TrustListMasks));
})

UA_INLINABLE( UA_TrustListMasks *
UA_TrustListMasks_new(void), {
    return (UA_TrustListMasks*)UA_new(&UA_TYPES[UA_TYPES_TRUSTLISTMASKS]);
})

UA_INLINABLE( UA_StatusCode
UA_TrustListMasks_copy(const UA_TrustListMasks *src, UA_TrustListMasks *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRUSTLISTMASKS]);
})

UA_INLINABLE( void
UA_TrustListMasks_clear(UA_TrustListMasks *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRUSTLISTMASKS]);
})

UA_INLINABLE( void
UA_TrustListMasks_delete(UA_TrustListMasks *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRUSTLISTMASKS]);
})

UA_INLINABLE( UA_Boolean
UA_TrustListMasks_equal(const UA_TrustListMasks *p1, const UA_TrustListMasks *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRUSTLISTMASKS]) == UA_ORDER_EQ);
})


/* TrustListDataType */
typedef struct {
    UA_UInt32 specifiedLists;
    size_t trustedCertificatesSize;
    UA_ByteString *trustedCertificates;
    size_t trustedCrlsSize;
    UA_ByteString *trustedCrls;
    size_t issuerCertificatesSize;
    UA_ByteString *issuerCertificates;
    size_t issuerCrlsSize;
    UA_ByteString *issuerCrls;
} UA_TrustListDataType;

#define UA_TYPES_TRUSTLISTDATATYPE 58

UA_INLINABLE( void
UA_TrustListDataType_init(UA_TrustListDataType *p), {
    memset(p, 0, sizeof(UA_TrustListDataType));
})

UA_INLINABLE( UA_TrustListDataType *
UA_TrustListDataType_new(void), {
    return (UA_TrustListDataType*)UA_new(&UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_TrustListDataType_copy(const UA_TrustListDataType *src, UA_TrustListDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE]);
})

UA_INLINABLE( void
UA_TrustListDataType_clear(UA_TrustListDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE]);
})

UA_INLINABLE( void
UA_TrustListDataType_delete(UA_TrustListDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_TrustListDataType_equal(const UA_TrustListDataType *p1, const UA_TrustListDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRUSTLISTDATATYPE]) == UA_ORDER_EQ);
})


/* BaseConfigurationDataType */
typedef struct {
    UA_UInt32 configurationVersion;
    size_t configurationPropertiesSize;
    UA_KeyValuePair *configurationProperties;
} UA_BaseConfigurationDataType;

#define UA_TYPES_BASECONFIGURATIONDATATYPE 59

UA_INLINABLE( void
UA_BaseConfigurationDataType_init(UA_BaseConfigurationDataType *p), {
    memset(p, 0, sizeof(UA_BaseConfigurationDataType));
})

UA_INLINABLE( UA_BaseConfigurationDataType *
UA_BaseConfigurationDataType_new(void), {
    return (UA_BaseConfigurationDataType*)UA_new(&UA_TYPES[UA_TYPES_BASECONFIGURATIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_BaseConfigurationDataType_copy(const UA_BaseConfigurationDataType *src, UA_BaseConfigurationDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BASECONFIGURATIONDATATYPE]);
})

UA_INLINABLE( void
UA_BaseConfigurationDataType_clear(UA_BaseConfigurationDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BASECONFIGURATIONDATATYPE]);
})

UA_INLINABLE( void
UA_BaseConfigurationDataType_delete(UA_BaseConfigurationDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BASECONFIGURATIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_BaseConfigurationDataType_equal(const UA_BaseConfigurationDataType *p1, const UA_BaseConfigurationDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BASECONFIGURATIONDATATYPE]) == UA_ORDER_EQ);
})


/* BaseConfigurationRecordDataType */
typedef struct {
    UA_String name;
    size_t recordPropertiesSize;
    UA_KeyValuePair *recordProperties;
} UA_BaseConfigurationRecordDataType;

#define UA_TYPES_BASECONFIGURATIONRECORDDATATYPE 60

UA_INLINABLE( void
UA_BaseConfigurationRecordDataType_init(UA_BaseConfigurationRecordDataType *p), {
    memset(p, 0, sizeof(UA_BaseConfigurationRecordDataType));
})

UA_INLINABLE( UA_BaseConfigurationRecordDataType *
UA_BaseConfigurationRecordDataType_new(void), {
    return (UA_BaseConfigurationRecordDataType*)UA_new(&UA_TYPES[UA_TYPES_BASECONFIGURATIONRECORDDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_BaseConfigurationRecordDataType_copy(const UA_BaseConfigurationRecordDataType *src, UA_BaseConfigurationRecordDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BASECONFIGURATIONRECORDDATATYPE]);
})

UA_INLINABLE( void
UA_BaseConfigurationRecordDataType_clear(UA_BaseConfigurationRecordDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BASECONFIGURATIONRECORDDATATYPE]);
})

UA_INLINABLE( void
UA_BaseConfigurationRecordDataType_delete(UA_BaseConfigurationRecordDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BASECONFIGURATIONRECORDDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_BaseConfigurationRecordDataType_equal(const UA_BaseConfigurationRecordDataType *p1, const UA_BaseConfigurationRecordDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BASECONFIGURATIONRECORDDATATYPE]) == UA_ORDER_EQ);
})


/* CertificateGroupDataType */
typedef struct {
    UA_String name;
    size_t recordPropertiesSize;
    UA_KeyValuePair *recordProperties;
    UA_NodeId purpose;
    size_t certificateTypesSize;
    UA_NodeId *certificateTypes;
    size_t isCertificateAssignedSize;
    UA_Boolean *isCertificateAssigned;
    UA_TrustListValidationOptions validationOptions;
} UA_CertificateGroupDataType;

#define UA_TYPES_CERTIFICATEGROUPDATATYPE 61

UA_INLINABLE( void
UA_CertificateGroupDataType_init(UA_CertificateGroupDataType *p), {
    memset(p, 0, sizeof(UA_CertificateGroupDataType));
})

UA_INLINABLE( UA_CertificateGroupDataType *
UA_CertificateGroupDataType_new(void), {
    return (UA_CertificateGroupDataType*)UA_new(&UA_TYPES[UA_TYPES_CERTIFICATEGROUPDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_CertificateGroupDataType_copy(const UA_CertificateGroupDataType *src, UA_CertificateGroupDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CERTIFICATEGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_CertificateGroupDataType_clear(UA_CertificateGroupDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CERTIFICATEGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_CertificateGroupDataType_delete(UA_CertificateGroupDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CERTIFICATEGROUPDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_CertificateGroupDataType_equal(const UA_CertificateGroupDataType *p1, const UA_CertificateGroupDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CERTIFICATEGROUPDATATYPE]) == UA_ORDER_EQ);
})


/* ConfigurationUpdateType */
typedef enum {
    UA_CONFIGURATIONUPDATETYPE_INSERT = 1,
    UA_CONFIGURATIONUPDATETYPE_REPLACE = 2,
    UA_CONFIGURATIONUPDATETYPE_INSERTORREPLACE = 3,
    UA_CONFIGURATIONUPDATETYPE_DELETE = 4,
    __UA_CONFIGURATIONUPDATETYPE_FORCE32BIT = 0x7fffffff
} UA_ConfigurationUpdateType;

UA_STATIC_ASSERT(sizeof(UA_ConfigurationUpdateType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_CONFIGURATIONUPDATETYPE 62

UA_INLINABLE( void
UA_ConfigurationUpdateType_init(UA_ConfigurationUpdateType *p), {
    memset(p, 0, sizeof(UA_ConfigurationUpdateType));
})

UA_INLINABLE( UA_ConfigurationUpdateType *
UA_ConfigurationUpdateType_new(void), {
    return (UA_ConfigurationUpdateType*)UA_new(&UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ConfigurationUpdateType_copy(const UA_ConfigurationUpdateType *src, UA_ConfigurationUpdateType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETYPE]);
})

UA_INLINABLE( void
UA_ConfigurationUpdateType_clear(UA_ConfigurationUpdateType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETYPE]);
})

UA_INLINABLE( void
UA_ConfigurationUpdateType_delete(UA_ConfigurationUpdateType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ConfigurationUpdateType_equal(const UA_ConfigurationUpdateType *p1, const UA_ConfigurationUpdateType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETYPE]) == UA_ORDER_EQ);
})


/* TransactionErrorType */
typedef struct {
    UA_NodeId targetId;
    UA_StatusCode error;
    UA_LocalizedText message;
} UA_TransactionErrorType;

#define UA_TYPES_TRANSACTIONERRORTYPE 63

UA_INLINABLE( void
UA_TransactionErrorType_init(UA_TransactionErrorType *p), {
    memset(p, 0, sizeof(UA_TransactionErrorType));
})

UA_INLINABLE( UA_TransactionErrorType *
UA_TransactionErrorType_new(void), {
    return (UA_TransactionErrorType*)UA_new(&UA_TYPES[UA_TYPES_TRANSACTIONERRORTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_TransactionErrorType_copy(const UA_TransactionErrorType *src, UA_TransactionErrorType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSACTIONERRORTYPE]);
})

UA_INLINABLE( void
UA_TransactionErrorType_clear(UA_TransactionErrorType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSACTIONERRORTYPE]);
})

UA_INLINABLE( void
UA_TransactionErrorType_delete(UA_TransactionErrorType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSACTIONERRORTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_TransactionErrorType_equal(const UA_TransactionErrorType *p1, const UA_TransactionErrorType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRANSACTIONERRORTYPE]) == UA_ORDER_EQ);
})


/* EndpointDataType */
typedef struct {
    UA_String name;
    size_t recordPropertiesSize;
    UA_KeyValuePair *recordProperties;
    size_t discoveryUrlsSize;
    UA_String *discoveryUrls;
    UA_String networkName;
    UA_UInt16 port;
} UA_EndpointDataType;

#define UA_TYPES_ENDPOINTDATATYPE 64

UA_INLINABLE( void
UA_EndpointDataType_init(UA_EndpointDataType *p), {
    memset(p, 0, sizeof(UA_EndpointDataType));
})

UA_INLINABLE( UA_EndpointDataType *
UA_EndpointDataType_new(void), {
    return (UA_EndpointDataType*)UA_new(&UA_TYPES[UA_TYPES_ENDPOINTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_EndpointDataType_copy(const UA_EndpointDataType *src, UA_EndpointDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENDPOINTDATATYPE]);
})

UA_INLINABLE( void
UA_EndpointDataType_clear(UA_EndpointDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTDATATYPE]);
})

UA_INLINABLE( void
UA_EndpointDataType_delete(UA_EndpointDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENDPOINTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_EndpointDataType_equal(const UA_EndpointDataType *p1, const UA_EndpointDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENDPOINTDATATYPE]) == UA_ORDER_EQ);
})


/* ServerEndpointDataType */
typedef struct {
    UA_String name;
    size_t recordPropertiesSize;
    UA_KeyValuePair *recordProperties;
    size_t discoveryUrlsSize;
    UA_String *discoveryUrls;
    UA_String networkName;
    UA_UInt16 port;
    size_t endpointUrlsSize;
    UA_String *endpointUrls;
    size_t securitySettingNamesSize;
    UA_String *securitySettingNames;
    UA_String transportProfileUri;
    size_t userTokenSettingNamesSize;
    UA_String *userTokenSettingNames;
    size_t reverseConnectUrlsSize;
    UA_String *reverseConnectUrls;
} UA_ServerEndpointDataType;

#define UA_TYPES_SERVERENDPOINTDATATYPE 65

UA_INLINABLE( void
UA_ServerEndpointDataType_init(UA_ServerEndpointDataType *p), {
    memset(p, 0, sizeof(UA_ServerEndpointDataType));
})

UA_INLINABLE( UA_ServerEndpointDataType *
UA_ServerEndpointDataType_new(void), {
    return (UA_ServerEndpointDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVERENDPOINTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ServerEndpointDataType_copy(const UA_ServerEndpointDataType *src, UA_ServerEndpointDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERENDPOINTDATATYPE]);
})

UA_INLINABLE( void
UA_ServerEndpointDataType_clear(UA_ServerEndpointDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERENDPOINTDATATYPE]);
})

UA_INLINABLE( void
UA_ServerEndpointDataType_delete(UA_ServerEndpointDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVERENDPOINTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ServerEndpointDataType_equal(const UA_ServerEndpointDataType *p1, const UA_ServerEndpointDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SERVERENDPOINTDATATYPE]) == UA_ORDER_EQ);
})


/* ServiceCertificateDataType */
typedef struct {
    UA_ByteString certificate;
    size_t issuersSize;
    UA_ByteString *issuers;
    UA_DateTime validFrom;
    UA_DateTime validTo;
} UA_ServiceCertificateDataType;

#define UA_TYPES_SERVICECERTIFICATEDATATYPE 66

UA_INLINABLE( void
UA_ServiceCertificateDataType_init(UA_ServiceCertificateDataType *p), {
    memset(p, 0, sizeof(UA_ServiceCertificateDataType));
})

UA_INLINABLE( UA_ServiceCertificateDataType *
UA_ServiceCertificateDataType_new(void), {
    return (UA_ServiceCertificateDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVICECERTIFICATEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ServiceCertificateDataType_copy(const UA_ServiceCertificateDataType *src, UA_ServiceCertificateDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVICECERTIFICATEDATATYPE]);
})

UA_INLINABLE( void
UA_ServiceCertificateDataType_clear(UA_ServiceCertificateDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVICECERTIFICATEDATATYPE]);
})

UA_INLINABLE( void
UA_ServiceCertificateDataType_delete(UA_ServiceCertificateDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVICECERTIFICATEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ServiceCertificateDataType_equal(const UA_ServiceCertificateDataType *p1, const UA_ServiceCertificateDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SERVICECERTIFICATEDATATYPE]) == UA_ORDER_EQ);
})


/* AuthorizationServiceConfigurationDataType */
typedef struct {
    UA_String name;
    size_t recordPropertiesSize;
    UA_KeyValuePair *recordProperties;
    UA_String serviceUri;
    size_t serviceCertificatesSize;
    UA_ServiceCertificateDataType *serviceCertificates;
    UA_String issuerEndpointSettings;
} UA_AuthorizationServiceConfigurationDataType;

#define UA_TYPES_AUTHORIZATIONSERVICECONFIGURATIONDATATYPE 67

UA_INLINABLE( void
UA_AuthorizationServiceConfigurationDataType_init(UA_AuthorizationServiceConfigurationDataType *p), {
    memset(p, 0, sizeof(UA_AuthorizationServiceConfigurationDataType));
})

UA_INLINABLE( UA_AuthorizationServiceConfigurationDataType *
UA_AuthorizationServiceConfigurationDataType_new(void), {
    return (UA_AuthorizationServiceConfigurationDataType*)UA_new(&UA_TYPES[UA_TYPES_AUTHORIZATIONSERVICECONFIGURATIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_AuthorizationServiceConfigurationDataType_copy(const UA_AuthorizationServiceConfigurationDataType *src, UA_AuthorizationServiceConfigurationDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AUTHORIZATIONSERVICECONFIGURATIONDATATYPE]);
})

UA_INLINABLE( void
UA_AuthorizationServiceConfigurationDataType_clear(UA_AuthorizationServiceConfigurationDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_AUTHORIZATIONSERVICECONFIGURATIONDATATYPE]);
})

UA_INLINABLE( void
UA_AuthorizationServiceConfigurationDataType_delete(UA_AuthorizationServiceConfigurationDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_AUTHORIZATIONSERVICECONFIGURATIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_AuthorizationServiceConfigurationDataType_equal(const UA_AuthorizationServiceConfigurationDataType *p1, const UA_AuthorizationServiceConfigurationDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_AUTHORIZATIONSERVICECONFIGURATIONDATATYPE]) == UA_ORDER_EQ);
})


/* DataTypeDescription */
typedef struct {
    UA_NodeId dataTypeId;
    UA_QualifiedName name;
} UA_DataTypeDescription;

#define UA_TYPES_DATATYPEDESCRIPTION 68

UA_INLINABLE( void
UA_DataTypeDescription_init(UA_DataTypeDescription *p), {
    memset(p, 0, sizeof(UA_DataTypeDescription));
})

UA_INLINABLE( UA_DataTypeDescription *
UA_DataTypeDescription_new(void), {
    return (UA_DataTypeDescription*)UA_new(&UA_TYPES[UA_TYPES_DATATYPEDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_DataTypeDescription_copy(const UA_DataTypeDescription *src, UA_DataTypeDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATATYPEDESCRIPTION]);
})

UA_INLINABLE( void
UA_DataTypeDescription_clear(UA_DataTypeDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATATYPEDESCRIPTION]);
})

UA_INLINABLE( void
UA_DataTypeDescription_delete(UA_DataTypeDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATATYPEDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_DataTypeDescription_equal(const UA_DataTypeDescription *p1, const UA_DataTypeDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATATYPEDESCRIPTION]) == UA_ORDER_EQ);
})


/* SimpleTypeDescription */
typedef struct {
    UA_NodeId dataTypeId;
    UA_QualifiedName name;
    UA_NodeId baseDataType;
    UA_Byte builtInType;
} UA_SimpleTypeDescription;

#define UA_TYPES_SIMPLETYPEDESCRIPTION 69

UA_INLINABLE( void
UA_SimpleTypeDescription_init(UA_SimpleTypeDescription *p), {
    memset(p, 0, sizeof(UA_SimpleTypeDescription));
})

UA_INLINABLE( UA_SimpleTypeDescription *
UA_SimpleTypeDescription_new(void), {
    return (UA_SimpleTypeDescription*)UA_new(&UA_TYPES[UA_TYPES_SIMPLETYPEDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_SimpleTypeDescription_copy(const UA_SimpleTypeDescription *src, UA_SimpleTypeDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIMPLETYPEDESCRIPTION]);
})

UA_INLINABLE( void
UA_SimpleTypeDescription_clear(UA_SimpleTypeDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIMPLETYPEDESCRIPTION]);
})

UA_INLINABLE( void
UA_SimpleTypeDescription_delete(UA_SimpleTypeDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SIMPLETYPEDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_SimpleTypeDescription_equal(const UA_SimpleTypeDescription *p1, const UA_SimpleTypeDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SIMPLETYPEDESCRIPTION]) == UA_ORDER_EQ);
})


/* PortableQualifiedName */
typedef struct {
    UA_String namespaceUri;
    UA_String name;
} UA_PortableQualifiedName;

#define UA_TYPES_PORTABLEQUALIFIEDNAME 70

UA_INLINABLE( void
UA_PortableQualifiedName_init(UA_PortableQualifiedName *p), {
    memset(p, 0, sizeof(UA_PortableQualifiedName));
})

UA_INLINABLE( UA_PortableQualifiedName *
UA_PortableQualifiedName_new(void), {
    return (UA_PortableQualifiedName*)UA_new(&UA_TYPES[UA_TYPES_PORTABLEQUALIFIEDNAME]);
})

UA_INLINABLE( UA_StatusCode
UA_PortableQualifiedName_copy(const UA_PortableQualifiedName *src, UA_PortableQualifiedName *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PORTABLEQUALIFIEDNAME]);
})

UA_INLINABLE( void
UA_PortableQualifiedName_clear(UA_PortableQualifiedName *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PORTABLEQUALIFIEDNAME]);
})

UA_INLINABLE( void
UA_PortableQualifiedName_delete(UA_PortableQualifiedName *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PORTABLEQUALIFIEDNAME]);
})

UA_INLINABLE( UA_Boolean
UA_PortableQualifiedName_equal(const UA_PortableQualifiedName *p1, const UA_PortableQualifiedName *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PORTABLEQUALIFIEDNAME]) == UA_ORDER_EQ);
})


/* PortableNodeId */
typedef struct {
    UA_String namespaceUri;
    UA_NodeId identifier;
} UA_PortableNodeId;

#define UA_TYPES_PORTABLENODEID 71

UA_INLINABLE( void
UA_PortableNodeId_init(UA_PortableNodeId *p), {
    memset(p, 0, sizeof(UA_PortableNodeId));
})

UA_INLINABLE( UA_PortableNodeId *
UA_PortableNodeId_new(void), {
    return (UA_PortableNodeId*)UA_new(&UA_TYPES[UA_TYPES_PORTABLENODEID]);
})

UA_INLINABLE( UA_StatusCode
UA_PortableNodeId_copy(const UA_PortableNodeId *src, UA_PortableNodeId *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PORTABLENODEID]);
})

UA_INLINABLE( void
UA_PortableNodeId_clear(UA_PortableNodeId *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PORTABLENODEID]);
})

UA_INLINABLE( void
UA_PortableNodeId_delete(UA_PortableNodeId *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PORTABLENODEID]);
})

UA_INLINABLE( UA_Boolean
UA_PortableNodeId_equal(const UA_PortableNodeId *p1, const UA_PortableNodeId *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PORTABLENODEID]) == UA_ORDER_EQ);
})


/* UnsignedRationalNumber */
typedef struct {
    UA_UInt32 numerator;
    UA_UInt32 denominator;
} UA_UnsignedRationalNumber;

#define UA_TYPES_UNSIGNEDRATIONALNUMBER 72

UA_INLINABLE( void
UA_UnsignedRationalNumber_init(UA_UnsignedRationalNumber *p), {
    memset(p, 0, sizeof(UA_UnsignedRationalNumber));
})

UA_INLINABLE( UA_UnsignedRationalNumber *
UA_UnsignedRationalNumber_new(void), {
    return (UA_UnsignedRationalNumber*)UA_new(&UA_TYPES[UA_TYPES_UNSIGNEDRATIONALNUMBER]);
})

UA_INLINABLE( UA_StatusCode
UA_UnsignedRationalNumber_copy(const UA_UnsignedRationalNumber *src, UA_UnsignedRationalNumber *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UNSIGNEDRATIONALNUMBER]);
})

UA_INLINABLE( void
UA_UnsignedRationalNumber_clear(UA_UnsignedRationalNumber *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UNSIGNEDRATIONALNUMBER]);
})

UA_INLINABLE( void
UA_UnsignedRationalNumber_delete(UA_UnsignedRationalNumber *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UNSIGNEDRATIONALNUMBER]);
})

UA_INLINABLE( UA_Boolean
UA_UnsignedRationalNumber_equal(const UA_UnsignedRationalNumber *p1, const UA_UnsignedRationalNumber *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UNSIGNEDRATIONALNUMBER]) == UA_ORDER_EQ);
})


/* PubSubState */
typedef enum {
    UA_PUBSUBSTATE_DISABLED = 0,
    UA_PUBSUBSTATE_PAUSED = 1,
    UA_PUBSUBSTATE_OPERATIONAL = 2,
    UA_PUBSUBSTATE_ERROR = 3,
    UA_PUBSUBSTATE_PREOPERATIONAL = 4,
    __UA_PUBSUBSTATE_FORCE32BIT = 0x7fffffff
} UA_PubSubState;

UA_STATIC_ASSERT(sizeof(UA_PubSubState) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_PUBSUBSTATE 73

UA_INLINABLE( void
UA_PubSubState_init(UA_PubSubState *p), {
    memset(p, 0, sizeof(UA_PubSubState));
})

UA_INLINABLE( UA_PubSubState *
UA_PubSubState_new(void), {
    return (UA_PubSubState*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBSTATE]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubState_copy(const UA_PubSubState *src, UA_PubSubState *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBSTATE]);
})

UA_INLINABLE( void
UA_PubSubState_clear(UA_PubSubState *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBSTATE]);
})

UA_INLINABLE( void
UA_PubSubState_delete(UA_PubSubState *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBSTATE]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubState_equal(const UA_PubSubState *p1, const UA_PubSubState *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBSTATE]) == UA_ORDER_EQ);
})


/* DataSetFieldFlags */
typedef UA_UInt16 UA_DataSetFieldFlags;

#define UA_DATASETFIELDFLAGS_NONE 0
#define UA_DATASETFIELDFLAGS_PROMOTEDFIELD 1

#define UA_TYPES_DATASETFIELDFLAGS 74

UA_INLINABLE( void
UA_DataSetFieldFlags_init(UA_DataSetFieldFlags *p), {
    memset(p, 0, sizeof(UA_DataSetFieldFlags));
})

UA_INLINABLE( UA_DataSetFieldFlags *
UA_DataSetFieldFlags_new(void), {
    return (UA_DataSetFieldFlags*)UA_new(&UA_TYPES[UA_TYPES_DATASETFIELDFLAGS]);
})

UA_INLINABLE( UA_StatusCode
UA_DataSetFieldFlags_copy(const UA_DataSetFieldFlags *src, UA_DataSetFieldFlags *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATASETFIELDFLAGS]);
})

UA_INLINABLE( void
UA_DataSetFieldFlags_clear(UA_DataSetFieldFlags *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATASETFIELDFLAGS]);
})

UA_INLINABLE( void
UA_DataSetFieldFlags_delete(UA_DataSetFieldFlags *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATASETFIELDFLAGS]);
})

UA_INLINABLE( UA_Boolean
UA_DataSetFieldFlags_equal(const UA_DataSetFieldFlags *p1, const UA_DataSetFieldFlags *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATASETFIELDFLAGS]) == UA_ORDER_EQ);
})


/* ConfigurationVersionDataType */
typedef struct {
    UA_UInt32 majorVersion;
    UA_UInt32 minorVersion;
} UA_ConfigurationVersionDataType;

#define UA_TYPES_CONFIGURATIONVERSIONDATATYPE 75

UA_INLINABLE( void
UA_ConfigurationVersionDataType_init(UA_ConfigurationVersionDataType *p), {
    memset(p, 0, sizeof(UA_ConfigurationVersionDataType));
})

UA_INLINABLE( UA_ConfigurationVersionDataType *
UA_ConfigurationVersionDataType_new(void), {
    return (UA_ConfigurationVersionDataType*)UA_new(&UA_TYPES[UA_TYPES_CONFIGURATIONVERSIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ConfigurationVersionDataType_copy(const UA_ConfigurationVersionDataType *src, UA_ConfigurationVersionDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONFIGURATIONVERSIONDATATYPE]);
})

UA_INLINABLE( void
UA_ConfigurationVersionDataType_clear(UA_ConfigurationVersionDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONFIGURATIONVERSIONDATATYPE]);
})

UA_INLINABLE( void
UA_ConfigurationVersionDataType_delete(UA_ConfigurationVersionDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONFIGURATIONVERSIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ConfigurationVersionDataType_equal(const UA_ConfigurationVersionDataType *p1, const UA_ConfigurationVersionDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONFIGURATIONVERSIONDATATYPE]) == UA_ORDER_EQ);
})


/* PublishedVariableDataType */
typedef struct {
    UA_NodeId publishedVariable;
    UA_UInt32 attributeId;
    UA_Double samplingIntervalHint;
    UA_UInt32 deadbandType;
    UA_Double deadbandValue;
    UA_String indexRange;
    UA_Variant substituteValue;
    size_t metaDataPropertiesSize;
    UA_QualifiedName *metaDataProperties;
} UA_PublishedVariableDataType;

#define UA_TYPES_PUBLISHEDVARIABLEDATATYPE 76

UA_INLINABLE( void
UA_PublishedVariableDataType_init(UA_PublishedVariableDataType *p), {
    memset(p, 0, sizeof(UA_PublishedVariableDataType));
})

UA_INLINABLE( UA_PublishedVariableDataType *
UA_PublishedVariableDataType_new(void), {
    return (UA_PublishedVariableDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishedVariableDataType_copy(const UA_PublishedVariableDataType *src, UA_PublishedVariableDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedVariableDataType_clear(UA_PublishedVariableDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedVariableDataType_delete(UA_PublishedVariableDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PublishedVariableDataType_equal(const UA_PublishedVariableDataType *p1, const UA_PublishedVariableDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]) == UA_ORDER_EQ);
})


/* PublishedDataItemsDataType */
typedef struct {
    size_t publishedDataSize;
    UA_PublishedVariableDataType *publishedData;
} UA_PublishedDataItemsDataType;

#define UA_TYPES_PUBLISHEDDATAITEMSDATATYPE 77

UA_INLINABLE( void
UA_PublishedDataItemsDataType_init(UA_PublishedDataItemsDataType *p), {
    memset(p, 0, sizeof(UA_PublishedDataItemsDataType));
})

UA_INLINABLE( UA_PublishedDataItemsDataType *
UA_PublishedDataItemsDataType_new(void), {
    return (UA_PublishedDataItemsDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHEDDATAITEMSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishedDataItemsDataType_copy(const UA_PublishedDataItemsDataType *src, UA_PublishedDataItemsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHEDDATAITEMSDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedDataItemsDataType_clear(UA_PublishedDataItemsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHEDDATAITEMSDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedDataItemsDataType_delete(UA_PublishedDataItemsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHEDDATAITEMSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PublishedDataItemsDataType_equal(const UA_PublishedDataItemsDataType *p1, const UA_PublishedDataItemsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHEDDATAITEMSDATATYPE]) == UA_ORDER_EQ);
})


/* PublishedDataSetCustomSourceDataType */
typedef struct {
    UA_Boolean cyclicDataSet;
} UA_PublishedDataSetCustomSourceDataType;

#define UA_TYPES_PUBLISHEDDATASETCUSTOMSOURCEDATATYPE 78

UA_INLINABLE( void
UA_PublishedDataSetCustomSourceDataType_init(UA_PublishedDataSetCustomSourceDataType *p), {
    memset(p, 0, sizeof(UA_PublishedDataSetCustomSourceDataType));
})

UA_INLINABLE( UA_PublishedDataSetCustomSourceDataType *
UA_PublishedDataSetCustomSourceDataType_new(void), {
    return (UA_PublishedDataSetCustomSourceDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHEDDATASETCUSTOMSOURCEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishedDataSetCustomSourceDataType_copy(const UA_PublishedDataSetCustomSourceDataType *src, UA_PublishedDataSetCustomSourceDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHEDDATASETCUSTOMSOURCEDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedDataSetCustomSourceDataType_clear(UA_PublishedDataSetCustomSourceDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHEDDATASETCUSTOMSOURCEDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedDataSetCustomSourceDataType_delete(UA_PublishedDataSetCustomSourceDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHEDDATASETCUSTOMSOURCEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PublishedDataSetCustomSourceDataType_equal(const UA_PublishedDataSetCustomSourceDataType *p1, const UA_PublishedDataSetCustomSourceDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHEDDATASETCUSTOMSOURCEDATATYPE]) == UA_ORDER_EQ);
})


/* ActionTargetDataType */
typedef struct {
    UA_UInt16 actionTargetId;
    UA_String name;
    UA_LocalizedText description;
} UA_ActionTargetDataType;

#define UA_TYPES_ACTIONTARGETDATATYPE 79

UA_INLINABLE( void
UA_ActionTargetDataType_init(UA_ActionTargetDataType *p), {
    memset(p, 0, sizeof(UA_ActionTargetDataType));
})

UA_INLINABLE( UA_ActionTargetDataType *
UA_ActionTargetDataType_new(void), {
    return (UA_ActionTargetDataType*)UA_new(&UA_TYPES[UA_TYPES_ACTIONTARGETDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ActionTargetDataType_copy(const UA_ActionTargetDataType *src, UA_ActionTargetDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIONTARGETDATATYPE]);
})

UA_INLINABLE( void
UA_ActionTargetDataType_clear(UA_ActionTargetDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIONTARGETDATATYPE]);
})

UA_INLINABLE( void
UA_ActionTargetDataType_delete(UA_ActionTargetDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACTIONTARGETDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ActionTargetDataType_equal(const UA_ActionTargetDataType *p1, const UA_ActionTargetDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ACTIONTARGETDATATYPE]) == UA_ORDER_EQ);
})


/* ActionState */
typedef enum {
    UA_ACTIONSTATE_IDLE = 0,
    UA_ACTIONSTATE_EXECUTING = 1,
    UA_ACTIONSTATE_DONE = 2,
    __UA_ACTIONSTATE_FORCE32BIT = 0x7fffffff
} UA_ActionState;

UA_STATIC_ASSERT(sizeof(UA_ActionState) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_ACTIONSTATE 80

UA_INLINABLE( void
UA_ActionState_init(UA_ActionState *p), {
    memset(p, 0, sizeof(UA_ActionState));
})

UA_INLINABLE( UA_ActionState *
UA_ActionState_new(void), {
    return (UA_ActionState*)UA_new(&UA_TYPES[UA_TYPES_ACTIONSTATE]);
})

UA_INLINABLE( UA_StatusCode
UA_ActionState_copy(const UA_ActionState *src, UA_ActionState *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIONSTATE]);
})

UA_INLINABLE( void
UA_ActionState_clear(UA_ActionState *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIONSTATE]);
})

UA_INLINABLE( void
UA_ActionState_delete(UA_ActionState *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACTIONSTATE]);
})

UA_INLINABLE( UA_Boolean
UA_ActionState_equal(const UA_ActionState *p1, const UA_ActionState *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ACTIONSTATE]) == UA_ORDER_EQ);
})


/* ActionMethodDataType */
typedef struct {
    UA_NodeId objectId;
    UA_NodeId methodId;
} UA_ActionMethodDataType;

#define UA_TYPES_ACTIONMETHODDATATYPE 81

UA_INLINABLE( void
UA_ActionMethodDataType_init(UA_ActionMethodDataType *p), {
    memset(p, 0, sizeof(UA_ActionMethodDataType));
})

UA_INLINABLE( UA_ActionMethodDataType *
UA_ActionMethodDataType_new(void), {
    return (UA_ActionMethodDataType*)UA_new(&UA_TYPES[UA_TYPES_ACTIONMETHODDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ActionMethodDataType_copy(const UA_ActionMethodDataType *src, UA_ActionMethodDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIONMETHODDATATYPE]);
})

UA_INLINABLE( void
UA_ActionMethodDataType_clear(UA_ActionMethodDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIONMETHODDATATYPE]);
})

UA_INLINABLE( void
UA_ActionMethodDataType_delete(UA_ActionMethodDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACTIONMETHODDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ActionMethodDataType_equal(const UA_ActionMethodDataType *p1, const UA_ActionMethodDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ACTIONMETHODDATATYPE]) == UA_ORDER_EQ);
})


/* DataSetFieldContentMask */
typedef UA_UInt32 UA_DataSetFieldContentMask;

#define UA_DATASETFIELDCONTENTMASK_NONE 0
#define UA_DATASETFIELDCONTENTMASK_STATUSCODE 1
#define UA_DATASETFIELDCONTENTMASK_SOURCETIMESTAMP 2
#define UA_DATASETFIELDCONTENTMASK_SERVERTIMESTAMP 4
#define UA_DATASETFIELDCONTENTMASK_SOURCEPICOSECONDS 8
#define UA_DATASETFIELDCONTENTMASK_SERVERPICOSECONDS 16
#define UA_DATASETFIELDCONTENTMASK_RAWDATA 32

#define UA_TYPES_DATASETFIELDCONTENTMASK 82

UA_INLINABLE( void
UA_DataSetFieldContentMask_init(UA_DataSetFieldContentMask *p), {
    memset(p, 0, sizeof(UA_DataSetFieldContentMask));
})

UA_INLINABLE( UA_DataSetFieldContentMask *
UA_DataSetFieldContentMask_new(void), {
    return (UA_DataSetFieldContentMask*)UA_new(&UA_TYPES[UA_TYPES_DATASETFIELDCONTENTMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_DataSetFieldContentMask_copy(const UA_DataSetFieldContentMask *src, UA_DataSetFieldContentMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATASETFIELDCONTENTMASK]);
})

UA_INLINABLE( void
UA_DataSetFieldContentMask_clear(UA_DataSetFieldContentMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATASETFIELDCONTENTMASK]);
})

UA_INLINABLE( void
UA_DataSetFieldContentMask_delete(UA_DataSetFieldContentMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATASETFIELDCONTENTMASK]);
})

UA_INLINABLE( UA_Boolean
UA_DataSetFieldContentMask_equal(const UA_DataSetFieldContentMask *p1, const UA_DataSetFieldContentMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATASETFIELDCONTENTMASK]) == UA_ORDER_EQ);
})


/* DataSetWriterDataType */
typedef struct {
    UA_String name;
    UA_Boolean enabled;
    UA_UInt16 dataSetWriterId;
    UA_DataSetFieldContentMask dataSetFieldContentMask;
    UA_UInt32 keyFrameCount;
    UA_String dataSetName;
    size_t dataSetWriterPropertiesSize;
    UA_KeyValuePair *dataSetWriterProperties;
    UA_ExtensionObject transportSettings;
    UA_ExtensionObject messageSettings;
} UA_DataSetWriterDataType;

#define UA_TYPES_DATASETWRITERDATATYPE 83

UA_INLINABLE( void
UA_DataSetWriterDataType_init(UA_DataSetWriterDataType *p), {
    memset(p, 0, sizeof(UA_DataSetWriterDataType));
})

UA_INLINABLE( UA_DataSetWriterDataType *
UA_DataSetWriterDataType_new(void), {
    return (UA_DataSetWriterDataType*)UA_new(&UA_TYPES[UA_TYPES_DATASETWRITERDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DataSetWriterDataType_copy(const UA_DataSetWriterDataType *src, UA_DataSetWriterDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATASETWRITERDATATYPE]);
})

UA_INLINABLE( void
UA_DataSetWriterDataType_clear(UA_DataSetWriterDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATASETWRITERDATATYPE]);
})

UA_INLINABLE( void
UA_DataSetWriterDataType_delete(UA_DataSetWriterDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATASETWRITERDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DataSetWriterDataType_equal(const UA_DataSetWriterDataType *p1, const UA_DataSetWriterDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATASETWRITERDATATYPE]) == UA_ORDER_EQ);
})


/* NetworkAddressDataType */
typedef struct {
    UA_String networkInterface;
} UA_NetworkAddressDataType;

#define UA_TYPES_NETWORKADDRESSDATATYPE 84

UA_INLINABLE( void
UA_NetworkAddressDataType_init(UA_NetworkAddressDataType *p), {
    memset(p, 0, sizeof(UA_NetworkAddressDataType));
})

UA_INLINABLE( UA_NetworkAddressDataType *
UA_NetworkAddressDataType_new(void), {
    return (UA_NetworkAddressDataType*)UA_new(&UA_TYPES[UA_TYPES_NETWORKADDRESSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_NetworkAddressDataType_copy(const UA_NetworkAddressDataType *src, UA_NetworkAddressDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NETWORKADDRESSDATATYPE]);
})

UA_INLINABLE( void
UA_NetworkAddressDataType_clear(UA_NetworkAddressDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NETWORKADDRESSDATATYPE]);
})

UA_INLINABLE( void
UA_NetworkAddressDataType_delete(UA_NetworkAddressDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NETWORKADDRESSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_NetworkAddressDataType_equal(const UA_NetworkAddressDataType *p1, const UA_NetworkAddressDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NETWORKADDRESSDATATYPE]) == UA_ORDER_EQ);
})


/* NetworkAddressUrlDataType */
typedef struct {
    UA_String networkInterface;
    UA_String url;
} UA_NetworkAddressUrlDataType;

#define UA_TYPES_NETWORKADDRESSURLDATATYPE 85

UA_INLINABLE( void
UA_NetworkAddressUrlDataType_init(UA_NetworkAddressUrlDataType *p), {
    memset(p, 0, sizeof(UA_NetworkAddressUrlDataType));
})

UA_INLINABLE( UA_NetworkAddressUrlDataType *
UA_NetworkAddressUrlDataType_new(void), {
    return (UA_NetworkAddressUrlDataType*)UA_new(&UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_NetworkAddressUrlDataType_copy(const UA_NetworkAddressUrlDataType *src, UA_NetworkAddressUrlDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
})

UA_INLINABLE( void
UA_NetworkAddressUrlDataType_clear(UA_NetworkAddressUrlDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
})

UA_INLINABLE( void
UA_NetworkAddressUrlDataType_delete(UA_NetworkAddressUrlDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_NetworkAddressUrlDataType_equal(const UA_NetworkAddressUrlDataType *p1, const UA_NetworkAddressUrlDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]) == UA_ORDER_EQ);
})


/* OverrideValueHandling */
typedef enum {
    UA_OVERRIDEVALUEHANDLING_DISABLED = 0,
    UA_OVERRIDEVALUEHANDLING_LASTUSABLEVALUE = 1,
    UA_OVERRIDEVALUEHANDLING_OVERRIDEVALUE = 2,
    __UA_OVERRIDEVALUEHANDLING_FORCE32BIT = 0x7fffffff
} UA_OverrideValueHandling;

UA_STATIC_ASSERT(sizeof(UA_OverrideValueHandling) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_OVERRIDEVALUEHANDLING 86

UA_INLINABLE( void
UA_OverrideValueHandling_init(UA_OverrideValueHandling *p), {
    memset(p, 0, sizeof(UA_OverrideValueHandling));
})

UA_INLINABLE( UA_OverrideValueHandling *
UA_OverrideValueHandling_new(void), {
    return (UA_OverrideValueHandling*)UA_new(&UA_TYPES[UA_TYPES_OVERRIDEVALUEHANDLING]);
})

UA_INLINABLE( UA_StatusCode
UA_OverrideValueHandling_copy(const UA_OverrideValueHandling *src, UA_OverrideValueHandling *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OVERRIDEVALUEHANDLING]);
})

UA_INLINABLE( void
UA_OverrideValueHandling_clear(UA_OverrideValueHandling *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_OVERRIDEVALUEHANDLING]);
})

UA_INLINABLE( void
UA_OverrideValueHandling_delete(UA_OverrideValueHandling *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_OVERRIDEVALUEHANDLING]);
})

UA_INLINABLE( UA_Boolean
UA_OverrideValueHandling_equal(const UA_OverrideValueHandling *p1, const UA_OverrideValueHandling *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_OVERRIDEVALUEHANDLING]) == UA_ORDER_EQ);
})


/* StandaloneSubscribedDataSetRefDataType */
typedef struct {
    UA_String dataSetName;
} UA_StandaloneSubscribedDataSetRefDataType;

#define UA_TYPES_STANDALONESUBSCRIBEDDATASETREFDATATYPE 87

UA_INLINABLE( void
UA_StandaloneSubscribedDataSetRefDataType_init(UA_StandaloneSubscribedDataSetRefDataType *p), {
    memset(p, 0, sizeof(UA_StandaloneSubscribedDataSetRefDataType));
})

UA_INLINABLE( UA_StandaloneSubscribedDataSetRefDataType *
UA_StandaloneSubscribedDataSetRefDataType_new(void), {
    return (UA_StandaloneSubscribedDataSetRefDataType*)UA_new(&UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETREFDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_StandaloneSubscribedDataSetRefDataType_copy(const UA_StandaloneSubscribedDataSetRefDataType *src, UA_StandaloneSubscribedDataSetRefDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETREFDATATYPE]);
})

UA_INLINABLE( void
UA_StandaloneSubscribedDataSetRefDataType_clear(UA_StandaloneSubscribedDataSetRefDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETREFDATATYPE]);
})

UA_INLINABLE( void
UA_StandaloneSubscribedDataSetRefDataType_delete(UA_StandaloneSubscribedDataSetRefDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETREFDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_StandaloneSubscribedDataSetRefDataType_equal(const UA_StandaloneSubscribedDataSetRefDataType *p1, const UA_StandaloneSubscribedDataSetRefDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETREFDATATYPE]) == UA_ORDER_EQ);
})


/* DataSetOrderingType */
typedef enum {
    UA_DATASETORDERINGTYPE_UNDEFINED = 0,
    UA_DATASETORDERINGTYPE_ASCENDINGWRITERID = 1,
    UA_DATASETORDERINGTYPE_ASCENDINGWRITERIDSINGLE = 2,
    __UA_DATASETORDERINGTYPE_FORCE32BIT = 0x7fffffff
} UA_DataSetOrderingType;

UA_STATIC_ASSERT(sizeof(UA_DataSetOrderingType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_DATASETORDERINGTYPE 88

UA_INLINABLE( void
UA_DataSetOrderingType_init(UA_DataSetOrderingType *p), {
    memset(p, 0, sizeof(UA_DataSetOrderingType));
})

UA_INLINABLE( UA_DataSetOrderingType *
UA_DataSetOrderingType_new(void), {
    return (UA_DataSetOrderingType*)UA_new(&UA_TYPES[UA_TYPES_DATASETORDERINGTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DataSetOrderingType_copy(const UA_DataSetOrderingType *src, UA_DataSetOrderingType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATASETORDERINGTYPE]);
})

UA_INLINABLE( void
UA_DataSetOrderingType_clear(UA_DataSetOrderingType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATASETORDERINGTYPE]);
})

UA_INLINABLE( void
UA_DataSetOrderingType_delete(UA_DataSetOrderingType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATASETORDERINGTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DataSetOrderingType_equal(const UA_DataSetOrderingType *p1, const UA_DataSetOrderingType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATASETORDERINGTYPE]) == UA_ORDER_EQ);
})


/* UadpNetworkMessageContentMask */
typedef UA_UInt32 UA_UadpNetworkMessageContentMask;

#define UA_UADPNETWORKMESSAGECONTENTMASK_NONE 0
#define UA_UADPNETWORKMESSAGECONTENTMASK_PUBLISHERID 1
#define UA_UADPNETWORKMESSAGECONTENTMASK_GROUPHEADER 2
#define UA_UADPNETWORKMESSAGECONTENTMASK_WRITERGROUPID 4
#define UA_UADPNETWORKMESSAGECONTENTMASK_GROUPVERSION 8
#define UA_UADPNETWORKMESSAGECONTENTMASK_NETWORKMESSAGENUMBER 16
#define UA_UADPNETWORKMESSAGECONTENTMASK_SEQUENCENUMBER 32
#define UA_UADPNETWORKMESSAGECONTENTMASK_PAYLOADHEADER 64
#define UA_UADPNETWORKMESSAGECONTENTMASK_TIMESTAMP 128
#define UA_UADPNETWORKMESSAGECONTENTMASK_PICOSECONDS 256
#define UA_UADPNETWORKMESSAGECONTENTMASK_DATASETCLASSID 512
#define UA_UADPNETWORKMESSAGECONTENTMASK_PROMOTEDFIELDS 1024

#define UA_TYPES_UADPNETWORKMESSAGECONTENTMASK 89

UA_INLINABLE( void
UA_UadpNetworkMessageContentMask_init(UA_UadpNetworkMessageContentMask *p), {
    memset(p, 0, sizeof(UA_UadpNetworkMessageContentMask));
})

UA_INLINABLE( UA_UadpNetworkMessageContentMask *
UA_UadpNetworkMessageContentMask_new(void), {
    return (UA_UadpNetworkMessageContentMask*)UA_new(&UA_TYPES[UA_TYPES_UADPNETWORKMESSAGECONTENTMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_UadpNetworkMessageContentMask_copy(const UA_UadpNetworkMessageContentMask *src, UA_UadpNetworkMessageContentMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UADPNETWORKMESSAGECONTENTMASK]);
})

UA_INLINABLE( void
UA_UadpNetworkMessageContentMask_clear(UA_UadpNetworkMessageContentMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UADPNETWORKMESSAGECONTENTMASK]);
})

UA_INLINABLE( void
UA_UadpNetworkMessageContentMask_delete(UA_UadpNetworkMessageContentMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UADPNETWORKMESSAGECONTENTMASK]);
})

UA_INLINABLE( UA_Boolean
UA_UadpNetworkMessageContentMask_equal(const UA_UadpNetworkMessageContentMask *p1, const UA_UadpNetworkMessageContentMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UADPNETWORKMESSAGECONTENTMASK]) == UA_ORDER_EQ);
})


/* UadpWriterGroupMessageDataType */
typedef struct {
    UA_UInt32 groupVersion;
    UA_DataSetOrderingType dataSetOrdering;
    UA_UadpNetworkMessageContentMask networkMessageContentMask;
    UA_Double samplingOffset;
    size_t publishingOffsetSize;
    UA_Double *publishingOffset;
} UA_UadpWriterGroupMessageDataType;

#define UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE 90

UA_INLINABLE( void
UA_UadpWriterGroupMessageDataType_init(UA_UadpWriterGroupMessageDataType *p), {
    memset(p, 0, sizeof(UA_UadpWriterGroupMessageDataType));
})

UA_INLINABLE( UA_UadpWriterGroupMessageDataType *
UA_UadpWriterGroupMessageDataType_new(void), {
    return (UA_UadpWriterGroupMessageDataType*)UA_new(&UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_UadpWriterGroupMessageDataType_copy(const UA_UadpWriterGroupMessageDataType *src, UA_UadpWriterGroupMessageDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_UadpWriterGroupMessageDataType_clear(UA_UadpWriterGroupMessageDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_UadpWriterGroupMessageDataType_delete(UA_UadpWriterGroupMessageDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_UadpWriterGroupMessageDataType_equal(const UA_UadpWriterGroupMessageDataType *p1, const UA_UadpWriterGroupMessageDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]) == UA_ORDER_EQ);
})


/* UadpDataSetMessageContentMask */
typedef UA_UInt32 UA_UadpDataSetMessageContentMask;

#define UA_UADPDATASETMESSAGECONTENTMASK_NONE 0
#define UA_UADPDATASETMESSAGECONTENTMASK_TIMESTAMP 1
#define UA_UADPDATASETMESSAGECONTENTMASK_PICOSECONDS 2
#define UA_UADPDATASETMESSAGECONTENTMASK_STATUS 4
#define UA_UADPDATASETMESSAGECONTENTMASK_MAJORVERSION 8
#define UA_UADPDATASETMESSAGECONTENTMASK_MINORVERSION 16
#define UA_UADPDATASETMESSAGECONTENTMASK_SEQUENCENUMBER 32

#define UA_TYPES_UADPDATASETMESSAGECONTENTMASK 91

UA_INLINABLE( void
UA_UadpDataSetMessageContentMask_init(UA_UadpDataSetMessageContentMask *p), {
    memset(p, 0, sizeof(UA_UadpDataSetMessageContentMask));
})

UA_INLINABLE( UA_UadpDataSetMessageContentMask *
UA_UadpDataSetMessageContentMask_new(void), {
    return (UA_UadpDataSetMessageContentMask*)UA_new(&UA_TYPES[UA_TYPES_UADPDATASETMESSAGECONTENTMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_UadpDataSetMessageContentMask_copy(const UA_UadpDataSetMessageContentMask *src, UA_UadpDataSetMessageContentMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UADPDATASETMESSAGECONTENTMASK]);
})

UA_INLINABLE( void
UA_UadpDataSetMessageContentMask_clear(UA_UadpDataSetMessageContentMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UADPDATASETMESSAGECONTENTMASK]);
})

UA_INLINABLE( void
UA_UadpDataSetMessageContentMask_delete(UA_UadpDataSetMessageContentMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UADPDATASETMESSAGECONTENTMASK]);
})

UA_INLINABLE( UA_Boolean
UA_UadpDataSetMessageContentMask_equal(const UA_UadpDataSetMessageContentMask *p1, const UA_UadpDataSetMessageContentMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UADPDATASETMESSAGECONTENTMASK]) == UA_ORDER_EQ);
})


/* UadpDataSetWriterMessageDataType */
typedef struct {
    UA_UadpDataSetMessageContentMask dataSetMessageContentMask;
    UA_UInt16 configuredSize;
    UA_UInt16 networkMessageNumber;
    UA_UInt16 dataSetOffset;
} UA_UadpDataSetWriterMessageDataType;

#define UA_TYPES_UADPDATASETWRITERMESSAGEDATATYPE 92

UA_INLINABLE( void
UA_UadpDataSetWriterMessageDataType_init(UA_UadpDataSetWriterMessageDataType *p), {
    memset(p, 0, sizeof(UA_UadpDataSetWriterMessageDataType));
})

UA_INLINABLE( UA_UadpDataSetWriterMessageDataType *
UA_UadpDataSetWriterMessageDataType_new(void), {
    return (UA_UadpDataSetWriterMessageDataType*)UA_new(&UA_TYPES[UA_TYPES_UADPDATASETWRITERMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_UadpDataSetWriterMessageDataType_copy(const UA_UadpDataSetWriterMessageDataType *src, UA_UadpDataSetWriterMessageDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UADPDATASETWRITERMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_UadpDataSetWriterMessageDataType_clear(UA_UadpDataSetWriterMessageDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UADPDATASETWRITERMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_UadpDataSetWriterMessageDataType_delete(UA_UadpDataSetWriterMessageDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UADPDATASETWRITERMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_UadpDataSetWriterMessageDataType_equal(const UA_UadpDataSetWriterMessageDataType *p1, const UA_UadpDataSetWriterMessageDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UADPDATASETWRITERMESSAGEDATATYPE]) == UA_ORDER_EQ);
})


/* UadpDataSetReaderMessageDataType */
typedef struct {
    UA_UInt32 groupVersion;
    UA_UInt16 networkMessageNumber;
    UA_UInt16 dataSetOffset;
    UA_Guid dataSetClassId;
    UA_UadpNetworkMessageContentMask networkMessageContentMask;
    UA_UadpDataSetMessageContentMask dataSetMessageContentMask;
    UA_Double publishingInterval;
    UA_Double receiveOffset;
    UA_Double processingOffset;
} UA_UadpDataSetReaderMessageDataType;

#define UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE 93

UA_INLINABLE( void
UA_UadpDataSetReaderMessageDataType_init(UA_UadpDataSetReaderMessageDataType *p), {
    memset(p, 0, sizeof(UA_UadpDataSetReaderMessageDataType));
})

UA_INLINABLE( UA_UadpDataSetReaderMessageDataType *
UA_UadpDataSetReaderMessageDataType_new(void), {
    return (UA_UadpDataSetReaderMessageDataType*)UA_new(&UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_UadpDataSetReaderMessageDataType_copy(const UA_UadpDataSetReaderMessageDataType *src, UA_UadpDataSetReaderMessageDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_UadpDataSetReaderMessageDataType_clear(UA_UadpDataSetReaderMessageDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_UadpDataSetReaderMessageDataType_delete(UA_UadpDataSetReaderMessageDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_UadpDataSetReaderMessageDataType_equal(const UA_UadpDataSetReaderMessageDataType *p1, const UA_UadpDataSetReaderMessageDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]) == UA_ORDER_EQ);
})


/* JsonNetworkMessageContentMask */
typedef UA_UInt32 UA_JsonNetworkMessageContentMask;

#define UA_JSONNETWORKMESSAGECONTENTMASK_NONE 0
#define UA_JSONNETWORKMESSAGECONTENTMASK_NETWORKMESSAGEHEADER 1
#define UA_JSONNETWORKMESSAGECONTENTMASK_DATASETMESSAGEHEADER 2
#define UA_JSONNETWORKMESSAGECONTENTMASK_SINGLEDATASETMESSAGE 4
#define UA_JSONNETWORKMESSAGECONTENTMASK_PUBLISHERID 8
#define UA_JSONNETWORKMESSAGECONTENTMASK_DATASETCLASSID 16
#define UA_JSONNETWORKMESSAGECONTENTMASK_REPLYTO 32
#define UA_JSONNETWORKMESSAGECONTENTMASK_WRITERGROUPNAME 64

#define UA_TYPES_JSONNETWORKMESSAGECONTENTMASK 94

UA_INLINABLE( void
UA_JsonNetworkMessageContentMask_init(UA_JsonNetworkMessageContentMask *p), {
    memset(p, 0, sizeof(UA_JsonNetworkMessageContentMask));
})

UA_INLINABLE( UA_JsonNetworkMessageContentMask *
UA_JsonNetworkMessageContentMask_new(void), {
    return (UA_JsonNetworkMessageContentMask*)UA_new(&UA_TYPES[UA_TYPES_JSONNETWORKMESSAGECONTENTMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonNetworkMessageContentMask_copy(const UA_JsonNetworkMessageContentMask *src, UA_JsonNetworkMessageContentMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONNETWORKMESSAGECONTENTMASK]);
})

UA_INLINABLE( void
UA_JsonNetworkMessageContentMask_clear(UA_JsonNetworkMessageContentMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONNETWORKMESSAGECONTENTMASK]);
})

UA_INLINABLE( void
UA_JsonNetworkMessageContentMask_delete(UA_JsonNetworkMessageContentMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONNETWORKMESSAGECONTENTMASK]);
})

UA_INLINABLE( UA_Boolean
UA_JsonNetworkMessageContentMask_equal(const UA_JsonNetworkMessageContentMask *p1, const UA_JsonNetworkMessageContentMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONNETWORKMESSAGECONTENTMASK]) == UA_ORDER_EQ);
})


/* JsonWriterGroupMessageDataType */
typedef struct {
    UA_JsonNetworkMessageContentMask networkMessageContentMask;
} UA_JsonWriterGroupMessageDataType;

#define UA_TYPES_JSONWRITERGROUPMESSAGEDATATYPE 95

UA_INLINABLE( void
UA_JsonWriterGroupMessageDataType_init(UA_JsonWriterGroupMessageDataType *p), {
    memset(p, 0, sizeof(UA_JsonWriterGroupMessageDataType));
})

UA_INLINABLE( UA_JsonWriterGroupMessageDataType *
UA_JsonWriterGroupMessageDataType_new(void), {
    return (UA_JsonWriterGroupMessageDataType*)UA_new(&UA_TYPES[UA_TYPES_JSONWRITERGROUPMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonWriterGroupMessageDataType_copy(const UA_JsonWriterGroupMessageDataType *src, UA_JsonWriterGroupMessageDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONWRITERGROUPMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_JsonWriterGroupMessageDataType_clear(UA_JsonWriterGroupMessageDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONWRITERGROUPMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_JsonWriterGroupMessageDataType_delete(UA_JsonWriterGroupMessageDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONWRITERGROUPMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonWriterGroupMessageDataType_equal(const UA_JsonWriterGroupMessageDataType *p1, const UA_JsonWriterGroupMessageDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONWRITERGROUPMESSAGEDATATYPE]) == UA_ORDER_EQ);
})


/* JsonDataSetMessageContentMask */
typedef UA_UInt32 UA_JsonDataSetMessageContentMask;

#define UA_JSONDATASETMESSAGECONTENTMASK_NONE 0
#define UA_JSONDATASETMESSAGECONTENTMASK_DATASETWRITERID 1
#define UA_JSONDATASETMESSAGECONTENTMASK_METADATAVERSION 2
#define UA_JSONDATASETMESSAGECONTENTMASK_SEQUENCENUMBER 4
#define UA_JSONDATASETMESSAGECONTENTMASK_TIMESTAMP 8
#define UA_JSONDATASETMESSAGECONTENTMASK_STATUS 16
#define UA_JSONDATASETMESSAGECONTENTMASK_MESSAGETYPE 32
#define UA_JSONDATASETMESSAGECONTENTMASK_DATASETWRITERNAME 64
#define UA_JSONDATASETMESSAGECONTENTMASK_FIELDENCODING1 128
#define UA_JSONDATASETMESSAGECONTENTMASK_PUBLISHERID 256
#define UA_JSONDATASETMESSAGECONTENTMASK_WRITERGROUPNAME 512
#define UA_JSONDATASETMESSAGECONTENTMASK_MINORVERSION 1024
#define UA_JSONDATASETMESSAGECONTENTMASK_FIELDENCODING2 2048

#define UA_TYPES_JSONDATASETMESSAGECONTENTMASK 96

UA_INLINABLE( void
UA_JsonDataSetMessageContentMask_init(UA_JsonDataSetMessageContentMask *p), {
    memset(p, 0, sizeof(UA_JsonDataSetMessageContentMask));
})

UA_INLINABLE( UA_JsonDataSetMessageContentMask *
UA_JsonDataSetMessageContentMask_new(void), {
    return (UA_JsonDataSetMessageContentMask*)UA_new(&UA_TYPES[UA_TYPES_JSONDATASETMESSAGECONTENTMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonDataSetMessageContentMask_copy(const UA_JsonDataSetMessageContentMask *src, UA_JsonDataSetMessageContentMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONDATASETMESSAGECONTENTMASK]);
})

UA_INLINABLE( void
UA_JsonDataSetMessageContentMask_clear(UA_JsonDataSetMessageContentMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONDATASETMESSAGECONTENTMASK]);
})

UA_INLINABLE( void
UA_JsonDataSetMessageContentMask_delete(UA_JsonDataSetMessageContentMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONDATASETMESSAGECONTENTMASK]);
})

UA_INLINABLE( UA_Boolean
UA_JsonDataSetMessageContentMask_equal(const UA_JsonDataSetMessageContentMask *p1, const UA_JsonDataSetMessageContentMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONDATASETMESSAGECONTENTMASK]) == UA_ORDER_EQ);
})


/* JsonDataSetWriterMessageDataType */
typedef struct {
    UA_JsonDataSetMessageContentMask dataSetMessageContentMask;
} UA_JsonDataSetWriterMessageDataType;

#define UA_TYPES_JSONDATASETWRITERMESSAGEDATATYPE 97

UA_INLINABLE( void
UA_JsonDataSetWriterMessageDataType_init(UA_JsonDataSetWriterMessageDataType *p), {
    memset(p, 0, sizeof(UA_JsonDataSetWriterMessageDataType));
})

UA_INLINABLE( UA_JsonDataSetWriterMessageDataType *
UA_JsonDataSetWriterMessageDataType_new(void), {
    return (UA_JsonDataSetWriterMessageDataType*)UA_new(&UA_TYPES[UA_TYPES_JSONDATASETWRITERMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonDataSetWriterMessageDataType_copy(const UA_JsonDataSetWriterMessageDataType *src, UA_JsonDataSetWriterMessageDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONDATASETWRITERMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_JsonDataSetWriterMessageDataType_clear(UA_JsonDataSetWriterMessageDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONDATASETWRITERMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_JsonDataSetWriterMessageDataType_delete(UA_JsonDataSetWriterMessageDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONDATASETWRITERMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonDataSetWriterMessageDataType_equal(const UA_JsonDataSetWriterMessageDataType *p1, const UA_JsonDataSetWriterMessageDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONDATASETWRITERMESSAGEDATATYPE]) == UA_ORDER_EQ);
})


/* JsonDataSetReaderMessageDataType */
typedef struct {
    UA_JsonNetworkMessageContentMask networkMessageContentMask;
    UA_JsonDataSetMessageContentMask dataSetMessageContentMask;
} UA_JsonDataSetReaderMessageDataType;

#define UA_TYPES_JSONDATASETREADERMESSAGEDATATYPE 98

UA_INLINABLE( void
UA_JsonDataSetReaderMessageDataType_init(UA_JsonDataSetReaderMessageDataType *p), {
    memset(p, 0, sizeof(UA_JsonDataSetReaderMessageDataType));
})

UA_INLINABLE( UA_JsonDataSetReaderMessageDataType *
UA_JsonDataSetReaderMessageDataType_new(void), {
    return (UA_JsonDataSetReaderMessageDataType*)UA_new(&UA_TYPES[UA_TYPES_JSONDATASETREADERMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonDataSetReaderMessageDataType_copy(const UA_JsonDataSetReaderMessageDataType *src, UA_JsonDataSetReaderMessageDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONDATASETREADERMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_JsonDataSetReaderMessageDataType_clear(UA_JsonDataSetReaderMessageDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONDATASETREADERMESSAGEDATATYPE]);
})

UA_INLINABLE( void
UA_JsonDataSetReaderMessageDataType_delete(UA_JsonDataSetReaderMessageDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONDATASETREADERMESSAGEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonDataSetReaderMessageDataType_equal(const UA_JsonDataSetReaderMessageDataType *p1, const UA_JsonDataSetReaderMessageDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONDATASETREADERMESSAGEDATATYPE]) == UA_ORDER_EQ);
})


/* TransmitQosPriorityDataType */
typedef struct {
    UA_String priorityLabel;
} UA_TransmitQosPriorityDataType;

#define UA_TYPES_TRANSMITQOSPRIORITYDATATYPE 99

UA_INLINABLE( void
UA_TransmitQosPriorityDataType_init(UA_TransmitQosPriorityDataType *p), {
    memset(p, 0, sizeof(UA_TransmitQosPriorityDataType));
})

UA_INLINABLE( UA_TransmitQosPriorityDataType *
UA_TransmitQosPriorityDataType_new(void), {
    return (UA_TransmitQosPriorityDataType*)UA_new(&UA_TYPES[UA_TYPES_TRANSMITQOSPRIORITYDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_TransmitQosPriorityDataType_copy(const UA_TransmitQosPriorityDataType *src, UA_TransmitQosPriorityDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSMITQOSPRIORITYDATATYPE]);
})

UA_INLINABLE( void
UA_TransmitQosPriorityDataType_clear(UA_TransmitQosPriorityDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSMITQOSPRIORITYDATATYPE]);
})

UA_INLINABLE( void
UA_TransmitQosPriorityDataType_delete(UA_TransmitQosPriorityDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSMITQOSPRIORITYDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_TransmitQosPriorityDataType_equal(const UA_TransmitQosPriorityDataType *p1, const UA_TransmitQosPriorityDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRANSMITQOSPRIORITYDATATYPE]) == UA_ORDER_EQ);
})


/* ReceiveQosPriorityDataType */
typedef struct {
    UA_String priorityLabel;
} UA_ReceiveQosPriorityDataType;

#define UA_TYPES_RECEIVEQOSPRIORITYDATATYPE 100

UA_INLINABLE( void
UA_ReceiveQosPriorityDataType_init(UA_ReceiveQosPriorityDataType *p), {
    memset(p, 0, sizeof(UA_ReceiveQosPriorityDataType));
})

UA_INLINABLE( UA_ReceiveQosPriorityDataType *
UA_ReceiveQosPriorityDataType_new(void), {
    return (UA_ReceiveQosPriorityDataType*)UA_new(&UA_TYPES[UA_TYPES_RECEIVEQOSPRIORITYDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ReceiveQosPriorityDataType_copy(const UA_ReceiveQosPriorityDataType *src, UA_ReceiveQosPriorityDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RECEIVEQOSPRIORITYDATATYPE]);
})

UA_INLINABLE( void
UA_ReceiveQosPriorityDataType_clear(UA_ReceiveQosPriorityDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_RECEIVEQOSPRIORITYDATATYPE]);
})

UA_INLINABLE( void
UA_ReceiveQosPriorityDataType_delete(UA_ReceiveQosPriorityDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_RECEIVEQOSPRIORITYDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ReceiveQosPriorityDataType_equal(const UA_ReceiveQosPriorityDataType *p1, const UA_ReceiveQosPriorityDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_RECEIVEQOSPRIORITYDATATYPE]) == UA_ORDER_EQ);
})


/* DatagramConnectionTransportDataType */
typedef struct {
    UA_ExtensionObject discoveryAddress;
} UA_DatagramConnectionTransportDataType;

#define UA_TYPES_DATAGRAMCONNECTIONTRANSPORTDATATYPE 101

UA_INLINABLE( void
UA_DatagramConnectionTransportDataType_init(UA_DatagramConnectionTransportDataType *p), {
    memset(p, 0, sizeof(UA_DatagramConnectionTransportDataType));
})

UA_INLINABLE( UA_DatagramConnectionTransportDataType *
UA_DatagramConnectionTransportDataType_new(void), {
    return (UA_DatagramConnectionTransportDataType*)UA_new(&UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DatagramConnectionTransportDataType_copy(const UA_DatagramConnectionTransportDataType *src, UA_DatagramConnectionTransportDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_DatagramConnectionTransportDataType_clear(UA_DatagramConnectionTransportDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_DatagramConnectionTransportDataType_delete(UA_DatagramConnectionTransportDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DatagramConnectionTransportDataType_equal(const UA_DatagramConnectionTransportDataType *p1, const UA_DatagramConnectionTransportDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORTDATATYPE]) == UA_ORDER_EQ);
})


/* DatagramConnectionTransport2DataType */
typedef struct {
    UA_ExtensionObject discoveryAddress;
    UA_UInt32 discoveryAnnounceRate;
    UA_UInt32 discoveryMaxMessageSize;
    UA_String qosCategory;
    size_t datagramQosSize;
    UA_ExtensionObject *datagramQos;
} UA_DatagramConnectionTransport2DataType;

#define UA_TYPES_DATAGRAMCONNECTIONTRANSPORT2DATATYPE 102

UA_INLINABLE( void
UA_DatagramConnectionTransport2DataType_init(UA_DatagramConnectionTransport2DataType *p), {
    memset(p, 0, sizeof(UA_DatagramConnectionTransport2DataType));
})

UA_INLINABLE( UA_DatagramConnectionTransport2DataType *
UA_DatagramConnectionTransport2DataType_new(void), {
    return (UA_DatagramConnectionTransport2DataType*)UA_new(&UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORT2DATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DatagramConnectionTransport2DataType_copy(const UA_DatagramConnectionTransport2DataType *src, UA_DatagramConnectionTransport2DataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORT2DATATYPE]);
})

UA_INLINABLE( void
UA_DatagramConnectionTransport2DataType_clear(UA_DatagramConnectionTransport2DataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORT2DATATYPE]);
})

UA_INLINABLE( void
UA_DatagramConnectionTransport2DataType_delete(UA_DatagramConnectionTransport2DataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORT2DATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DatagramConnectionTransport2DataType_equal(const UA_DatagramConnectionTransport2DataType *p1, const UA_DatagramConnectionTransport2DataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATAGRAMCONNECTIONTRANSPORT2DATATYPE]) == UA_ORDER_EQ);
})


/* DatagramWriterGroupTransportDataType */
typedef struct {
    UA_Byte messageRepeatCount;
    UA_Double messageRepeatDelay;
} UA_DatagramWriterGroupTransportDataType;

#define UA_TYPES_DATAGRAMWRITERGROUPTRANSPORTDATATYPE 103

UA_INLINABLE( void
UA_DatagramWriterGroupTransportDataType_init(UA_DatagramWriterGroupTransportDataType *p), {
    memset(p, 0, sizeof(UA_DatagramWriterGroupTransportDataType));
})

UA_INLINABLE( UA_DatagramWriterGroupTransportDataType *
UA_DatagramWriterGroupTransportDataType_new(void), {
    return (UA_DatagramWriterGroupTransportDataType*)UA_new(&UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DatagramWriterGroupTransportDataType_copy(const UA_DatagramWriterGroupTransportDataType *src, UA_DatagramWriterGroupTransportDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_DatagramWriterGroupTransportDataType_clear(UA_DatagramWriterGroupTransportDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_DatagramWriterGroupTransportDataType_delete(UA_DatagramWriterGroupTransportDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DatagramWriterGroupTransportDataType_equal(const UA_DatagramWriterGroupTransportDataType *p1, const UA_DatagramWriterGroupTransportDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORTDATATYPE]) == UA_ORDER_EQ);
})


/* DatagramWriterGroupTransport2DataType */
typedef struct {
    UA_Byte messageRepeatCount;
    UA_Double messageRepeatDelay;
    UA_ExtensionObject address;
    UA_String qosCategory;
    size_t datagramQosSize;
    UA_ExtensionObject *datagramQos;
    UA_UInt32 discoveryAnnounceRate;
    UA_String topic;
} UA_DatagramWriterGroupTransport2DataType;

#define UA_TYPES_DATAGRAMWRITERGROUPTRANSPORT2DATATYPE 104

UA_INLINABLE( void
UA_DatagramWriterGroupTransport2DataType_init(UA_DatagramWriterGroupTransport2DataType *p), {
    memset(p, 0, sizeof(UA_DatagramWriterGroupTransport2DataType));
})

UA_INLINABLE( UA_DatagramWriterGroupTransport2DataType *
UA_DatagramWriterGroupTransport2DataType_new(void), {
    return (UA_DatagramWriterGroupTransport2DataType*)UA_new(&UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORT2DATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DatagramWriterGroupTransport2DataType_copy(const UA_DatagramWriterGroupTransport2DataType *src, UA_DatagramWriterGroupTransport2DataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORT2DATATYPE]);
})

UA_INLINABLE( void
UA_DatagramWriterGroupTransport2DataType_clear(UA_DatagramWriterGroupTransport2DataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORT2DATATYPE]);
})

UA_INLINABLE( void
UA_DatagramWriterGroupTransport2DataType_delete(UA_DatagramWriterGroupTransport2DataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORT2DATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DatagramWriterGroupTransport2DataType_equal(const UA_DatagramWriterGroupTransport2DataType *p1, const UA_DatagramWriterGroupTransport2DataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATAGRAMWRITERGROUPTRANSPORT2DATATYPE]) == UA_ORDER_EQ);
})


/* DatagramDataSetReaderTransportDataType */
typedef struct {
    UA_ExtensionObject address;
    UA_String qosCategory;
    size_t datagramQosSize;
    UA_ExtensionObject *datagramQos;
    UA_String topic;
} UA_DatagramDataSetReaderTransportDataType;

#define UA_TYPES_DATAGRAMDATASETREADERTRANSPORTDATATYPE 105

UA_INLINABLE( void
UA_DatagramDataSetReaderTransportDataType_init(UA_DatagramDataSetReaderTransportDataType *p), {
    memset(p, 0, sizeof(UA_DatagramDataSetReaderTransportDataType));
})

UA_INLINABLE( UA_DatagramDataSetReaderTransportDataType *
UA_DatagramDataSetReaderTransportDataType_new(void), {
    return (UA_DatagramDataSetReaderTransportDataType*)UA_new(&UA_TYPES[UA_TYPES_DATAGRAMDATASETREADERTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DatagramDataSetReaderTransportDataType_copy(const UA_DatagramDataSetReaderTransportDataType *src, UA_DatagramDataSetReaderTransportDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAGRAMDATASETREADERTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_DatagramDataSetReaderTransportDataType_clear(UA_DatagramDataSetReaderTransportDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATAGRAMDATASETREADERTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_DatagramDataSetReaderTransportDataType_delete(UA_DatagramDataSetReaderTransportDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATAGRAMDATASETREADERTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DatagramDataSetReaderTransportDataType_equal(const UA_DatagramDataSetReaderTransportDataType *p1, const UA_DatagramDataSetReaderTransportDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATAGRAMDATASETREADERTRANSPORTDATATYPE]) == UA_ORDER_EQ);
})


/* DtlsPubSubConnectionDataType */
typedef struct {
    UA_String clientCipherSuite;
    size_t serverCipherSuitesSize;
    UA_String *serverCipherSuites;
    UA_Boolean zeroRTT;
    UA_NodeId certificateGroupId;
    UA_Boolean verifyClientCertificate;
} UA_DtlsPubSubConnectionDataType;

#define UA_TYPES_DTLSPUBSUBCONNECTIONDATATYPE 106

UA_INLINABLE( void
UA_DtlsPubSubConnectionDataType_init(UA_DtlsPubSubConnectionDataType *p), {
    memset(p, 0, sizeof(UA_DtlsPubSubConnectionDataType));
})

UA_INLINABLE( UA_DtlsPubSubConnectionDataType *
UA_DtlsPubSubConnectionDataType_new(void), {
    return (UA_DtlsPubSubConnectionDataType*)UA_new(&UA_TYPES[UA_TYPES_DTLSPUBSUBCONNECTIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DtlsPubSubConnectionDataType_copy(const UA_DtlsPubSubConnectionDataType *src, UA_DtlsPubSubConnectionDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DTLSPUBSUBCONNECTIONDATATYPE]);
})

UA_INLINABLE( void
UA_DtlsPubSubConnectionDataType_clear(UA_DtlsPubSubConnectionDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DTLSPUBSUBCONNECTIONDATATYPE]);
})

UA_INLINABLE( void
UA_DtlsPubSubConnectionDataType_delete(UA_DtlsPubSubConnectionDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DTLSPUBSUBCONNECTIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DtlsPubSubConnectionDataType_equal(const UA_DtlsPubSubConnectionDataType *p1, const UA_DtlsPubSubConnectionDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DTLSPUBSUBCONNECTIONDATATYPE]) == UA_ORDER_EQ);
})


/* BrokerConnectionTransportDataType */
typedef struct {
    UA_String resourceUri;
    UA_String authenticationProfileUri;
} UA_BrokerConnectionTransportDataType;

#define UA_TYPES_BROKERCONNECTIONTRANSPORTDATATYPE 107

UA_INLINABLE( void
UA_BrokerConnectionTransportDataType_init(UA_BrokerConnectionTransportDataType *p), {
    memset(p, 0, sizeof(UA_BrokerConnectionTransportDataType));
})

UA_INLINABLE( UA_BrokerConnectionTransportDataType *
UA_BrokerConnectionTransportDataType_new(void), {
    return (UA_BrokerConnectionTransportDataType*)UA_new(&UA_TYPES[UA_TYPES_BROKERCONNECTIONTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_BrokerConnectionTransportDataType_copy(const UA_BrokerConnectionTransportDataType *src, UA_BrokerConnectionTransportDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROKERCONNECTIONTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_BrokerConnectionTransportDataType_clear(UA_BrokerConnectionTransportDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROKERCONNECTIONTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_BrokerConnectionTransportDataType_delete(UA_BrokerConnectionTransportDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROKERCONNECTIONTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_BrokerConnectionTransportDataType_equal(const UA_BrokerConnectionTransportDataType *p1, const UA_BrokerConnectionTransportDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROKERCONNECTIONTRANSPORTDATATYPE]) == UA_ORDER_EQ);
})


/* BrokerTransportQualityOfService */
typedef enum {
    UA_BROKERTRANSPORTQUALITYOFSERVICE_NOTSPECIFIED = 0,
    UA_BROKERTRANSPORTQUALITYOFSERVICE_BESTEFFORT = 1,
    UA_BROKERTRANSPORTQUALITYOFSERVICE_ATLEASTONCE = 2,
    UA_BROKERTRANSPORTQUALITYOFSERVICE_ATMOSTONCE = 3,
    UA_BROKERTRANSPORTQUALITYOFSERVICE_EXACTLYONCE = 4,
    __UA_BROKERTRANSPORTQUALITYOFSERVICE_FORCE32BIT = 0x7fffffff
} UA_BrokerTransportQualityOfService;

UA_STATIC_ASSERT(sizeof(UA_BrokerTransportQualityOfService) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_BROKERTRANSPORTQUALITYOFSERVICE 108

UA_INLINABLE( void
UA_BrokerTransportQualityOfService_init(UA_BrokerTransportQualityOfService *p), {
    memset(p, 0, sizeof(UA_BrokerTransportQualityOfService));
})

UA_INLINABLE( UA_BrokerTransportQualityOfService *
UA_BrokerTransportQualityOfService_new(void), {
    return (UA_BrokerTransportQualityOfService*)UA_new(&UA_TYPES[UA_TYPES_BROKERTRANSPORTQUALITYOFSERVICE]);
})

UA_INLINABLE( UA_StatusCode
UA_BrokerTransportQualityOfService_copy(const UA_BrokerTransportQualityOfService *src, UA_BrokerTransportQualityOfService *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROKERTRANSPORTQUALITYOFSERVICE]);
})

UA_INLINABLE( void
UA_BrokerTransportQualityOfService_clear(UA_BrokerTransportQualityOfService *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROKERTRANSPORTQUALITYOFSERVICE]);
})

UA_INLINABLE( void
UA_BrokerTransportQualityOfService_delete(UA_BrokerTransportQualityOfService *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROKERTRANSPORTQUALITYOFSERVICE]);
})

UA_INLINABLE( UA_Boolean
UA_BrokerTransportQualityOfService_equal(const UA_BrokerTransportQualityOfService *p1, const UA_BrokerTransportQualityOfService *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROKERTRANSPORTQUALITYOFSERVICE]) == UA_ORDER_EQ);
})


/* BrokerWriterGroupTransportDataType */
typedef struct {
    UA_String queueName;
    UA_String resourceUri;
    UA_String authenticationProfileUri;
    UA_BrokerTransportQualityOfService requestedDeliveryGuarantee;
} UA_BrokerWriterGroupTransportDataType;

#define UA_TYPES_BROKERWRITERGROUPTRANSPORTDATATYPE 109

UA_INLINABLE( void
UA_BrokerWriterGroupTransportDataType_init(UA_BrokerWriterGroupTransportDataType *p), {
    memset(p, 0, sizeof(UA_BrokerWriterGroupTransportDataType));
})

UA_INLINABLE( UA_BrokerWriterGroupTransportDataType *
UA_BrokerWriterGroupTransportDataType_new(void), {
    return (UA_BrokerWriterGroupTransportDataType*)UA_new(&UA_TYPES[UA_TYPES_BROKERWRITERGROUPTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_BrokerWriterGroupTransportDataType_copy(const UA_BrokerWriterGroupTransportDataType *src, UA_BrokerWriterGroupTransportDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROKERWRITERGROUPTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_BrokerWriterGroupTransportDataType_clear(UA_BrokerWriterGroupTransportDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROKERWRITERGROUPTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_BrokerWriterGroupTransportDataType_delete(UA_BrokerWriterGroupTransportDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROKERWRITERGROUPTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_BrokerWriterGroupTransportDataType_equal(const UA_BrokerWriterGroupTransportDataType *p1, const UA_BrokerWriterGroupTransportDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROKERWRITERGROUPTRANSPORTDATATYPE]) == UA_ORDER_EQ);
})


/* BrokerDataSetWriterTransportDataType */
typedef struct {
    UA_String queueName;
    UA_String resourceUri;
    UA_String authenticationProfileUri;
    UA_BrokerTransportQualityOfService requestedDeliveryGuarantee;
    UA_String metaDataQueueName;
    UA_Double metaDataUpdateTime;
} UA_BrokerDataSetWriterTransportDataType;

#define UA_TYPES_BROKERDATASETWRITERTRANSPORTDATATYPE 110

UA_INLINABLE( void
UA_BrokerDataSetWriterTransportDataType_init(UA_BrokerDataSetWriterTransportDataType *p), {
    memset(p, 0, sizeof(UA_BrokerDataSetWriterTransportDataType));
})

UA_INLINABLE( UA_BrokerDataSetWriterTransportDataType *
UA_BrokerDataSetWriterTransportDataType_new(void), {
    return (UA_BrokerDataSetWriterTransportDataType*)UA_new(&UA_TYPES[UA_TYPES_BROKERDATASETWRITERTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_BrokerDataSetWriterTransportDataType_copy(const UA_BrokerDataSetWriterTransportDataType *src, UA_BrokerDataSetWriterTransportDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROKERDATASETWRITERTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_BrokerDataSetWriterTransportDataType_clear(UA_BrokerDataSetWriterTransportDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROKERDATASETWRITERTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_BrokerDataSetWriterTransportDataType_delete(UA_BrokerDataSetWriterTransportDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROKERDATASETWRITERTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_BrokerDataSetWriterTransportDataType_equal(const UA_BrokerDataSetWriterTransportDataType *p1, const UA_BrokerDataSetWriterTransportDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROKERDATASETWRITERTRANSPORTDATATYPE]) == UA_ORDER_EQ);
})


/* BrokerDataSetReaderTransportDataType */
typedef struct {
    UA_String queueName;
    UA_String resourceUri;
    UA_String authenticationProfileUri;
    UA_BrokerTransportQualityOfService requestedDeliveryGuarantee;
    UA_String metaDataQueueName;
} UA_BrokerDataSetReaderTransportDataType;

#define UA_TYPES_BROKERDATASETREADERTRANSPORTDATATYPE 111

UA_INLINABLE( void
UA_BrokerDataSetReaderTransportDataType_init(UA_BrokerDataSetReaderTransportDataType *p), {
    memset(p, 0, sizeof(UA_BrokerDataSetReaderTransportDataType));
})

UA_INLINABLE( UA_BrokerDataSetReaderTransportDataType *
UA_BrokerDataSetReaderTransportDataType_new(void), {
    return (UA_BrokerDataSetReaderTransportDataType*)UA_new(&UA_TYPES[UA_TYPES_BROKERDATASETREADERTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_BrokerDataSetReaderTransportDataType_copy(const UA_BrokerDataSetReaderTransportDataType *src, UA_BrokerDataSetReaderTransportDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROKERDATASETREADERTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_BrokerDataSetReaderTransportDataType_clear(UA_BrokerDataSetReaderTransportDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROKERDATASETREADERTRANSPORTDATATYPE]);
})

UA_INLINABLE( void
UA_BrokerDataSetReaderTransportDataType_delete(UA_BrokerDataSetReaderTransportDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROKERDATASETREADERTRANSPORTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_BrokerDataSetReaderTransportDataType_equal(const UA_BrokerDataSetReaderTransportDataType *p1, const UA_BrokerDataSetReaderTransportDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROKERDATASETREADERTRANSPORTDATATYPE]) == UA_ORDER_EQ);
})


/* PubSubConfigurationRefMask */
typedef UA_UInt32 UA_PubSubConfigurationRefMask;

#define UA_PUBSUBCONFIGURATIONREFMASK_NONE 0
#define UA_PUBSUBCONFIGURATIONREFMASK_ELEMENTADD 1
#define UA_PUBSUBCONFIGURATIONREFMASK_ELEMENTMATCH 2
#define UA_PUBSUBCONFIGURATIONREFMASK_ELEMENTMODIFY 4
#define UA_PUBSUBCONFIGURATIONREFMASK_ELEMENTREMOVE 8
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCEWRITER 16
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCEREADER 32
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCEWRITERGROUP 64
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCEREADERGROUP 128
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCECONNECTION 256
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCEPUBDATASET 512
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCESUBDATASET 1024
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCESECURITYGROUP 2048
#define UA_PUBSUBCONFIGURATIONREFMASK_REFERENCEPUSHTARGET 4096

#define UA_TYPES_PUBSUBCONFIGURATIONREFMASK 112

UA_INLINABLE( void
UA_PubSubConfigurationRefMask_init(UA_PubSubConfigurationRefMask *p), {
    memset(p, 0, sizeof(UA_PubSubConfigurationRefMask));
})

UA_INLINABLE( UA_PubSubConfigurationRefMask *
UA_PubSubConfigurationRefMask_new(void), {
    return (UA_PubSubConfigurationRefMask*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubConfigurationRefMask_copy(const UA_PubSubConfigurationRefMask *src, UA_PubSubConfigurationRefMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFMASK]);
})

UA_INLINABLE( void
UA_PubSubConfigurationRefMask_clear(UA_PubSubConfigurationRefMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFMASK]);
})

UA_INLINABLE( void
UA_PubSubConfigurationRefMask_delete(UA_PubSubConfigurationRefMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFMASK]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubConfigurationRefMask_equal(const UA_PubSubConfigurationRefMask *p1, const UA_PubSubConfigurationRefMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFMASK]) == UA_ORDER_EQ);
})


/* PubSubConfigurationRefDataType */
typedef struct {
    UA_PubSubConfigurationRefMask configurationMask;
    UA_UInt16 elementIndex;
    UA_UInt16 connectionIndex;
    UA_UInt16 groupIndex;
} UA_PubSubConfigurationRefDataType;

#define UA_TYPES_PUBSUBCONFIGURATIONREFDATATYPE 113

UA_INLINABLE( void
UA_PubSubConfigurationRefDataType_init(UA_PubSubConfigurationRefDataType *p), {
    memset(p, 0, sizeof(UA_PubSubConfigurationRefDataType));
})

UA_INLINABLE( UA_PubSubConfigurationRefDataType *
UA_PubSubConfigurationRefDataType_new(void), {
    return (UA_PubSubConfigurationRefDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubConfigurationRefDataType_copy(const UA_PubSubConfigurationRefDataType *src, UA_PubSubConfigurationRefDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConfigurationRefDataType_clear(UA_PubSubConfigurationRefDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConfigurationRefDataType_delete(UA_PubSubConfigurationRefDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubConfigurationRefDataType_equal(const UA_PubSubConfigurationRefDataType *p1, const UA_PubSubConfigurationRefDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONREFDATATYPE]) == UA_ORDER_EQ);
})


/* PubSubConfigurationValueDataType */
typedef struct {
    UA_PubSubConfigurationRefDataType configurationElement;
    UA_String name;
    UA_Variant identifier;
} UA_PubSubConfigurationValueDataType;

#define UA_TYPES_PUBSUBCONFIGURATIONVALUEDATATYPE 114

UA_INLINABLE( void
UA_PubSubConfigurationValueDataType_init(UA_PubSubConfigurationValueDataType *p), {
    memset(p, 0, sizeof(UA_PubSubConfigurationValueDataType));
})

UA_INLINABLE( UA_PubSubConfigurationValueDataType *
UA_PubSubConfigurationValueDataType_new(void), {
    return (UA_PubSubConfigurationValueDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONVALUEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubConfigurationValueDataType_copy(const UA_PubSubConfigurationValueDataType *src, UA_PubSubConfigurationValueDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONVALUEDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConfigurationValueDataType_clear(UA_PubSubConfigurationValueDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONVALUEDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConfigurationValueDataType_delete(UA_PubSubConfigurationValueDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONVALUEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubConfigurationValueDataType_equal(const UA_PubSubConfigurationValueDataType *p1, const UA_PubSubConfigurationValueDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONVALUEDATATYPE]) == UA_ORDER_EQ);
})


/* DiagnosticsLevel */
typedef enum {
    UA_DIAGNOSTICSLEVEL_BASIC = 0,
    UA_DIAGNOSTICSLEVEL_ADVANCED = 1,
    UA_DIAGNOSTICSLEVEL_INFO = 2,
    UA_DIAGNOSTICSLEVEL_LOG = 3,
    UA_DIAGNOSTICSLEVEL_DEBUG = 4,
    __UA_DIAGNOSTICSLEVEL_FORCE32BIT = 0x7fffffff
} UA_DiagnosticsLevel;

UA_STATIC_ASSERT(sizeof(UA_DiagnosticsLevel) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_DIAGNOSTICSLEVEL 115

UA_INLINABLE( void
UA_DiagnosticsLevel_init(UA_DiagnosticsLevel *p), {
    memset(p, 0, sizeof(UA_DiagnosticsLevel));
})

UA_INLINABLE( UA_DiagnosticsLevel *
UA_DiagnosticsLevel_new(void), {
    return (UA_DiagnosticsLevel*)UA_new(&UA_TYPES[UA_TYPES_DIAGNOSTICSLEVEL]);
})

UA_INLINABLE( UA_StatusCode
UA_DiagnosticsLevel_copy(const UA_DiagnosticsLevel *src, UA_DiagnosticsLevel *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DIAGNOSTICSLEVEL]);
})

UA_INLINABLE( void
UA_DiagnosticsLevel_clear(UA_DiagnosticsLevel *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DIAGNOSTICSLEVEL]);
})

UA_INLINABLE( void
UA_DiagnosticsLevel_delete(UA_DiagnosticsLevel *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DIAGNOSTICSLEVEL]);
})

UA_INLINABLE( UA_Boolean
UA_DiagnosticsLevel_equal(const UA_DiagnosticsLevel *p1, const UA_DiagnosticsLevel *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DIAGNOSTICSLEVEL]) == UA_ORDER_EQ);
})


/* PubSubDiagnosticsCounterClassification */
typedef enum {
    UA_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION_INFORMATION = 0,
    UA_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION_ERROR = 1,
    __UA_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION_FORCE32BIT = 0x7fffffff
} UA_PubSubDiagnosticsCounterClassification;

UA_STATIC_ASSERT(sizeof(UA_PubSubDiagnosticsCounterClassification) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION 116

UA_INLINABLE( void
UA_PubSubDiagnosticsCounterClassification_init(UA_PubSubDiagnosticsCounterClassification *p), {
    memset(p, 0, sizeof(UA_PubSubDiagnosticsCounterClassification));
})

UA_INLINABLE( UA_PubSubDiagnosticsCounterClassification *
UA_PubSubDiagnosticsCounterClassification_new(void), {
    return (UA_PubSubDiagnosticsCounterClassification*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubDiagnosticsCounterClassification_copy(const UA_PubSubDiagnosticsCounterClassification *src, UA_PubSubDiagnosticsCounterClassification *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION]);
})

UA_INLINABLE( void
UA_PubSubDiagnosticsCounterClassification_clear(UA_PubSubDiagnosticsCounterClassification *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION]);
})

UA_INLINABLE( void
UA_PubSubDiagnosticsCounterClassification_delete(UA_PubSubDiagnosticsCounterClassification *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubDiagnosticsCounterClassification_equal(const UA_PubSubDiagnosticsCounterClassification *p1, const UA_PubSubDiagnosticsCounterClassification *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION]) == UA_ORDER_EQ);
})


/* JsonNetworkMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_String writerGroupName;
    UA_String dataSetClassId;
    size_t messagesSize;
    UA_ExtensionObject *messages;
} UA_JsonNetworkMessage;

#define UA_TYPES_JSONNETWORKMESSAGE 117

UA_INLINABLE( void
UA_JsonNetworkMessage_init(UA_JsonNetworkMessage *p), {
    memset(p, 0, sizeof(UA_JsonNetworkMessage));
})

UA_INLINABLE( UA_JsonNetworkMessage *
UA_JsonNetworkMessage_new(void), {
    return (UA_JsonNetworkMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONNETWORKMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonNetworkMessage_copy(const UA_JsonNetworkMessage *src, UA_JsonNetworkMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONNETWORKMESSAGE]);
})

UA_INLINABLE( void
UA_JsonNetworkMessage_clear(UA_JsonNetworkMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONNETWORKMESSAGE]);
})

UA_INLINABLE( void
UA_JsonNetworkMessage_delete(UA_JsonNetworkMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONNETWORKMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonNetworkMessage_equal(const UA_JsonNetworkMessage *p1, const UA_JsonNetworkMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONNETWORKMESSAGE]) == UA_ORDER_EQ);
})


/* JsonDataSetMessage */
typedef struct {
    UA_UInt16 dataSetWriterId;
    UA_String dataSetWriterName;
    UA_String publisherId;
    UA_String writerGroupName;
    UA_UInt32 sequenceNumber;
    UA_ConfigurationVersionDataType metaDataVersion;
    UA_UInt32 minorVersion;
    UA_DateTime timestamp;
    UA_StatusCode status;
    UA_String messageType;
    UA_ExtensionObject payload;
} UA_JsonDataSetMessage;

#define UA_TYPES_JSONDATASETMESSAGE 118

UA_INLINABLE( void
UA_JsonDataSetMessage_init(UA_JsonDataSetMessage *p), {
    memset(p, 0, sizeof(UA_JsonDataSetMessage));
})

UA_INLINABLE( UA_JsonDataSetMessage *
UA_JsonDataSetMessage_new(void), {
    return (UA_JsonDataSetMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONDATASETMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonDataSetMessage_copy(const UA_JsonDataSetMessage *src, UA_JsonDataSetMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONDATASETMESSAGE]);
})

UA_INLINABLE( void
UA_JsonDataSetMessage_clear(UA_JsonDataSetMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONDATASETMESSAGE]);
})

UA_INLINABLE( void
UA_JsonDataSetMessage_delete(UA_JsonDataSetMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONDATASETMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonDataSetMessage_equal(const UA_JsonDataSetMessage *p1, const UA_JsonDataSetMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONDATASETMESSAGE]) == UA_ORDER_EQ);
})


/* JsonStatusMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_DateTime timestamp;
    UA_Boolean isCyclic;
    UA_PubSubState status;
    UA_DateTime nextReportTime;
} UA_JsonStatusMessage;

#define UA_TYPES_JSONSTATUSMESSAGE 119

UA_INLINABLE( void
UA_JsonStatusMessage_init(UA_JsonStatusMessage *p), {
    memset(p, 0, sizeof(UA_JsonStatusMessage));
})

UA_INLINABLE( UA_JsonStatusMessage *
UA_JsonStatusMessage_new(void), {
    return (UA_JsonStatusMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONSTATUSMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonStatusMessage_copy(const UA_JsonStatusMessage *src, UA_JsonStatusMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONSTATUSMESSAGE]);
})

UA_INLINABLE( void
UA_JsonStatusMessage_clear(UA_JsonStatusMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONSTATUSMESSAGE]);
})

UA_INLINABLE( void
UA_JsonStatusMessage_delete(UA_JsonStatusMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONSTATUSMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonStatusMessage_equal(const UA_JsonStatusMessage *p1, const UA_JsonStatusMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONSTATUSMESSAGE]) == UA_ORDER_EQ);
})


/* JsonActionNetworkMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_DateTime timestamp;
    UA_String responseAddress;
    UA_ByteString correlationData;
    UA_String requestorId;
    UA_Double timeoutHint;
    size_t messagesSize;
    UA_ExtensionObject *messages;
} UA_JsonActionNetworkMessage;

#define UA_TYPES_JSONACTIONNETWORKMESSAGE 120

UA_INLINABLE( void
UA_JsonActionNetworkMessage_init(UA_JsonActionNetworkMessage *p), {
    memset(p, 0, sizeof(UA_JsonActionNetworkMessage));
})

UA_INLINABLE( UA_JsonActionNetworkMessage *
UA_JsonActionNetworkMessage_new(void), {
    return (UA_JsonActionNetworkMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONACTIONNETWORKMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonActionNetworkMessage_copy(const UA_JsonActionNetworkMessage *src, UA_JsonActionNetworkMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONACTIONNETWORKMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionNetworkMessage_clear(UA_JsonActionNetworkMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONACTIONNETWORKMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionNetworkMessage_delete(UA_JsonActionNetworkMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONACTIONNETWORKMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonActionNetworkMessage_equal(const UA_JsonActionNetworkMessage *p1, const UA_JsonActionNetworkMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONACTIONNETWORKMESSAGE]) == UA_ORDER_EQ);
})


/* JsonActionRequestMessage */
typedef struct {
    UA_UInt16 dataSetWriterId;
    UA_UInt16 actionTargetId;
    UA_String dataSetWriterName;
    UA_String writerGroupName;
    UA_ConfigurationVersionDataType metaDataVersion;
    UA_UInt32 minorVersion;
    UA_DateTime timestamp;
    UA_String messageType;
    UA_UInt16 requestId;
    UA_ActionState actionState;
    UA_ExtensionObject payload;
} UA_JsonActionRequestMessage;

#define UA_TYPES_JSONACTIONREQUESTMESSAGE 121

UA_INLINABLE( void
UA_JsonActionRequestMessage_init(UA_JsonActionRequestMessage *p), {
    memset(p, 0, sizeof(UA_JsonActionRequestMessage));
})

UA_INLINABLE( UA_JsonActionRequestMessage *
UA_JsonActionRequestMessage_new(void), {
    return (UA_JsonActionRequestMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONACTIONREQUESTMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonActionRequestMessage_copy(const UA_JsonActionRequestMessage *src, UA_JsonActionRequestMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONACTIONREQUESTMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionRequestMessage_clear(UA_JsonActionRequestMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONACTIONREQUESTMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionRequestMessage_delete(UA_JsonActionRequestMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONACTIONREQUESTMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonActionRequestMessage_equal(const UA_JsonActionRequestMessage *p1, const UA_JsonActionRequestMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONACTIONREQUESTMESSAGE]) == UA_ORDER_EQ);
})


/* JsonActionResponseMessage */
typedef struct {
    UA_UInt16 dataSetWriterId;
    UA_UInt16 actionTargetId;
    UA_String dataSetWriterName;
    UA_String writerGroupName;
    UA_ConfigurationVersionDataType metaDataVersion;
    UA_UInt32 minorVersion;
    UA_DateTime timestamp;
    UA_StatusCode status;
    UA_String messageType;
    UA_UInt16 requestId;
    UA_ActionState actionState;
    UA_ExtensionObject payload;
} UA_JsonActionResponseMessage;

#define UA_TYPES_JSONACTIONRESPONSEMESSAGE 122

UA_INLINABLE( void
UA_JsonActionResponseMessage_init(UA_JsonActionResponseMessage *p), {
    memset(p, 0, sizeof(UA_JsonActionResponseMessage));
})

UA_INLINABLE( UA_JsonActionResponseMessage *
UA_JsonActionResponseMessage_new(void), {
    return (UA_JsonActionResponseMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONACTIONRESPONSEMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonActionResponseMessage_copy(const UA_JsonActionResponseMessage *src, UA_JsonActionResponseMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONACTIONRESPONSEMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionResponseMessage_clear(UA_JsonActionResponseMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONACTIONRESPONSEMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionResponseMessage_delete(UA_JsonActionResponseMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONACTIONRESPONSEMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonActionResponseMessage_equal(const UA_JsonActionResponseMessage *p1, const UA_JsonActionResponseMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONACTIONRESPONSEMESSAGE]) == UA_ORDER_EQ);
})


/* AliasNameDataType */
typedef struct {
    UA_QualifiedName aliasName;
    size_t referencedNodesSize;
    UA_ExpandedNodeId *referencedNodes;
} UA_AliasNameDataType;

#define UA_TYPES_ALIASNAMEDATATYPE 123

UA_INLINABLE( void
UA_AliasNameDataType_init(UA_AliasNameDataType *p), {
    memset(p, 0, sizeof(UA_AliasNameDataType));
})

UA_INLINABLE( UA_AliasNameDataType *
UA_AliasNameDataType_new(void), {
    return (UA_AliasNameDataType*)UA_new(&UA_TYPES[UA_TYPES_ALIASNAMEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_AliasNameDataType_copy(const UA_AliasNameDataType *src, UA_AliasNameDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ALIASNAMEDATATYPE]);
})

UA_INLINABLE( void
UA_AliasNameDataType_clear(UA_AliasNameDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ALIASNAMEDATATYPE]);
})

UA_INLINABLE( void
UA_AliasNameDataType_delete(UA_AliasNameDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ALIASNAMEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_AliasNameDataType_equal(const UA_AliasNameDataType *p1, const UA_AliasNameDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ALIASNAMEDATATYPE]) == UA_ORDER_EQ);
})


/* PasswordOptionsMask */
typedef UA_UInt32 UA_PasswordOptionsMask;

#define UA_PASSWORDOPTIONSMASK_NONE 0
#define UA_PASSWORDOPTIONSMASK_SUPPORTINITIALPASSWORDCHANGE 1
#define UA_PASSWORDOPTIONSMASK_SUPPORTDISABLEUSER 2
#define UA_PASSWORDOPTIONSMASK_SUPPORTDISABLEDELETEFORUSER 4
#define UA_PASSWORDOPTIONSMASK_SUPPORTNOCHANGEFORUSER 8
#define UA_PASSWORDOPTIONSMASK_SUPPORTDESCRIPTIONFORUSER 16
#define UA_PASSWORDOPTIONSMASK_REQUIRESUPPERCASECHARACTERS 32
#define UA_PASSWORDOPTIONSMASK_REQUIRESLOWERCASECHARACTERS 64
#define UA_PASSWORDOPTIONSMASK_REQUIRESDIGITCHARACTERS 128
#define UA_PASSWORDOPTIONSMASK_REQUIRESSPECIALCHARACTERS 256

#define UA_TYPES_PASSWORDOPTIONSMASK 124

UA_INLINABLE( void
UA_PasswordOptionsMask_init(UA_PasswordOptionsMask *p), {
    memset(p, 0, sizeof(UA_PasswordOptionsMask));
})

UA_INLINABLE( UA_PasswordOptionsMask *
UA_PasswordOptionsMask_new(void), {
    return (UA_PasswordOptionsMask*)UA_new(&UA_TYPES[UA_TYPES_PASSWORDOPTIONSMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_PasswordOptionsMask_copy(const UA_PasswordOptionsMask *src, UA_PasswordOptionsMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PASSWORDOPTIONSMASK]);
})

UA_INLINABLE( void
UA_PasswordOptionsMask_clear(UA_PasswordOptionsMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PASSWORDOPTIONSMASK]);
})

UA_INLINABLE( void
UA_PasswordOptionsMask_delete(UA_PasswordOptionsMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PASSWORDOPTIONSMASK]);
})

UA_INLINABLE( UA_Boolean
UA_PasswordOptionsMask_equal(const UA_PasswordOptionsMask *p1, const UA_PasswordOptionsMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PASSWORDOPTIONSMASK]) == UA_ORDER_EQ);
})


/* UserConfigurationMask */
typedef UA_UInt32 UA_UserConfigurationMask;

#define UA_USERCONFIGURATIONMASK_NONE 0
#define UA_USERCONFIGURATIONMASK_NODELETE 1
#define UA_USERCONFIGURATIONMASK_DISABLED 2
#define UA_USERCONFIGURATIONMASK_NOCHANGEBYUSER 4
#define UA_USERCONFIGURATIONMASK_MUSTCHANGEPASSWORD 8

#define UA_TYPES_USERCONFIGURATIONMASK 125

UA_INLINABLE( void
UA_UserConfigurationMask_init(UA_UserConfigurationMask *p), {
    memset(p, 0, sizeof(UA_UserConfigurationMask));
})

UA_INLINABLE( UA_UserConfigurationMask *
UA_UserConfigurationMask_new(void), {
    return (UA_UserConfigurationMask*)UA_new(&UA_TYPES[UA_TYPES_USERCONFIGURATIONMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_UserConfigurationMask_copy(const UA_UserConfigurationMask *src, UA_UserConfigurationMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERCONFIGURATIONMASK]);
})

UA_INLINABLE( void
UA_UserConfigurationMask_clear(UA_UserConfigurationMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERCONFIGURATIONMASK]);
})

UA_INLINABLE( void
UA_UserConfigurationMask_delete(UA_UserConfigurationMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERCONFIGURATIONMASK]);
})

UA_INLINABLE( UA_Boolean
UA_UserConfigurationMask_equal(const UA_UserConfigurationMask *p1, const UA_UserConfigurationMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_USERCONFIGURATIONMASK]) == UA_ORDER_EQ);
})


/* UserManagementDataType */
typedef struct {
    UA_String userName;
    UA_UserConfigurationMask userConfiguration;
    UA_String description;
} UA_UserManagementDataType;

#define UA_TYPES_USERMANAGEMENTDATATYPE 126

UA_INLINABLE( void
UA_UserManagementDataType_init(UA_UserManagementDataType *p), {
    memset(p, 0, sizeof(UA_UserManagementDataType));
})

UA_INLINABLE( UA_UserManagementDataType *
UA_UserManagementDataType_new(void), {
    return (UA_UserManagementDataType*)UA_new(&UA_TYPES[UA_TYPES_USERMANAGEMENTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_UserManagementDataType_copy(const UA_UserManagementDataType *src, UA_UserManagementDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERMANAGEMENTDATATYPE]);
})

UA_INLINABLE( void
UA_UserManagementDataType_clear(UA_UserManagementDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERMANAGEMENTDATATYPE]);
})

UA_INLINABLE( void
UA_UserManagementDataType_delete(UA_UserManagementDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERMANAGEMENTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_UserManagementDataType_equal(const UA_UserManagementDataType *p1, const UA_UserManagementDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_USERMANAGEMENTDATATYPE]) == UA_ORDER_EQ);
})


/* EncodedTicket */
typedef UA_ByteString UA_EncodedTicket;

#define UA_TYPES_ENCODEDTICKET 127

UA_INLINABLE( void
UA_EncodedTicket_init(UA_EncodedTicket *p), {
    memset(p, 0, sizeof(UA_EncodedTicket));
})

UA_INLINABLE( UA_EncodedTicket *
UA_EncodedTicket_new(void), {
    return (UA_EncodedTicket*)UA_new(&UA_TYPES[UA_TYPES_ENCODEDTICKET]);
})

UA_INLINABLE( UA_StatusCode
UA_EncodedTicket_copy(const UA_EncodedTicket *src, UA_EncodedTicket *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENCODEDTICKET]);
})

UA_INLINABLE( void
UA_EncodedTicket_clear(UA_EncodedTicket *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENCODEDTICKET]);
})

UA_INLINABLE( void
UA_EncodedTicket_delete(UA_EncodedTicket *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENCODEDTICKET]);
})

UA_INLINABLE( UA_Boolean
UA_EncodedTicket_equal(const UA_EncodedTicket *p1, const UA_EncodedTicket *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENCODEDTICKET]) == UA_ORDER_EQ);
})


/* Duplex */
typedef enum {
    UA_DUPLEX_FULL = 0,
    UA_DUPLEX_HALF = 1,
    UA_DUPLEX_UNKNOWN = 2,
    __UA_DUPLEX_FORCE32BIT = 0x7fffffff
} UA_Duplex;

UA_STATIC_ASSERT(sizeof(UA_Duplex) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_DUPLEX 128

UA_INLINABLE( void
UA_Duplex_init(UA_Duplex *p), {
    memset(p, 0, sizeof(UA_Duplex));
})

UA_INLINABLE( UA_Duplex *
UA_Duplex_new(void), {
    return (UA_Duplex*)UA_new(&UA_TYPES[UA_TYPES_DUPLEX]);
})

UA_INLINABLE( UA_StatusCode
UA_Duplex_copy(const UA_Duplex *src, UA_Duplex *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DUPLEX]);
})

UA_INLINABLE( void
UA_Duplex_clear(UA_Duplex *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DUPLEX]);
})

UA_INLINABLE( void
UA_Duplex_delete(UA_Duplex *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DUPLEX]);
})

UA_INLINABLE( UA_Boolean
UA_Duplex_equal(const UA_Duplex *p1, const UA_Duplex *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DUPLEX]) == UA_ORDER_EQ);
})


/* InterfaceAdminStatus */
typedef enum {
    UA_INTERFACEADMINSTATUS_UP = 0,
    UA_INTERFACEADMINSTATUS_DOWN = 1,
    UA_INTERFACEADMINSTATUS_TESTING = 2,
    __UA_INTERFACEADMINSTATUS_FORCE32BIT = 0x7fffffff
} UA_InterfaceAdminStatus;

UA_STATIC_ASSERT(sizeof(UA_InterfaceAdminStatus) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_INTERFACEADMINSTATUS 129

UA_INLINABLE( void
UA_InterfaceAdminStatus_init(UA_InterfaceAdminStatus *p), {
    memset(p, 0, sizeof(UA_InterfaceAdminStatus));
})

UA_INLINABLE( UA_InterfaceAdminStatus *
UA_InterfaceAdminStatus_new(void), {
    return (UA_InterfaceAdminStatus*)UA_new(&UA_TYPES[UA_TYPES_INTERFACEADMINSTATUS]);
})

UA_INLINABLE( UA_StatusCode
UA_InterfaceAdminStatus_copy(const UA_InterfaceAdminStatus *src, UA_InterfaceAdminStatus *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INTERFACEADMINSTATUS]);
})

UA_INLINABLE( void
UA_InterfaceAdminStatus_clear(UA_InterfaceAdminStatus *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_INTERFACEADMINSTATUS]);
})

UA_INLINABLE( void
UA_InterfaceAdminStatus_delete(UA_InterfaceAdminStatus *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_INTERFACEADMINSTATUS]);
})

UA_INLINABLE( UA_Boolean
UA_InterfaceAdminStatus_equal(const UA_InterfaceAdminStatus *p1, const UA_InterfaceAdminStatus *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_INTERFACEADMINSTATUS]) == UA_ORDER_EQ);
})


/* InterfaceOperStatus */
typedef enum {
    UA_INTERFACEOPERSTATUS_UP = 0,
    UA_INTERFACEOPERSTATUS_DOWN = 1,
    UA_INTERFACEOPERSTATUS_TESTING = 2,
    UA_INTERFACEOPERSTATUS_UNKNOWN = 3,
    UA_INTERFACEOPERSTATUS_DORMANT = 4,
    UA_INTERFACEOPERSTATUS_NOTPRESENT = 5,
    UA_INTERFACEOPERSTATUS_LOWERLAYERDOWN = 6,
    __UA_INTERFACEOPERSTATUS_FORCE32BIT = 0x7fffffff
} UA_InterfaceOperStatus;

UA_STATIC_ASSERT(sizeof(UA_InterfaceOperStatus) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_INTERFACEOPERSTATUS 130

UA_INLINABLE( void
UA_InterfaceOperStatus_init(UA_InterfaceOperStatus *p), {
    memset(p, 0, sizeof(UA_InterfaceOperStatus));
})

UA_INLINABLE( UA_InterfaceOperStatus *
UA_InterfaceOperStatus_new(void), {
    return (UA_InterfaceOperStatus*)UA_new(&UA_TYPES[UA_TYPES_INTERFACEOPERSTATUS]);
})

UA_INLINABLE( UA_StatusCode
UA_InterfaceOperStatus_copy(const UA_InterfaceOperStatus *src, UA_InterfaceOperStatus *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INTERFACEOPERSTATUS]);
})

UA_INLINABLE( void
UA_InterfaceOperStatus_clear(UA_InterfaceOperStatus *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_INTERFACEOPERSTATUS]);
})

UA_INLINABLE( void
UA_InterfaceOperStatus_delete(UA_InterfaceOperStatus *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_INTERFACEOPERSTATUS]);
})

UA_INLINABLE( UA_Boolean
UA_InterfaceOperStatus_equal(const UA_InterfaceOperStatus *p1, const UA_InterfaceOperStatus *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_INTERFACEOPERSTATUS]) == UA_ORDER_EQ);
})


/* NegotiationStatus */
typedef enum {
    UA_NEGOTIATIONSTATUS_INPROGRESS = 0,
    UA_NEGOTIATIONSTATUS_COMPLETE = 1,
    UA_NEGOTIATIONSTATUS_FAILED = 2,
    UA_NEGOTIATIONSTATUS_UNKNOWN = 3,
    UA_NEGOTIATIONSTATUS_NONEGOTIATION = 4,
    __UA_NEGOTIATIONSTATUS_FORCE32BIT = 0x7fffffff
} UA_NegotiationStatus;

UA_STATIC_ASSERT(sizeof(UA_NegotiationStatus) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_NEGOTIATIONSTATUS 131

UA_INLINABLE( void
UA_NegotiationStatus_init(UA_NegotiationStatus *p), {
    memset(p, 0, sizeof(UA_NegotiationStatus));
})

UA_INLINABLE( UA_NegotiationStatus *
UA_NegotiationStatus_new(void), {
    return (UA_NegotiationStatus*)UA_new(&UA_TYPES[UA_TYPES_NEGOTIATIONSTATUS]);
})

UA_INLINABLE( UA_StatusCode
UA_NegotiationStatus_copy(const UA_NegotiationStatus *src, UA_NegotiationStatus *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NEGOTIATIONSTATUS]);
})

UA_INLINABLE( void
UA_NegotiationStatus_clear(UA_NegotiationStatus *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NEGOTIATIONSTATUS]);
})

UA_INLINABLE( void
UA_NegotiationStatus_delete(UA_NegotiationStatus *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NEGOTIATIONSTATUS]);
})

UA_INLINABLE( UA_Boolean
UA_NegotiationStatus_equal(const UA_NegotiationStatus *p1, const UA_NegotiationStatus *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NEGOTIATIONSTATUS]) == UA_ORDER_EQ);
})


/* TsnFailureCode */
typedef enum {
    UA_TSNFAILURECODE_NOFAILURE = 0,
    UA_TSNFAILURECODE_INSUFFICIENTBANDWIDTH = 1,
    UA_TSNFAILURECODE_INSUFFICIENTRESOURCES = 2,
    UA_TSNFAILURECODE_INSUFFICIENTTRAFFICCLASSBANDWIDTH = 3,
    UA_TSNFAILURECODE_STREAMIDINUSE = 4,
    UA_TSNFAILURECODE_STREAMDESTINATIONADDRESSINUSE = 5,
    UA_TSNFAILURECODE_STREAMPREEMPTEDBYHIGHERRANK = 6,
    UA_TSNFAILURECODE_LATENCYHASCHANGED = 7,
    UA_TSNFAILURECODE_EGRESSPORTNOTAVBCAPABLE = 8,
    UA_TSNFAILURECODE_USEDIFFERENTDESTINATIONADDRESS = 9,
    UA_TSNFAILURECODE_OUTOFMSRPRESOURCES = 10,
    UA_TSNFAILURECODE_OUTOFMMRPRESOURCES = 11,
    UA_TSNFAILURECODE_CANNOTSTOREDESTINATIONADDRESS = 12,
    UA_TSNFAILURECODE_PRIORITYISNOTANSRCCLASS = 13,
    UA_TSNFAILURECODE_MAXFRAMESIZETOOLARGE = 14,
    UA_TSNFAILURECODE_MAXFANINPORTSLIMITREACHED = 15,
    UA_TSNFAILURECODE_FIRSTVALUECHANGEDFORSTREAMID = 16,
    UA_TSNFAILURECODE_VLANBLOCKEDONEGRESS = 17,
    UA_TSNFAILURECODE_VLANTAGGINGDISABLEDONEGRESS = 18,
    UA_TSNFAILURECODE_SRCLASSPRIORITYMISMATCH = 19,
    UA_TSNFAILURECODE_FEATURENOTPROPAGATED = 20,
    UA_TSNFAILURECODE_MAXLATENCYEXCEEDED = 21,
    UA_TSNFAILURECODE_BRIDGEDOESNOTPROVIDENETWORKID = 22,
    UA_TSNFAILURECODE_STREAMTRANSFORMNOTSUPPORTED = 23,
    UA_TSNFAILURECODE_STREAMIDTYPENOTSUPPORTED = 24,
    UA_TSNFAILURECODE_FEATURENOTSUPPORTED = 25,
    __UA_TSNFAILURECODE_FORCE32BIT = 0x7fffffff
} UA_TsnFailureCode;

UA_STATIC_ASSERT(sizeof(UA_TsnFailureCode) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_TSNFAILURECODE 132

UA_INLINABLE( void
UA_TsnFailureCode_init(UA_TsnFailureCode *p), {
    memset(p, 0, sizeof(UA_TsnFailureCode));
})

UA_INLINABLE( UA_TsnFailureCode *
UA_TsnFailureCode_new(void), {
    return (UA_TsnFailureCode*)UA_new(&UA_TYPES[UA_TYPES_TSNFAILURECODE]);
})

UA_INLINABLE( UA_StatusCode
UA_TsnFailureCode_copy(const UA_TsnFailureCode *src, UA_TsnFailureCode *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TSNFAILURECODE]);
})

UA_INLINABLE( void
UA_TsnFailureCode_clear(UA_TsnFailureCode *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TSNFAILURECODE]);
})

UA_INLINABLE( void
UA_TsnFailureCode_delete(UA_TsnFailureCode *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TSNFAILURECODE]);
})

UA_INLINABLE( UA_Boolean
UA_TsnFailureCode_equal(const UA_TsnFailureCode *p1, const UA_TsnFailureCode *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TSNFAILURECODE]) == UA_ORDER_EQ);
})


/* TsnStreamState */
typedef enum {
    UA_TSNSTREAMSTATE_DISABLED = 0,
    UA_TSNSTREAMSTATE_CONFIGURING = 1,
    UA_TSNSTREAMSTATE_READY = 2,
    UA_TSNSTREAMSTATE_OPERATIONAL = 3,
    UA_TSNSTREAMSTATE_ERROR = 4,
    __UA_TSNSTREAMSTATE_FORCE32BIT = 0x7fffffff
} UA_TsnStreamState;

UA_STATIC_ASSERT(sizeof(UA_TsnStreamState) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_TSNSTREAMSTATE 133

UA_INLINABLE( void
UA_TsnStreamState_init(UA_TsnStreamState *p), {
    memset(p, 0, sizeof(UA_TsnStreamState));
})

UA_INLINABLE( UA_TsnStreamState *
UA_TsnStreamState_new(void), {
    return (UA_TsnStreamState*)UA_new(&UA_TYPES[UA_TYPES_TSNSTREAMSTATE]);
})

UA_INLINABLE( UA_StatusCode
UA_TsnStreamState_copy(const UA_TsnStreamState *src, UA_TsnStreamState *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TSNSTREAMSTATE]);
})

UA_INLINABLE( void
UA_TsnStreamState_clear(UA_TsnStreamState *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TSNSTREAMSTATE]);
})

UA_INLINABLE( void
UA_TsnStreamState_delete(UA_TsnStreamState *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TSNSTREAMSTATE]);
})

UA_INLINABLE( UA_Boolean
UA_TsnStreamState_equal(const UA_TsnStreamState *p1, const UA_TsnStreamState *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TSNSTREAMSTATE]) == UA_ORDER_EQ);
})


/* TsnTalkerStatus */
typedef enum {
    UA_TSNTALKERSTATUS_NONE = 0,
    UA_TSNTALKERSTATUS_READY = 1,
    UA_TSNTALKERSTATUS_FAILED = 2,
    __UA_TSNTALKERSTATUS_FORCE32BIT = 0x7fffffff
} UA_TsnTalkerStatus;

UA_STATIC_ASSERT(sizeof(UA_TsnTalkerStatus) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_TSNTALKERSTATUS 134

UA_INLINABLE( void
UA_TsnTalkerStatus_init(UA_TsnTalkerStatus *p), {
    memset(p, 0, sizeof(UA_TsnTalkerStatus));
})

UA_INLINABLE( UA_TsnTalkerStatus *
UA_TsnTalkerStatus_new(void), {
    return (UA_TsnTalkerStatus*)UA_new(&UA_TYPES[UA_TYPES_TSNTALKERSTATUS]);
})

UA_INLINABLE( UA_StatusCode
UA_TsnTalkerStatus_copy(const UA_TsnTalkerStatus *src, UA_TsnTalkerStatus *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TSNTALKERSTATUS]);
})

UA_INLINABLE( void
UA_TsnTalkerStatus_clear(UA_TsnTalkerStatus *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TSNTALKERSTATUS]);
})

UA_INLINABLE( void
UA_TsnTalkerStatus_delete(UA_TsnTalkerStatus *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TSNTALKERSTATUS]);
})

UA_INLINABLE( UA_Boolean
UA_TsnTalkerStatus_equal(const UA_TsnTalkerStatus *p1, const UA_TsnTalkerStatus *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TSNTALKERSTATUS]) == UA_ORDER_EQ);
})


/* TsnListenerStatus */
typedef enum {
    UA_TSNLISTENERSTATUS_NONE = 0,
    UA_TSNLISTENERSTATUS_READY = 1,
    UA_TSNLISTENERSTATUS_PARTIALFAILED = 2,
    UA_TSNLISTENERSTATUS_FAILED = 3,
    __UA_TSNLISTENERSTATUS_FORCE32BIT = 0x7fffffff
} UA_TsnListenerStatus;

UA_STATIC_ASSERT(sizeof(UA_TsnListenerStatus) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_TSNLISTENERSTATUS 135

UA_INLINABLE( void
UA_TsnListenerStatus_init(UA_TsnListenerStatus *p), {
    memset(p, 0, sizeof(UA_TsnListenerStatus));
})

UA_INLINABLE( UA_TsnListenerStatus *
UA_TsnListenerStatus_new(void), {
    return (UA_TsnListenerStatus*)UA_new(&UA_TYPES[UA_TYPES_TSNLISTENERSTATUS]);
})

UA_INLINABLE( UA_StatusCode
UA_TsnListenerStatus_copy(const UA_TsnListenerStatus *src, UA_TsnListenerStatus *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TSNLISTENERSTATUS]);
})

UA_INLINABLE( void
UA_TsnListenerStatus_clear(UA_TsnListenerStatus *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TSNLISTENERSTATUS]);
})

UA_INLINABLE( void
UA_TsnListenerStatus_delete(UA_TsnListenerStatus *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TSNLISTENERSTATUS]);
})

UA_INLINABLE( UA_Boolean
UA_TsnListenerStatus_equal(const UA_TsnListenerStatus *p1, const UA_TsnListenerStatus *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TSNLISTENERSTATUS]) == UA_ORDER_EQ);
})


/* ChassisIdSubtype */
typedef enum {
    UA_CHASSISIDSUBTYPE_CHASSISCOMPONENT = 1,
    UA_CHASSISIDSUBTYPE_INTERFACEALIAS = 2,
    UA_CHASSISIDSUBTYPE_PORTCOMPONENT = 3,
    UA_CHASSISIDSUBTYPE_MACADDRESS = 4,
    UA_CHASSISIDSUBTYPE_NETWORKADDRESS = 5,
    UA_CHASSISIDSUBTYPE_INTERFACENAME = 6,
    UA_CHASSISIDSUBTYPE_LOCAL = 7,
    __UA_CHASSISIDSUBTYPE_FORCE32BIT = 0x7fffffff
} UA_ChassisIdSubtype;

UA_STATIC_ASSERT(sizeof(UA_ChassisIdSubtype) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_CHASSISIDSUBTYPE 136

UA_INLINABLE( void
UA_ChassisIdSubtype_init(UA_ChassisIdSubtype *p), {
    memset(p, 0, sizeof(UA_ChassisIdSubtype));
})

UA_INLINABLE( UA_ChassisIdSubtype *
UA_ChassisIdSubtype_new(void), {
    return (UA_ChassisIdSubtype*)UA_new(&UA_TYPES[UA_TYPES_CHASSISIDSUBTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ChassisIdSubtype_copy(const UA_ChassisIdSubtype *src, UA_ChassisIdSubtype *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CHASSISIDSUBTYPE]);
})

UA_INLINABLE( void
UA_ChassisIdSubtype_clear(UA_ChassisIdSubtype *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CHASSISIDSUBTYPE]);
})

UA_INLINABLE( void
UA_ChassisIdSubtype_delete(UA_ChassisIdSubtype *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CHASSISIDSUBTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ChassisIdSubtype_equal(const UA_ChassisIdSubtype *p1, const UA_ChassisIdSubtype *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CHASSISIDSUBTYPE]) == UA_ORDER_EQ);
})


/* PortIdSubtype */
typedef enum {
    UA_PORTIDSUBTYPE_INTERFACEALIAS = 1,
    UA_PORTIDSUBTYPE_PORTCOMPONENT = 2,
    UA_PORTIDSUBTYPE_MACADDRESS = 3,
    UA_PORTIDSUBTYPE_NETWORKADDRESS = 4,
    UA_PORTIDSUBTYPE_INTERFACENAME = 5,
    UA_PORTIDSUBTYPE_AGENTCIRCUITID = 6,
    UA_PORTIDSUBTYPE_LOCAL = 7,
    __UA_PORTIDSUBTYPE_FORCE32BIT = 0x7fffffff
} UA_PortIdSubtype;

UA_STATIC_ASSERT(sizeof(UA_PortIdSubtype) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_PORTIDSUBTYPE 137

UA_INLINABLE( void
UA_PortIdSubtype_init(UA_PortIdSubtype *p), {
    memset(p, 0, sizeof(UA_PortIdSubtype));
})

UA_INLINABLE( UA_PortIdSubtype *
UA_PortIdSubtype_new(void), {
    return (UA_PortIdSubtype*)UA_new(&UA_TYPES[UA_TYPES_PORTIDSUBTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PortIdSubtype_copy(const UA_PortIdSubtype *src, UA_PortIdSubtype *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PORTIDSUBTYPE]);
})

UA_INLINABLE( void
UA_PortIdSubtype_clear(UA_PortIdSubtype *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PORTIDSUBTYPE]);
})

UA_INLINABLE( void
UA_PortIdSubtype_delete(UA_PortIdSubtype *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PORTIDSUBTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PortIdSubtype_equal(const UA_PortIdSubtype *p1, const UA_PortIdSubtype *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PORTIDSUBTYPE]) == UA_ORDER_EQ);
})


/* ManAddrIfSubtype */
typedef enum {
    UA_MANADDRIFSUBTYPE_NONE = 0,
    UA_MANADDRIFSUBTYPE_UNKNOWN = 1,
    UA_MANADDRIFSUBTYPE_PORTREF = 2,
    UA_MANADDRIFSUBTYPE_SYSTEMPORTNUMBER = 3,
    __UA_MANADDRIFSUBTYPE_FORCE32BIT = 0x7fffffff
} UA_ManAddrIfSubtype;

UA_STATIC_ASSERT(sizeof(UA_ManAddrIfSubtype) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_MANADDRIFSUBTYPE 138

UA_INLINABLE( void
UA_ManAddrIfSubtype_init(UA_ManAddrIfSubtype *p), {
    memset(p, 0, sizeof(UA_ManAddrIfSubtype));
})

UA_INLINABLE( UA_ManAddrIfSubtype *
UA_ManAddrIfSubtype_new(void), {
    return (UA_ManAddrIfSubtype*)UA_new(&UA_TYPES[UA_TYPES_MANADDRIFSUBTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ManAddrIfSubtype_copy(const UA_ManAddrIfSubtype *src, UA_ManAddrIfSubtype *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MANADDRIFSUBTYPE]);
})

UA_INLINABLE( void
UA_ManAddrIfSubtype_clear(UA_ManAddrIfSubtype *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MANADDRIFSUBTYPE]);
})

UA_INLINABLE( void
UA_ManAddrIfSubtype_delete(UA_ManAddrIfSubtype *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MANADDRIFSUBTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ManAddrIfSubtype_equal(const UA_ManAddrIfSubtype *p1, const UA_ManAddrIfSubtype *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MANADDRIFSUBTYPE]) == UA_ORDER_EQ);
})


/* PriorityMappingEntryType */
typedef struct {
    UA_String mappingUri;
    UA_String priorityLabel;
    UA_Byte priorityValue_PCP;
    UA_UInt32 priorityValue_DSCP;
} UA_PriorityMappingEntryType;

#define UA_TYPES_PRIORITYMAPPINGENTRYTYPE 139

UA_INLINABLE( void
UA_PriorityMappingEntryType_init(UA_PriorityMappingEntryType *p), {
    memset(p, 0, sizeof(UA_PriorityMappingEntryType));
})

UA_INLINABLE( UA_PriorityMappingEntryType *
UA_PriorityMappingEntryType_new(void), {
    return (UA_PriorityMappingEntryType*)UA_new(&UA_TYPES[UA_TYPES_PRIORITYMAPPINGENTRYTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PriorityMappingEntryType_copy(const UA_PriorityMappingEntryType *src, UA_PriorityMappingEntryType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PRIORITYMAPPINGENTRYTYPE]);
})

UA_INLINABLE( void
UA_PriorityMappingEntryType_clear(UA_PriorityMappingEntryType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PRIORITYMAPPINGENTRYTYPE]);
})

UA_INLINABLE( void
UA_PriorityMappingEntryType_delete(UA_PriorityMappingEntryType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PRIORITYMAPPINGENTRYTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PriorityMappingEntryType_equal(const UA_PriorityMappingEntryType *p1, const UA_PriorityMappingEntryType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PRIORITYMAPPINGENTRYTYPE]) == UA_ORDER_EQ);
})


/* LldpManagementAddressTxPortType */
typedef struct {
    UA_UInt32 addressSubtype;
    UA_String manAddress;
    UA_Boolean txEnable;
    UA_UInt32 addrLen;
    UA_ManAddrIfSubtype ifSubtype;
    UA_UInt32 ifId;
} UA_LldpManagementAddressTxPortType;

#define UA_TYPES_LLDPMANAGEMENTADDRESSTXPORTTYPE 140

UA_INLINABLE( void
UA_LldpManagementAddressTxPortType_init(UA_LldpManagementAddressTxPortType *p), {
    memset(p, 0, sizeof(UA_LldpManagementAddressTxPortType));
})

UA_INLINABLE( UA_LldpManagementAddressTxPortType *
UA_LldpManagementAddressTxPortType_new(void), {
    return (UA_LldpManagementAddressTxPortType*)UA_new(&UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTXPORTTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_LldpManagementAddressTxPortType_copy(const UA_LldpManagementAddressTxPortType *src, UA_LldpManagementAddressTxPortType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTXPORTTYPE]);
})

UA_INLINABLE( void
UA_LldpManagementAddressTxPortType_clear(UA_LldpManagementAddressTxPortType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTXPORTTYPE]);
})

UA_INLINABLE( void
UA_LldpManagementAddressTxPortType_delete(UA_LldpManagementAddressTxPortType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTXPORTTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_LldpManagementAddressTxPortType_equal(const UA_LldpManagementAddressTxPortType *p1, const UA_LldpManagementAddressTxPortType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTXPORTTYPE]) == UA_ORDER_EQ);
})


/* LldpManagementAddressType */
typedef struct {
    UA_UInt32 addressSubtype;
    UA_String address;
    UA_ManAddrIfSubtype ifSubtype;
    UA_UInt32 ifId;
} UA_LldpManagementAddressType;

#define UA_TYPES_LLDPMANAGEMENTADDRESSTYPE 141

UA_INLINABLE( void
UA_LldpManagementAddressType_init(UA_LldpManagementAddressType *p), {
    memset(p, 0, sizeof(UA_LldpManagementAddressType));
})

UA_INLINABLE( UA_LldpManagementAddressType *
UA_LldpManagementAddressType_new(void), {
    return (UA_LldpManagementAddressType*)UA_new(&UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_LldpManagementAddressType_copy(const UA_LldpManagementAddressType *src, UA_LldpManagementAddressType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTYPE]);
})

UA_INLINABLE( void
UA_LldpManagementAddressType_clear(UA_LldpManagementAddressType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTYPE]);
})

UA_INLINABLE( void
UA_LldpManagementAddressType_delete(UA_LldpManagementAddressType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_LldpManagementAddressType_equal(const UA_LldpManagementAddressType *p1, const UA_LldpManagementAddressType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LLDPMANAGEMENTADDRESSTYPE]) == UA_ORDER_EQ);
})


/* LldpTlvType */
typedef struct {
    UA_UInt32 tlvType;
    UA_ByteString tlvInfo;
} UA_LldpTlvType;

#define UA_TYPES_LLDPTLVTYPE 142

UA_INLINABLE( void
UA_LldpTlvType_init(UA_LldpTlvType *p), {
    memset(p, 0, sizeof(UA_LldpTlvType));
})

UA_INLINABLE( UA_LldpTlvType *
UA_LldpTlvType_new(void), {
    return (UA_LldpTlvType*)UA_new(&UA_TYPES[UA_TYPES_LLDPTLVTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_LldpTlvType_copy(const UA_LldpTlvType *src, UA_LldpTlvType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LLDPTLVTYPE]);
})

UA_INLINABLE( void
UA_LldpTlvType_clear(UA_LldpTlvType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LLDPTLVTYPE]);
})

UA_INLINABLE( void
UA_LldpTlvType_delete(UA_LldpTlvType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LLDPTLVTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_LldpTlvType_equal(const UA_LldpTlvType *p1, const UA_LldpTlvType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LLDPTLVTYPE]) == UA_ORDER_EQ);
})


/* LldpSystemCapabilitiesMap */
typedef UA_UInt32 UA_LldpSystemCapabilitiesMap;

#define UA_LLDPSYSTEMCAPABILITIESMAP_NONE 0
#define UA_LLDPSYSTEMCAPABILITIESMAP_OTHER 1
#define UA_LLDPSYSTEMCAPABILITIESMAP_REPEATER 2
#define UA_LLDPSYSTEMCAPABILITIESMAP_BRIDGE 4
#define UA_LLDPSYSTEMCAPABILITIESMAP_WLANACCESSPOINT 8
#define UA_LLDPSYSTEMCAPABILITIESMAP_ROUTER 16
#define UA_LLDPSYSTEMCAPABILITIESMAP_TELEPHONE 32
#define UA_LLDPSYSTEMCAPABILITIESMAP_DOCSISCABLEDEVICE 64
#define UA_LLDPSYSTEMCAPABILITIESMAP_STATIONONLY 128
#define UA_LLDPSYSTEMCAPABILITIESMAP_CVLANCOMPONENT 256
#define UA_LLDPSYSTEMCAPABILITIESMAP_SVLANCOMPONENT 512
#define UA_LLDPSYSTEMCAPABILITIESMAP_TWOPORTMACRELAY 1024

#define UA_TYPES_LLDPSYSTEMCAPABILITIESMAP 143

UA_INLINABLE( void
UA_LldpSystemCapabilitiesMap_init(UA_LldpSystemCapabilitiesMap *p), {
    memset(p, 0, sizeof(UA_LldpSystemCapabilitiesMap));
})

UA_INLINABLE( UA_LldpSystemCapabilitiesMap *
UA_LldpSystemCapabilitiesMap_new(void), {
    return (UA_LldpSystemCapabilitiesMap*)UA_new(&UA_TYPES[UA_TYPES_LLDPSYSTEMCAPABILITIESMAP]);
})

UA_INLINABLE( UA_StatusCode
UA_LldpSystemCapabilitiesMap_copy(const UA_LldpSystemCapabilitiesMap *src, UA_LldpSystemCapabilitiesMap *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LLDPSYSTEMCAPABILITIESMAP]);
})

UA_INLINABLE( void
UA_LldpSystemCapabilitiesMap_clear(UA_LldpSystemCapabilitiesMap *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LLDPSYSTEMCAPABILITIESMAP]);
})

UA_INLINABLE( void
UA_LldpSystemCapabilitiesMap_delete(UA_LldpSystemCapabilitiesMap *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LLDPSYSTEMCAPABILITIESMAP]);
})

UA_INLINABLE( UA_Boolean
UA_LldpSystemCapabilitiesMap_equal(const UA_LldpSystemCapabilitiesMap *p1, const UA_LldpSystemCapabilitiesMap *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LLDPSYSTEMCAPABILITIESMAP]) == UA_ORDER_EQ);
})


/* ReferenceDescriptionDataType */
typedef struct {
    UA_NodeId sourceNode;
    UA_NodeId referenceType;
    UA_Boolean isForward;
    UA_ExpandedNodeId targetNode;
} UA_ReferenceDescriptionDataType;

#define UA_TYPES_REFERENCEDESCRIPTIONDATATYPE 144

UA_INLINABLE( void
UA_ReferenceDescriptionDataType_init(UA_ReferenceDescriptionDataType *p), {
    memset(p, 0, sizeof(UA_ReferenceDescriptionDataType));
})

UA_INLINABLE( UA_ReferenceDescriptionDataType *
UA_ReferenceDescriptionDataType_new(void), {
    return (UA_ReferenceDescriptionDataType*)UA_new(&UA_TYPES[UA_TYPES_REFERENCEDESCRIPTIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ReferenceDescriptionDataType_copy(const UA_ReferenceDescriptionDataType *src, UA_ReferenceDescriptionDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTIONDATATYPE]);
})

UA_INLINABLE( void
UA_ReferenceDescriptionDataType_clear(UA_ReferenceDescriptionDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTIONDATATYPE]);
})

UA_INLINABLE( void
UA_ReferenceDescriptionDataType_delete(UA_ReferenceDescriptionDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ReferenceDescriptionDataType_equal(const UA_ReferenceDescriptionDataType *p1, const UA_ReferenceDescriptionDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTIONDATATYPE]) == UA_ORDER_EQ);
})


/* ReferenceListEntryDataType */
typedef struct {
    UA_NodeId referenceType;
    UA_Boolean isForward;
    UA_ExpandedNodeId targetNode;
} UA_ReferenceListEntryDataType;

#define UA_TYPES_REFERENCELISTENTRYDATATYPE 145

UA_INLINABLE( void
UA_ReferenceListEntryDataType_init(UA_ReferenceListEntryDataType *p), {
    memset(p, 0, sizeof(UA_ReferenceListEntryDataType));
})

UA_INLINABLE( UA_ReferenceListEntryDataType *
UA_ReferenceListEntryDataType_new(void), {
    return (UA_ReferenceListEntryDataType*)UA_new(&UA_TYPES[UA_TYPES_REFERENCELISTENTRYDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ReferenceListEntryDataType_copy(const UA_ReferenceListEntryDataType *src, UA_ReferenceListEntryDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REFERENCELISTENTRYDATATYPE]);
})

UA_INLINABLE( void
UA_ReferenceListEntryDataType_clear(UA_ReferenceListEntryDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCELISTENTRYDATATYPE]);
})

UA_INLINABLE( void
UA_ReferenceListEntryDataType_delete(UA_ReferenceListEntryDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REFERENCELISTENTRYDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ReferenceListEntryDataType_equal(const UA_ReferenceListEntryDataType *p1, const UA_ReferenceListEntryDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REFERENCELISTENTRYDATATYPE]) == UA_ORDER_EQ);
})


/* SpanContextDataType */
typedef struct {
    UA_Guid traceId;
    UA_UInt64 spanId;
} UA_SpanContextDataType;

#define UA_TYPES_SPANCONTEXTDATATYPE 146

UA_INLINABLE( void
UA_SpanContextDataType_init(UA_SpanContextDataType *p), {
    memset(p, 0, sizeof(UA_SpanContextDataType));
})

UA_INLINABLE( UA_SpanContextDataType *
UA_SpanContextDataType_new(void), {
    return (UA_SpanContextDataType*)UA_new(&UA_TYPES[UA_TYPES_SPANCONTEXTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SpanContextDataType_copy(const UA_SpanContextDataType *src, UA_SpanContextDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SPANCONTEXTDATATYPE]);
})

UA_INLINABLE( void
UA_SpanContextDataType_clear(UA_SpanContextDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SPANCONTEXTDATATYPE]);
})

UA_INLINABLE( void
UA_SpanContextDataType_delete(UA_SpanContextDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SPANCONTEXTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SpanContextDataType_equal(const UA_SpanContextDataType *p1, const UA_SpanContextDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SPANCONTEXTDATATYPE]) == UA_ORDER_EQ);
})


/* TraceContextDataType */
typedef struct {
    UA_Guid traceId;
    UA_UInt64 spanId;
    UA_UInt64 parentSpanId;
    UA_String parentIdentifier;
} UA_TraceContextDataType;

#define UA_TYPES_TRACECONTEXTDATATYPE 147

UA_INLINABLE( void
UA_TraceContextDataType_init(UA_TraceContextDataType *p), {
    memset(p, 0, sizeof(UA_TraceContextDataType));
})

UA_INLINABLE( UA_TraceContextDataType *
UA_TraceContextDataType_new(void), {
    return (UA_TraceContextDataType*)UA_new(&UA_TYPES[UA_TYPES_TRACECONTEXTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_TraceContextDataType_copy(const UA_TraceContextDataType *src, UA_TraceContextDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRACECONTEXTDATATYPE]);
})

UA_INLINABLE( void
UA_TraceContextDataType_clear(UA_TraceContextDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRACECONTEXTDATATYPE]);
})

UA_INLINABLE( void
UA_TraceContextDataType_delete(UA_TraceContextDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRACECONTEXTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_TraceContextDataType_equal(const UA_TraceContextDataType *p1, const UA_TraceContextDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRACECONTEXTDATATYPE]) == UA_ORDER_EQ);
})


/* NameValuePair */
typedef struct {
    UA_String name;
    UA_Variant value;
} UA_NameValuePair;

#define UA_TYPES_NAMEVALUEPAIR 148

UA_INLINABLE( void
UA_NameValuePair_init(UA_NameValuePair *p), {
    memset(p, 0, sizeof(UA_NameValuePair));
})

UA_INLINABLE( UA_NameValuePair *
UA_NameValuePair_new(void), {
    return (UA_NameValuePair*)UA_new(&UA_TYPES[UA_TYPES_NAMEVALUEPAIR]);
})

UA_INLINABLE( UA_StatusCode
UA_NameValuePair_copy(const UA_NameValuePair *src, UA_NameValuePair *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NAMEVALUEPAIR]);
})

UA_INLINABLE( void
UA_NameValuePair_clear(UA_NameValuePair *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NAMEVALUEPAIR]);
})

UA_INLINABLE( void
UA_NameValuePair_delete(UA_NameValuePair *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NAMEVALUEPAIR]);
})

UA_INLINABLE( UA_Boolean
UA_NameValuePair_equal(const UA_NameValuePair *p1, const UA_NameValuePair *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NAMEVALUEPAIR]) == UA_ORDER_EQ);
})


/* LogRecordMask */
typedef UA_UInt32 UA_LogRecordMask;

#define UA_LOGRECORDMASK_NONE 0
#define UA_LOGRECORDMASK_EVENTTYPE 1
#define UA_LOGRECORDMASK_SOURCENODE 2
#define UA_LOGRECORDMASK_SOURCENAME 4
#define UA_LOGRECORDMASK_TRACECONTEXT 8
#define UA_LOGRECORDMASK_ADDITIONALDATA 16

#define UA_TYPES_LOGRECORDMASK 149

UA_INLINABLE( void
UA_LogRecordMask_init(UA_LogRecordMask *p), {
    memset(p, 0, sizeof(UA_LogRecordMask));
})

UA_INLINABLE( UA_LogRecordMask *
UA_LogRecordMask_new(void), {
    return (UA_LogRecordMask*)UA_new(&UA_TYPES[UA_TYPES_LOGRECORDMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_LogRecordMask_copy(const UA_LogRecordMask *src, UA_LogRecordMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOGRECORDMASK]);
})

UA_INLINABLE( void
UA_LogRecordMask_clear(UA_LogRecordMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOGRECORDMASK]);
})

UA_INLINABLE( void
UA_LogRecordMask_delete(UA_LogRecordMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LOGRECORDMASK]);
})

UA_INLINABLE( UA_Boolean
UA_LogRecordMask_equal(const UA_LogRecordMask *p1, const UA_LogRecordMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LOGRECORDMASK]) == UA_ORDER_EQ);
})


/* IdType */
typedef enum {
    UA_IDTYPE_NUMERIC = 0,
    UA_IDTYPE_STRING = 1,
    UA_IDTYPE_GUID = 2,
    UA_IDTYPE_OPAQUE = 3,
    __UA_IDTYPE_FORCE32BIT = 0x7fffffff
} UA_IdType;

UA_STATIC_ASSERT(sizeof(UA_IdType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_IDTYPE 150

UA_INLINABLE( void
UA_IdType_init(UA_IdType *p), {
    memset(p, 0, sizeof(UA_IdType));
})

UA_INLINABLE( UA_IdType *
UA_IdType_new(void), {
    return (UA_IdType*)UA_new(&UA_TYPES[UA_TYPES_IDTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_IdType_copy(const UA_IdType *src, UA_IdType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_IDTYPE]);
})

UA_INLINABLE( void
UA_IdType_clear(UA_IdType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_IDTYPE]);
})

UA_INLINABLE( void
UA_IdType_delete(UA_IdType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_IDTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_IdType_equal(const UA_IdType *p1, const UA_IdType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_IDTYPE]) == UA_ORDER_EQ);
})


/* NodeClass */
typedef enum {
    UA_NODECLASS_UNSPECIFIED = 0,
    UA_NODECLASS_OBJECT = 1,
    UA_NODECLASS_VARIABLE = 2,
    UA_NODECLASS_METHOD = 4,
    UA_NODECLASS_OBJECTTYPE = 8,
    UA_NODECLASS_VARIABLETYPE = 16,
    UA_NODECLASS_REFERENCETYPE = 32,
    UA_NODECLASS_DATATYPE = 64,
    UA_NODECLASS_VIEW = 128,
    __UA_NODECLASS_FORCE32BIT = 0x7fffffff
} UA_NodeClass;

UA_STATIC_ASSERT(sizeof(UA_NodeClass) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_NODECLASS 151

UA_INLINABLE( void
UA_NodeClass_init(UA_NodeClass *p), {
    memset(p, 0, sizeof(UA_NodeClass));
})

UA_INLINABLE( UA_NodeClass *
UA_NodeClass_new(void), {
    return (UA_NodeClass*)UA_new(&UA_TYPES[UA_TYPES_NODECLASS]);
})

UA_INLINABLE( UA_StatusCode
UA_NodeClass_copy(const UA_NodeClass *src, UA_NodeClass *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODECLASS]);
})

UA_INLINABLE( void
UA_NodeClass_clear(UA_NodeClass *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODECLASS]);
})

UA_INLINABLE( void
UA_NodeClass_delete(UA_NodeClass *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODECLASS]);
})

UA_INLINABLE( UA_Boolean
UA_NodeClass_equal(const UA_NodeClass *p1, const UA_NodeClass *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NODECLASS]) == UA_ORDER_EQ);
})


/* PermissionType */
typedef UA_UInt32 UA_PermissionType;

#define UA_PERMISSIONTYPE_NONE 0
#define UA_PERMISSIONTYPE_BROWSE 1
#define UA_PERMISSIONTYPE_READROLEPERMISSIONS 2
#define UA_PERMISSIONTYPE_WRITEATTRIBUTE 4
#define UA_PERMISSIONTYPE_WRITEROLEPERMISSIONS 8
#define UA_PERMISSIONTYPE_WRITEHISTORIZING 16
#define UA_PERMISSIONTYPE_READ 32
#define UA_PERMISSIONTYPE_WRITE 64
#define UA_PERMISSIONTYPE_READHISTORY 128
#define UA_PERMISSIONTYPE_INSERTHISTORY 256
#define UA_PERMISSIONTYPE_MODIFYHISTORY 512
#define UA_PERMISSIONTYPE_DELETEHISTORY 1024
#define UA_PERMISSIONTYPE_RECEIVEEVENTS 2048
#define UA_PERMISSIONTYPE_CALL 4096
#define UA_PERMISSIONTYPE_ADDREFERENCE 8192
#define UA_PERMISSIONTYPE_REMOVEREFERENCE 16384
#define UA_PERMISSIONTYPE_DELETENODE 32768
#define UA_PERMISSIONTYPE_ADDNODE 65536

#define UA_TYPES_PERMISSIONTYPE 152

UA_INLINABLE( void
UA_PermissionType_init(UA_PermissionType *p), {
    memset(p, 0, sizeof(UA_PermissionType));
})

UA_INLINABLE( UA_PermissionType *
UA_PermissionType_new(void), {
    return (UA_PermissionType*)UA_new(&UA_TYPES[UA_TYPES_PERMISSIONTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PermissionType_copy(const UA_PermissionType *src, UA_PermissionType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PERMISSIONTYPE]);
})

UA_INLINABLE( void
UA_PermissionType_clear(UA_PermissionType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PERMISSIONTYPE]);
})

UA_INLINABLE( void
UA_PermissionType_delete(UA_PermissionType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PERMISSIONTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PermissionType_equal(const UA_PermissionType *p1, const UA_PermissionType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PERMISSIONTYPE]) == UA_ORDER_EQ);
})


/* AccessLevelType */
typedef UA_Byte UA_AccessLevelType;

#define UA_ACCESSLEVELTYPE_NONE 0
#define UA_ACCESSLEVELTYPE_CURRENTREAD 1
#define UA_ACCESSLEVELTYPE_CURRENTWRITE 2
#define UA_ACCESSLEVELTYPE_HISTORYREAD 4
#define UA_ACCESSLEVELTYPE_HISTORYWRITE 8
#define UA_ACCESSLEVELTYPE_SEMANTICCHANGE 16
#define UA_ACCESSLEVELTYPE_STATUSWRITE 32
#define UA_ACCESSLEVELTYPE_TIMESTAMPWRITE 64

#define UA_TYPES_ACCESSLEVELTYPE 153

UA_INLINABLE( void
UA_AccessLevelType_init(UA_AccessLevelType *p), {
    memset(p, 0, sizeof(UA_AccessLevelType));
})

UA_INLINABLE( UA_AccessLevelType *
UA_AccessLevelType_new(void), {
    return (UA_AccessLevelType*)UA_new(&UA_TYPES[UA_TYPES_ACCESSLEVELTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_AccessLevelType_copy(const UA_AccessLevelType *src, UA_AccessLevelType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACCESSLEVELTYPE]);
})

UA_INLINABLE( void
UA_AccessLevelType_clear(UA_AccessLevelType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACCESSLEVELTYPE]);
})

UA_INLINABLE( void
UA_AccessLevelType_delete(UA_AccessLevelType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACCESSLEVELTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_AccessLevelType_equal(const UA_AccessLevelType *p1, const UA_AccessLevelType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ACCESSLEVELTYPE]) == UA_ORDER_EQ);
})


/* AccessLevelExType */
typedef UA_UInt32 UA_AccessLevelExType;

#define UA_ACCESSLEVELEXTYPE_NONE 0
#define UA_ACCESSLEVELEXTYPE_CURRENTREAD 1
#define UA_ACCESSLEVELEXTYPE_CURRENTWRITE 2
#define UA_ACCESSLEVELEXTYPE_HISTORYREAD 4
#define UA_ACCESSLEVELEXTYPE_HISTORYWRITE 8
#define UA_ACCESSLEVELEXTYPE_SEMANTICCHANGE 16
#define UA_ACCESSLEVELEXTYPE_STATUSWRITE 32
#define UA_ACCESSLEVELEXTYPE_TIMESTAMPWRITE 64
#define UA_ACCESSLEVELEXTYPE_NONATOMICREAD 256
#define UA_ACCESSLEVELEXTYPE_NONATOMICWRITE 512
#define UA_ACCESSLEVELEXTYPE_WRITEFULLARRAYONLY 1024
#define UA_ACCESSLEVELEXTYPE_NOSUBDATATYPES 2048
#define UA_ACCESSLEVELEXTYPE_NONVOLATILE 4096
#define UA_ACCESSLEVELEXTYPE_CONSTANT 8192

#define UA_TYPES_ACCESSLEVELEXTYPE 154

UA_INLINABLE( void
UA_AccessLevelExType_init(UA_AccessLevelExType *p), {
    memset(p, 0, sizeof(UA_AccessLevelExType));
})

UA_INLINABLE( UA_AccessLevelExType *
UA_AccessLevelExType_new(void), {
    return (UA_AccessLevelExType*)UA_new(&UA_TYPES[UA_TYPES_ACCESSLEVELEXTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_AccessLevelExType_copy(const UA_AccessLevelExType *src, UA_AccessLevelExType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACCESSLEVELEXTYPE]);
})

UA_INLINABLE( void
UA_AccessLevelExType_clear(UA_AccessLevelExType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACCESSLEVELEXTYPE]);
})

UA_INLINABLE( void
UA_AccessLevelExType_delete(UA_AccessLevelExType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACCESSLEVELEXTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_AccessLevelExType_equal(const UA_AccessLevelExType *p1, const UA_AccessLevelExType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ACCESSLEVELEXTYPE]) == UA_ORDER_EQ);
})


/* EventNotifierType */
typedef UA_Byte UA_EventNotifierType;

#define UA_EVENTNOTIFIERTYPE_NONE 0
#define UA_EVENTNOTIFIERTYPE_SUBSCRIBETOEVENTS 1
#define UA_EVENTNOTIFIERTYPE_HISTORYREAD 4
#define UA_EVENTNOTIFIERTYPE_HISTORYWRITE 8

#define UA_TYPES_EVENTNOTIFIERTYPE 155

UA_INLINABLE( void
UA_EventNotifierType_init(UA_EventNotifierType *p), {
    memset(p, 0, sizeof(UA_EventNotifierType));
})

UA_INLINABLE( UA_EventNotifierType *
UA_EventNotifierType_new(void), {
    return (UA_EventNotifierType*)UA_new(&UA_TYPES[UA_TYPES_EVENTNOTIFIERTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_EventNotifierType_copy(const UA_EventNotifierType *src, UA_EventNotifierType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTNOTIFIERTYPE]);
})

UA_INLINABLE( void
UA_EventNotifierType_clear(UA_EventNotifierType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTNOTIFIERTYPE]);
})

UA_INLINABLE( void
UA_EventNotifierType_delete(UA_EventNotifierType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTNOTIFIERTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_EventNotifierType_equal(const UA_EventNotifierType *p1, const UA_EventNotifierType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EVENTNOTIFIERTYPE]) == UA_ORDER_EQ);
})


/* AccessRestrictionType */
typedef UA_UInt16 UA_AccessRestrictionType;

#define UA_ACCESSRESTRICTIONTYPE_NONE 0
#define UA_ACCESSRESTRICTIONTYPE_SIGNINGREQUIRED 1
#define UA_ACCESSRESTRICTIONTYPE_ENCRYPTIONREQUIRED 2
#define UA_ACCESSRESTRICTIONTYPE_SESSIONREQUIRED 4
#define UA_ACCESSRESTRICTIONTYPE_APPLYRESTRICTIONSTOBROWSE 8

#define UA_TYPES_ACCESSRESTRICTIONTYPE 156

UA_INLINABLE( void
UA_AccessRestrictionType_init(UA_AccessRestrictionType *p), {
    memset(p, 0, sizeof(UA_AccessRestrictionType));
})

UA_INLINABLE( UA_AccessRestrictionType *
UA_AccessRestrictionType_new(void), {
    return (UA_AccessRestrictionType*)UA_new(&UA_TYPES[UA_TYPES_ACCESSRESTRICTIONTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_AccessRestrictionType_copy(const UA_AccessRestrictionType *src, UA_AccessRestrictionType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACCESSRESTRICTIONTYPE]);
})

UA_INLINABLE( void
UA_AccessRestrictionType_clear(UA_AccessRestrictionType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACCESSRESTRICTIONTYPE]);
})

UA_INLINABLE( void
UA_AccessRestrictionType_delete(UA_AccessRestrictionType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACCESSRESTRICTIONTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_AccessRestrictionType_equal(const UA_AccessRestrictionType *p1, const UA_AccessRestrictionType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ACCESSRESTRICTIONTYPE]) == UA_ORDER_EQ);
})


/* RolePermissionType */
typedef struct {
    UA_NodeId roleId;
    UA_PermissionType permissions;
} UA_RolePermissionType;

#define UA_TYPES_ROLEPERMISSIONTYPE 157

UA_INLINABLE( void
UA_RolePermissionType_init(UA_RolePermissionType *p), {
    memset(p, 0, sizeof(UA_RolePermissionType));
})

UA_INLINABLE( UA_RolePermissionType *
UA_RolePermissionType_new(void), {
    return (UA_RolePermissionType*)UA_new(&UA_TYPES[UA_TYPES_ROLEPERMISSIONTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_RolePermissionType_copy(const UA_RolePermissionType *src, UA_RolePermissionType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ROLEPERMISSIONTYPE]);
})

UA_INLINABLE( void
UA_RolePermissionType_clear(UA_RolePermissionType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ROLEPERMISSIONTYPE]);
})

UA_INLINABLE( void
UA_RolePermissionType_delete(UA_RolePermissionType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ROLEPERMISSIONTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_RolePermissionType_equal(const UA_RolePermissionType *p1, const UA_RolePermissionType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ROLEPERMISSIONTYPE]) == UA_ORDER_EQ);
})


/* StructureType */
typedef enum {
    UA_STRUCTURETYPE_STRUCTURE = 0,
    UA_STRUCTURETYPE_STRUCTUREWITHOPTIONALFIELDS = 1,
    UA_STRUCTURETYPE_UNION = 2,
    UA_STRUCTURETYPE_STRUCTUREWITHSUBTYPEDVALUES = 3,
    UA_STRUCTURETYPE_UNIONWITHSUBTYPEDVALUES = 4,
    __UA_STRUCTURETYPE_FORCE32BIT = 0x7fffffff
} UA_StructureType;

UA_STATIC_ASSERT(sizeof(UA_StructureType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_STRUCTURETYPE 158

UA_INLINABLE( void
UA_StructureType_init(UA_StructureType *p), {
    memset(p, 0, sizeof(UA_StructureType));
})

UA_INLINABLE( UA_StructureType *
UA_StructureType_new(void), {
    return (UA_StructureType*)UA_new(&UA_TYPES[UA_TYPES_STRUCTURETYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_StructureType_copy(const UA_StructureType *src, UA_StructureType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTURETYPE]);
})

UA_INLINABLE( void
UA_StructureType_clear(UA_StructureType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTURETYPE]);
})

UA_INLINABLE( void
UA_StructureType_delete(UA_StructureType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTURETYPE]);
})

UA_INLINABLE( UA_Boolean
UA_StructureType_equal(const UA_StructureType *p1, const UA_StructureType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STRUCTURETYPE]) == UA_ORDER_EQ);
})


/* StructureField */
typedef struct {
    UA_String name;
    UA_LocalizedText description;
    UA_NodeId dataType;
    UA_Int32 valueRank;
    size_t arrayDimensionsSize;
    UA_UInt32 *arrayDimensions;
    UA_UInt32 maxStringLength;
    UA_Boolean isOptional;
} UA_StructureField;

#define UA_TYPES_STRUCTUREFIELD 159

UA_INLINABLE( void
UA_StructureField_init(UA_StructureField *p), {
    memset(p, 0, sizeof(UA_StructureField));
})

UA_INLINABLE( UA_StructureField *
UA_StructureField_new(void), {
    return (UA_StructureField*)UA_new(&UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
})

UA_INLINABLE( UA_StatusCode
UA_StructureField_copy(const UA_StructureField *src, UA_StructureField *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
})

UA_INLINABLE( void
UA_StructureField_clear(UA_StructureField *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
})

UA_INLINABLE( void
UA_StructureField_delete(UA_StructureField *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]);
})

UA_INLINABLE( UA_Boolean
UA_StructureField_equal(const UA_StructureField *p1, const UA_StructureField *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]) == UA_ORDER_EQ);
})


/* StructureDefinition */
typedef struct {
    UA_NodeId defaultEncodingId;
    UA_NodeId baseDataType;
    UA_StructureType structureType;
    size_t fieldsSize;
    UA_StructureField *fields;
} UA_StructureDefinition;

#define UA_TYPES_STRUCTUREDEFINITION 160

UA_INLINABLE( void
UA_StructureDefinition_init(UA_StructureDefinition *p), {
    memset(p, 0, sizeof(UA_StructureDefinition));
})

UA_INLINABLE( UA_StructureDefinition *
UA_StructureDefinition_new(void), {
    return (UA_StructureDefinition*)UA_new(&UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
})

UA_INLINABLE( UA_StatusCode
UA_StructureDefinition_copy(const UA_StructureDefinition *src, UA_StructureDefinition *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
})

UA_INLINABLE( void
UA_StructureDefinition_clear(UA_StructureDefinition *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
})

UA_INLINABLE( void
UA_StructureDefinition_delete(UA_StructureDefinition *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]);
})

UA_INLINABLE( UA_Boolean
UA_StructureDefinition_equal(const UA_StructureDefinition *p1, const UA_StructureDefinition *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]) == UA_ORDER_EQ);
})


/* Argument */
typedef struct {
    UA_String name;
    UA_NodeId dataType;
    UA_Int32 valueRank;
    size_t arrayDimensionsSize;
    UA_UInt32 *arrayDimensions;
    UA_LocalizedText description;
} UA_Argument;

#define UA_TYPES_ARGUMENT 161

UA_INLINABLE( void
UA_Argument_init(UA_Argument *p), {
    memset(p, 0, sizeof(UA_Argument));
})

UA_INLINABLE( UA_Argument *
UA_Argument_new(void), {
    return (UA_Argument*)UA_new(&UA_TYPES[UA_TYPES_ARGUMENT]);
})

UA_INLINABLE( UA_StatusCode
UA_Argument_copy(const UA_Argument *src, UA_Argument *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ARGUMENT]);
})

UA_INLINABLE( void
UA_Argument_clear(UA_Argument *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ARGUMENT]);
})

UA_INLINABLE( void
UA_Argument_delete(UA_Argument *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ARGUMENT]);
})

UA_INLINABLE( UA_Boolean
UA_Argument_equal(const UA_Argument *p1, const UA_Argument *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ARGUMENT]) == UA_ORDER_EQ);
})


/* EnumValueType */
typedef struct {
    UA_Int64 value;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
} UA_EnumValueType;

#define UA_TYPES_ENUMVALUETYPE 162

UA_INLINABLE( void
UA_EnumValueType_init(UA_EnumValueType *p), {
    memset(p, 0, sizeof(UA_EnumValueType));
})

UA_INLINABLE( UA_EnumValueType *
UA_EnumValueType_new(void), {
    return (UA_EnumValueType*)UA_new(&UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_EnumValueType_copy(const UA_EnumValueType *src, UA_EnumValueType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
})

UA_INLINABLE( void
UA_EnumValueType_clear(UA_EnumValueType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
})

UA_INLINABLE( void
UA_EnumValueType_delete(UA_EnumValueType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]);
})

UA_INLINABLE( UA_Boolean
UA_EnumValueType_equal(const UA_EnumValueType *p1, const UA_EnumValueType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]) == UA_ORDER_EQ);
})


/* EnumField */
typedef struct {
    UA_Int64 value;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_String name;
} UA_EnumField;

#define UA_TYPES_ENUMFIELD 163

UA_INLINABLE( void
UA_EnumField_init(UA_EnumField *p), {
    memset(p, 0, sizeof(UA_EnumField));
})

UA_INLINABLE( UA_EnumField *
UA_EnumField_new(void), {
    return (UA_EnumField*)UA_new(&UA_TYPES[UA_TYPES_ENUMFIELD]);
})

UA_INLINABLE( UA_StatusCode
UA_EnumField_copy(const UA_EnumField *src, UA_EnumField *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMFIELD]);
})

UA_INLINABLE( void
UA_EnumField_clear(UA_EnumField *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMFIELD]);
})

UA_INLINABLE( void
UA_EnumField_delete(UA_EnumField *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENUMFIELD]);
})

UA_INLINABLE( UA_Boolean
UA_EnumField_equal(const UA_EnumField *p1, const UA_EnumField *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENUMFIELD]) == UA_ORDER_EQ);
})


/* OptionSet */
typedef struct {
    UA_ByteString value;
    UA_ByteString validBits;
} UA_OptionSet;

#define UA_TYPES_OPTIONSET 164

UA_INLINABLE( void
UA_OptionSet_init(UA_OptionSet *p), {
    memset(p, 0, sizeof(UA_OptionSet));
})

UA_INLINABLE( UA_OptionSet *
UA_OptionSet_new(void), {
    return (UA_OptionSet*)UA_new(&UA_TYPES[UA_TYPES_OPTIONSET]);
})

UA_INLINABLE( UA_StatusCode
UA_OptionSet_copy(const UA_OptionSet *src, UA_OptionSet *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPTIONSET]);
})

UA_INLINABLE( void
UA_OptionSet_clear(UA_OptionSet *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPTIONSET]);
})

UA_INLINABLE( void
UA_OptionSet_delete(UA_OptionSet *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_OPTIONSET]);
})

UA_INLINABLE( UA_Boolean
UA_OptionSet_equal(const UA_OptionSet *p1, const UA_OptionSet *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_OPTIONSET]) == UA_ORDER_EQ);
})


/* NormalizedString */
typedef UA_String UA_NormalizedString;

#define UA_TYPES_NORMALIZEDSTRING 165

UA_INLINABLE( void
UA_NormalizedString_init(UA_NormalizedString *p), {
    memset(p, 0, sizeof(UA_NormalizedString));
})

UA_INLINABLE( UA_NormalizedString *
UA_NormalizedString_new(void), {
    return (UA_NormalizedString*)UA_new(&UA_TYPES[UA_TYPES_NORMALIZEDSTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_NormalizedString_copy(const UA_NormalizedString *src, UA_NormalizedString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NORMALIZEDSTRING]);
})

UA_INLINABLE( void
UA_NormalizedString_clear(UA_NormalizedString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NORMALIZEDSTRING]);
})

UA_INLINABLE( void
UA_NormalizedString_delete(UA_NormalizedString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NORMALIZEDSTRING]);
})

UA_INLINABLE( UA_Boolean
UA_NormalizedString_equal(const UA_NormalizedString *p1, const UA_NormalizedString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NORMALIZEDSTRING]) == UA_ORDER_EQ);
})


/* DecimalString */
typedef UA_String UA_DecimalString;

#define UA_TYPES_DECIMALSTRING 166

UA_INLINABLE( void
UA_DecimalString_init(UA_DecimalString *p), {
    memset(p, 0, sizeof(UA_DecimalString));
})

UA_INLINABLE( UA_DecimalString *
UA_DecimalString_new(void), {
    return (UA_DecimalString*)UA_new(&UA_TYPES[UA_TYPES_DECIMALSTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_DecimalString_copy(const UA_DecimalString *src, UA_DecimalString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DECIMALSTRING]);
})

UA_INLINABLE( void
UA_DecimalString_clear(UA_DecimalString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DECIMALSTRING]);
})

UA_INLINABLE( void
UA_DecimalString_delete(UA_DecimalString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DECIMALSTRING]);
})

UA_INLINABLE( UA_Boolean
UA_DecimalString_equal(const UA_DecimalString *p1, const UA_DecimalString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DECIMALSTRING]) == UA_ORDER_EQ);
})


/* DurationString */
typedef UA_String UA_DurationString;

#define UA_TYPES_DURATIONSTRING 167

UA_INLINABLE( void
UA_DurationString_init(UA_DurationString *p), {
    memset(p, 0, sizeof(UA_DurationString));
})

UA_INLINABLE( UA_DurationString *
UA_DurationString_new(void), {
    return (UA_DurationString*)UA_new(&UA_TYPES[UA_TYPES_DURATIONSTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_DurationString_copy(const UA_DurationString *src, UA_DurationString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DURATIONSTRING]);
})

UA_INLINABLE( void
UA_DurationString_clear(UA_DurationString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DURATIONSTRING]);
})

UA_INLINABLE( void
UA_DurationString_delete(UA_DurationString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DURATIONSTRING]);
})

UA_INLINABLE( UA_Boolean
UA_DurationString_equal(const UA_DurationString *p1, const UA_DurationString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DURATIONSTRING]) == UA_ORDER_EQ);
})


/* TimeString */
typedef UA_String UA_TimeString;

#define UA_TYPES_TIMESTRING 168

UA_INLINABLE( void
UA_TimeString_init(UA_TimeString *p), {
    memset(p, 0, sizeof(UA_TimeString));
})

UA_INLINABLE( UA_TimeString *
UA_TimeString_new(void), {
    return (UA_TimeString*)UA_new(&UA_TYPES[UA_TYPES_TIMESTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_TimeString_copy(const UA_TimeString *src, UA_TimeString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TIMESTRING]);
})

UA_INLINABLE( void
UA_TimeString_clear(UA_TimeString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TIMESTRING]);
})

UA_INLINABLE( void
UA_TimeString_delete(UA_TimeString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TIMESTRING]);
})

UA_INLINABLE( UA_Boolean
UA_TimeString_equal(const UA_TimeString *p1, const UA_TimeString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TIMESTRING]) == UA_ORDER_EQ);
})


/* DateString */
typedef UA_String UA_DateString;

#define UA_TYPES_DATESTRING 169

UA_INLINABLE( void
UA_DateString_init(UA_DateString *p), {
    memset(p, 0, sizeof(UA_DateString));
})

UA_INLINABLE( UA_DateString *
UA_DateString_new(void), {
    return (UA_DateString*)UA_new(&UA_TYPES[UA_TYPES_DATESTRING]);
})

UA_INLINABLE( UA_StatusCode
UA_DateString_copy(const UA_DateString *src, UA_DateString *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATESTRING]);
})

UA_INLINABLE( void
UA_DateString_clear(UA_DateString *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATESTRING]);
})

UA_INLINABLE( void
UA_DateString_delete(UA_DateString *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATESTRING]);
})

UA_INLINABLE( UA_Boolean
UA_DateString_equal(const UA_DateString *p1, const UA_DateString *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATESTRING]) == UA_ORDER_EQ);
})


/* Duration */
typedef UA_Double UA_Duration;

#define UA_TYPES_DURATION 170

UA_INLINABLE( void
UA_Duration_init(UA_Duration *p), {
    memset(p, 0, sizeof(UA_Duration));
})

UA_INLINABLE( UA_Duration *
UA_Duration_new(void), {
    return (UA_Duration*)UA_new(&UA_TYPES[UA_TYPES_DURATION]);
})

UA_INLINABLE( UA_StatusCode
UA_Duration_copy(const UA_Duration *src, UA_Duration *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DURATION]);
})

UA_INLINABLE( void
UA_Duration_clear(UA_Duration *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DURATION]);
})

UA_INLINABLE( void
UA_Duration_delete(UA_Duration *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DURATION]);
})

UA_INLINABLE( UA_Boolean
UA_Duration_equal(const UA_Duration *p1, const UA_Duration *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DURATION]) == UA_ORDER_EQ);
})


/* UtcTime */
typedef UA_DateTime UA_UtcTime;

#define UA_TYPES_UTCTIME 171

UA_INLINABLE( void
UA_UtcTime_init(UA_UtcTime *p), {
    memset(p, 0, sizeof(UA_UtcTime));
})

UA_INLINABLE( UA_UtcTime *
UA_UtcTime_new(void), {
    return (UA_UtcTime*)UA_new(&UA_TYPES[UA_TYPES_UTCTIME]);
})

UA_INLINABLE( UA_StatusCode
UA_UtcTime_copy(const UA_UtcTime *src, UA_UtcTime *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UTCTIME]);
})

UA_INLINABLE( void
UA_UtcTime_clear(UA_UtcTime *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UTCTIME]);
})

UA_INLINABLE( void
UA_UtcTime_delete(UA_UtcTime *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UTCTIME]);
})

UA_INLINABLE( UA_Boolean
UA_UtcTime_equal(const UA_UtcTime *p1, const UA_UtcTime *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UTCTIME]) == UA_ORDER_EQ);
})


/* LocaleId */
typedef UA_String UA_LocaleId;

#define UA_TYPES_LOCALEID 172

UA_INLINABLE( void
UA_LocaleId_init(UA_LocaleId *p), {
    memset(p, 0, sizeof(UA_LocaleId));
})

UA_INLINABLE( UA_LocaleId *
UA_LocaleId_new(void), {
    return (UA_LocaleId*)UA_new(&UA_TYPES[UA_TYPES_LOCALEID]);
})

UA_INLINABLE( UA_StatusCode
UA_LocaleId_copy(const UA_LocaleId *src, UA_LocaleId *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOCALEID]);
})

UA_INLINABLE( void
UA_LocaleId_clear(UA_LocaleId *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOCALEID]);
})

UA_INLINABLE( void
UA_LocaleId_delete(UA_LocaleId *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LOCALEID]);
})

UA_INLINABLE( UA_Boolean
UA_LocaleId_equal(const UA_LocaleId *p1, const UA_LocaleId *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LOCALEID]) == UA_ORDER_EQ);
})


/* TimeZoneDataType */
typedef struct {
    UA_Int16 offset;
    UA_Boolean daylightSavingInOffset;
} UA_TimeZoneDataType;

#define UA_TYPES_TIMEZONEDATATYPE 173

UA_INLINABLE( void
UA_TimeZoneDataType_init(UA_TimeZoneDataType *p), {
    memset(p, 0, sizeof(UA_TimeZoneDataType));
})

UA_INLINABLE( UA_TimeZoneDataType *
UA_TimeZoneDataType_new(void), {
    return (UA_TimeZoneDataType*)UA_new(&UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_TimeZoneDataType_copy(const UA_TimeZoneDataType *src, UA_TimeZoneDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
})

UA_INLINABLE( void
UA_TimeZoneDataType_clear(UA_TimeZoneDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
})

UA_INLINABLE( void
UA_TimeZoneDataType_delete(UA_TimeZoneDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_TimeZoneDataType_equal(const UA_TimeZoneDataType *p1, const UA_TimeZoneDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]) == UA_ORDER_EQ);
})


/* Index */
typedef UA_ByteString UA_Index;

#define UA_TYPES_INDEX 174

UA_INLINABLE( void
UA_Index_init(UA_Index *p), {
    memset(p, 0, sizeof(UA_Index));
})

UA_INLINABLE( UA_Index *
UA_Index_new(void), {
    return (UA_Index*)UA_new(&UA_TYPES[UA_TYPES_INDEX]);
})

UA_INLINABLE( UA_StatusCode
UA_Index_copy(const UA_Index *src, UA_Index *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INDEX]);
})

UA_INLINABLE( void
UA_Index_clear(UA_Index *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_INDEX]);
})

UA_INLINABLE( void
UA_Index_delete(UA_Index *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_INDEX]);
})

UA_INLINABLE( UA_Boolean
UA_Index_equal(const UA_Index *p1, const UA_Index *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_INDEX]) == UA_ORDER_EQ);
})


/* IntegerId */
typedef UA_UInt32 UA_IntegerId;

#define UA_TYPES_INTEGERID 175

UA_INLINABLE( void
UA_IntegerId_init(UA_IntegerId *p), {
    memset(p, 0, sizeof(UA_IntegerId));
})

UA_INLINABLE( UA_IntegerId *
UA_IntegerId_new(void), {
    return (UA_IntegerId*)UA_new(&UA_TYPES[UA_TYPES_INTEGERID]);
})

UA_INLINABLE( UA_StatusCode
UA_IntegerId_copy(const UA_IntegerId *src, UA_IntegerId *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INTEGERID]);
})

UA_INLINABLE( void
UA_IntegerId_clear(UA_IntegerId *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_INTEGERID]);
})

UA_INLINABLE( void
UA_IntegerId_delete(UA_IntegerId *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_INTEGERID]);
})

UA_INLINABLE( UA_Boolean
UA_IntegerId_equal(const UA_IntegerId *p1, const UA_IntegerId *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_INTEGERID]) == UA_ORDER_EQ);
})


/* ApplicationType */
typedef enum {
    UA_APPLICATIONTYPE_SERVER = 0,
    UA_APPLICATIONTYPE_CLIENT = 1,
    UA_APPLICATIONTYPE_CLIENTANDSERVER = 2,
    UA_APPLICATIONTYPE_DISCOVERYSERVER = 3,
    __UA_APPLICATIONTYPE_FORCE32BIT = 0x7fffffff
} UA_ApplicationType;

UA_STATIC_ASSERT(sizeof(UA_ApplicationType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_APPLICATIONTYPE 176

UA_INLINABLE( void
UA_ApplicationType_init(UA_ApplicationType *p), {
    memset(p, 0, sizeof(UA_ApplicationType));
})

UA_INLINABLE( UA_ApplicationType *
UA_ApplicationType_new(void), {
    return (UA_ApplicationType*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ApplicationType_copy(const UA_ApplicationType *src, UA_ApplicationType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
})

UA_INLINABLE( void
UA_ApplicationType_clear(UA_ApplicationType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
})

UA_INLINABLE( void
UA_ApplicationType_delete(UA_ApplicationType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ApplicationType_equal(const UA_ApplicationType *p1, const UA_ApplicationType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]) == UA_ORDER_EQ);
})


/* ApplicationDescription */
typedef struct {
    UA_String applicationUri;
    UA_String productUri;
    UA_LocalizedText applicationName;
    UA_ApplicationType applicationType;
    UA_String gatewayServerUri;
    UA_String discoveryProfileUri;
    size_t discoveryUrlsSize;
    UA_String *discoveryUrls;
} UA_ApplicationDescription;

#define UA_TYPES_APPLICATIONDESCRIPTION 177

UA_INLINABLE( void
UA_ApplicationDescription_init(UA_ApplicationDescription *p), {
    memset(p, 0, sizeof(UA_ApplicationDescription));
})

UA_INLINABLE( UA_ApplicationDescription *
UA_ApplicationDescription_new(void), {
    return (UA_ApplicationDescription*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_ApplicationDescription_copy(const UA_ApplicationDescription *src, UA_ApplicationDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
})

UA_INLINABLE( void
UA_ApplicationDescription_clear(UA_ApplicationDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
})

UA_INLINABLE( void
UA_ApplicationDescription_delete(UA_ApplicationDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_ApplicationDescription_equal(const UA_ApplicationDescription *p1, const UA_ApplicationDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]) == UA_ORDER_EQ);
})


/* RequestHeader */
typedef struct {
    UA_NodeId authenticationToken;
    UA_DateTime timestamp;
    UA_UInt32 requestHandle;
    UA_UInt32 returnDiagnostics;
    UA_String auditEntryId;
    UA_UInt32 timeoutHint;
    UA_ExtensionObject additionalHeader;
} UA_RequestHeader;

#define UA_TYPES_REQUESTHEADER 178

UA_INLINABLE( void
UA_RequestHeader_init(UA_RequestHeader *p), {
    memset(p, 0, sizeof(UA_RequestHeader));
})

UA_INLINABLE( UA_RequestHeader *
UA_RequestHeader_new(void), {
    return (UA_RequestHeader*)UA_new(&UA_TYPES[UA_TYPES_REQUESTHEADER]);
})

UA_INLINABLE( UA_StatusCode
UA_RequestHeader_copy(const UA_RequestHeader *src, UA_RequestHeader *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REQUESTHEADER]);
})

UA_INLINABLE( void
UA_RequestHeader_clear(UA_RequestHeader *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REQUESTHEADER]);
})

UA_INLINABLE( void
UA_RequestHeader_delete(UA_RequestHeader *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REQUESTHEADER]);
})

UA_INLINABLE( UA_Boolean
UA_RequestHeader_equal(const UA_RequestHeader *p1, const UA_RequestHeader *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REQUESTHEADER]) == UA_ORDER_EQ);
})


/* ResponseHeader */
typedef struct {
    UA_DateTime timestamp;
    UA_UInt32 requestHandle;
    UA_StatusCode serviceResult;
    UA_DiagnosticInfo serviceDiagnostics;
    size_t stringTableSize;
    UA_String *stringTable;
    UA_ExtensionObject additionalHeader;
} UA_ResponseHeader;

#define UA_TYPES_RESPONSEHEADER 179

UA_INLINABLE( void
UA_ResponseHeader_init(UA_ResponseHeader *p), {
    memset(p, 0, sizeof(UA_ResponseHeader));
})

UA_INLINABLE( UA_ResponseHeader *
UA_ResponseHeader_new(void), {
    return (UA_ResponseHeader*)UA_new(&UA_TYPES[UA_TYPES_RESPONSEHEADER]);
})

UA_INLINABLE( UA_StatusCode
UA_ResponseHeader_copy(const UA_ResponseHeader *src, UA_ResponseHeader *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
})

UA_INLINABLE( void
UA_ResponseHeader_clear(UA_ResponseHeader *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
})

UA_INLINABLE( void
UA_ResponseHeader_delete(UA_ResponseHeader *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
})

UA_INLINABLE( UA_Boolean
UA_ResponseHeader_equal(const UA_ResponseHeader *p1, const UA_ResponseHeader *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_RESPONSEHEADER]) == UA_ORDER_EQ);
})


/* VersionTime */
typedef UA_ByteString UA_VersionTime;

#define UA_TYPES_VERSIONTIME 180

UA_INLINABLE( void
UA_VersionTime_init(UA_VersionTime *p), {
    memset(p, 0, sizeof(UA_VersionTime));
})

UA_INLINABLE( UA_VersionTime *
UA_VersionTime_new(void), {
    return (UA_VersionTime*)UA_new(&UA_TYPES[UA_TYPES_VERSIONTIME]);
})

UA_INLINABLE( UA_StatusCode
UA_VersionTime_copy(const UA_VersionTime *src, UA_VersionTime *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VERSIONTIME]);
})

UA_INLINABLE( void
UA_VersionTime_clear(UA_VersionTime *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_VERSIONTIME]);
})

UA_INLINABLE( void
UA_VersionTime_delete(UA_VersionTime *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_VERSIONTIME]);
})

UA_INLINABLE( UA_Boolean
UA_VersionTime_equal(const UA_VersionTime *p1, const UA_VersionTime *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_VERSIONTIME]) == UA_ORDER_EQ);
})


/* ServiceFault */
typedef struct {
    UA_ResponseHeader responseHeader;
} UA_ServiceFault;

#define UA_TYPES_SERVICEFAULT 181

UA_INLINABLE( void
UA_ServiceFault_init(UA_ServiceFault *p), {
    memset(p, 0, sizeof(UA_ServiceFault));
})

UA_INLINABLE( UA_ServiceFault *
UA_ServiceFault_new(void), {
    return (UA_ServiceFault*)UA_new(&UA_TYPES[UA_TYPES_SERVICEFAULT]);
})

UA_INLINABLE( UA_StatusCode
UA_ServiceFault_copy(const UA_ServiceFault *src, UA_ServiceFault *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
})

UA_INLINABLE( void
UA_ServiceFault_clear(UA_ServiceFault *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
})

UA_INLINABLE( void
UA_ServiceFault_delete(UA_ServiceFault *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
})

UA_INLINABLE( UA_Boolean
UA_ServiceFault_equal(const UA_ServiceFault *p1, const UA_ServiceFault *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SERVICEFAULT]) == UA_ORDER_EQ);
})


/* SessionlessInvokeRequestType */
typedef struct {
    UA_UInt32 urisVersion;
    size_t namespaceUrisSize;
    UA_String *namespaceUris;
    size_t serverUrisSize;
    UA_String *serverUris;
    size_t localeIdsSize;
    UA_String *localeIds;
    UA_UInt32 serviceId;
} UA_SessionlessInvokeRequestType;

#define UA_TYPES_SESSIONLESSINVOKEREQUESTTYPE 182

UA_INLINABLE( void
UA_SessionlessInvokeRequestType_init(UA_SessionlessInvokeRequestType *p), {
    memset(p, 0, sizeof(UA_SessionlessInvokeRequestType));
})

UA_INLINABLE( UA_SessionlessInvokeRequestType *
UA_SessionlessInvokeRequestType_new(void), {
    return (UA_SessionlessInvokeRequestType*)UA_new(&UA_TYPES[UA_TYPES_SESSIONLESSINVOKEREQUESTTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SessionlessInvokeRequestType_copy(const UA_SessionlessInvokeRequestType *src, UA_SessionlessInvokeRequestType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SESSIONLESSINVOKEREQUESTTYPE]);
})

UA_INLINABLE( void
UA_SessionlessInvokeRequestType_clear(UA_SessionlessInvokeRequestType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SESSIONLESSINVOKEREQUESTTYPE]);
})

UA_INLINABLE( void
UA_SessionlessInvokeRequestType_delete(UA_SessionlessInvokeRequestType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SESSIONLESSINVOKEREQUESTTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SessionlessInvokeRequestType_equal(const UA_SessionlessInvokeRequestType *p1, const UA_SessionlessInvokeRequestType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SESSIONLESSINVOKEREQUESTTYPE]) == UA_ORDER_EQ);
})


/* SessionlessInvokeResponseType */
typedef struct {
    size_t namespaceUrisSize;
    UA_String *namespaceUris;
    size_t serverUrisSize;
    UA_String *serverUris;
    UA_UInt32 serviceId;
} UA_SessionlessInvokeResponseType;

#define UA_TYPES_SESSIONLESSINVOKERESPONSETYPE 183

UA_INLINABLE( void
UA_SessionlessInvokeResponseType_init(UA_SessionlessInvokeResponseType *p), {
    memset(p, 0, sizeof(UA_SessionlessInvokeResponseType));
})

UA_INLINABLE( UA_SessionlessInvokeResponseType *
UA_SessionlessInvokeResponseType_new(void), {
    return (UA_SessionlessInvokeResponseType*)UA_new(&UA_TYPES[UA_TYPES_SESSIONLESSINVOKERESPONSETYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SessionlessInvokeResponseType_copy(const UA_SessionlessInvokeResponseType *src, UA_SessionlessInvokeResponseType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SESSIONLESSINVOKERESPONSETYPE]);
})

UA_INLINABLE( void
UA_SessionlessInvokeResponseType_clear(UA_SessionlessInvokeResponseType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SESSIONLESSINVOKERESPONSETYPE]);
})

UA_INLINABLE( void
UA_SessionlessInvokeResponseType_delete(UA_SessionlessInvokeResponseType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SESSIONLESSINVOKERESPONSETYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SessionlessInvokeResponseType_equal(const UA_SessionlessInvokeResponseType *p1, const UA_SessionlessInvokeResponseType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SESSIONLESSINVOKERESPONSETYPE]) == UA_ORDER_EQ);
})


/* FindServersRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_String endpointUrl;
    size_t localeIdsSize;
    UA_String *localeIds;
    size_t serverUrisSize;
    UA_String *serverUris;
} UA_FindServersRequest;

#define UA_TYPES_FINDSERVERSREQUEST 184

UA_INLINABLE( void
UA_FindServersRequest_init(UA_FindServersRequest *p), {
    memset(p, 0, sizeof(UA_FindServersRequest));
})

UA_INLINABLE( UA_FindServersRequest *
UA_FindServersRequest_new(void), {
    return (UA_FindServersRequest*)UA_new(&UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_FindServersRequest_copy(const UA_FindServersRequest *src, UA_FindServersRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
})

UA_INLINABLE( void
UA_FindServersRequest_clear(UA_FindServersRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
})

UA_INLINABLE( void
UA_FindServersRequest_delete(UA_FindServersRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_FindServersRequest_equal(const UA_FindServersRequest *p1, const UA_FindServersRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]) == UA_ORDER_EQ);
})


/* FindServersResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t serversSize;
    UA_ApplicationDescription *servers;
} UA_FindServersResponse;

#define UA_TYPES_FINDSERVERSRESPONSE 185

UA_INLINABLE( void
UA_FindServersResponse_init(UA_FindServersResponse *p), {
    memset(p, 0, sizeof(UA_FindServersResponse));
})

UA_INLINABLE( UA_FindServersResponse *
UA_FindServersResponse_new(void), {
    return (UA_FindServersResponse*)UA_new(&UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_FindServersResponse_copy(const UA_FindServersResponse *src, UA_FindServersResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
})

UA_INLINABLE( void
UA_FindServersResponse_clear(UA_FindServersResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
})

UA_INLINABLE( void
UA_FindServersResponse_delete(UA_FindServersResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_FindServersResponse_equal(const UA_FindServersResponse *p1, const UA_FindServersResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]) == UA_ORDER_EQ);
})


/* ServerOnNetwork */
typedef struct {
    UA_UInt32 recordId;
    UA_String serverName;
    UA_String discoveryUrl;
    size_t serverCapabilitiesSize;
    UA_String *serverCapabilities;
} UA_ServerOnNetwork;

#define UA_TYPES_SERVERONNETWORK 186

UA_INLINABLE( void
UA_ServerOnNetwork_init(UA_ServerOnNetwork *p), {
    memset(p, 0, sizeof(UA_ServerOnNetwork));
})

UA_INLINABLE( UA_ServerOnNetwork *
UA_ServerOnNetwork_new(void), {
    return (UA_ServerOnNetwork*)UA_new(&UA_TYPES[UA_TYPES_SERVERONNETWORK]);
})

UA_INLINABLE( UA_StatusCode
UA_ServerOnNetwork_copy(const UA_ServerOnNetwork *src, UA_ServerOnNetwork *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERONNETWORK]);
})

UA_INLINABLE( void
UA_ServerOnNetwork_clear(UA_ServerOnNetwork *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERONNETWORK]);
})

UA_INLINABLE( void
UA_ServerOnNetwork_delete(UA_ServerOnNetwork *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVERONNETWORK]);
})

UA_INLINABLE( UA_Boolean
UA_ServerOnNetwork_equal(const UA_ServerOnNetwork *p1, const UA_ServerOnNetwork *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SERVERONNETWORK]) == UA_ORDER_EQ);
})


/* FindServersOnNetworkRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 startingRecordId;
    UA_UInt32 maxRecordsToReturn;
    size_t serverCapabilityFilterSize;
    UA_String *serverCapabilityFilter;
} UA_FindServersOnNetworkRequest;

#define UA_TYPES_FINDSERVERSONNETWORKREQUEST 187

UA_INLINABLE( void
UA_FindServersOnNetworkRequest_init(UA_FindServersOnNetworkRequest *p), {
    memset(p, 0, sizeof(UA_FindServersOnNetworkRequest));
})

UA_INLINABLE( UA_FindServersOnNetworkRequest *
UA_FindServersOnNetworkRequest_new(void), {
    return (UA_FindServersOnNetworkRequest*)UA_new(&UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_FindServersOnNetworkRequest_copy(const UA_FindServersOnNetworkRequest *src, UA_FindServersOnNetworkRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKREQUEST]);
})

UA_INLINABLE( void
UA_FindServersOnNetworkRequest_clear(UA_FindServersOnNetworkRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKREQUEST]);
})

UA_INLINABLE( void
UA_FindServersOnNetworkRequest_delete(UA_FindServersOnNetworkRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_FindServersOnNetworkRequest_equal(const UA_FindServersOnNetworkRequest *p1, const UA_FindServersOnNetworkRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKREQUEST]) == UA_ORDER_EQ);
})


/* FindServersOnNetworkResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_DateTime lastCounterResetTime;
    size_t serversSize;
    UA_ServerOnNetwork *servers;
} UA_FindServersOnNetworkResponse;

#define UA_TYPES_FINDSERVERSONNETWORKRESPONSE 188

UA_INLINABLE( void
UA_FindServersOnNetworkResponse_init(UA_FindServersOnNetworkResponse *p), {
    memset(p, 0, sizeof(UA_FindServersOnNetworkResponse));
})

UA_INLINABLE( UA_FindServersOnNetworkResponse *
UA_FindServersOnNetworkResponse_new(void), {
    return (UA_FindServersOnNetworkResponse*)UA_new(&UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_FindServersOnNetworkResponse_copy(const UA_FindServersOnNetworkResponse *src, UA_FindServersOnNetworkResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKRESPONSE]);
})

UA_INLINABLE( void
UA_FindServersOnNetworkResponse_clear(UA_FindServersOnNetworkResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKRESPONSE]);
})

UA_INLINABLE( void
UA_FindServersOnNetworkResponse_delete(UA_FindServersOnNetworkResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_FindServersOnNetworkResponse_equal(const UA_FindServersOnNetworkResponse *p1, const UA_FindServersOnNetworkResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKRESPONSE]) == UA_ORDER_EQ);
})


/* ApplicationInstanceCertificate */
typedef UA_ByteString UA_ApplicationInstanceCertificate;

#define UA_TYPES_APPLICATIONINSTANCECERTIFICATE 189

UA_INLINABLE( void
UA_ApplicationInstanceCertificate_init(UA_ApplicationInstanceCertificate *p), {
    memset(p, 0, sizeof(UA_ApplicationInstanceCertificate));
})

UA_INLINABLE( UA_ApplicationInstanceCertificate *
UA_ApplicationInstanceCertificate_new(void), {
    return (UA_ApplicationInstanceCertificate*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONINSTANCECERTIFICATE]);
})

UA_INLINABLE( UA_StatusCode
UA_ApplicationInstanceCertificate_copy(const UA_ApplicationInstanceCertificate *src, UA_ApplicationInstanceCertificate *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONINSTANCECERTIFICATE]);
})

UA_INLINABLE( void
UA_ApplicationInstanceCertificate_clear(UA_ApplicationInstanceCertificate *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONINSTANCECERTIFICATE]);
})

UA_INLINABLE( void
UA_ApplicationInstanceCertificate_delete(UA_ApplicationInstanceCertificate *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONINSTANCECERTIFICATE]);
})

UA_INLINABLE( UA_Boolean
UA_ApplicationInstanceCertificate_equal(const UA_ApplicationInstanceCertificate *p1, const UA_ApplicationInstanceCertificate *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_APPLICATIONINSTANCECERTIFICATE]) == UA_ORDER_EQ);
})


/* MessageSecurityMode */
typedef enum {
    UA_MESSAGESECURITYMODE_INVALID = 0,
    UA_MESSAGESECURITYMODE_NONE = 1,
    UA_MESSAGESECURITYMODE_SIGN = 2,
    UA_MESSAGESECURITYMODE_SIGNANDENCRYPT = 3,
    __UA_MESSAGESECURITYMODE_FORCE32BIT = 0x7fffffff
} UA_MessageSecurityMode;

UA_STATIC_ASSERT(sizeof(UA_MessageSecurityMode) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_MESSAGESECURITYMODE 190

UA_INLINABLE( void
UA_MessageSecurityMode_init(UA_MessageSecurityMode *p), {
    memset(p, 0, sizeof(UA_MessageSecurityMode));
})

UA_INLINABLE( UA_MessageSecurityMode *
UA_MessageSecurityMode_new(void), {
    return (UA_MessageSecurityMode*)UA_new(&UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
})

UA_INLINABLE( UA_StatusCode
UA_MessageSecurityMode_copy(const UA_MessageSecurityMode *src, UA_MessageSecurityMode *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
})

UA_INLINABLE( void
UA_MessageSecurityMode_clear(UA_MessageSecurityMode *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
})

UA_INLINABLE( void
UA_MessageSecurityMode_delete(UA_MessageSecurityMode *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]);
})

UA_INLINABLE( UA_Boolean
UA_MessageSecurityMode_equal(const UA_MessageSecurityMode *p1, const UA_MessageSecurityMode *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]) == UA_ORDER_EQ);
})


/* UserTokenType */
typedef enum {
    UA_USERTOKENTYPE_ANONYMOUS = 0,
    UA_USERTOKENTYPE_USERNAME = 1,
    UA_USERTOKENTYPE_CERTIFICATE = 2,
    UA_USERTOKENTYPE_ISSUEDTOKEN = 3,
    __UA_USERTOKENTYPE_FORCE32BIT = 0x7fffffff
} UA_UserTokenType;

UA_STATIC_ASSERT(sizeof(UA_UserTokenType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_USERTOKENTYPE 191

UA_INLINABLE( void
UA_UserTokenType_init(UA_UserTokenType *p), {
    memset(p, 0, sizeof(UA_UserTokenType));
})

UA_INLINABLE( UA_UserTokenType *
UA_UserTokenType_new(void), {
    return (UA_UserTokenType*)UA_new(&UA_TYPES[UA_TYPES_USERTOKENTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_UserTokenType_copy(const UA_UserTokenType *src, UA_UserTokenType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERTOKENTYPE]);
})

UA_INLINABLE( void
UA_UserTokenType_clear(UA_UserTokenType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENTYPE]);
})

UA_INLINABLE( void
UA_UserTokenType_delete(UA_UserTokenType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERTOKENTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_UserTokenType_equal(const UA_UserTokenType *p1, const UA_UserTokenType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_USERTOKENTYPE]) == UA_ORDER_EQ);
})


/* UserTokenPolicy */
typedef struct {
    UA_String policyId;
    UA_UserTokenType tokenType;
    UA_String issuedTokenType;
    UA_String issuerEndpointUrl;
    UA_String securityPolicyUri;
} UA_UserTokenPolicy;

#define UA_TYPES_USERTOKENPOLICY 192

UA_INLINABLE( void
UA_UserTokenPolicy_init(UA_UserTokenPolicy *p), {
    memset(p, 0, sizeof(UA_UserTokenPolicy));
})

UA_INLINABLE( UA_UserTokenPolicy *
UA_UserTokenPolicy_new(void), {
    return (UA_UserTokenPolicy*)UA_new(&UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
})

UA_INLINABLE( UA_StatusCode
UA_UserTokenPolicy_copy(const UA_UserTokenPolicy *src, UA_UserTokenPolicy *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
})

UA_INLINABLE( void
UA_UserTokenPolicy_clear(UA_UserTokenPolicy *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
})

UA_INLINABLE( void
UA_UserTokenPolicy_delete(UA_UserTokenPolicy *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]);
})

UA_INLINABLE( UA_Boolean
UA_UserTokenPolicy_equal(const UA_UserTokenPolicy *p1, const UA_UserTokenPolicy *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]) == UA_ORDER_EQ);
})


/* EndpointDescription */
typedef struct {
    UA_String endpointUrl;
    UA_ApplicationDescription server;
    UA_ByteString serverCertificate;
    UA_MessageSecurityMode securityMode;
    UA_String securityPolicyUri;
    size_t userIdentityTokensSize;
    UA_UserTokenPolicy *userIdentityTokens;
    UA_String transportProfileUri;
    UA_Byte securityLevel;
} UA_EndpointDescription;

#define UA_TYPES_ENDPOINTDESCRIPTION 193

UA_INLINABLE( void
UA_EndpointDescription_init(UA_EndpointDescription *p), {
    memset(p, 0, sizeof(UA_EndpointDescription));
})

UA_INLINABLE( UA_EndpointDescription *
UA_EndpointDescription_new(void), {
    return (UA_EndpointDescription*)UA_new(&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_EndpointDescription_copy(const UA_EndpointDescription *src, UA_EndpointDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
})

UA_INLINABLE( void
UA_EndpointDescription_clear(UA_EndpointDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
})

UA_INLINABLE( void
UA_EndpointDescription_delete(UA_EndpointDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_EndpointDescription_equal(const UA_EndpointDescription *p1, const UA_EndpointDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]) == UA_ORDER_EQ);
})


/* GetEndpointsRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_String endpointUrl;
    size_t localeIdsSize;
    UA_String *localeIds;
    size_t profileUrisSize;
    UA_String *profileUris;
} UA_GetEndpointsRequest;

#define UA_TYPES_GETENDPOINTSREQUEST 194

UA_INLINABLE( void
UA_GetEndpointsRequest_init(UA_GetEndpointsRequest *p), {
    memset(p, 0, sizeof(UA_GetEndpointsRequest));
})

UA_INLINABLE( UA_GetEndpointsRequest *
UA_GetEndpointsRequest_new(void), {
    return (UA_GetEndpointsRequest*)UA_new(&UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_GetEndpointsRequest_copy(const UA_GetEndpointsRequest *src, UA_GetEndpointsRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
})

UA_INLINABLE( void
UA_GetEndpointsRequest_clear(UA_GetEndpointsRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
})

UA_INLINABLE( void
UA_GetEndpointsRequest_delete(UA_GetEndpointsRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_GetEndpointsRequest_equal(const UA_GetEndpointsRequest *p1, const UA_GetEndpointsRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]) == UA_ORDER_EQ);
})


/* GetEndpointsResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t endpointsSize;
    UA_EndpointDescription *endpoints;
} UA_GetEndpointsResponse;

#define UA_TYPES_GETENDPOINTSRESPONSE 195

UA_INLINABLE( void
UA_GetEndpointsResponse_init(UA_GetEndpointsResponse *p), {
    memset(p, 0, sizeof(UA_GetEndpointsResponse));
})

UA_INLINABLE( UA_GetEndpointsResponse *
UA_GetEndpointsResponse_new(void), {
    return (UA_GetEndpointsResponse*)UA_new(&UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_GetEndpointsResponse_copy(const UA_GetEndpointsResponse *src, UA_GetEndpointsResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
})

UA_INLINABLE( void
UA_GetEndpointsResponse_clear(UA_GetEndpointsResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
})

UA_INLINABLE( void
UA_GetEndpointsResponse_delete(UA_GetEndpointsResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_GetEndpointsResponse_equal(const UA_GetEndpointsResponse *p1, const UA_GetEndpointsResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]) == UA_ORDER_EQ);
})


/* RegisteredServer */
typedef struct {
    UA_String serverUri;
    UA_String productUri;
    size_t serverNamesSize;
    UA_LocalizedText *serverNames;
    UA_ApplicationType serverType;
    UA_String gatewayServerUri;
    size_t discoveryUrlsSize;
    UA_String *discoveryUrls;
    UA_String semaphoreFilePath;
    UA_Boolean isOnline;
} UA_RegisteredServer;

#define UA_TYPES_REGISTEREDSERVER 196

UA_INLINABLE( void
UA_RegisteredServer_init(UA_RegisteredServer *p), {
    memset(p, 0, sizeof(UA_RegisteredServer));
})

UA_INLINABLE( UA_RegisteredServer *
UA_RegisteredServer_new(void), {
    return (UA_RegisteredServer*)UA_new(&UA_TYPES[UA_TYPES_REGISTEREDSERVER]);
})

UA_INLINABLE( UA_StatusCode
UA_RegisteredServer_copy(const UA_RegisteredServer *src, UA_RegisteredServer *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTEREDSERVER]);
})

UA_INLINABLE( void
UA_RegisteredServer_clear(UA_RegisteredServer *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTEREDSERVER]);
})

UA_INLINABLE( void
UA_RegisteredServer_delete(UA_RegisteredServer *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTEREDSERVER]);
})

UA_INLINABLE( UA_Boolean
UA_RegisteredServer_equal(const UA_RegisteredServer *p1, const UA_RegisteredServer *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REGISTEREDSERVER]) == UA_ORDER_EQ);
})


/* RegisterServerRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_RegisteredServer server;
} UA_RegisterServerRequest;

#define UA_TYPES_REGISTERSERVERREQUEST 197

UA_INLINABLE( void
UA_RegisterServerRequest_init(UA_RegisterServerRequest *p), {
    memset(p, 0, sizeof(UA_RegisterServerRequest));
})

UA_INLINABLE( UA_RegisterServerRequest *
UA_RegisterServerRequest_new(void), {
    return (UA_RegisterServerRequest*)UA_new(&UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_RegisterServerRequest_copy(const UA_RegisterServerRequest *src, UA_RegisterServerRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST]);
})

UA_INLINABLE( void
UA_RegisterServerRequest_clear(UA_RegisterServerRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST]);
})

UA_INLINABLE( void
UA_RegisterServerRequest_delete(UA_RegisterServerRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_RegisterServerRequest_equal(const UA_RegisterServerRequest *p1, const UA_RegisterServerRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST]) == UA_ORDER_EQ);
})


/* RegisterServerResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
} UA_RegisterServerResponse;

#define UA_TYPES_REGISTERSERVERRESPONSE 198

UA_INLINABLE( void
UA_RegisterServerResponse_init(UA_RegisterServerResponse *p), {
    memset(p, 0, sizeof(UA_RegisterServerResponse));
})

UA_INLINABLE( UA_RegisterServerResponse *
UA_RegisterServerResponse_new(void), {
    return (UA_RegisterServerResponse*)UA_new(&UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_RegisterServerResponse_copy(const UA_RegisterServerResponse *src, UA_RegisterServerResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]);
})

UA_INLINABLE( void
UA_RegisterServerResponse_clear(UA_RegisterServerResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]);
})

UA_INLINABLE( void
UA_RegisterServerResponse_delete(UA_RegisterServerResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_RegisterServerResponse_equal(const UA_RegisterServerResponse *p1, const UA_RegisterServerResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]) == UA_ORDER_EQ);
})


/* MdnsDiscoveryConfiguration */
typedef struct {
    UA_String mdnsServerName;
    size_t serverCapabilitiesSize;
    UA_String *serverCapabilities;
} UA_MdnsDiscoveryConfiguration;

#define UA_TYPES_MDNSDISCOVERYCONFIGURATION 199

UA_INLINABLE( void
UA_MdnsDiscoveryConfiguration_init(UA_MdnsDiscoveryConfiguration *p), {
    memset(p, 0, sizeof(UA_MdnsDiscoveryConfiguration));
})

UA_INLINABLE( UA_MdnsDiscoveryConfiguration *
UA_MdnsDiscoveryConfiguration_new(void), {
    return (UA_MdnsDiscoveryConfiguration*)UA_new(&UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION]);
})

UA_INLINABLE( UA_StatusCode
UA_MdnsDiscoveryConfiguration_copy(const UA_MdnsDiscoveryConfiguration *src, UA_MdnsDiscoveryConfiguration *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION]);
})

UA_INLINABLE( void
UA_MdnsDiscoveryConfiguration_clear(UA_MdnsDiscoveryConfiguration *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION]);
})

UA_INLINABLE( void
UA_MdnsDiscoveryConfiguration_delete(UA_MdnsDiscoveryConfiguration *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION]);
})

UA_INLINABLE( UA_Boolean
UA_MdnsDiscoveryConfiguration_equal(const UA_MdnsDiscoveryConfiguration *p1, const UA_MdnsDiscoveryConfiguration *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION]) == UA_ORDER_EQ);
})


/* RegisterServer2Request */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_RegisteredServer server;
    size_t discoveryConfigurationSize;
    UA_ExtensionObject *discoveryConfiguration;
} UA_RegisterServer2Request;

#define UA_TYPES_REGISTERSERVER2REQUEST 200

UA_INLINABLE( void
UA_RegisterServer2Request_init(UA_RegisterServer2Request *p), {
    memset(p, 0, sizeof(UA_RegisterServer2Request));
})

UA_INLINABLE( UA_RegisterServer2Request *
UA_RegisterServer2Request_new(void), {
    return (UA_RegisterServer2Request*)UA_new(&UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_RegisterServer2Request_copy(const UA_RegisterServer2Request *src, UA_RegisterServer2Request *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST]);
})

UA_INLINABLE( void
UA_RegisterServer2Request_clear(UA_RegisterServer2Request *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST]);
})

UA_INLINABLE( void
UA_RegisterServer2Request_delete(UA_RegisterServer2Request *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_RegisterServer2Request_equal(const UA_RegisterServer2Request *p1, const UA_RegisterServer2Request *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST]) == UA_ORDER_EQ);
})


/* RegisterServer2Response */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t configurationResultsSize;
    UA_StatusCode *configurationResults;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_RegisterServer2Response;

#define UA_TYPES_REGISTERSERVER2RESPONSE 201

UA_INLINABLE( void
UA_RegisterServer2Response_init(UA_RegisterServer2Response *p), {
    memset(p, 0, sizeof(UA_RegisterServer2Response));
})

UA_INLINABLE( UA_RegisterServer2Response *
UA_RegisterServer2Response_new(void), {
    return (UA_RegisterServer2Response*)UA_new(&UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_RegisterServer2Response_copy(const UA_RegisterServer2Response *src, UA_RegisterServer2Response *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]);
})

UA_INLINABLE( void
UA_RegisterServer2Response_clear(UA_RegisterServer2Response *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]);
})

UA_INLINABLE( void
UA_RegisterServer2Response_delete(UA_RegisterServer2Response *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_RegisterServer2Response_equal(const UA_RegisterServer2Response *p1, const UA_RegisterServer2Response *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]) == UA_ORDER_EQ);
})


/* SecurityTokenRequestType */
typedef enum {
    UA_SECURITYTOKENREQUESTTYPE_ISSUE = 0,
    UA_SECURITYTOKENREQUESTTYPE_RENEW = 1,
    __UA_SECURITYTOKENREQUESTTYPE_FORCE32BIT = 0x7fffffff
} UA_SecurityTokenRequestType;

UA_STATIC_ASSERT(sizeof(UA_SecurityTokenRequestType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_SECURITYTOKENREQUESTTYPE 202

UA_INLINABLE( void
UA_SecurityTokenRequestType_init(UA_SecurityTokenRequestType *p), {
    memset(p, 0, sizeof(UA_SecurityTokenRequestType));
})

UA_INLINABLE( UA_SecurityTokenRequestType *
UA_SecurityTokenRequestType_new(void), {
    return (UA_SecurityTokenRequestType*)UA_new(&UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SecurityTokenRequestType_copy(const UA_SecurityTokenRequestType *src, UA_SecurityTokenRequestType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
})

UA_INLINABLE( void
UA_SecurityTokenRequestType_clear(UA_SecurityTokenRequestType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
})

UA_INLINABLE( void
UA_SecurityTokenRequestType_delete(UA_SecurityTokenRequestType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SecurityTokenRequestType_equal(const UA_SecurityTokenRequestType *p1, const UA_SecurityTokenRequestType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]) == UA_ORDER_EQ);
})


/* ChannelSecurityToken */
typedef struct {
    UA_UInt32 channelId;
    UA_UInt32 tokenId;
    UA_DateTime createdAt;
    UA_UInt32 revisedLifetime;
} UA_ChannelSecurityToken;

#define UA_TYPES_CHANNELSECURITYTOKEN 203

UA_INLINABLE( void
UA_ChannelSecurityToken_init(UA_ChannelSecurityToken *p), {
    memset(p, 0, sizeof(UA_ChannelSecurityToken));
})

UA_INLINABLE( UA_ChannelSecurityToken *
UA_ChannelSecurityToken_new(void), {
    return (UA_ChannelSecurityToken*)UA_new(&UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
})

UA_INLINABLE( UA_StatusCode
UA_ChannelSecurityToken_copy(const UA_ChannelSecurityToken *src, UA_ChannelSecurityToken *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
})

UA_INLINABLE( void
UA_ChannelSecurityToken_clear(UA_ChannelSecurityToken *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
})

UA_INLINABLE( void
UA_ChannelSecurityToken_delete(UA_ChannelSecurityToken *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]);
})

UA_INLINABLE( UA_Boolean
UA_ChannelSecurityToken_equal(const UA_ChannelSecurityToken *p1, const UA_ChannelSecurityToken *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]) == UA_ORDER_EQ);
})


/* OpenSecureChannelRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 clientProtocolVersion;
    UA_SecurityTokenRequestType requestType;
    UA_MessageSecurityMode securityMode;
    UA_ByteString clientNonce;
    UA_UInt32 requestedLifetime;
} UA_OpenSecureChannelRequest;

#define UA_TYPES_OPENSECURECHANNELREQUEST 204

UA_INLINABLE( void
UA_OpenSecureChannelRequest_init(UA_OpenSecureChannelRequest *p), {
    memset(p, 0, sizeof(UA_OpenSecureChannelRequest));
})

UA_INLINABLE( UA_OpenSecureChannelRequest *
UA_OpenSecureChannelRequest_new(void), {
    return (UA_OpenSecureChannelRequest*)UA_new(&UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_OpenSecureChannelRequest_copy(const UA_OpenSecureChannelRequest *src, UA_OpenSecureChannelRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
})

UA_INLINABLE( void
UA_OpenSecureChannelRequest_clear(UA_OpenSecureChannelRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
})

UA_INLINABLE( void
UA_OpenSecureChannelRequest_delete(UA_OpenSecureChannelRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_OpenSecureChannelRequest_equal(const UA_OpenSecureChannelRequest *p1, const UA_OpenSecureChannelRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]) == UA_ORDER_EQ);
})


/* OpenSecureChannelResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_UInt32 serverProtocolVersion;
    UA_ChannelSecurityToken securityToken;
    UA_ByteString serverNonce;
} UA_OpenSecureChannelResponse;

#define UA_TYPES_OPENSECURECHANNELRESPONSE 205

UA_INLINABLE( void
UA_OpenSecureChannelResponse_init(UA_OpenSecureChannelResponse *p), {
    memset(p, 0, sizeof(UA_OpenSecureChannelResponse));
})

UA_INLINABLE( UA_OpenSecureChannelResponse *
UA_OpenSecureChannelResponse_new(void), {
    return (UA_OpenSecureChannelResponse*)UA_new(&UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_OpenSecureChannelResponse_copy(const UA_OpenSecureChannelResponse *src, UA_OpenSecureChannelResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
})

UA_INLINABLE( void
UA_OpenSecureChannelResponse_clear(UA_OpenSecureChannelResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
})

UA_INLINABLE( void
UA_OpenSecureChannelResponse_delete(UA_OpenSecureChannelResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_OpenSecureChannelResponse_equal(const UA_OpenSecureChannelResponse *p1, const UA_OpenSecureChannelResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]) == UA_ORDER_EQ);
})


/* CloseSecureChannelRequest */
typedef struct {
    UA_RequestHeader requestHeader;
} UA_CloseSecureChannelRequest;

#define UA_TYPES_CLOSESECURECHANNELREQUEST 206

UA_INLINABLE( void
UA_CloseSecureChannelRequest_init(UA_CloseSecureChannelRequest *p), {
    memset(p, 0, sizeof(UA_CloseSecureChannelRequest));
})

UA_INLINABLE( UA_CloseSecureChannelRequest *
UA_CloseSecureChannelRequest_new(void), {
    return (UA_CloseSecureChannelRequest*)UA_new(&UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_CloseSecureChannelRequest_copy(const UA_CloseSecureChannelRequest *src, UA_CloseSecureChannelRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
})

UA_INLINABLE( void
UA_CloseSecureChannelRequest_clear(UA_CloseSecureChannelRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
})

UA_INLINABLE( void
UA_CloseSecureChannelRequest_delete(UA_CloseSecureChannelRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_CloseSecureChannelRequest_equal(const UA_CloseSecureChannelRequest *p1, const UA_CloseSecureChannelRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]) == UA_ORDER_EQ);
})


/* CloseSecureChannelResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
} UA_CloseSecureChannelResponse;

#define UA_TYPES_CLOSESECURECHANNELRESPONSE 207

UA_INLINABLE( void
UA_CloseSecureChannelResponse_init(UA_CloseSecureChannelResponse *p), {
    memset(p, 0, sizeof(UA_CloseSecureChannelResponse));
})

UA_INLINABLE( UA_CloseSecureChannelResponse *
UA_CloseSecureChannelResponse_new(void), {
    return (UA_CloseSecureChannelResponse*)UA_new(&UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_CloseSecureChannelResponse_copy(const UA_CloseSecureChannelResponse *src, UA_CloseSecureChannelResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
})

UA_INLINABLE( void
UA_CloseSecureChannelResponse_clear(UA_CloseSecureChannelResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
})

UA_INLINABLE( void
UA_CloseSecureChannelResponse_delete(UA_CloseSecureChannelResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_CloseSecureChannelResponse_equal(const UA_CloseSecureChannelResponse *p1, const UA_CloseSecureChannelResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]) == UA_ORDER_EQ);
})


/* SignedSoftwareCertificate */
typedef struct {
    UA_ByteString certificateData;
    UA_ByteString signature;
} UA_SignedSoftwareCertificate;

#define UA_TYPES_SIGNEDSOFTWARECERTIFICATE 208

UA_INLINABLE( void
UA_SignedSoftwareCertificate_init(UA_SignedSoftwareCertificate *p), {
    memset(p, 0, sizeof(UA_SignedSoftwareCertificate));
})

UA_INLINABLE( UA_SignedSoftwareCertificate *
UA_SignedSoftwareCertificate_new(void), {
    return (UA_SignedSoftwareCertificate*)UA_new(&UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
})

UA_INLINABLE( UA_StatusCode
UA_SignedSoftwareCertificate_copy(const UA_SignedSoftwareCertificate *src, UA_SignedSoftwareCertificate *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
})

UA_INLINABLE( void
UA_SignedSoftwareCertificate_clear(UA_SignedSoftwareCertificate *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
})

UA_INLINABLE( void
UA_SignedSoftwareCertificate_delete(UA_SignedSoftwareCertificate *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]);
})

UA_INLINABLE( UA_Boolean
UA_SignedSoftwareCertificate_equal(const UA_SignedSoftwareCertificate *p1, const UA_SignedSoftwareCertificate *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]) == UA_ORDER_EQ);
})


/* SessionAuthenticationToken */
typedef UA_NodeId UA_SessionAuthenticationToken;

#define UA_TYPES_SESSIONAUTHENTICATIONTOKEN 209

UA_INLINABLE( void
UA_SessionAuthenticationToken_init(UA_SessionAuthenticationToken *p), {
    memset(p, 0, sizeof(UA_SessionAuthenticationToken));
})

UA_INLINABLE( UA_SessionAuthenticationToken *
UA_SessionAuthenticationToken_new(void), {
    return (UA_SessionAuthenticationToken*)UA_new(&UA_TYPES[UA_TYPES_SESSIONAUTHENTICATIONTOKEN]);
})

UA_INLINABLE( UA_StatusCode
UA_SessionAuthenticationToken_copy(const UA_SessionAuthenticationToken *src, UA_SessionAuthenticationToken *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SESSIONAUTHENTICATIONTOKEN]);
})

UA_INLINABLE( void
UA_SessionAuthenticationToken_clear(UA_SessionAuthenticationToken *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SESSIONAUTHENTICATIONTOKEN]);
})

UA_INLINABLE( void
UA_SessionAuthenticationToken_delete(UA_SessionAuthenticationToken *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SESSIONAUTHENTICATIONTOKEN]);
})

UA_INLINABLE( UA_Boolean
UA_SessionAuthenticationToken_equal(const UA_SessionAuthenticationToken *p1, const UA_SessionAuthenticationToken *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SESSIONAUTHENTICATIONTOKEN]) == UA_ORDER_EQ);
})


/* SignatureData */
typedef struct {
    UA_String algorithm;
    UA_ByteString signature;
} UA_SignatureData;

#define UA_TYPES_SIGNATUREDATA 210

UA_INLINABLE( void
UA_SignatureData_init(UA_SignatureData *p), {
    memset(p, 0, sizeof(UA_SignatureData));
})

UA_INLINABLE( UA_SignatureData *
UA_SignatureData_new(void), {
    return (UA_SignatureData*)UA_new(&UA_TYPES[UA_TYPES_SIGNATUREDATA]);
})

UA_INLINABLE( UA_StatusCode
UA_SignatureData_copy(const UA_SignatureData *src, UA_SignatureData *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIGNATUREDATA]);
})

UA_INLINABLE( void
UA_SignatureData_clear(UA_SignatureData *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIGNATUREDATA]);
})

UA_INLINABLE( void
UA_SignatureData_delete(UA_SignatureData *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SIGNATUREDATA]);
})

UA_INLINABLE( UA_Boolean
UA_SignatureData_equal(const UA_SignatureData *p1, const UA_SignatureData *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SIGNATUREDATA]) == UA_ORDER_EQ);
})


/* CreateSessionRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_ApplicationDescription clientDescription;
    UA_String serverUri;
    UA_String endpointUrl;
    UA_String sessionName;
    UA_ByteString clientNonce;
    UA_ByteString clientCertificate;
    UA_Double requestedSessionTimeout;
    UA_UInt32 maxResponseMessageSize;
} UA_CreateSessionRequest;

#define UA_TYPES_CREATESESSIONREQUEST 211

UA_INLINABLE( void
UA_CreateSessionRequest_init(UA_CreateSessionRequest *p), {
    memset(p, 0, sizeof(UA_CreateSessionRequest));
})

UA_INLINABLE( UA_CreateSessionRequest *
UA_CreateSessionRequest_new(void), {
    return (UA_CreateSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_CreateSessionRequest_copy(const UA_CreateSessionRequest *src, UA_CreateSessionRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
})

UA_INLINABLE( void
UA_CreateSessionRequest_clear(UA_CreateSessionRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
})

UA_INLINABLE( void
UA_CreateSessionRequest_delete(UA_CreateSessionRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_CreateSessionRequest_equal(const UA_CreateSessionRequest *p1, const UA_CreateSessionRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]) == UA_ORDER_EQ);
})


/* CreateSessionResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_NodeId sessionId;
    UA_NodeId authenticationToken;
    UA_Double revisedSessionTimeout;
    UA_ByteString serverNonce;
    UA_ByteString serverCertificate;
    size_t serverEndpointsSize;
    UA_EndpointDescription *serverEndpoints;
    size_t serverSoftwareCertificatesSize;
    UA_SignedSoftwareCertificate *serverSoftwareCertificates;
    UA_SignatureData serverSignature;
    UA_UInt32 maxRequestMessageSize;
} UA_CreateSessionResponse;

#define UA_TYPES_CREATESESSIONRESPONSE 212

UA_INLINABLE( void
UA_CreateSessionResponse_init(UA_CreateSessionResponse *p), {
    memset(p, 0, sizeof(UA_CreateSessionResponse));
})

UA_INLINABLE( UA_CreateSessionResponse *
UA_CreateSessionResponse_new(void), {
    return (UA_CreateSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_CreateSessionResponse_copy(const UA_CreateSessionResponse *src, UA_CreateSessionResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
})

UA_INLINABLE( void
UA_CreateSessionResponse_clear(UA_CreateSessionResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
})

UA_INLINABLE( void
UA_CreateSessionResponse_delete(UA_CreateSessionResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_CreateSessionResponse_equal(const UA_CreateSessionResponse *p1, const UA_CreateSessionResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]) == UA_ORDER_EQ);
})


/* UserIdentityToken */
typedef struct {
    UA_String policyId;
} UA_UserIdentityToken;

#define UA_TYPES_USERIDENTITYTOKEN 213

UA_INLINABLE( void
UA_UserIdentityToken_init(UA_UserIdentityToken *p), {
    memset(p, 0, sizeof(UA_UserIdentityToken));
})

UA_INLINABLE( UA_UserIdentityToken *
UA_UserIdentityToken_new(void), {
    return (UA_UserIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
})

UA_INLINABLE( UA_StatusCode
UA_UserIdentityToken_copy(const UA_UserIdentityToken *src, UA_UserIdentityToken *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_UserIdentityToken_clear(UA_UserIdentityToken *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_UserIdentityToken_delete(UA_UserIdentityToken *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]);
})

UA_INLINABLE( UA_Boolean
UA_UserIdentityToken_equal(const UA_UserIdentityToken *p1, const UA_UserIdentityToken *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]) == UA_ORDER_EQ);
})


/* AnonymousIdentityToken */
typedef struct {
    UA_String policyId;
} UA_AnonymousIdentityToken;

#define UA_TYPES_ANONYMOUSIDENTITYTOKEN 214

UA_INLINABLE( void
UA_AnonymousIdentityToken_init(UA_AnonymousIdentityToken *p), {
    memset(p, 0, sizeof(UA_AnonymousIdentityToken));
})

UA_INLINABLE( UA_AnonymousIdentityToken *
UA_AnonymousIdentityToken_new(void), {
    return (UA_AnonymousIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
})

UA_INLINABLE( UA_StatusCode
UA_AnonymousIdentityToken_copy(const UA_AnonymousIdentityToken *src, UA_AnonymousIdentityToken *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_AnonymousIdentityToken_clear(UA_AnonymousIdentityToken *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_AnonymousIdentityToken_delete(UA_AnonymousIdentityToken *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]);
})

UA_INLINABLE( UA_Boolean
UA_AnonymousIdentityToken_equal(const UA_AnonymousIdentityToken *p1, const UA_AnonymousIdentityToken *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]) == UA_ORDER_EQ);
})


/* UserNameIdentityToken */
typedef struct {
    UA_String policyId;
    UA_String userName;
    UA_ByteString password;
    UA_String encryptionAlgorithm;
} UA_UserNameIdentityToken;

#define UA_TYPES_USERNAMEIDENTITYTOKEN 215

UA_INLINABLE( void
UA_UserNameIdentityToken_init(UA_UserNameIdentityToken *p), {
    memset(p, 0, sizeof(UA_UserNameIdentityToken));
})

UA_INLINABLE( UA_UserNameIdentityToken *
UA_UserNameIdentityToken_new(void), {
    return (UA_UserNameIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
})

UA_INLINABLE( UA_StatusCode
UA_UserNameIdentityToken_copy(const UA_UserNameIdentityToken *src, UA_UserNameIdentityToken *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_UserNameIdentityToken_clear(UA_UserNameIdentityToken *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_UserNameIdentityToken_delete(UA_UserNameIdentityToken *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]);
})

UA_INLINABLE( UA_Boolean
UA_UserNameIdentityToken_equal(const UA_UserNameIdentityToken *p1, const UA_UserNameIdentityToken *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]) == UA_ORDER_EQ);
})


/* X509IdentityToken */
typedef struct {
    UA_String policyId;
    UA_ByteString certificateData;
} UA_X509IdentityToken;

#define UA_TYPES_X509IDENTITYTOKEN 216

UA_INLINABLE( void
UA_X509IdentityToken_init(UA_X509IdentityToken *p), {
    memset(p, 0, sizeof(UA_X509IdentityToken));
})

UA_INLINABLE( UA_X509IdentityToken *
UA_X509IdentityToken_new(void), {
    return (UA_X509IdentityToken*)UA_new(&UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
})

UA_INLINABLE( UA_StatusCode
UA_X509IdentityToken_copy(const UA_X509IdentityToken *src, UA_X509IdentityToken *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_X509IdentityToken_clear(UA_X509IdentityToken *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_X509IdentityToken_delete(UA_X509IdentityToken *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]);
})

UA_INLINABLE( UA_Boolean
UA_X509IdentityToken_equal(const UA_X509IdentityToken *p1, const UA_X509IdentityToken *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]) == UA_ORDER_EQ);
})


/* IssuedIdentityToken */
typedef struct {
    UA_String policyId;
    UA_ByteString tokenData;
    UA_String encryptionAlgorithm;
} UA_IssuedIdentityToken;

#define UA_TYPES_ISSUEDIDENTITYTOKEN 217

UA_INLINABLE( void
UA_IssuedIdentityToken_init(UA_IssuedIdentityToken *p), {
    memset(p, 0, sizeof(UA_IssuedIdentityToken));
})

UA_INLINABLE( UA_IssuedIdentityToken *
UA_IssuedIdentityToken_new(void), {
    return (UA_IssuedIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
})

UA_INLINABLE( UA_StatusCode
UA_IssuedIdentityToken_copy(const UA_IssuedIdentityToken *src, UA_IssuedIdentityToken *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_IssuedIdentityToken_clear(UA_IssuedIdentityToken *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
})

UA_INLINABLE( void
UA_IssuedIdentityToken_delete(UA_IssuedIdentityToken *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]);
})

UA_INLINABLE( UA_Boolean
UA_IssuedIdentityToken_equal(const UA_IssuedIdentityToken *p1, const UA_IssuedIdentityToken *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]) == UA_ORDER_EQ);
})


/* RsaEncryptedSecret */
typedef UA_ByteString UA_RsaEncryptedSecret;

#define UA_TYPES_RSAENCRYPTEDSECRET 218

UA_INLINABLE( void
UA_RsaEncryptedSecret_init(UA_RsaEncryptedSecret *p), {
    memset(p, 0, sizeof(UA_RsaEncryptedSecret));
})

UA_INLINABLE( UA_RsaEncryptedSecret *
UA_RsaEncryptedSecret_new(void), {
    return (UA_RsaEncryptedSecret*)UA_new(&UA_TYPES[UA_TYPES_RSAENCRYPTEDSECRET]);
})

UA_INLINABLE( UA_StatusCode
UA_RsaEncryptedSecret_copy(const UA_RsaEncryptedSecret *src, UA_RsaEncryptedSecret *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RSAENCRYPTEDSECRET]);
})

UA_INLINABLE( void
UA_RsaEncryptedSecret_clear(UA_RsaEncryptedSecret *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_RSAENCRYPTEDSECRET]);
})

UA_INLINABLE( void
UA_RsaEncryptedSecret_delete(UA_RsaEncryptedSecret *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_RSAENCRYPTEDSECRET]);
})

UA_INLINABLE( UA_Boolean
UA_RsaEncryptedSecret_equal(const UA_RsaEncryptedSecret *p1, const UA_RsaEncryptedSecret *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_RSAENCRYPTEDSECRET]) == UA_ORDER_EQ);
})


/* EccEncryptedSecret */
typedef UA_ByteString UA_EccEncryptedSecret;

#define UA_TYPES_ECCENCRYPTEDSECRET 219

UA_INLINABLE( void
UA_EccEncryptedSecret_init(UA_EccEncryptedSecret *p), {
    memset(p, 0, sizeof(UA_EccEncryptedSecret));
})

UA_INLINABLE( UA_EccEncryptedSecret *
UA_EccEncryptedSecret_new(void), {
    return (UA_EccEncryptedSecret*)UA_new(&UA_TYPES[UA_TYPES_ECCENCRYPTEDSECRET]);
})

UA_INLINABLE( UA_StatusCode
UA_EccEncryptedSecret_copy(const UA_EccEncryptedSecret *src, UA_EccEncryptedSecret *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ECCENCRYPTEDSECRET]);
})

UA_INLINABLE( void
UA_EccEncryptedSecret_clear(UA_EccEncryptedSecret *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ECCENCRYPTEDSECRET]);
})

UA_INLINABLE( void
UA_EccEncryptedSecret_delete(UA_EccEncryptedSecret *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ECCENCRYPTEDSECRET]);
})

UA_INLINABLE( UA_Boolean
UA_EccEncryptedSecret_equal(const UA_EccEncryptedSecret *p1, const UA_EccEncryptedSecret *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ECCENCRYPTEDSECRET]) == UA_ORDER_EQ);
})


/* ActivateSessionRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_SignatureData clientSignature;
    size_t clientSoftwareCertificatesSize;
    UA_SignedSoftwareCertificate *clientSoftwareCertificates;
    size_t localeIdsSize;
    UA_String *localeIds;
    UA_ExtensionObject userIdentityToken;
    UA_SignatureData userTokenSignature;
} UA_ActivateSessionRequest;

#define UA_TYPES_ACTIVATESESSIONREQUEST 220

UA_INLINABLE( void
UA_ActivateSessionRequest_init(UA_ActivateSessionRequest *p), {
    memset(p, 0, sizeof(UA_ActivateSessionRequest));
})

UA_INLINABLE( UA_ActivateSessionRequest *
UA_ActivateSessionRequest_new(void), {
    return (UA_ActivateSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_ActivateSessionRequest_copy(const UA_ActivateSessionRequest *src, UA_ActivateSessionRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
})

UA_INLINABLE( void
UA_ActivateSessionRequest_clear(UA_ActivateSessionRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
})

UA_INLINABLE( void
UA_ActivateSessionRequest_delete(UA_ActivateSessionRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_ActivateSessionRequest_equal(const UA_ActivateSessionRequest *p1, const UA_ActivateSessionRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]) == UA_ORDER_EQ);
})


/* ActivateSessionResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_ByteString serverNonce;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_ActivateSessionResponse;

#define UA_TYPES_ACTIVATESESSIONRESPONSE 221

UA_INLINABLE( void
UA_ActivateSessionResponse_init(UA_ActivateSessionResponse *p), {
    memset(p, 0, sizeof(UA_ActivateSessionResponse));
})

UA_INLINABLE( UA_ActivateSessionResponse *
UA_ActivateSessionResponse_new(void), {
    return (UA_ActivateSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_ActivateSessionResponse_copy(const UA_ActivateSessionResponse *src, UA_ActivateSessionResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
})

UA_INLINABLE( void
UA_ActivateSessionResponse_clear(UA_ActivateSessionResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
})

UA_INLINABLE( void
UA_ActivateSessionResponse_delete(UA_ActivateSessionResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_ActivateSessionResponse_equal(const UA_ActivateSessionResponse *p1, const UA_ActivateSessionResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]) == UA_ORDER_EQ);
})


/* CloseSessionRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_Boolean deleteSubscriptions;
} UA_CloseSessionRequest;

#define UA_TYPES_CLOSESESSIONREQUEST 222

UA_INLINABLE( void
UA_CloseSessionRequest_init(UA_CloseSessionRequest *p), {
    memset(p, 0, sizeof(UA_CloseSessionRequest));
})

UA_INLINABLE( UA_CloseSessionRequest *
UA_CloseSessionRequest_new(void), {
    return (UA_CloseSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_CloseSessionRequest_copy(const UA_CloseSessionRequest *src, UA_CloseSessionRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
})

UA_INLINABLE( void
UA_CloseSessionRequest_clear(UA_CloseSessionRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
})

UA_INLINABLE( void
UA_CloseSessionRequest_delete(UA_CloseSessionRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_CloseSessionRequest_equal(const UA_CloseSessionRequest *p1, const UA_CloseSessionRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]) == UA_ORDER_EQ);
})


/* CloseSessionResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
} UA_CloseSessionResponse;

#define UA_TYPES_CLOSESESSIONRESPONSE 223

UA_INLINABLE( void
UA_CloseSessionResponse_init(UA_CloseSessionResponse *p), {
    memset(p, 0, sizeof(UA_CloseSessionResponse));
})

UA_INLINABLE( UA_CloseSessionResponse *
UA_CloseSessionResponse_new(void), {
    return (UA_CloseSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_CloseSessionResponse_copy(const UA_CloseSessionResponse *src, UA_CloseSessionResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
})

UA_INLINABLE( void
UA_CloseSessionResponse_clear(UA_CloseSessionResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
})

UA_INLINABLE( void
UA_CloseSessionResponse_delete(UA_CloseSessionResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_CloseSessionResponse_equal(const UA_CloseSessionResponse *p1, const UA_CloseSessionResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]) == UA_ORDER_EQ);
})


/* CancelRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 requestHandle;
} UA_CancelRequest;

#define UA_TYPES_CANCELREQUEST 224

UA_INLINABLE( void
UA_CancelRequest_init(UA_CancelRequest *p), {
    memset(p, 0, sizeof(UA_CancelRequest));
})

UA_INLINABLE( UA_CancelRequest *
UA_CancelRequest_new(void), {
    return (UA_CancelRequest*)UA_new(&UA_TYPES[UA_TYPES_CANCELREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_CancelRequest_copy(const UA_CancelRequest *src, UA_CancelRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CANCELREQUEST]);
})

UA_INLINABLE( void
UA_CancelRequest_clear(UA_CancelRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CANCELREQUEST]);
})

UA_INLINABLE( void
UA_CancelRequest_delete(UA_CancelRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CANCELREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_CancelRequest_equal(const UA_CancelRequest *p1, const UA_CancelRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CANCELREQUEST]) == UA_ORDER_EQ);
})


/* CancelResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_UInt32 cancelCount;
} UA_CancelResponse;

#define UA_TYPES_CANCELRESPONSE 225

UA_INLINABLE( void
UA_CancelResponse_init(UA_CancelResponse *p), {
    memset(p, 0, sizeof(UA_CancelResponse));
})

UA_INLINABLE( UA_CancelResponse *
UA_CancelResponse_new(void), {
    return (UA_CancelResponse*)UA_new(&UA_TYPES[UA_TYPES_CANCELRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_CancelResponse_copy(const UA_CancelResponse *src, UA_CancelResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CANCELRESPONSE]);
})

UA_INLINABLE( void
UA_CancelResponse_clear(UA_CancelResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CANCELRESPONSE]);
})

UA_INLINABLE( void
UA_CancelResponse_delete(UA_CancelResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CANCELRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_CancelResponse_equal(const UA_CancelResponse *p1, const UA_CancelResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CANCELRESPONSE]) == UA_ORDER_EQ);
})


/* NodeAttributesMask */
typedef enum {
    UA_NODEATTRIBUTESMASK_NONE = 0,
    UA_NODEATTRIBUTESMASK_ACCESSLEVEL = 1,
    UA_NODEATTRIBUTESMASK_ARRAYDIMENSIONS = 2,
    UA_NODEATTRIBUTESMASK_BROWSENAME = 4,
    UA_NODEATTRIBUTESMASK_CONTAINSNOLOOPS = 8,
    UA_NODEATTRIBUTESMASK_DATATYPE = 16,
    UA_NODEATTRIBUTESMASK_DESCRIPTION = 32,
    UA_NODEATTRIBUTESMASK_DISPLAYNAME = 64,
    UA_NODEATTRIBUTESMASK_EVENTNOTIFIER = 128,
    UA_NODEATTRIBUTESMASK_EXECUTABLE = 256,
    UA_NODEATTRIBUTESMASK_HISTORIZING = 512,
    UA_NODEATTRIBUTESMASK_INVERSENAME = 1024,
    UA_NODEATTRIBUTESMASK_ISABSTRACT = 2048,
    UA_NODEATTRIBUTESMASK_MINIMUMSAMPLINGINTERVAL = 4096,
    UA_NODEATTRIBUTESMASK_NODECLASS = 8192,
    UA_NODEATTRIBUTESMASK_NODEID = 16384,
    UA_NODEATTRIBUTESMASK_SYMMETRIC = 32768,
    UA_NODEATTRIBUTESMASK_USERACCESSLEVEL = 65536,
    UA_NODEATTRIBUTESMASK_USEREXECUTABLE = 131072,
    UA_NODEATTRIBUTESMASK_USERWRITEMASK = 262144,
    UA_NODEATTRIBUTESMASK_VALUERANK = 524288,
    UA_NODEATTRIBUTESMASK_WRITEMASK = 1048576,
    UA_NODEATTRIBUTESMASK_VALUE = 2097152,
    UA_NODEATTRIBUTESMASK_DATATYPEDEFINITION = 4194304,
    UA_NODEATTRIBUTESMASK_ROLEPERMISSIONS = 8388608,
    UA_NODEATTRIBUTESMASK_ACCESSRESTRICTIONS = 16777216,
    UA_NODEATTRIBUTESMASK_ALL = 33554431,
    UA_NODEATTRIBUTESMASK_BASENODE = 26501220,
    UA_NODEATTRIBUTESMASK_OBJECT = 26501348,
    UA_NODEATTRIBUTESMASK_OBJECTTYPE = 26503268,
    UA_NODEATTRIBUTESMASK_VARIABLE = 26571383,
    UA_NODEATTRIBUTESMASK_VARIABLETYPE = 28600438,
    UA_NODEATTRIBUTESMASK_METHOD = 26632548,
    UA_NODEATTRIBUTESMASK_REFERENCETYPE = 26537060,
    UA_NODEATTRIBUTESMASK_VIEW = 26501356,
    __UA_NODEATTRIBUTESMASK_FORCE32BIT = 0x7fffffff
} UA_NodeAttributesMask;

UA_STATIC_ASSERT(sizeof(UA_NodeAttributesMask) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_NODEATTRIBUTESMASK 226

UA_INLINABLE( void
UA_NodeAttributesMask_init(UA_NodeAttributesMask *p), {
    memset(p, 0, sizeof(UA_NodeAttributesMask));
})

UA_INLINABLE( UA_NodeAttributesMask *
UA_NodeAttributesMask_new(void), {
    return (UA_NodeAttributesMask*)UA_new(&UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_NodeAttributesMask_copy(const UA_NodeAttributesMask *src, UA_NodeAttributesMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
})

UA_INLINABLE( void
UA_NodeAttributesMask_clear(UA_NodeAttributesMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
})

UA_INLINABLE( void
UA_NodeAttributesMask_delete(UA_NodeAttributesMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]);
})

UA_INLINABLE( UA_Boolean
UA_NodeAttributesMask_equal(const UA_NodeAttributesMask *p1, const UA_NodeAttributesMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]) == UA_ORDER_EQ);
})


/* NodeAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
} UA_NodeAttributes;

#define UA_TYPES_NODEATTRIBUTES 227

UA_INLINABLE( void
UA_NodeAttributes_init(UA_NodeAttributes *p), {
    memset(p, 0, sizeof(UA_NodeAttributes));
})

UA_INLINABLE( UA_NodeAttributes *
UA_NodeAttributes_new(void), {
    return (UA_NodeAttributes*)UA_new(&UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_NodeAttributes_copy(const UA_NodeAttributes *src, UA_NodeAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
})

UA_INLINABLE( void
UA_NodeAttributes_clear(UA_NodeAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
})

UA_INLINABLE( void
UA_NodeAttributes_delete(UA_NodeAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_NodeAttributes_equal(const UA_NodeAttributes *p1, const UA_NodeAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]) == UA_ORDER_EQ);
})


/* ObjectAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    UA_Byte eventNotifier;
} UA_ObjectAttributes;

#define UA_TYPES_OBJECTATTRIBUTES 228

UA_INLINABLE( void
UA_ObjectAttributes_init(UA_ObjectAttributes *p), {
    memset(p, 0, sizeof(UA_ObjectAttributes));
})

UA_INLINABLE( UA_ObjectAttributes *
UA_ObjectAttributes_new(void), {
    return (UA_ObjectAttributes*)UA_new(&UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_ObjectAttributes_copy(const UA_ObjectAttributes *src, UA_ObjectAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
})

UA_INLINABLE( void
UA_ObjectAttributes_clear(UA_ObjectAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
})

UA_INLINABLE( void
UA_ObjectAttributes_delete(UA_ObjectAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_ObjectAttributes_equal(const UA_ObjectAttributes *p1, const UA_ObjectAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]) == UA_ORDER_EQ);
})


/* VariableAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    UA_Variant value;
    UA_NodeId dataType;
    UA_Int32 valueRank;
    size_t arrayDimensionsSize;
    UA_UInt32 *arrayDimensions;
    UA_Byte accessLevel;
    UA_Byte userAccessLevel;
    UA_Double minimumSamplingInterval;
    UA_Boolean historizing;
} UA_VariableAttributes;

#define UA_TYPES_VARIABLEATTRIBUTES 229

UA_INLINABLE( void
UA_VariableAttributes_init(UA_VariableAttributes *p), {
    memset(p, 0, sizeof(UA_VariableAttributes));
})

UA_INLINABLE( UA_VariableAttributes *
UA_VariableAttributes_new(void), {
    return (UA_VariableAttributes*)UA_new(&UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_VariableAttributes_copy(const UA_VariableAttributes *src, UA_VariableAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
})

UA_INLINABLE( void
UA_VariableAttributes_clear(UA_VariableAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
})

UA_INLINABLE( void
UA_VariableAttributes_delete(UA_VariableAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_VariableAttributes_equal(const UA_VariableAttributes *p1, const UA_VariableAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]) == UA_ORDER_EQ);
})


/* MethodAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    UA_Boolean executable;
    UA_Boolean userExecutable;
} UA_MethodAttributes;

#define UA_TYPES_METHODATTRIBUTES 230

UA_INLINABLE( void
UA_MethodAttributes_init(UA_MethodAttributes *p), {
    memset(p, 0, sizeof(UA_MethodAttributes));
})

UA_INLINABLE( UA_MethodAttributes *
UA_MethodAttributes_new(void), {
    return (UA_MethodAttributes*)UA_new(&UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_MethodAttributes_copy(const UA_MethodAttributes *src, UA_MethodAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
})

UA_INLINABLE( void
UA_MethodAttributes_clear(UA_MethodAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
})

UA_INLINABLE( void
UA_MethodAttributes_delete(UA_MethodAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_MethodAttributes_equal(const UA_MethodAttributes *p1, const UA_MethodAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]) == UA_ORDER_EQ);
})


/* ObjectTypeAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    UA_Boolean isAbstract;
} UA_ObjectTypeAttributes;

#define UA_TYPES_OBJECTTYPEATTRIBUTES 231

UA_INLINABLE( void
UA_ObjectTypeAttributes_init(UA_ObjectTypeAttributes *p), {
    memset(p, 0, sizeof(UA_ObjectTypeAttributes));
})

UA_INLINABLE( UA_ObjectTypeAttributes *
UA_ObjectTypeAttributes_new(void), {
    return (UA_ObjectTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_ObjectTypeAttributes_copy(const UA_ObjectTypeAttributes *src, UA_ObjectTypeAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
})

UA_INLINABLE( void
UA_ObjectTypeAttributes_clear(UA_ObjectTypeAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
})

UA_INLINABLE( void
UA_ObjectTypeAttributes_delete(UA_ObjectTypeAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_ObjectTypeAttributes_equal(const UA_ObjectTypeAttributes *p1, const UA_ObjectTypeAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]) == UA_ORDER_EQ);
})


/* VariableTypeAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    UA_Variant value;
    UA_NodeId dataType;
    UA_Int32 valueRank;
    size_t arrayDimensionsSize;
    UA_UInt32 *arrayDimensions;
    UA_Boolean isAbstract;
} UA_VariableTypeAttributes;

#define UA_TYPES_VARIABLETYPEATTRIBUTES 232

UA_INLINABLE( void
UA_VariableTypeAttributes_init(UA_VariableTypeAttributes *p), {
    memset(p, 0, sizeof(UA_VariableTypeAttributes));
})

UA_INLINABLE( UA_VariableTypeAttributes *
UA_VariableTypeAttributes_new(void), {
    return (UA_VariableTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_VariableTypeAttributes_copy(const UA_VariableTypeAttributes *src, UA_VariableTypeAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
})

UA_INLINABLE( void
UA_VariableTypeAttributes_clear(UA_VariableTypeAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
})

UA_INLINABLE( void
UA_VariableTypeAttributes_delete(UA_VariableTypeAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_VariableTypeAttributes_equal(const UA_VariableTypeAttributes *p1, const UA_VariableTypeAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]) == UA_ORDER_EQ);
})


/* ReferenceTypeAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    UA_Boolean isAbstract;
    UA_Boolean symmetric;
    UA_LocalizedText inverseName;
} UA_ReferenceTypeAttributes;

#define UA_TYPES_REFERENCETYPEATTRIBUTES 233

UA_INLINABLE( void
UA_ReferenceTypeAttributes_init(UA_ReferenceTypeAttributes *p), {
    memset(p, 0, sizeof(UA_ReferenceTypeAttributes));
})

UA_INLINABLE( UA_ReferenceTypeAttributes *
UA_ReferenceTypeAttributes_new(void), {
    return (UA_ReferenceTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_ReferenceTypeAttributes_copy(const UA_ReferenceTypeAttributes *src, UA_ReferenceTypeAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
})

UA_INLINABLE( void
UA_ReferenceTypeAttributes_clear(UA_ReferenceTypeAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
})

UA_INLINABLE( void
UA_ReferenceTypeAttributes_delete(UA_ReferenceTypeAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_ReferenceTypeAttributes_equal(const UA_ReferenceTypeAttributes *p1, const UA_ReferenceTypeAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]) == UA_ORDER_EQ);
})


/* DataTypeAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    UA_Boolean isAbstract;
} UA_DataTypeAttributes;

#define UA_TYPES_DATATYPEATTRIBUTES 234

UA_INLINABLE( void
UA_DataTypeAttributes_init(UA_DataTypeAttributes *p), {
    memset(p, 0, sizeof(UA_DataTypeAttributes));
})

UA_INLINABLE( UA_DataTypeAttributes *
UA_DataTypeAttributes_new(void), {
    return (UA_DataTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_DataTypeAttributes_copy(const UA_DataTypeAttributes *src, UA_DataTypeAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
})

UA_INLINABLE( void
UA_DataTypeAttributes_clear(UA_DataTypeAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
})

UA_INLINABLE( void
UA_DataTypeAttributes_delete(UA_DataTypeAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_DataTypeAttributes_equal(const UA_DataTypeAttributes *p1, const UA_DataTypeAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]) == UA_ORDER_EQ);
})


/* ViewAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    UA_Boolean containsNoLoops;
    UA_Byte eventNotifier;
} UA_ViewAttributes;

#define UA_TYPES_VIEWATTRIBUTES 235

UA_INLINABLE( void
UA_ViewAttributes_init(UA_ViewAttributes *p), {
    memset(p, 0, sizeof(UA_ViewAttributes));
})

UA_INLINABLE( UA_ViewAttributes *
UA_ViewAttributes_new(void), {
    return (UA_ViewAttributes*)UA_new(&UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_ViewAttributes_copy(const UA_ViewAttributes *src, UA_ViewAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
})

UA_INLINABLE( void
UA_ViewAttributes_clear(UA_ViewAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
})

UA_INLINABLE( void
UA_ViewAttributes_delete(UA_ViewAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_ViewAttributes_equal(const UA_ViewAttributes *p1, const UA_ViewAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]) == UA_ORDER_EQ);
})


/* GenericAttributeValue */
typedef struct {
    UA_UInt32 attributeId;
    UA_Variant value;
} UA_GenericAttributeValue;

#define UA_TYPES_GENERICATTRIBUTEVALUE 236

UA_INLINABLE( void
UA_GenericAttributeValue_init(UA_GenericAttributeValue *p), {
    memset(p, 0, sizeof(UA_GenericAttributeValue));
})

UA_INLINABLE( UA_GenericAttributeValue *
UA_GenericAttributeValue_new(void), {
    return (UA_GenericAttributeValue*)UA_new(&UA_TYPES[UA_TYPES_GENERICATTRIBUTEVALUE]);
})

UA_INLINABLE( UA_StatusCode
UA_GenericAttributeValue_copy(const UA_GenericAttributeValue *src, UA_GenericAttributeValue *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GENERICATTRIBUTEVALUE]);
})

UA_INLINABLE( void
UA_GenericAttributeValue_clear(UA_GenericAttributeValue *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_GENERICATTRIBUTEVALUE]);
})

UA_INLINABLE( void
UA_GenericAttributeValue_delete(UA_GenericAttributeValue *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_GENERICATTRIBUTEVALUE]);
})

UA_INLINABLE( UA_Boolean
UA_GenericAttributeValue_equal(const UA_GenericAttributeValue *p1, const UA_GenericAttributeValue *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_GENERICATTRIBUTEVALUE]) == UA_ORDER_EQ);
})


/* GenericAttributes */
typedef struct {
    UA_UInt32 specifiedAttributes;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
    UA_UInt32 writeMask;
    UA_UInt32 userWriteMask;
    size_t attributeValuesSize;
    UA_GenericAttributeValue *attributeValues;
} UA_GenericAttributes;

#define UA_TYPES_GENERICATTRIBUTES 237

UA_INLINABLE( void
UA_GenericAttributes_init(UA_GenericAttributes *p), {
    memset(p, 0, sizeof(UA_GenericAttributes));
})

UA_INLINABLE( UA_GenericAttributes *
UA_GenericAttributes_new(void), {
    return (UA_GenericAttributes*)UA_new(&UA_TYPES[UA_TYPES_GENERICATTRIBUTES]);
})

UA_INLINABLE( UA_StatusCode
UA_GenericAttributes_copy(const UA_GenericAttributes *src, UA_GenericAttributes *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GENERICATTRIBUTES]);
})

UA_INLINABLE( void
UA_GenericAttributes_clear(UA_GenericAttributes *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_GENERICATTRIBUTES]);
})

UA_INLINABLE( void
UA_GenericAttributes_delete(UA_GenericAttributes *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_GENERICATTRIBUTES]);
})

UA_INLINABLE( UA_Boolean
UA_GenericAttributes_equal(const UA_GenericAttributes *p1, const UA_GenericAttributes *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_GENERICATTRIBUTES]) == UA_ORDER_EQ);
})


/* AddNodesItem */
typedef struct {
    UA_ExpandedNodeId parentNodeId;
    UA_NodeId referenceTypeId;
    UA_ExpandedNodeId requestedNewNodeId;
    UA_QualifiedName browseName;
    UA_NodeClass nodeClass;
    UA_ExtensionObject nodeAttributes;
    UA_ExpandedNodeId typeDefinition;
} UA_AddNodesItem;

#define UA_TYPES_ADDNODESITEM 238

UA_INLINABLE( void
UA_AddNodesItem_init(UA_AddNodesItem *p), {
    memset(p, 0, sizeof(UA_AddNodesItem));
})

UA_INLINABLE( UA_AddNodesItem *
UA_AddNodesItem_new(void), {
    return (UA_AddNodesItem*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESITEM]);
})

UA_INLINABLE( UA_StatusCode
UA_AddNodesItem_copy(const UA_AddNodesItem *src, UA_AddNodesItem *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESITEM]);
})

UA_INLINABLE( void
UA_AddNodesItem_clear(UA_AddNodesItem *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESITEM]);
})

UA_INLINABLE( void
UA_AddNodesItem_delete(UA_AddNodesItem *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESITEM]);
})

UA_INLINABLE( UA_Boolean
UA_AddNodesItem_equal(const UA_AddNodesItem *p1, const UA_AddNodesItem *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ADDNODESITEM]) == UA_ORDER_EQ);
})


/* AddNodesResult */
typedef struct {
    UA_StatusCode statusCode;
    UA_NodeId addedNodeId;
} UA_AddNodesResult;

#define UA_TYPES_ADDNODESRESULT 239

UA_INLINABLE( void
UA_AddNodesResult_init(UA_AddNodesResult *p), {
    memset(p, 0, sizeof(UA_AddNodesResult));
})

UA_INLINABLE( UA_AddNodesResult *
UA_AddNodesResult_new(void), {
    return (UA_AddNodesResult*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_AddNodesResult_copy(const UA_AddNodesResult *src, UA_AddNodesResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESRESULT]);
})

UA_INLINABLE( void
UA_AddNodesResult_clear(UA_AddNodesResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESULT]);
})

UA_INLINABLE( void
UA_AddNodesResult_delete(UA_AddNodesResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_AddNodesResult_equal(const UA_AddNodesResult *p1, const UA_AddNodesResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ADDNODESRESULT]) == UA_ORDER_EQ);
})


/* AddNodesRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t nodesToAddSize;
    UA_AddNodesItem *nodesToAdd;
} UA_AddNodesRequest;

#define UA_TYPES_ADDNODESREQUEST 240

UA_INLINABLE( void
UA_AddNodesRequest_init(UA_AddNodesRequest *p), {
    memset(p, 0, sizeof(UA_AddNodesRequest));
})

UA_INLINABLE( UA_AddNodesRequest *
UA_AddNodesRequest_new(void), {
    return (UA_AddNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_AddNodesRequest_copy(const UA_AddNodesRequest *src, UA_AddNodesRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
})

UA_INLINABLE( void
UA_AddNodesRequest_clear(UA_AddNodesRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
})

UA_INLINABLE( void
UA_AddNodesRequest_delete(UA_AddNodesRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_AddNodesRequest_equal(const UA_AddNodesRequest *p1, const UA_AddNodesRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]) == UA_ORDER_EQ);
})


/* AddNodesResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_AddNodesResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_AddNodesResponse;

#define UA_TYPES_ADDNODESRESPONSE 241

UA_INLINABLE( void
UA_AddNodesResponse_init(UA_AddNodesResponse *p), {
    memset(p, 0, sizeof(UA_AddNodesResponse));
})

UA_INLINABLE( UA_AddNodesResponse *
UA_AddNodesResponse_new(void), {
    return (UA_AddNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_AddNodesResponse_copy(const UA_AddNodesResponse *src, UA_AddNodesResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
})

UA_INLINABLE( void
UA_AddNodesResponse_clear(UA_AddNodesResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
})

UA_INLINABLE( void
UA_AddNodesResponse_delete(UA_AddNodesResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_AddNodesResponse_equal(const UA_AddNodesResponse *p1, const UA_AddNodesResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]) == UA_ORDER_EQ);
})


/* AddReferencesItem */
typedef struct {
    UA_NodeId sourceNodeId;
    UA_NodeId referenceTypeId;
    UA_Boolean isForward;
    UA_String targetServerUri;
    UA_ExpandedNodeId targetNodeId;
    UA_NodeClass targetNodeClass;
} UA_AddReferencesItem;

#define UA_TYPES_ADDREFERENCESITEM 242

UA_INLINABLE( void
UA_AddReferencesItem_init(UA_AddReferencesItem *p), {
    memset(p, 0, sizeof(UA_AddReferencesItem));
})

UA_INLINABLE( UA_AddReferencesItem *
UA_AddReferencesItem_new(void), {
    return (UA_AddReferencesItem*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
})

UA_INLINABLE( UA_StatusCode
UA_AddReferencesItem_copy(const UA_AddReferencesItem *src, UA_AddReferencesItem *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
})

UA_INLINABLE( void
UA_AddReferencesItem_clear(UA_AddReferencesItem *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
})

UA_INLINABLE( void
UA_AddReferencesItem_delete(UA_AddReferencesItem *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]);
})

UA_INLINABLE( UA_Boolean
UA_AddReferencesItem_equal(const UA_AddReferencesItem *p1, const UA_AddReferencesItem *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]) == UA_ORDER_EQ);
})


/* AddReferencesRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t referencesToAddSize;
    UA_AddReferencesItem *referencesToAdd;
} UA_AddReferencesRequest;

#define UA_TYPES_ADDREFERENCESREQUEST 243

UA_INLINABLE( void
UA_AddReferencesRequest_init(UA_AddReferencesRequest *p), {
    memset(p, 0, sizeof(UA_AddReferencesRequest));
})

UA_INLINABLE( UA_AddReferencesRequest *
UA_AddReferencesRequest_new(void), {
    return (UA_AddReferencesRequest*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_AddReferencesRequest_copy(const UA_AddReferencesRequest *src, UA_AddReferencesRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
})

UA_INLINABLE( void
UA_AddReferencesRequest_clear(UA_AddReferencesRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
})

UA_INLINABLE( void
UA_AddReferencesRequest_delete(UA_AddReferencesRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_AddReferencesRequest_equal(const UA_AddReferencesRequest *p1, const UA_AddReferencesRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]) == UA_ORDER_EQ);
})


/* AddReferencesResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_AddReferencesResponse;

#define UA_TYPES_ADDREFERENCESRESPONSE 244

UA_INLINABLE( void
UA_AddReferencesResponse_init(UA_AddReferencesResponse *p), {
    memset(p, 0, sizeof(UA_AddReferencesResponse));
})

UA_INLINABLE( UA_AddReferencesResponse *
UA_AddReferencesResponse_new(void), {
    return (UA_AddReferencesResponse*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_AddReferencesResponse_copy(const UA_AddReferencesResponse *src, UA_AddReferencesResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
})

UA_INLINABLE( void
UA_AddReferencesResponse_clear(UA_AddReferencesResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
})

UA_INLINABLE( void
UA_AddReferencesResponse_delete(UA_AddReferencesResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_AddReferencesResponse_equal(const UA_AddReferencesResponse *p1, const UA_AddReferencesResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]) == UA_ORDER_EQ);
})


/* DeleteNodesItem */
typedef struct {
    UA_NodeId nodeId;
    UA_Boolean deleteTargetReferences;
} UA_DeleteNodesItem;

#define UA_TYPES_DELETENODESITEM 245

UA_INLINABLE( void
UA_DeleteNodesItem_init(UA_DeleteNodesItem *p), {
    memset(p, 0, sizeof(UA_DeleteNodesItem));
})

UA_INLINABLE( UA_DeleteNodesItem *
UA_DeleteNodesItem_new(void), {
    return (UA_DeleteNodesItem*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESITEM]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteNodesItem_copy(const UA_DeleteNodesItem *src, UA_DeleteNodesItem *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESITEM]);
})

UA_INLINABLE( void
UA_DeleteNodesItem_clear(UA_DeleteNodesItem *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESITEM]);
})

UA_INLINABLE( void
UA_DeleteNodesItem_delete(UA_DeleteNodesItem *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESITEM]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteNodesItem_equal(const UA_DeleteNodesItem *p1, const UA_DeleteNodesItem *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETENODESITEM]) == UA_ORDER_EQ);
})


/* DeleteNodesRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t nodesToDeleteSize;
    UA_DeleteNodesItem *nodesToDelete;
} UA_DeleteNodesRequest;

#define UA_TYPES_DELETENODESREQUEST 246

UA_INLINABLE( void
UA_DeleteNodesRequest_init(UA_DeleteNodesRequest *p), {
    memset(p, 0, sizeof(UA_DeleteNodesRequest));
})

UA_INLINABLE( UA_DeleteNodesRequest *
UA_DeleteNodesRequest_new(void), {
    return (UA_DeleteNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteNodesRequest_copy(const UA_DeleteNodesRequest *src, UA_DeleteNodesRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
})

UA_INLINABLE( void
UA_DeleteNodesRequest_clear(UA_DeleteNodesRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
})

UA_INLINABLE( void
UA_DeleteNodesRequest_delete(UA_DeleteNodesRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteNodesRequest_equal(const UA_DeleteNodesRequest *p1, const UA_DeleteNodesRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]) == UA_ORDER_EQ);
})


/* DeleteNodesResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_DeleteNodesResponse;

#define UA_TYPES_DELETENODESRESPONSE 247

UA_INLINABLE( void
UA_DeleteNodesResponse_init(UA_DeleteNodesResponse *p), {
    memset(p, 0, sizeof(UA_DeleteNodesResponse));
})

UA_INLINABLE( UA_DeleteNodesResponse *
UA_DeleteNodesResponse_new(void), {
    return (UA_DeleteNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteNodesResponse_copy(const UA_DeleteNodesResponse *src, UA_DeleteNodesResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
})

UA_INLINABLE( void
UA_DeleteNodesResponse_clear(UA_DeleteNodesResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
})

UA_INLINABLE( void
UA_DeleteNodesResponse_delete(UA_DeleteNodesResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteNodesResponse_equal(const UA_DeleteNodesResponse *p1, const UA_DeleteNodesResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]) == UA_ORDER_EQ);
})


/* DeleteReferencesItem */
typedef struct {
    UA_NodeId sourceNodeId;
    UA_NodeId referenceTypeId;
    UA_Boolean isForward;
    UA_ExpandedNodeId targetNodeId;
    UA_Boolean deleteBidirectional;
} UA_DeleteReferencesItem;

#define UA_TYPES_DELETEREFERENCESITEM 248

UA_INLINABLE( void
UA_DeleteReferencesItem_init(UA_DeleteReferencesItem *p), {
    memset(p, 0, sizeof(UA_DeleteReferencesItem));
})

UA_INLINABLE( UA_DeleteReferencesItem *
UA_DeleteReferencesItem_new(void), {
    return (UA_DeleteReferencesItem*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteReferencesItem_copy(const UA_DeleteReferencesItem *src, UA_DeleteReferencesItem *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
})

UA_INLINABLE( void
UA_DeleteReferencesItem_clear(UA_DeleteReferencesItem *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
})

UA_INLINABLE( void
UA_DeleteReferencesItem_delete(UA_DeleteReferencesItem *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteReferencesItem_equal(const UA_DeleteReferencesItem *p1, const UA_DeleteReferencesItem *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]) == UA_ORDER_EQ);
})


/* DeleteReferencesRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t referencesToDeleteSize;
    UA_DeleteReferencesItem *referencesToDelete;
} UA_DeleteReferencesRequest;

#define UA_TYPES_DELETEREFERENCESREQUEST 249

UA_INLINABLE( void
UA_DeleteReferencesRequest_init(UA_DeleteReferencesRequest *p), {
    memset(p, 0, sizeof(UA_DeleteReferencesRequest));
})

UA_INLINABLE( UA_DeleteReferencesRequest *
UA_DeleteReferencesRequest_new(void), {
    return (UA_DeleteReferencesRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteReferencesRequest_copy(const UA_DeleteReferencesRequest *src, UA_DeleteReferencesRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
})

UA_INLINABLE( void
UA_DeleteReferencesRequest_clear(UA_DeleteReferencesRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
})

UA_INLINABLE( void
UA_DeleteReferencesRequest_delete(UA_DeleteReferencesRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteReferencesRequest_equal(const UA_DeleteReferencesRequest *p1, const UA_DeleteReferencesRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]) == UA_ORDER_EQ);
})


/* DeleteReferencesResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_DeleteReferencesResponse;

#define UA_TYPES_DELETEREFERENCESRESPONSE 250

UA_INLINABLE( void
UA_DeleteReferencesResponse_init(UA_DeleteReferencesResponse *p), {
    memset(p, 0, sizeof(UA_DeleteReferencesResponse));
})

UA_INLINABLE( UA_DeleteReferencesResponse *
UA_DeleteReferencesResponse_new(void), {
    return (UA_DeleteReferencesResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteReferencesResponse_copy(const UA_DeleteReferencesResponse *src, UA_DeleteReferencesResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
})

UA_INLINABLE( void
UA_DeleteReferencesResponse_clear(UA_DeleteReferencesResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
})

UA_INLINABLE( void
UA_DeleteReferencesResponse_delete(UA_DeleteReferencesResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteReferencesResponse_equal(const UA_DeleteReferencesResponse *p1, const UA_DeleteReferencesResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]) == UA_ORDER_EQ);
})


/* AttributeWriteMask */
typedef UA_UInt32 UA_AttributeWriteMask;

#define UA_ATTRIBUTEWRITEMASK_NONE 0
#define UA_ATTRIBUTEWRITEMASK_ACCESSLEVEL 1
#define UA_ATTRIBUTEWRITEMASK_ARRAYDIMENSIONS 2
#define UA_ATTRIBUTEWRITEMASK_BROWSENAME 4
#define UA_ATTRIBUTEWRITEMASK_CONTAINSNOLOOPS 8
#define UA_ATTRIBUTEWRITEMASK_DATATYPE 16
#define UA_ATTRIBUTEWRITEMASK_DESCRIPTION 32
#define UA_ATTRIBUTEWRITEMASK_DISPLAYNAME 64
#define UA_ATTRIBUTEWRITEMASK_EVENTNOTIFIER 128
#define UA_ATTRIBUTEWRITEMASK_EXECUTABLE 256
#define UA_ATTRIBUTEWRITEMASK_HISTORIZING 512
#define UA_ATTRIBUTEWRITEMASK_INVERSENAME 1024
#define UA_ATTRIBUTEWRITEMASK_ISABSTRACT 2048
#define UA_ATTRIBUTEWRITEMASK_MINIMUMSAMPLINGINTERVAL 4096
#define UA_ATTRIBUTEWRITEMASK_NODECLASS 8192
#define UA_ATTRIBUTEWRITEMASK_NODEID 16384
#define UA_ATTRIBUTEWRITEMASK_SYMMETRIC 32768
#define UA_ATTRIBUTEWRITEMASK_USERACCESSLEVEL 65536
#define UA_ATTRIBUTEWRITEMASK_USEREXECUTABLE 131072
#define UA_ATTRIBUTEWRITEMASK_USERWRITEMASK 262144
#define UA_ATTRIBUTEWRITEMASK_VALUERANK 524288
#define UA_ATTRIBUTEWRITEMASK_WRITEMASK 1048576
#define UA_ATTRIBUTEWRITEMASK_VALUEFORVARIABLETYPE 2097152
#define UA_ATTRIBUTEWRITEMASK_DATATYPEDEFINITION 4194304
#define UA_ATTRIBUTEWRITEMASK_ROLEPERMISSIONS 8388608
#define UA_ATTRIBUTEWRITEMASK_ACCESSRESTRICTIONS 16777216
#define UA_ATTRIBUTEWRITEMASK_ACCESSLEVELEX 33554432

#define UA_TYPES_ATTRIBUTEWRITEMASK 251

UA_INLINABLE( void
UA_AttributeWriteMask_init(UA_AttributeWriteMask *p), {
    memset(p, 0, sizeof(UA_AttributeWriteMask));
})

UA_INLINABLE( UA_AttributeWriteMask *
UA_AttributeWriteMask_new(void), {
    return (UA_AttributeWriteMask*)UA_new(&UA_TYPES[UA_TYPES_ATTRIBUTEWRITEMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_AttributeWriteMask_copy(const UA_AttributeWriteMask *src, UA_AttributeWriteMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ATTRIBUTEWRITEMASK]);
})

UA_INLINABLE( void
UA_AttributeWriteMask_clear(UA_AttributeWriteMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ATTRIBUTEWRITEMASK]);
})

UA_INLINABLE( void
UA_AttributeWriteMask_delete(UA_AttributeWriteMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ATTRIBUTEWRITEMASK]);
})

UA_INLINABLE( UA_Boolean
UA_AttributeWriteMask_equal(const UA_AttributeWriteMask *p1, const UA_AttributeWriteMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ATTRIBUTEWRITEMASK]) == UA_ORDER_EQ);
})


/* BrowseDirection */
typedef enum {
    UA_BROWSEDIRECTION_FORWARD = 0,
    UA_BROWSEDIRECTION_INVERSE = 1,
    UA_BROWSEDIRECTION_BOTH = 2,
    UA_BROWSEDIRECTION_INVALID = 3,
    __UA_BROWSEDIRECTION_FORCE32BIT = 0x7fffffff
} UA_BrowseDirection;

UA_STATIC_ASSERT(sizeof(UA_BrowseDirection) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_BROWSEDIRECTION 252

UA_INLINABLE( void
UA_BrowseDirection_init(UA_BrowseDirection *p), {
    memset(p, 0, sizeof(UA_BrowseDirection));
})

UA_INLINABLE( UA_BrowseDirection *
UA_BrowseDirection_new(void), {
    return (UA_BrowseDirection*)UA_new(&UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowseDirection_copy(const UA_BrowseDirection *src, UA_BrowseDirection *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
})

UA_INLINABLE( void
UA_BrowseDirection_clear(UA_BrowseDirection *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
})

UA_INLINABLE( void
UA_BrowseDirection_delete(UA_BrowseDirection *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]);
})

UA_INLINABLE( UA_Boolean
UA_BrowseDirection_equal(const UA_BrowseDirection *p1, const UA_BrowseDirection *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]) == UA_ORDER_EQ);
})


/* ViewDescription */
typedef struct {
    UA_NodeId viewId;
    UA_DateTime timestamp;
    UA_UInt32 viewVersion;
} UA_ViewDescription;

#define UA_TYPES_VIEWDESCRIPTION 253

UA_INLINABLE( void
UA_ViewDescription_init(UA_ViewDescription *p), {
    memset(p, 0, sizeof(UA_ViewDescription));
})

UA_INLINABLE( UA_ViewDescription *
UA_ViewDescription_new(void), {
    return (UA_ViewDescription*)UA_new(&UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_ViewDescription_copy(const UA_ViewDescription *src, UA_ViewDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
})

UA_INLINABLE( void
UA_ViewDescription_clear(UA_ViewDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
})

UA_INLINABLE( void
UA_ViewDescription_delete(UA_ViewDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_ViewDescription_equal(const UA_ViewDescription *p1, const UA_ViewDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]) == UA_ORDER_EQ);
})


/* BrowseDescription */
typedef struct {
    UA_NodeId nodeId;
    UA_BrowseDirection browseDirection;
    UA_NodeId referenceTypeId;
    UA_Boolean includeSubtypes;
    UA_UInt32 nodeClassMask;
    UA_UInt32 resultMask;
} UA_BrowseDescription;

#define UA_TYPES_BROWSEDESCRIPTION 254

UA_INLINABLE( void
UA_BrowseDescription_init(UA_BrowseDescription *p), {
    memset(p, 0, sizeof(UA_BrowseDescription));
})

UA_INLINABLE( UA_BrowseDescription *
UA_BrowseDescription_new(void), {
    return (UA_BrowseDescription*)UA_new(&UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowseDescription_copy(const UA_BrowseDescription *src, UA_BrowseDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
})

UA_INLINABLE( void
UA_BrowseDescription_clear(UA_BrowseDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
})

UA_INLINABLE( void
UA_BrowseDescription_delete(UA_BrowseDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_BrowseDescription_equal(const UA_BrowseDescription *p1, const UA_BrowseDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]) == UA_ORDER_EQ);
})


/* BrowseResultMask */
typedef enum {
    UA_BROWSERESULTMASK_NONE = 0,
    UA_BROWSERESULTMASK_REFERENCETYPEID = 1,
    UA_BROWSERESULTMASK_ISFORWARD = 2,
    UA_BROWSERESULTMASK_NODECLASS = 4,
    UA_BROWSERESULTMASK_BROWSENAME = 8,
    UA_BROWSERESULTMASK_DISPLAYNAME = 16,
    UA_BROWSERESULTMASK_TYPEDEFINITION = 32,
    UA_BROWSERESULTMASK_ALL = 63,
    UA_BROWSERESULTMASK_REFERENCETYPEINFO = 3,
    UA_BROWSERESULTMASK_TARGETINFO = 60,
    __UA_BROWSERESULTMASK_FORCE32BIT = 0x7fffffff
} UA_BrowseResultMask;

UA_STATIC_ASSERT(sizeof(UA_BrowseResultMask) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_BROWSERESULTMASK 255

UA_INLINABLE( void
UA_BrowseResultMask_init(UA_BrowseResultMask *p), {
    memset(p, 0, sizeof(UA_BrowseResultMask));
})

UA_INLINABLE( UA_BrowseResultMask *
UA_BrowseResultMask_new(void), {
    return (UA_BrowseResultMask*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowseResultMask_copy(const UA_BrowseResultMask *src, UA_BrowseResultMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
})

UA_INLINABLE( void
UA_BrowseResultMask_clear(UA_BrowseResultMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
})

UA_INLINABLE( void
UA_BrowseResultMask_delete(UA_BrowseResultMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]);
})

UA_INLINABLE( UA_Boolean
UA_BrowseResultMask_equal(const UA_BrowseResultMask *p1, const UA_BrowseResultMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]) == UA_ORDER_EQ);
})


/* ReferenceDescription */
typedef struct {
    UA_NodeId referenceTypeId;
    UA_Boolean isForward;
    UA_ExpandedNodeId nodeId;
    UA_QualifiedName browseName;
    UA_LocalizedText displayName;
    UA_NodeClass nodeClass;
    UA_ExpandedNodeId typeDefinition;
} UA_ReferenceDescription;

#define UA_TYPES_REFERENCEDESCRIPTION 256

UA_INLINABLE( void
UA_ReferenceDescription_init(UA_ReferenceDescription *p), {
    memset(p, 0, sizeof(UA_ReferenceDescription));
})

UA_INLINABLE( UA_ReferenceDescription *
UA_ReferenceDescription_new(void), {
    return (UA_ReferenceDescription*)UA_new(&UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_ReferenceDescription_copy(const UA_ReferenceDescription *src, UA_ReferenceDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
})

UA_INLINABLE( void
UA_ReferenceDescription_clear(UA_ReferenceDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
})

UA_INLINABLE( void
UA_ReferenceDescription_delete(UA_ReferenceDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_ReferenceDescription_equal(const UA_ReferenceDescription *p1, const UA_ReferenceDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]) == UA_ORDER_EQ);
})


/* ContinuationPoint */
typedef UA_ByteString UA_ContinuationPoint;

#define UA_TYPES_CONTINUATIONPOINT 257

UA_INLINABLE( void
UA_ContinuationPoint_init(UA_ContinuationPoint *p), {
    memset(p, 0, sizeof(UA_ContinuationPoint));
})

UA_INLINABLE( UA_ContinuationPoint *
UA_ContinuationPoint_new(void), {
    return (UA_ContinuationPoint*)UA_new(&UA_TYPES[UA_TYPES_CONTINUATIONPOINT]);
})

UA_INLINABLE( UA_StatusCode
UA_ContinuationPoint_copy(const UA_ContinuationPoint *src, UA_ContinuationPoint *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTINUATIONPOINT]);
})

UA_INLINABLE( void
UA_ContinuationPoint_clear(UA_ContinuationPoint *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTINUATIONPOINT]);
})

UA_INLINABLE( void
UA_ContinuationPoint_delete(UA_ContinuationPoint *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTINUATIONPOINT]);
})

UA_INLINABLE( UA_Boolean
UA_ContinuationPoint_equal(const UA_ContinuationPoint *p1, const UA_ContinuationPoint *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONTINUATIONPOINT]) == UA_ORDER_EQ);
})


/* BrowseResult */
typedef struct {
    UA_StatusCode statusCode;
    UA_ByteString continuationPoint;
    size_t referencesSize;
    UA_ReferenceDescription *references;
} UA_BrowseResult;

#define UA_TYPES_BROWSERESULT 258

UA_INLINABLE( void
UA_BrowseResult_init(UA_BrowseResult *p), {
    memset(p, 0, sizeof(UA_BrowseResult));
})

UA_INLINABLE( UA_BrowseResult *
UA_BrowseResult_new(void), {
    return (UA_BrowseResult*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowseResult_copy(const UA_BrowseResult *src, UA_BrowseResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESULT]);
})

UA_INLINABLE( void
UA_BrowseResult_clear(UA_BrowseResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULT]);
})

UA_INLINABLE( void
UA_BrowseResult_delete(UA_BrowseResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESULT]);
})

UA_INLINABLE( UA_Boolean
UA_BrowseResult_equal(const UA_BrowseResult *p1, const UA_BrowseResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSERESULT]) == UA_ORDER_EQ);
})


/* BrowseRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_ViewDescription view;
    UA_UInt32 requestedMaxReferencesPerNode;
    size_t nodesToBrowseSize;
    UA_BrowseDescription *nodesToBrowse;
} UA_BrowseRequest;

#define UA_TYPES_BROWSEREQUEST 259

UA_INLINABLE( void
UA_BrowseRequest_init(UA_BrowseRequest *p), {
    memset(p, 0, sizeof(UA_BrowseRequest));
})

UA_INLINABLE( UA_BrowseRequest *
UA_BrowseRequest_new(void), {
    return (UA_BrowseRequest*)UA_new(&UA_TYPES[UA_TYPES_BROWSEREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowseRequest_copy(const UA_BrowseRequest *src, UA_BrowseRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEREQUEST]);
})

UA_INLINABLE( void
UA_BrowseRequest_clear(UA_BrowseRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEREQUEST]);
})

UA_INLINABLE( void
UA_BrowseRequest_delete(UA_BrowseRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_BrowseRequest_equal(const UA_BrowseRequest *p1, const UA_BrowseRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSEREQUEST]) == UA_ORDER_EQ);
})


/* BrowseResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_BrowseResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_BrowseResponse;

#define UA_TYPES_BROWSERESPONSE 260

UA_INLINABLE( void
UA_BrowseResponse_init(UA_BrowseResponse *p), {
    memset(p, 0, sizeof(UA_BrowseResponse));
})

UA_INLINABLE( UA_BrowseResponse *
UA_BrowseResponse_new(void), {
    return (UA_BrowseResponse*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowseResponse_copy(const UA_BrowseResponse *src, UA_BrowseResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESPONSE]);
})

UA_INLINABLE( void
UA_BrowseResponse_clear(UA_BrowseResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESPONSE]);
})

UA_INLINABLE( void
UA_BrowseResponse_delete(UA_BrowseResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_BrowseResponse_equal(const UA_BrowseResponse *p1, const UA_BrowseResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSERESPONSE]) == UA_ORDER_EQ);
})


/* BrowseNextRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_Boolean releaseContinuationPoints;
    size_t continuationPointsSize;
    UA_ByteString *continuationPoints;
} UA_BrowseNextRequest;

#define UA_TYPES_BROWSENEXTREQUEST 261

UA_INLINABLE( void
UA_BrowseNextRequest_init(UA_BrowseNextRequest *p), {
    memset(p, 0, sizeof(UA_BrowseNextRequest));
})

UA_INLINABLE( UA_BrowseNextRequest *
UA_BrowseNextRequest_new(void), {
    return (UA_BrowseNextRequest*)UA_new(&UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowseNextRequest_copy(const UA_BrowseNextRequest *src, UA_BrowseNextRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
})

UA_INLINABLE( void
UA_BrowseNextRequest_clear(UA_BrowseNextRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
})

UA_INLINABLE( void
UA_BrowseNextRequest_delete(UA_BrowseNextRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_BrowseNextRequest_equal(const UA_BrowseNextRequest *p1, const UA_BrowseNextRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]) == UA_ORDER_EQ);
})


/* BrowseNextResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_BrowseResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_BrowseNextResponse;

#define UA_TYPES_BROWSENEXTRESPONSE 262

UA_INLINABLE( void
UA_BrowseNextResponse_init(UA_BrowseNextResponse *p), {
    memset(p, 0, sizeof(UA_BrowseNextResponse));
})

UA_INLINABLE( UA_BrowseNextResponse *
UA_BrowseNextResponse_new(void), {
    return (UA_BrowseNextResponse*)UA_new(&UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowseNextResponse_copy(const UA_BrowseNextResponse *src, UA_BrowseNextResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
})

UA_INLINABLE( void
UA_BrowseNextResponse_clear(UA_BrowseNextResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
})

UA_INLINABLE( void
UA_BrowseNextResponse_delete(UA_BrowseNextResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_BrowseNextResponse_equal(const UA_BrowseNextResponse *p1, const UA_BrowseNextResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]) == UA_ORDER_EQ);
})


/* RelativePathElement */
typedef struct {
    UA_NodeId referenceTypeId;
    UA_Boolean isInverse;
    UA_Boolean includeSubtypes;
    UA_QualifiedName targetName;
} UA_RelativePathElement;

#define UA_TYPES_RELATIVEPATHELEMENT 263

UA_INLINABLE( void
UA_RelativePathElement_init(UA_RelativePathElement *p), {
    memset(p, 0, sizeof(UA_RelativePathElement));
})

UA_INLINABLE( UA_RelativePathElement *
UA_RelativePathElement_new(void), {
    return (UA_RelativePathElement*)UA_new(&UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
})

UA_INLINABLE( UA_StatusCode
UA_RelativePathElement_copy(const UA_RelativePathElement *src, UA_RelativePathElement *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
})

UA_INLINABLE( void
UA_RelativePathElement_clear(UA_RelativePathElement *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
})

UA_INLINABLE( void
UA_RelativePathElement_delete(UA_RelativePathElement *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
})

UA_INLINABLE( UA_Boolean
UA_RelativePathElement_equal(const UA_RelativePathElement *p1, const UA_RelativePathElement *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]) == UA_ORDER_EQ);
})


/* RelativePath */
typedef struct {
    size_t elementsSize;
    UA_RelativePathElement *elements;
} UA_RelativePath;

#define UA_TYPES_RELATIVEPATH 264

UA_INLINABLE( void
UA_RelativePath_init(UA_RelativePath *p), {
    memset(p, 0, sizeof(UA_RelativePath));
})

UA_INLINABLE( UA_RelativePath *
UA_RelativePath_new(void), {
    return (UA_RelativePath*)UA_new(&UA_TYPES[UA_TYPES_RELATIVEPATH]);
})

UA_INLINABLE( UA_StatusCode
UA_RelativePath_copy(const UA_RelativePath *src, UA_RelativePath *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RELATIVEPATH]);
})

UA_INLINABLE( void
UA_RelativePath_clear(UA_RelativePath *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATH]);
})

UA_INLINABLE( void
UA_RelativePath_delete(UA_RelativePath *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_RELATIVEPATH]);
})

UA_INLINABLE( UA_Boolean
UA_RelativePath_equal(const UA_RelativePath *p1, const UA_RelativePath *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_RELATIVEPATH]) == UA_ORDER_EQ);
})


/* BrowsePath */
typedef struct {
    UA_NodeId startingNode;
    UA_RelativePath relativePath;
} UA_BrowsePath;

#define UA_TYPES_BROWSEPATH 265

UA_INLINABLE( void
UA_BrowsePath_init(UA_BrowsePath *p), {
    memset(p, 0, sizeof(UA_BrowsePath));
})

UA_INLINABLE( UA_BrowsePath *
UA_BrowsePath_new(void), {
    return (UA_BrowsePath*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATH]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowsePath_copy(const UA_BrowsePath *src, UA_BrowsePath *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATH]);
})

UA_INLINABLE( void
UA_BrowsePath_clear(UA_BrowsePath *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATH]);
})

UA_INLINABLE( void
UA_BrowsePath_delete(UA_BrowsePath *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATH]);
})

UA_INLINABLE( UA_Boolean
UA_BrowsePath_equal(const UA_BrowsePath *p1, const UA_BrowsePath *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSEPATH]) == UA_ORDER_EQ);
})


/* BrowsePathTarget */
typedef struct {
    UA_ExpandedNodeId targetId;
    UA_UInt32 remainingPathIndex;
} UA_BrowsePathTarget;

#define UA_TYPES_BROWSEPATHTARGET 266

UA_INLINABLE( void
UA_BrowsePathTarget_init(UA_BrowsePathTarget *p), {
    memset(p, 0, sizeof(UA_BrowsePathTarget));
})

UA_INLINABLE( UA_BrowsePathTarget *
UA_BrowsePathTarget_new(void), {
    return (UA_BrowsePathTarget*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowsePathTarget_copy(const UA_BrowsePathTarget *src, UA_BrowsePathTarget *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
})

UA_INLINABLE( void
UA_BrowsePathTarget_clear(UA_BrowsePathTarget *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
})

UA_INLINABLE( void
UA_BrowsePathTarget_delete(UA_BrowsePathTarget *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]);
})

UA_INLINABLE( UA_Boolean
UA_BrowsePathTarget_equal(const UA_BrowsePathTarget *p1, const UA_BrowsePathTarget *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]) == UA_ORDER_EQ);
})


/* BrowsePathResult */
typedef struct {
    UA_StatusCode statusCode;
    size_t targetsSize;
    UA_BrowsePathTarget *targets;
} UA_BrowsePathResult;

#define UA_TYPES_BROWSEPATHRESULT 267

UA_INLINABLE( void
UA_BrowsePathResult_init(UA_BrowsePathResult *p), {
    memset(p, 0, sizeof(UA_BrowsePathResult));
})

UA_INLINABLE( UA_BrowsePathResult *
UA_BrowsePathResult_new(void), {
    return (UA_BrowsePathResult*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_BrowsePathResult_copy(const UA_BrowsePathResult *src, UA_BrowsePathResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
})

UA_INLINABLE( void
UA_BrowsePathResult_clear(UA_BrowsePathResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
})

UA_INLINABLE( void
UA_BrowsePathResult_delete(UA_BrowsePathResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_BrowsePathResult_equal(const UA_BrowsePathResult *p1, const UA_BrowsePathResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]) == UA_ORDER_EQ);
})


/* TranslateBrowsePathsToNodeIdsRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t browsePathsSize;
    UA_BrowsePath *browsePaths;
} UA_TranslateBrowsePathsToNodeIdsRequest;

#define UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST 268

UA_INLINABLE( void
UA_TranslateBrowsePathsToNodeIdsRequest_init(UA_TranslateBrowsePathsToNodeIdsRequest *p), {
    memset(p, 0, sizeof(UA_TranslateBrowsePathsToNodeIdsRequest));
})

UA_INLINABLE( UA_TranslateBrowsePathsToNodeIdsRequest *
UA_TranslateBrowsePathsToNodeIdsRequest_new(void), {
    return (UA_TranslateBrowsePathsToNodeIdsRequest*)UA_new(&UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_TranslateBrowsePathsToNodeIdsRequest_copy(const UA_TranslateBrowsePathsToNodeIdsRequest *src, UA_TranslateBrowsePathsToNodeIdsRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
})

UA_INLINABLE( void
UA_TranslateBrowsePathsToNodeIdsRequest_clear(UA_TranslateBrowsePathsToNodeIdsRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
})

UA_INLINABLE( void
UA_TranslateBrowsePathsToNodeIdsRequest_delete(UA_TranslateBrowsePathsToNodeIdsRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_TranslateBrowsePathsToNodeIdsRequest_equal(const UA_TranslateBrowsePathsToNodeIdsRequest *p1, const UA_TranslateBrowsePathsToNodeIdsRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]) == UA_ORDER_EQ);
})


/* TranslateBrowsePathsToNodeIdsResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_BrowsePathResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_TranslateBrowsePathsToNodeIdsResponse;

#define UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE 269

UA_INLINABLE( void
UA_TranslateBrowsePathsToNodeIdsResponse_init(UA_TranslateBrowsePathsToNodeIdsResponse *p), {
    memset(p, 0, sizeof(UA_TranslateBrowsePathsToNodeIdsResponse));
})

UA_INLINABLE( UA_TranslateBrowsePathsToNodeIdsResponse *
UA_TranslateBrowsePathsToNodeIdsResponse_new(void), {
    return (UA_TranslateBrowsePathsToNodeIdsResponse*)UA_new(&UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_TranslateBrowsePathsToNodeIdsResponse_copy(const UA_TranslateBrowsePathsToNodeIdsResponse *src, UA_TranslateBrowsePathsToNodeIdsResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
})

UA_INLINABLE( void
UA_TranslateBrowsePathsToNodeIdsResponse_clear(UA_TranslateBrowsePathsToNodeIdsResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
})

UA_INLINABLE( void
UA_TranslateBrowsePathsToNodeIdsResponse_delete(UA_TranslateBrowsePathsToNodeIdsResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_TranslateBrowsePathsToNodeIdsResponse_equal(const UA_TranslateBrowsePathsToNodeIdsResponse *p1, const UA_TranslateBrowsePathsToNodeIdsResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]) == UA_ORDER_EQ);
})


/* RegisterNodesRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t nodesToRegisterSize;
    UA_NodeId *nodesToRegister;
} UA_RegisterNodesRequest;

#define UA_TYPES_REGISTERNODESREQUEST 270

UA_INLINABLE( void
UA_RegisterNodesRequest_init(UA_RegisterNodesRequest *p), {
    memset(p, 0, sizeof(UA_RegisterNodesRequest));
})

UA_INLINABLE( UA_RegisterNodesRequest *
UA_RegisterNodesRequest_new(void), {
    return (UA_RegisterNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_RegisterNodesRequest_copy(const UA_RegisterNodesRequest *src, UA_RegisterNodesRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
})

UA_INLINABLE( void
UA_RegisterNodesRequest_clear(UA_RegisterNodesRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
})

UA_INLINABLE( void
UA_RegisterNodesRequest_delete(UA_RegisterNodesRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_RegisterNodesRequest_equal(const UA_RegisterNodesRequest *p1, const UA_RegisterNodesRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]) == UA_ORDER_EQ);
})


/* RegisterNodesResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t registeredNodeIdsSize;
    UA_NodeId *registeredNodeIds;
} UA_RegisterNodesResponse;

#define UA_TYPES_REGISTERNODESRESPONSE 271

UA_INLINABLE( void
UA_RegisterNodesResponse_init(UA_RegisterNodesResponse *p), {
    memset(p, 0, sizeof(UA_RegisterNodesResponse));
})

UA_INLINABLE( UA_RegisterNodesResponse *
UA_RegisterNodesResponse_new(void), {
    return (UA_RegisterNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_RegisterNodesResponse_copy(const UA_RegisterNodesResponse *src, UA_RegisterNodesResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
})

UA_INLINABLE( void
UA_RegisterNodesResponse_clear(UA_RegisterNodesResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
})

UA_INLINABLE( void
UA_RegisterNodesResponse_delete(UA_RegisterNodesResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_RegisterNodesResponse_equal(const UA_RegisterNodesResponse *p1, const UA_RegisterNodesResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]) == UA_ORDER_EQ);
})


/* UnregisterNodesRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t nodesToUnregisterSize;
    UA_NodeId *nodesToUnregister;
} UA_UnregisterNodesRequest;

#define UA_TYPES_UNREGISTERNODESREQUEST 272

UA_INLINABLE( void
UA_UnregisterNodesRequest_init(UA_UnregisterNodesRequest *p), {
    memset(p, 0, sizeof(UA_UnregisterNodesRequest));
})

UA_INLINABLE( UA_UnregisterNodesRequest *
UA_UnregisterNodesRequest_new(void), {
    return (UA_UnregisterNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_UnregisterNodesRequest_copy(const UA_UnregisterNodesRequest *src, UA_UnregisterNodesRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
})

UA_INLINABLE( void
UA_UnregisterNodesRequest_clear(UA_UnregisterNodesRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
})

UA_INLINABLE( void
UA_UnregisterNodesRequest_delete(UA_UnregisterNodesRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_UnregisterNodesRequest_equal(const UA_UnregisterNodesRequest *p1, const UA_UnregisterNodesRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]) == UA_ORDER_EQ);
})


/* UnregisterNodesResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
} UA_UnregisterNodesResponse;

#define UA_TYPES_UNREGISTERNODESRESPONSE 273

UA_INLINABLE( void
UA_UnregisterNodesResponse_init(UA_UnregisterNodesResponse *p), {
    memset(p, 0, sizeof(UA_UnregisterNodesResponse));
})

UA_INLINABLE( UA_UnregisterNodesResponse *
UA_UnregisterNodesResponse_new(void), {
    return (UA_UnregisterNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_UnregisterNodesResponse_copy(const UA_UnregisterNodesResponse *src, UA_UnregisterNodesResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
})

UA_INLINABLE( void
UA_UnregisterNodesResponse_clear(UA_UnregisterNodesResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
})

UA_INLINABLE( void
UA_UnregisterNodesResponse_delete(UA_UnregisterNodesResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_UnregisterNodesResponse_equal(const UA_UnregisterNodesResponse *p1, const UA_UnregisterNodesResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]) == UA_ORDER_EQ);
})


/* Counter */
typedef UA_UInt32 UA_Counter;

#define UA_TYPES_COUNTER 274

UA_INLINABLE( void
UA_Counter_init(UA_Counter *p), {
    memset(p, 0, sizeof(UA_Counter));
})

UA_INLINABLE( UA_Counter *
UA_Counter_new(void), {
    return (UA_Counter*)UA_new(&UA_TYPES[UA_TYPES_COUNTER]);
})

UA_INLINABLE( UA_StatusCode
UA_Counter_copy(const UA_Counter *src, UA_Counter *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_COUNTER]);
})

UA_INLINABLE( void
UA_Counter_clear(UA_Counter *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_COUNTER]);
})

UA_INLINABLE( void
UA_Counter_delete(UA_Counter *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_COUNTER]);
})

UA_INLINABLE( UA_Boolean
UA_Counter_equal(const UA_Counter *p1, const UA_Counter *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_COUNTER]) == UA_ORDER_EQ);
})


/* OpaqueNumericRange */
typedef UA_String UA_OpaqueNumericRange;

#define UA_TYPES_OPAQUENUMERICRANGE 275

UA_INLINABLE( void
UA_OpaqueNumericRange_init(UA_OpaqueNumericRange *p), {
    memset(p, 0, sizeof(UA_OpaqueNumericRange));
})

UA_INLINABLE( UA_OpaqueNumericRange *
UA_OpaqueNumericRange_new(void), {
    return (UA_OpaqueNumericRange*)UA_new(&UA_TYPES[UA_TYPES_OPAQUENUMERICRANGE]);
})

UA_INLINABLE( UA_StatusCode
UA_OpaqueNumericRange_copy(const UA_OpaqueNumericRange *src, UA_OpaqueNumericRange *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPAQUENUMERICRANGE]);
})

UA_INLINABLE( void
UA_OpaqueNumericRange_clear(UA_OpaqueNumericRange *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_OPAQUENUMERICRANGE]);
})

UA_INLINABLE( void
UA_OpaqueNumericRange_delete(UA_OpaqueNumericRange *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_OPAQUENUMERICRANGE]);
})

UA_INLINABLE( UA_Boolean
UA_OpaqueNumericRange_equal(const UA_OpaqueNumericRange *p1, const UA_OpaqueNumericRange *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_OPAQUENUMERICRANGE]) == UA_ORDER_EQ);
})


/* EndpointConfiguration */
typedef struct {
    UA_Int32 operationTimeout;
    UA_Boolean useBinaryEncoding;
    UA_Int32 maxStringLength;
    UA_Int32 maxByteStringLength;
    UA_Int32 maxArrayLength;
    UA_Int32 maxMessageSize;
    UA_Int32 maxBufferSize;
    UA_Int32 channelLifetime;
    UA_Int32 securityTokenLifetime;
} UA_EndpointConfiguration;

#define UA_TYPES_ENDPOINTCONFIGURATION 276

UA_INLINABLE( void
UA_EndpointConfiguration_init(UA_EndpointConfiguration *p), {
    memset(p, 0, sizeof(UA_EndpointConfiguration));
})

UA_INLINABLE( UA_EndpointConfiguration *
UA_EndpointConfiguration_new(void), {
    return (UA_EndpointConfiguration*)UA_new(&UA_TYPES[UA_TYPES_ENDPOINTCONFIGURATION]);
})

UA_INLINABLE( UA_StatusCode
UA_EndpointConfiguration_copy(const UA_EndpointConfiguration *src, UA_EndpointConfiguration *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENDPOINTCONFIGURATION]);
})

UA_INLINABLE( void
UA_EndpointConfiguration_clear(UA_EndpointConfiguration *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTCONFIGURATION]);
})

UA_INLINABLE( void
UA_EndpointConfiguration_delete(UA_EndpointConfiguration *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENDPOINTCONFIGURATION]);
})

UA_INLINABLE( UA_Boolean
UA_EndpointConfiguration_equal(const UA_EndpointConfiguration *p1, const UA_EndpointConfiguration *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENDPOINTCONFIGURATION]) == UA_ORDER_EQ);
})


/* QueryDataDescription */
typedef struct {
    UA_RelativePath relativePath;
    UA_UInt32 attributeId;
    UA_String indexRange;
} UA_QueryDataDescription;

#define UA_TYPES_QUERYDATADESCRIPTION 277

UA_INLINABLE( void
UA_QueryDataDescription_init(UA_QueryDataDescription *p), {
    memset(p, 0, sizeof(UA_QueryDataDescription));
})

UA_INLINABLE( UA_QueryDataDescription *
UA_QueryDataDescription_new(void), {
    return (UA_QueryDataDescription*)UA_new(&UA_TYPES[UA_TYPES_QUERYDATADESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_QueryDataDescription_copy(const UA_QueryDataDescription *src, UA_QueryDataDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUERYDATADESCRIPTION]);
})

UA_INLINABLE( void
UA_QueryDataDescription_clear(UA_QueryDataDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUERYDATADESCRIPTION]);
})

UA_INLINABLE( void
UA_QueryDataDescription_delete(UA_QueryDataDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUERYDATADESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_QueryDataDescription_equal(const UA_QueryDataDescription *p1, const UA_QueryDataDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_QUERYDATADESCRIPTION]) == UA_ORDER_EQ);
})


/* NodeTypeDescription */
typedef struct {
    UA_ExpandedNodeId typeDefinitionNode;
    UA_Boolean includeSubTypes;
    size_t dataToReturnSize;
    UA_QueryDataDescription *dataToReturn;
} UA_NodeTypeDescription;

#define UA_TYPES_NODETYPEDESCRIPTION 278

UA_INLINABLE( void
UA_NodeTypeDescription_init(UA_NodeTypeDescription *p), {
    memset(p, 0, sizeof(UA_NodeTypeDescription));
})

UA_INLINABLE( UA_NodeTypeDescription *
UA_NodeTypeDescription_new(void), {
    return (UA_NodeTypeDescription*)UA_new(&UA_TYPES[UA_TYPES_NODETYPEDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_NodeTypeDescription_copy(const UA_NodeTypeDescription *src, UA_NodeTypeDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODETYPEDESCRIPTION]);
})

UA_INLINABLE( void
UA_NodeTypeDescription_clear(UA_NodeTypeDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODETYPEDESCRIPTION]);
})

UA_INLINABLE( void
UA_NodeTypeDescription_delete(UA_NodeTypeDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODETYPEDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_NodeTypeDescription_equal(const UA_NodeTypeDescription *p1, const UA_NodeTypeDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NODETYPEDESCRIPTION]) == UA_ORDER_EQ);
})


/* FilterOperator */
typedef enum {
    UA_FILTEROPERATOR_EQUALS = 0,
    UA_FILTEROPERATOR_ISNULL = 1,
    UA_FILTEROPERATOR_GREATERTHAN = 2,
    UA_FILTEROPERATOR_LESSTHAN = 3,
    UA_FILTEROPERATOR_GREATERTHANOREQUAL = 4,
    UA_FILTEROPERATOR_LESSTHANOREQUAL = 5,
    UA_FILTEROPERATOR_LIKE = 6,
    UA_FILTEROPERATOR_NOT = 7,
    UA_FILTEROPERATOR_BETWEEN = 8,
    UA_FILTEROPERATOR_INLIST = 9,
    UA_FILTEROPERATOR_AND = 10,
    UA_FILTEROPERATOR_OR = 11,
    UA_FILTEROPERATOR_CAST = 12,
    UA_FILTEROPERATOR_INVIEW = 13,
    UA_FILTEROPERATOR_OFTYPE = 14,
    UA_FILTEROPERATOR_RELATEDTO = 15,
    UA_FILTEROPERATOR_BITWISEAND = 16,
    UA_FILTEROPERATOR_BITWISEOR = 17,
    __UA_FILTEROPERATOR_FORCE32BIT = 0x7fffffff
} UA_FilterOperator;

UA_STATIC_ASSERT(sizeof(UA_FilterOperator) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_FILTEROPERATOR 279

UA_INLINABLE( void
UA_FilterOperator_init(UA_FilterOperator *p), {
    memset(p, 0, sizeof(UA_FilterOperator));
})

UA_INLINABLE( UA_FilterOperator *
UA_FilterOperator_new(void), {
    return (UA_FilterOperator*)UA_new(&UA_TYPES[UA_TYPES_FILTEROPERATOR]);
})

UA_INLINABLE( UA_StatusCode
UA_FilterOperator_copy(const UA_FilterOperator *src, UA_FilterOperator *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FILTEROPERATOR]);
})

UA_INLINABLE( void
UA_FilterOperator_clear(UA_FilterOperator *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_FILTEROPERATOR]);
})

UA_INLINABLE( void
UA_FilterOperator_delete(UA_FilterOperator *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_FILTEROPERATOR]);
})

UA_INLINABLE( UA_Boolean
UA_FilterOperator_equal(const UA_FilterOperator *p1, const UA_FilterOperator *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_FILTEROPERATOR]) == UA_ORDER_EQ);
})


/* QueryDataSet */
typedef struct {
    UA_ExpandedNodeId nodeId;
    UA_ExpandedNodeId typeDefinitionNode;
    size_t valuesSize;
    UA_Variant *values;
} UA_QueryDataSet;

#define UA_TYPES_QUERYDATASET 280

UA_INLINABLE( void
UA_QueryDataSet_init(UA_QueryDataSet *p), {
    memset(p, 0, sizeof(UA_QueryDataSet));
})

UA_INLINABLE( UA_QueryDataSet *
UA_QueryDataSet_new(void), {
    return (UA_QueryDataSet*)UA_new(&UA_TYPES[UA_TYPES_QUERYDATASET]);
})

UA_INLINABLE( UA_StatusCode
UA_QueryDataSet_copy(const UA_QueryDataSet *src, UA_QueryDataSet *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUERYDATASET]);
})

UA_INLINABLE( void
UA_QueryDataSet_clear(UA_QueryDataSet *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUERYDATASET]);
})

UA_INLINABLE( void
UA_QueryDataSet_delete(UA_QueryDataSet *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUERYDATASET]);
})

UA_INLINABLE( UA_Boolean
UA_QueryDataSet_equal(const UA_QueryDataSet *p1, const UA_QueryDataSet *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_QUERYDATASET]) == UA_ORDER_EQ);
})


/* NodeReference */
typedef struct {
    UA_NodeId nodeId;
    UA_NodeId referenceTypeId;
    UA_Boolean isForward;
    size_t referencedNodeIdsSize;
    UA_NodeId *referencedNodeIds;
} UA_NodeReference;

#define UA_TYPES_NODEREFERENCE 281

UA_INLINABLE( void
UA_NodeReference_init(UA_NodeReference *p), {
    memset(p, 0, sizeof(UA_NodeReference));
})

UA_INLINABLE( UA_NodeReference *
UA_NodeReference_new(void), {
    return (UA_NodeReference*)UA_new(&UA_TYPES[UA_TYPES_NODEREFERENCE]);
})

UA_INLINABLE( UA_StatusCode
UA_NodeReference_copy(const UA_NodeReference *src, UA_NodeReference *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEREFERENCE]);
})

UA_INLINABLE( void
UA_NodeReference_clear(UA_NodeReference *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NODEREFERENCE]);
})

UA_INLINABLE( void
UA_NodeReference_delete(UA_NodeReference *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NODEREFERENCE]);
})

UA_INLINABLE( UA_Boolean
UA_NodeReference_equal(const UA_NodeReference *p1, const UA_NodeReference *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NODEREFERENCE]) == UA_ORDER_EQ);
})


/* ContentFilterElement */
typedef struct {
    UA_FilterOperator filterOperator;
    size_t filterOperandsSize;
    UA_ExtensionObject *filterOperands;
} UA_ContentFilterElement;

#define UA_TYPES_CONTENTFILTERELEMENT 282

UA_INLINABLE( void
UA_ContentFilterElement_init(UA_ContentFilterElement *p), {
    memset(p, 0, sizeof(UA_ContentFilterElement));
})

UA_INLINABLE( UA_ContentFilterElement *
UA_ContentFilterElement_new(void), {
    return (UA_ContentFilterElement*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
})

UA_INLINABLE( UA_StatusCode
UA_ContentFilterElement_copy(const UA_ContentFilterElement *src, UA_ContentFilterElement *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
})

UA_INLINABLE( void
UA_ContentFilterElement_clear(UA_ContentFilterElement *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
})

UA_INLINABLE( void
UA_ContentFilterElement_delete(UA_ContentFilterElement *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]);
})

UA_INLINABLE( UA_Boolean
UA_ContentFilterElement_equal(const UA_ContentFilterElement *p1, const UA_ContentFilterElement *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]) == UA_ORDER_EQ);
})


/* ContentFilter */
typedef struct {
    size_t elementsSize;
    UA_ContentFilterElement *elements;
} UA_ContentFilter;

#define UA_TYPES_CONTENTFILTER 283

UA_INLINABLE( void
UA_ContentFilter_init(UA_ContentFilter *p), {
    memset(p, 0, sizeof(UA_ContentFilter));
})

UA_INLINABLE( UA_ContentFilter *
UA_ContentFilter_new(void), {
    return (UA_ContentFilter*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTER]);
})

UA_INLINABLE( UA_StatusCode
UA_ContentFilter_copy(const UA_ContentFilter *src, UA_ContentFilter *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTER]);
})

UA_INLINABLE( void
UA_ContentFilter_clear(UA_ContentFilter *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTER]);
})

UA_INLINABLE( void
UA_ContentFilter_delete(UA_ContentFilter *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTER]);
})

UA_INLINABLE( UA_Boolean
UA_ContentFilter_equal(const UA_ContentFilter *p1, const UA_ContentFilter *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONTENTFILTER]) == UA_ORDER_EQ);
})


/* ElementOperand */
typedef struct {
    UA_UInt32 index;
} UA_ElementOperand;

#define UA_TYPES_ELEMENTOPERAND 284

UA_INLINABLE( void
UA_ElementOperand_init(UA_ElementOperand *p), {
    memset(p, 0, sizeof(UA_ElementOperand));
})

UA_INLINABLE( UA_ElementOperand *
UA_ElementOperand_new(void), {
    return (UA_ElementOperand*)UA_new(&UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
})

UA_INLINABLE( UA_StatusCode
UA_ElementOperand_copy(const UA_ElementOperand *src, UA_ElementOperand *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
})

UA_INLINABLE( void
UA_ElementOperand_clear(UA_ElementOperand *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
})

UA_INLINABLE( void
UA_ElementOperand_delete(UA_ElementOperand *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]);
})

UA_INLINABLE( UA_Boolean
UA_ElementOperand_equal(const UA_ElementOperand *p1, const UA_ElementOperand *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]) == UA_ORDER_EQ);
})


/* LiteralOperand */
typedef struct {
    UA_Variant value;
} UA_LiteralOperand;

#define UA_TYPES_LITERALOPERAND 285

UA_INLINABLE( void
UA_LiteralOperand_init(UA_LiteralOperand *p), {
    memset(p, 0, sizeof(UA_LiteralOperand));
})

UA_INLINABLE( UA_LiteralOperand *
UA_LiteralOperand_new(void), {
    return (UA_LiteralOperand*)UA_new(&UA_TYPES[UA_TYPES_LITERALOPERAND]);
})

UA_INLINABLE( UA_StatusCode
UA_LiteralOperand_copy(const UA_LiteralOperand *src, UA_LiteralOperand *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LITERALOPERAND]);
})

UA_INLINABLE( void
UA_LiteralOperand_clear(UA_LiteralOperand *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LITERALOPERAND]);
})

UA_INLINABLE( void
UA_LiteralOperand_delete(UA_LiteralOperand *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LITERALOPERAND]);
})

UA_INLINABLE( UA_Boolean
UA_LiteralOperand_equal(const UA_LiteralOperand *p1, const UA_LiteralOperand *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LITERALOPERAND]) == UA_ORDER_EQ);
})


/* AttributeOperand */
typedef struct {
    UA_NodeId nodeId;
    UA_String alias;
    UA_RelativePath browsePath;
    UA_UInt32 attributeId;
    UA_String indexRange;
} UA_AttributeOperand;

#define UA_TYPES_ATTRIBUTEOPERAND 286

UA_INLINABLE( void
UA_AttributeOperand_init(UA_AttributeOperand *p), {
    memset(p, 0, sizeof(UA_AttributeOperand));
})

UA_INLINABLE( UA_AttributeOperand *
UA_AttributeOperand_new(void), {
    return (UA_AttributeOperand*)UA_new(&UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
})

UA_INLINABLE( UA_StatusCode
UA_AttributeOperand_copy(const UA_AttributeOperand *src, UA_AttributeOperand *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
})

UA_INLINABLE( void
UA_AttributeOperand_clear(UA_AttributeOperand *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
})

UA_INLINABLE( void
UA_AttributeOperand_delete(UA_AttributeOperand *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]);
})

UA_INLINABLE( UA_Boolean
UA_AttributeOperand_equal(const UA_AttributeOperand *p1, const UA_AttributeOperand *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]) == UA_ORDER_EQ);
})


/* SimpleAttributeOperand */
typedef struct {
    UA_NodeId typeDefinitionId;
    size_t browsePathSize;
    UA_QualifiedName *browsePath;
    UA_UInt32 attributeId;
    UA_String indexRange;
} UA_SimpleAttributeOperand;

#define UA_TYPES_SIMPLEATTRIBUTEOPERAND 287

UA_INLINABLE( void
UA_SimpleAttributeOperand_init(UA_SimpleAttributeOperand *p), {
    memset(p, 0, sizeof(UA_SimpleAttributeOperand));
})

UA_INLINABLE( UA_SimpleAttributeOperand *
UA_SimpleAttributeOperand_new(void), {
    return (UA_SimpleAttributeOperand*)UA_new(&UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
})

UA_INLINABLE( UA_StatusCode
UA_SimpleAttributeOperand_copy(const UA_SimpleAttributeOperand *src, UA_SimpleAttributeOperand *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
})

UA_INLINABLE( void
UA_SimpleAttributeOperand_clear(UA_SimpleAttributeOperand *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
})

UA_INLINABLE( void
UA_SimpleAttributeOperand_delete(UA_SimpleAttributeOperand *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
})

UA_INLINABLE( UA_Boolean
UA_SimpleAttributeOperand_equal(const UA_SimpleAttributeOperand *p1, const UA_SimpleAttributeOperand *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]) == UA_ORDER_EQ);
})


/* ContentFilterElementResult */
typedef struct {
    UA_StatusCode statusCode;
    size_t operandStatusCodesSize;
    UA_StatusCode *operandStatusCodes;
    size_t operandDiagnosticInfosSize;
    UA_DiagnosticInfo *operandDiagnosticInfos;
} UA_ContentFilterElementResult;

#define UA_TYPES_CONTENTFILTERELEMENTRESULT 288

UA_INLINABLE( void
UA_ContentFilterElementResult_init(UA_ContentFilterElementResult *p), {
    memset(p, 0, sizeof(UA_ContentFilterElementResult));
})

UA_INLINABLE( UA_ContentFilterElementResult *
UA_ContentFilterElementResult_new(void), {
    return (UA_ContentFilterElementResult*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_ContentFilterElementResult_copy(const UA_ContentFilterElementResult *src, UA_ContentFilterElementResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
})

UA_INLINABLE( void
UA_ContentFilterElementResult_clear(UA_ContentFilterElementResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
})

UA_INLINABLE( void
UA_ContentFilterElementResult_delete(UA_ContentFilterElementResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_ContentFilterElementResult_equal(const UA_ContentFilterElementResult *p1, const UA_ContentFilterElementResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]) == UA_ORDER_EQ);
})


/* ContentFilterResult */
typedef struct {
    size_t elementResultsSize;
    UA_ContentFilterElementResult *elementResults;
    size_t elementDiagnosticInfosSize;
    UA_DiagnosticInfo *elementDiagnosticInfos;
} UA_ContentFilterResult;

#define UA_TYPES_CONTENTFILTERRESULT 289

UA_INLINABLE( void
UA_ContentFilterResult_init(UA_ContentFilterResult *p), {
    memset(p, 0, sizeof(UA_ContentFilterResult));
})

UA_INLINABLE( UA_ContentFilterResult *
UA_ContentFilterResult_new(void), {
    return (UA_ContentFilterResult*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_ContentFilterResult_copy(const UA_ContentFilterResult *src, UA_ContentFilterResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
})

UA_INLINABLE( void
UA_ContentFilterResult_clear(UA_ContentFilterResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
})

UA_INLINABLE( void
UA_ContentFilterResult_delete(UA_ContentFilterResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_ContentFilterResult_equal(const UA_ContentFilterResult *p1, const UA_ContentFilterResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]) == UA_ORDER_EQ);
})


/* ParsingResult */
typedef struct {
    UA_StatusCode statusCode;
    size_t dataStatusCodesSize;
    UA_StatusCode *dataStatusCodes;
    size_t dataDiagnosticInfosSize;
    UA_DiagnosticInfo *dataDiagnosticInfos;
} UA_ParsingResult;

#define UA_TYPES_PARSINGRESULT 290

UA_INLINABLE( void
UA_ParsingResult_init(UA_ParsingResult *p), {
    memset(p, 0, sizeof(UA_ParsingResult));
})

UA_INLINABLE( UA_ParsingResult *
UA_ParsingResult_new(void), {
    return (UA_ParsingResult*)UA_new(&UA_TYPES[UA_TYPES_PARSINGRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_ParsingResult_copy(const UA_ParsingResult *src, UA_ParsingResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PARSINGRESULT]);
})

UA_INLINABLE( void
UA_ParsingResult_clear(UA_ParsingResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PARSINGRESULT]);
})

UA_INLINABLE( void
UA_ParsingResult_delete(UA_ParsingResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PARSINGRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_ParsingResult_equal(const UA_ParsingResult *p1, const UA_ParsingResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PARSINGRESULT]) == UA_ORDER_EQ);
})


/* QueryFirstRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_ViewDescription view;
    size_t nodeTypesSize;
    UA_NodeTypeDescription *nodeTypes;
    UA_ContentFilter filter;
    UA_UInt32 maxDataSetsToReturn;
    UA_UInt32 maxReferencesToReturn;
} UA_QueryFirstRequest;

#define UA_TYPES_QUERYFIRSTREQUEST 291

UA_INLINABLE( void
UA_QueryFirstRequest_init(UA_QueryFirstRequest *p), {
    memset(p, 0, sizeof(UA_QueryFirstRequest));
})

UA_INLINABLE( UA_QueryFirstRequest *
UA_QueryFirstRequest_new(void), {
    return (UA_QueryFirstRequest*)UA_new(&UA_TYPES[UA_TYPES_QUERYFIRSTREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_QueryFirstRequest_copy(const UA_QueryFirstRequest *src, UA_QueryFirstRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUERYFIRSTREQUEST]);
})

UA_INLINABLE( void
UA_QueryFirstRequest_clear(UA_QueryFirstRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUERYFIRSTREQUEST]);
})

UA_INLINABLE( void
UA_QueryFirstRequest_delete(UA_QueryFirstRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUERYFIRSTREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_QueryFirstRequest_equal(const UA_QueryFirstRequest *p1, const UA_QueryFirstRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_QUERYFIRSTREQUEST]) == UA_ORDER_EQ);
})


/* QueryFirstResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t queryDataSetsSize;
    UA_QueryDataSet *queryDataSets;
    UA_ByteString continuationPoint;
    size_t parsingResultsSize;
    UA_ParsingResult *parsingResults;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
    UA_ContentFilterResult filterResult;
} UA_QueryFirstResponse;

#define UA_TYPES_QUERYFIRSTRESPONSE 292

UA_INLINABLE( void
UA_QueryFirstResponse_init(UA_QueryFirstResponse *p), {
    memset(p, 0, sizeof(UA_QueryFirstResponse));
})

UA_INLINABLE( UA_QueryFirstResponse *
UA_QueryFirstResponse_new(void), {
    return (UA_QueryFirstResponse*)UA_new(&UA_TYPES[UA_TYPES_QUERYFIRSTRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_QueryFirstResponse_copy(const UA_QueryFirstResponse *src, UA_QueryFirstResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUERYFIRSTRESPONSE]);
})

UA_INLINABLE( void
UA_QueryFirstResponse_clear(UA_QueryFirstResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUERYFIRSTRESPONSE]);
})

UA_INLINABLE( void
UA_QueryFirstResponse_delete(UA_QueryFirstResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUERYFIRSTRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_QueryFirstResponse_equal(const UA_QueryFirstResponse *p1, const UA_QueryFirstResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_QUERYFIRSTRESPONSE]) == UA_ORDER_EQ);
})


/* QueryNextRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_Boolean releaseContinuationPoint;
    UA_ByteString continuationPoint;
} UA_QueryNextRequest;

#define UA_TYPES_QUERYNEXTREQUEST 293

UA_INLINABLE( void
UA_QueryNextRequest_init(UA_QueryNextRequest *p), {
    memset(p, 0, sizeof(UA_QueryNextRequest));
})

UA_INLINABLE( UA_QueryNextRequest *
UA_QueryNextRequest_new(void), {
    return (UA_QueryNextRequest*)UA_new(&UA_TYPES[UA_TYPES_QUERYNEXTREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_QueryNextRequest_copy(const UA_QueryNextRequest *src, UA_QueryNextRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUERYNEXTREQUEST]);
})

UA_INLINABLE( void
UA_QueryNextRequest_clear(UA_QueryNextRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUERYNEXTREQUEST]);
})

UA_INLINABLE( void
UA_QueryNextRequest_delete(UA_QueryNextRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUERYNEXTREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_QueryNextRequest_equal(const UA_QueryNextRequest *p1, const UA_QueryNextRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_QUERYNEXTREQUEST]) == UA_ORDER_EQ);
})


/* QueryNextResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t queryDataSetsSize;
    UA_QueryDataSet *queryDataSets;
    UA_ByteString revisedContinuationPoint;
} UA_QueryNextResponse;

#define UA_TYPES_QUERYNEXTRESPONSE 294

UA_INLINABLE( void
UA_QueryNextResponse_init(UA_QueryNextResponse *p), {
    memset(p, 0, sizeof(UA_QueryNextResponse));
})

UA_INLINABLE( UA_QueryNextResponse *
UA_QueryNextResponse_new(void), {
    return (UA_QueryNextResponse*)UA_new(&UA_TYPES[UA_TYPES_QUERYNEXTRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_QueryNextResponse_copy(const UA_QueryNextResponse *src, UA_QueryNextResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUERYNEXTRESPONSE]);
})

UA_INLINABLE( void
UA_QueryNextResponse_clear(UA_QueryNextResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_QUERYNEXTRESPONSE]);
})

UA_INLINABLE( void
UA_QueryNextResponse_delete(UA_QueryNextResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_QUERYNEXTRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_QueryNextResponse_equal(const UA_QueryNextResponse *p1, const UA_QueryNextResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_QUERYNEXTRESPONSE]) == UA_ORDER_EQ);
})


/* TimestampsToReturn */
typedef enum {
    UA_TIMESTAMPSTORETURN_SOURCE = 0,
    UA_TIMESTAMPSTORETURN_SERVER = 1,
    UA_TIMESTAMPSTORETURN_BOTH = 2,
    UA_TIMESTAMPSTORETURN_NEITHER = 3,
    UA_TIMESTAMPSTORETURN_INVALID = 4,
    __UA_TIMESTAMPSTORETURN_FORCE32BIT = 0x7fffffff
} UA_TimestampsToReturn;

UA_STATIC_ASSERT(sizeof(UA_TimestampsToReturn) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_TIMESTAMPSTORETURN 295

UA_INLINABLE( void
UA_TimestampsToReturn_init(UA_TimestampsToReturn *p), {
    memset(p, 0, sizeof(UA_TimestampsToReturn));
})

UA_INLINABLE( UA_TimestampsToReturn *
UA_TimestampsToReturn_new(void), {
    return (UA_TimestampsToReturn*)UA_new(&UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
})

UA_INLINABLE( UA_StatusCode
UA_TimestampsToReturn_copy(const UA_TimestampsToReturn *src, UA_TimestampsToReturn *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
})

UA_INLINABLE( void
UA_TimestampsToReturn_clear(UA_TimestampsToReturn *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
})

UA_INLINABLE( void
UA_TimestampsToReturn_delete(UA_TimestampsToReturn *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]);
})

UA_INLINABLE( UA_Boolean
UA_TimestampsToReturn_equal(const UA_TimestampsToReturn *p1, const UA_TimestampsToReturn *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]) == UA_ORDER_EQ);
})


/* ReadValueId */
typedef struct {
    UA_NodeId nodeId;
    UA_UInt32 attributeId;
    UA_String indexRange;
    UA_QualifiedName dataEncoding;
} UA_ReadValueId;

#define UA_TYPES_READVALUEID 296

UA_INLINABLE( void
UA_ReadValueId_init(UA_ReadValueId *p), {
    memset(p, 0, sizeof(UA_ReadValueId));
})

UA_INLINABLE( UA_ReadValueId *
UA_ReadValueId_new(void), {
    return (UA_ReadValueId*)UA_new(&UA_TYPES[UA_TYPES_READVALUEID]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadValueId_copy(const UA_ReadValueId *src, UA_ReadValueId *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READVALUEID]);
})

UA_INLINABLE( void
UA_ReadValueId_clear(UA_ReadValueId *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READVALUEID]);
})

UA_INLINABLE( void
UA_ReadValueId_delete(UA_ReadValueId *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READVALUEID]);
})

UA_INLINABLE( UA_Boolean
UA_ReadValueId_equal(const UA_ReadValueId *p1, const UA_ReadValueId *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READVALUEID]) == UA_ORDER_EQ);
})


/* ReadRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_Double maxAge;
    UA_TimestampsToReturn timestampsToReturn;
    size_t nodesToReadSize;
    UA_ReadValueId *nodesToRead;
} UA_ReadRequest;

#define UA_TYPES_READREQUEST 297

UA_INLINABLE( void
UA_ReadRequest_init(UA_ReadRequest *p), {
    memset(p, 0, sizeof(UA_ReadRequest));
})

UA_INLINABLE( UA_ReadRequest *
UA_ReadRequest_new(void), {
    return (UA_ReadRequest*)UA_new(&UA_TYPES[UA_TYPES_READREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadRequest_copy(const UA_ReadRequest *src, UA_ReadRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READREQUEST]);
})

UA_INLINABLE( void
UA_ReadRequest_clear(UA_ReadRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READREQUEST]);
})

UA_INLINABLE( void
UA_ReadRequest_delete(UA_ReadRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_ReadRequest_equal(const UA_ReadRequest *p1, const UA_ReadRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READREQUEST]) == UA_ORDER_EQ);
})


/* ReadResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_DataValue *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_ReadResponse;

#define UA_TYPES_READRESPONSE 298

UA_INLINABLE( void
UA_ReadResponse_init(UA_ReadResponse *p), {
    memset(p, 0, sizeof(UA_ReadResponse));
})

UA_INLINABLE( UA_ReadResponse *
UA_ReadResponse_new(void), {
    return (UA_ReadResponse*)UA_new(&UA_TYPES[UA_TYPES_READRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadResponse_copy(const UA_ReadResponse *src, UA_ReadResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READRESPONSE]);
})

UA_INLINABLE( void
UA_ReadResponse_clear(UA_ReadResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READRESPONSE]);
})

UA_INLINABLE( void
UA_ReadResponse_delete(UA_ReadResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_ReadResponse_equal(const UA_ReadResponse *p1, const UA_ReadResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READRESPONSE]) == UA_ORDER_EQ);
})


/* HistoryReadValueId */
typedef struct {
    UA_NodeId nodeId;
    UA_String indexRange;
    UA_QualifiedName dataEncoding;
    UA_ByteString continuationPoint;
} UA_HistoryReadValueId;

#define UA_TYPES_HISTORYREADVALUEID 299

UA_INLINABLE( void
UA_HistoryReadValueId_init(UA_HistoryReadValueId *p), {
    memset(p, 0, sizeof(UA_HistoryReadValueId));
})

UA_INLINABLE( UA_HistoryReadValueId *
UA_HistoryReadValueId_new(void), {
    return (UA_HistoryReadValueId*)UA_new(&UA_TYPES[UA_TYPES_HISTORYREADVALUEID]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryReadValueId_copy(const UA_HistoryReadValueId *src, UA_HistoryReadValueId *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYREADVALUEID]);
})

UA_INLINABLE( void
UA_HistoryReadValueId_clear(UA_HistoryReadValueId *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYREADVALUEID]);
})

UA_INLINABLE( void
UA_HistoryReadValueId_delete(UA_HistoryReadValueId *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYREADVALUEID]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryReadValueId_equal(const UA_HistoryReadValueId *p1, const UA_HistoryReadValueId *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYREADVALUEID]) == UA_ORDER_EQ);
})


/* HistoryReadResult */
typedef struct {
    UA_StatusCode statusCode;
    UA_ByteString continuationPoint;
    UA_ExtensionObject historyData;
} UA_HistoryReadResult;

#define UA_TYPES_HISTORYREADRESULT 300

UA_INLINABLE( void
UA_HistoryReadResult_init(UA_HistoryReadResult *p), {
    memset(p, 0, sizeof(UA_HistoryReadResult));
})

UA_INLINABLE( UA_HistoryReadResult *
UA_HistoryReadResult_new(void), {
    return (UA_HistoryReadResult*)UA_new(&UA_TYPES[UA_TYPES_HISTORYREADRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryReadResult_copy(const UA_HistoryReadResult *src, UA_HistoryReadResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYREADRESULT]);
})

UA_INLINABLE( void
UA_HistoryReadResult_clear(UA_HistoryReadResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYREADRESULT]);
})

UA_INLINABLE( void
UA_HistoryReadResult_delete(UA_HistoryReadResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYREADRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryReadResult_equal(const UA_HistoryReadResult *p1, const UA_HistoryReadResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYREADRESULT]) == UA_ORDER_EQ);
})


/* SortOrderType */
typedef enum {
    UA_SORTORDERTYPE_ASCENDING = 0,
    UA_SORTORDERTYPE_DESCENDING = 1,
    __UA_SORTORDERTYPE_FORCE32BIT = 0x7fffffff
} UA_SortOrderType;

UA_STATIC_ASSERT(sizeof(UA_SortOrderType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_SORTORDERTYPE 301

UA_INLINABLE( void
UA_SortOrderType_init(UA_SortOrderType *p), {
    memset(p, 0, sizeof(UA_SortOrderType));
})

UA_INLINABLE( UA_SortOrderType *
UA_SortOrderType_new(void), {
    return (UA_SortOrderType*)UA_new(&UA_TYPES[UA_TYPES_SORTORDERTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SortOrderType_copy(const UA_SortOrderType *src, UA_SortOrderType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SORTORDERTYPE]);
})

UA_INLINABLE( void
UA_SortOrderType_clear(UA_SortOrderType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SORTORDERTYPE]);
})

UA_INLINABLE( void
UA_SortOrderType_delete(UA_SortOrderType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SORTORDERTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SortOrderType_equal(const UA_SortOrderType *p1, const UA_SortOrderType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SORTORDERTYPE]) == UA_ORDER_EQ);
})


/* SortRuleElement */
typedef struct {
    UA_SortOrderType sortOrder;
    UA_SimpleAttributeOperand eventField;
} UA_SortRuleElement;

#define UA_TYPES_SORTRULEELEMENT 302

UA_INLINABLE( void
UA_SortRuleElement_init(UA_SortRuleElement *p), {
    memset(p, 0, sizeof(UA_SortRuleElement));
})

UA_INLINABLE( UA_SortRuleElement *
UA_SortRuleElement_new(void), {
    return (UA_SortRuleElement*)UA_new(&UA_TYPES[UA_TYPES_SORTRULEELEMENT]);
})

UA_INLINABLE( UA_StatusCode
UA_SortRuleElement_copy(const UA_SortRuleElement *src, UA_SortRuleElement *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SORTRULEELEMENT]);
})

UA_INLINABLE( void
UA_SortRuleElement_clear(UA_SortRuleElement *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SORTRULEELEMENT]);
})

UA_INLINABLE( void
UA_SortRuleElement_delete(UA_SortRuleElement *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SORTRULEELEMENT]);
})

UA_INLINABLE( UA_Boolean
UA_SortRuleElement_equal(const UA_SortRuleElement *p1, const UA_SortRuleElement *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SORTRULEELEMENT]) == UA_ORDER_EQ);
})


/* ReadRawModifiedDetails */
typedef struct {
    UA_Boolean isReadModified;
    UA_DateTime startTime;
    UA_DateTime endTime;
    UA_UInt32 numValuesPerNode;
    UA_Boolean returnBounds;
} UA_ReadRawModifiedDetails;

#define UA_TYPES_READRAWMODIFIEDDETAILS 303

UA_INLINABLE( void
UA_ReadRawModifiedDetails_init(UA_ReadRawModifiedDetails *p), {
    memset(p, 0, sizeof(UA_ReadRawModifiedDetails));
})

UA_INLINABLE( UA_ReadRawModifiedDetails *
UA_ReadRawModifiedDetails_new(void), {
    return (UA_ReadRawModifiedDetails*)UA_new(&UA_TYPES[UA_TYPES_READRAWMODIFIEDDETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadRawModifiedDetails_copy(const UA_ReadRawModifiedDetails *src, UA_ReadRawModifiedDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READRAWMODIFIEDDETAILS]);
})

UA_INLINABLE( void
UA_ReadRawModifiedDetails_clear(UA_ReadRawModifiedDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READRAWMODIFIEDDETAILS]);
})

UA_INLINABLE( void
UA_ReadRawModifiedDetails_delete(UA_ReadRawModifiedDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READRAWMODIFIEDDETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_ReadRawModifiedDetails_equal(const UA_ReadRawModifiedDetails *p1, const UA_ReadRawModifiedDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READRAWMODIFIEDDETAILS]) == UA_ORDER_EQ);
})


/* ReadAtTimeDetails */
typedef struct {
    size_t reqTimesSize;
    UA_DateTime *reqTimes;
    UA_Boolean useSimpleBounds;
} UA_ReadAtTimeDetails;

#define UA_TYPES_READATTIMEDETAILS 304

UA_INLINABLE( void
UA_ReadAtTimeDetails_init(UA_ReadAtTimeDetails *p), {
    memset(p, 0, sizeof(UA_ReadAtTimeDetails));
})

UA_INLINABLE( UA_ReadAtTimeDetails *
UA_ReadAtTimeDetails_new(void), {
    return (UA_ReadAtTimeDetails*)UA_new(&UA_TYPES[UA_TYPES_READATTIMEDETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadAtTimeDetails_copy(const UA_ReadAtTimeDetails *src, UA_ReadAtTimeDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READATTIMEDETAILS]);
})

UA_INLINABLE( void
UA_ReadAtTimeDetails_clear(UA_ReadAtTimeDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READATTIMEDETAILS]);
})

UA_INLINABLE( void
UA_ReadAtTimeDetails_delete(UA_ReadAtTimeDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READATTIMEDETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_ReadAtTimeDetails_equal(const UA_ReadAtTimeDetails *p1, const UA_ReadAtTimeDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READATTIMEDETAILS]) == UA_ORDER_EQ);
})


/* ReadAnnotationDataDetails */
typedef struct {
    size_t reqTimesSize;
    UA_DateTime *reqTimes;
} UA_ReadAnnotationDataDetails;

#define UA_TYPES_READANNOTATIONDATADETAILS 305

UA_INLINABLE( void
UA_ReadAnnotationDataDetails_init(UA_ReadAnnotationDataDetails *p), {
    memset(p, 0, sizeof(UA_ReadAnnotationDataDetails));
})

UA_INLINABLE( UA_ReadAnnotationDataDetails *
UA_ReadAnnotationDataDetails_new(void), {
    return (UA_ReadAnnotationDataDetails*)UA_new(&UA_TYPES[UA_TYPES_READANNOTATIONDATADETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadAnnotationDataDetails_copy(const UA_ReadAnnotationDataDetails *src, UA_ReadAnnotationDataDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READANNOTATIONDATADETAILS]);
})

UA_INLINABLE( void
UA_ReadAnnotationDataDetails_clear(UA_ReadAnnotationDataDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READANNOTATIONDATADETAILS]);
})

UA_INLINABLE( void
UA_ReadAnnotationDataDetails_delete(UA_ReadAnnotationDataDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READANNOTATIONDATADETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_ReadAnnotationDataDetails_equal(const UA_ReadAnnotationDataDetails *p1, const UA_ReadAnnotationDataDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READANNOTATIONDATADETAILS]) == UA_ORDER_EQ);
})


/* HistoryData */
typedef struct {
    size_t dataValuesSize;
    UA_DataValue *dataValues;
} UA_HistoryData;

#define UA_TYPES_HISTORYDATA 306

UA_INLINABLE( void
UA_HistoryData_init(UA_HistoryData *p), {
    memset(p, 0, sizeof(UA_HistoryData));
})

UA_INLINABLE( UA_HistoryData *
UA_HistoryData_new(void), {
    return (UA_HistoryData*)UA_new(&UA_TYPES[UA_TYPES_HISTORYDATA]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryData_copy(const UA_HistoryData *src, UA_HistoryData *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYDATA]);
})

UA_INLINABLE( void
UA_HistoryData_clear(UA_HistoryData *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYDATA]);
})

UA_INLINABLE( void
UA_HistoryData_delete(UA_HistoryData *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYDATA]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryData_equal(const UA_HistoryData *p1, const UA_HistoryData *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYDATA]) == UA_ORDER_EQ);
})


/* HistoryReadRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_ExtensionObject historyReadDetails;
    UA_TimestampsToReturn timestampsToReturn;
    UA_Boolean releaseContinuationPoints;
    size_t nodesToReadSize;
    UA_HistoryReadValueId *nodesToRead;
} UA_HistoryReadRequest;

#define UA_TYPES_HISTORYREADREQUEST 307

UA_INLINABLE( void
UA_HistoryReadRequest_init(UA_HistoryReadRequest *p), {
    memset(p, 0, sizeof(UA_HistoryReadRequest));
})

UA_INLINABLE( UA_HistoryReadRequest *
UA_HistoryReadRequest_new(void), {
    return (UA_HistoryReadRequest*)UA_new(&UA_TYPES[UA_TYPES_HISTORYREADREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryReadRequest_copy(const UA_HistoryReadRequest *src, UA_HistoryReadRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYREADREQUEST]);
})

UA_INLINABLE( void
UA_HistoryReadRequest_clear(UA_HistoryReadRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYREADREQUEST]);
})

UA_INLINABLE( void
UA_HistoryReadRequest_delete(UA_HistoryReadRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYREADREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryReadRequest_equal(const UA_HistoryReadRequest *p1, const UA_HistoryReadRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYREADREQUEST]) == UA_ORDER_EQ);
})


/* HistoryReadResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_HistoryReadResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_HistoryReadResponse;

#define UA_TYPES_HISTORYREADRESPONSE 308

UA_INLINABLE( void
UA_HistoryReadResponse_init(UA_HistoryReadResponse *p), {
    memset(p, 0, sizeof(UA_HistoryReadResponse));
})

UA_INLINABLE( UA_HistoryReadResponse *
UA_HistoryReadResponse_new(void), {
    return (UA_HistoryReadResponse*)UA_new(&UA_TYPES[UA_TYPES_HISTORYREADRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryReadResponse_copy(const UA_HistoryReadResponse *src, UA_HistoryReadResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYREADRESPONSE]);
})

UA_INLINABLE( void
UA_HistoryReadResponse_clear(UA_HistoryReadResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYREADRESPONSE]);
})

UA_INLINABLE( void
UA_HistoryReadResponse_delete(UA_HistoryReadResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYREADRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryReadResponse_equal(const UA_HistoryReadResponse *p1, const UA_HistoryReadResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYREADRESPONSE]) == UA_ORDER_EQ);
})


/* WriteValue */
typedef struct {
    UA_NodeId nodeId;
    UA_UInt32 attributeId;
    UA_String indexRange;
    UA_DataValue value;
} UA_WriteValue;

#define UA_TYPES_WRITEVALUE 309

UA_INLINABLE( void
UA_WriteValue_init(UA_WriteValue *p), {
    memset(p, 0, sizeof(UA_WriteValue));
})

UA_INLINABLE( UA_WriteValue *
UA_WriteValue_new(void), {
    return (UA_WriteValue*)UA_new(&UA_TYPES[UA_TYPES_WRITEVALUE]);
})

UA_INLINABLE( UA_StatusCode
UA_WriteValue_copy(const UA_WriteValue *src, UA_WriteValue *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITEVALUE]);
})

UA_INLINABLE( void
UA_WriteValue_clear(UA_WriteValue *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITEVALUE]);
})

UA_INLINABLE( void
UA_WriteValue_delete(UA_WriteValue *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_WRITEVALUE]);
})

UA_INLINABLE( UA_Boolean
UA_WriteValue_equal(const UA_WriteValue *p1, const UA_WriteValue *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_WRITEVALUE]) == UA_ORDER_EQ);
})


/* WriteRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t nodesToWriteSize;
    UA_WriteValue *nodesToWrite;
} UA_WriteRequest;

#define UA_TYPES_WRITEREQUEST 310

UA_INLINABLE( void
UA_WriteRequest_init(UA_WriteRequest *p), {
    memset(p, 0, sizeof(UA_WriteRequest));
})

UA_INLINABLE( UA_WriteRequest *
UA_WriteRequest_new(void), {
    return (UA_WriteRequest*)UA_new(&UA_TYPES[UA_TYPES_WRITEREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_WriteRequest_copy(const UA_WriteRequest *src, UA_WriteRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITEREQUEST]);
})

UA_INLINABLE( void
UA_WriteRequest_clear(UA_WriteRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITEREQUEST]);
})

UA_INLINABLE( void
UA_WriteRequest_delete(UA_WriteRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_WRITEREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_WriteRequest_equal(const UA_WriteRequest *p1, const UA_WriteRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_WRITEREQUEST]) == UA_ORDER_EQ);
})


/* WriteResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_WriteResponse;

#define UA_TYPES_WRITERESPONSE 311

UA_INLINABLE( void
UA_WriteResponse_init(UA_WriteResponse *p), {
    memset(p, 0, sizeof(UA_WriteResponse));
})

UA_INLINABLE( UA_WriteResponse *
UA_WriteResponse_new(void), {
    return (UA_WriteResponse*)UA_new(&UA_TYPES[UA_TYPES_WRITERESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_WriteResponse_copy(const UA_WriteResponse *src, UA_WriteResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITERESPONSE]);
})

UA_INLINABLE( void
UA_WriteResponse_clear(UA_WriteResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITERESPONSE]);
})

UA_INLINABLE( void
UA_WriteResponse_delete(UA_WriteResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_WRITERESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_WriteResponse_equal(const UA_WriteResponse *p1, const UA_WriteResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_WRITERESPONSE]) == UA_ORDER_EQ);
})


/* HistoryUpdateType */
typedef enum {
    UA_HISTORYUPDATETYPE_INSERT = 1,
    UA_HISTORYUPDATETYPE_REPLACE = 2,
    UA_HISTORYUPDATETYPE_UPDATE = 3,
    UA_HISTORYUPDATETYPE_DELETE = 4,
    __UA_HISTORYUPDATETYPE_FORCE32BIT = 0x7fffffff
} UA_HistoryUpdateType;

UA_STATIC_ASSERT(sizeof(UA_HistoryUpdateType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_HISTORYUPDATETYPE 312

UA_INLINABLE( void
UA_HistoryUpdateType_init(UA_HistoryUpdateType *p), {
    memset(p, 0, sizeof(UA_HistoryUpdateType));
})

UA_INLINABLE( UA_HistoryUpdateType *
UA_HistoryUpdateType_new(void), {
    return (UA_HistoryUpdateType*)UA_new(&UA_TYPES[UA_TYPES_HISTORYUPDATETYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryUpdateType_copy(const UA_HistoryUpdateType *src, UA_HistoryUpdateType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYUPDATETYPE]);
})

UA_INLINABLE( void
UA_HistoryUpdateType_clear(UA_HistoryUpdateType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYUPDATETYPE]);
})

UA_INLINABLE( void
UA_HistoryUpdateType_delete(UA_HistoryUpdateType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYUPDATETYPE]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryUpdateType_equal(const UA_HistoryUpdateType *p1, const UA_HistoryUpdateType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYUPDATETYPE]) == UA_ORDER_EQ);
})


/* PerformUpdateType */
typedef enum {
    UA_PERFORMUPDATETYPE_INSERT = 1,
    UA_PERFORMUPDATETYPE_REPLACE = 2,
    UA_PERFORMUPDATETYPE_UPDATE = 3,
    UA_PERFORMUPDATETYPE_REMOVE = 4,
    __UA_PERFORMUPDATETYPE_FORCE32BIT = 0x7fffffff
} UA_PerformUpdateType;

UA_STATIC_ASSERT(sizeof(UA_PerformUpdateType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_PERFORMUPDATETYPE 313

UA_INLINABLE( void
UA_PerformUpdateType_init(UA_PerformUpdateType *p), {
    memset(p, 0, sizeof(UA_PerformUpdateType));
})

UA_INLINABLE( UA_PerformUpdateType *
UA_PerformUpdateType_new(void), {
    return (UA_PerformUpdateType*)UA_new(&UA_TYPES[UA_TYPES_PERFORMUPDATETYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PerformUpdateType_copy(const UA_PerformUpdateType *src, UA_PerformUpdateType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PERFORMUPDATETYPE]);
})

UA_INLINABLE( void
UA_PerformUpdateType_clear(UA_PerformUpdateType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PERFORMUPDATETYPE]);
})

UA_INLINABLE( void
UA_PerformUpdateType_delete(UA_PerformUpdateType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PERFORMUPDATETYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PerformUpdateType_equal(const UA_PerformUpdateType *p1, const UA_PerformUpdateType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PERFORMUPDATETYPE]) == UA_ORDER_EQ);
})


/* UpdateDataDetails */
typedef struct {
    UA_NodeId nodeId;
    UA_PerformUpdateType performInsertReplace;
    size_t updateValuesSize;
    UA_DataValue *updateValues;
} UA_UpdateDataDetails;

#define UA_TYPES_UPDATEDATADETAILS 314

UA_INLINABLE( void
UA_UpdateDataDetails_init(UA_UpdateDataDetails *p), {
    memset(p, 0, sizeof(UA_UpdateDataDetails));
})

UA_INLINABLE( UA_UpdateDataDetails *
UA_UpdateDataDetails_new(void), {
    return (UA_UpdateDataDetails*)UA_new(&UA_TYPES[UA_TYPES_UPDATEDATADETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_UpdateDataDetails_copy(const UA_UpdateDataDetails *src, UA_UpdateDataDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UPDATEDATADETAILS]);
})

UA_INLINABLE( void
UA_UpdateDataDetails_clear(UA_UpdateDataDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UPDATEDATADETAILS]);
})

UA_INLINABLE( void
UA_UpdateDataDetails_delete(UA_UpdateDataDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UPDATEDATADETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_UpdateDataDetails_equal(const UA_UpdateDataDetails *p1, const UA_UpdateDataDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UPDATEDATADETAILS]) == UA_ORDER_EQ);
})


/* UpdateStructureDataDetails */
typedef struct {
    UA_NodeId nodeId;
    UA_PerformUpdateType performInsertReplace;
    size_t updateValuesSize;
    UA_DataValue *updateValues;
} UA_UpdateStructureDataDetails;

#define UA_TYPES_UPDATESTRUCTUREDATADETAILS 315

UA_INLINABLE( void
UA_UpdateStructureDataDetails_init(UA_UpdateStructureDataDetails *p), {
    memset(p, 0, sizeof(UA_UpdateStructureDataDetails));
})

UA_INLINABLE( UA_UpdateStructureDataDetails *
UA_UpdateStructureDataDetails_new(void), {
    return (UA_UpdateStructureDataDetails*)UA_new(&UA_TYPES[UA_TYPES_UPDATESTRUCTUREDATADETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_UpdateStructureDataDetails_copy(const UA_UpdateStructureDataDetails *src, UA_UpdateStructureDataDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UPDATESTRUCTUREDATADETAILS]);
})

UA_INLINABLE( void
UA_UpdateStructureDataDetails_clear(UA_UpdateStructureDataDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UPDATESTRUCTUREDATADETAILS]);
})

UA_INLINABLE( void
UA_UpdateStructureDataDetails_delete(UA_UpdateStructureDataDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UPDATESTRUCTUREDATADETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_UpdateStructureDataDetails_equal(const UA_UpdateStructureDataDetails *p1, const UA_UpdateStructureDataDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UPDATESTRUCTUREDATADETAILS]) == UA_ORDER_EQ);
})


/* DeleteRawModifiedDetails */
typedef struct {
    UA_NodeId nodeId;
    UA_Boolean isDeleteModified;
    UA_DateTime startTime;
    UA_DateTime endTime;
} UA_DeleteRawModifiedDetails;

#define UA_TYPES_DELETERAWMODIFIEDDETAILS 316

UA_INLINABLE( void
UA_DeleteRawModifiedDetails_init(UA_DeleteRawModifiedDetails *p), {
    memset(p, 0, sizeof(UA_DeleteRawModifiedDetails));
})

UA_INLINABLE( UA_DeleteRawModifiedDetails *
UA_DeleteRawModifiedDetails_new(void), {
    return (UA_DeleteRawModifiedDetails*)UA_new(&UA_TYPES[UA_TYPES_DELETERAWMODIFIEDDETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteRawModifiedDetails_copy(const UA_DeleteRawModifiedDetails *src, UA_DeleteRawModifiedDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETERAWMODIFIEDDETAILS]);
})

UA_INLINABLE( void
UA_DeleteRawModifiedDetails_clear(UA_DeleteRawModifiedDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETERAWMODIFIEDDETAILS]);
})

UA_INLINABLE( void
UA_DeleteRawModifiedDetails_delete(UA_DeleteRawModifiedDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETERAWMODIFIEDDETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteRawModifiedDetails_equal(const UA_DeleteRawModifiedDetails *p1, const UA_DeleteRawModifiedDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETERAWMODIFIEDDETAILS]) == UA_ORDER_EQ);
})


/* DeleteAtTimeDetails */
typedef struct {
    UA_NodeId nodeId;
    size_t reqTimesSize;
    UA_DateTime *reqTimes;
} UA_DeleteAtTimeDetails;

#define UA_TYPES_DELETEATTIMEDETAILS 317

UA_INLINABLE( void
UA_DeleteAtTimeDetails_init(UA_DeleteAtTimeDetails *p), {
    memset(p, 0, sizeof(UA_DeleteAtTimeDetails));
})

UA_INLINABLE( UA_DeleteAtTimeDetails *
UA_DeleteAtTimeDetails_new(void), {
    return (UA_DeleteAtTimeDetails*)UA_new(&UA_TYPES[UA_TYPES_DELETEATTIMEDETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteAtTimeDetails_copy(const UA_DeleteAtTimeDetails *src, UA_DeleteAtTimeDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEATTIMEDETAILS]);
})

UA_INLINABLE( void
UA_DeleteAtTimeDetails_clear(UA_DeleteAtTimeDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEATTIMEDETAILS]);
})

UA_INLINABLE( void
UA_DeleteAtTimeDetails_delete(UA_DeleteAtTimeDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEATTIMEDETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteAtTimeDetails_equal(const UA_DeleteAtTimeDetails *p1, const UA_DeleteAtTimeDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETEATTIMEDETAILS]) == UA_ORDER_EQ);
})


/* DeleteEventDetails */
typedef struct {
    UA_NodeId nodeId;
    size_t eventIdsSize;
    UA_ByteString *eventIds;
} UA_DeleteEventDetails;

#define UA_TYPES_DELETEEVENTDETAILS 318

UA_INLINABLE( void
UA_DeleteEventDetails_init(UA_DeleteEventDetails *p), {
    memset(p, 0, sizeof(UA_DeleteEventDetails));
})

UA_INLINABLE( UA_DeleteEventDetails *
UA_DeleteEventDetails_new(void), {
    return (UA_DeleteEventDetails*)UA_new(&UA_TYPES[UA_TYPES_DELETEEVENTDETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteEventDetails_copy(const UA_DeleteEventDetails *src, UA_DeleteEventDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEEVENTDETAILS]);
})

UA_INLINABLE( void
UA_DeleteEventDetails_clear(UA_DeleteEventDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEEVENTDETAILS]);
})

UA_INLINABLE( void
UA_DeleteEventDetails_delete(UA_DeleteEventDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEEVENTDETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteEventDetails_equal(const UA_DeleteEventDetails *p1, const UA_DeleteEventDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETEEVENTDETAILS]) == UA_ORDER_EQ);
})


/* HistoryUpdateResult */
typedef struct {
    UA_StatusCode statusCode;
    size_t operationResultsSize;
    UA_StatusCode *operationResults;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_HistoryUpdateResult;

#define UA_TYPES_HISTORYUPDATERESULT 319

UA_INLINABLE( void
UA_HistoryUpdateResult_init(UA_HistoryUpdateResult *p), {
    memset(p, 0, sizeof(UA_HistoryUpdateResult));
})

UA_INLINABLE( UA_HistoryUpdateResult *
UA_HistoryUpdateResult_new(void), {
    return (UA_HistoryUpdateResult*)UA_new(&UA_TYPES[UA_TYPES_HISTORYUPDATERESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryUpdateResult_copy(const UA_HistoryUpdateResult *src, UA_HistoryUpdateResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYUPDATERESULT]);
})

UA_INLINABLE( void
UA_HistoryUpdateResult_clear(UA_HistoryUpdateResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYUPDATERESULT]);
})

UA_INLINABLE( void
UA_HistoryUpdateResult_delete(UA_HistoryUpdateResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYUPDATERESULT]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryUpdateResult_equal(const UA_HistoryUpdateResult *p1, const UA_HistoryUpdateResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYUPDATERESULT]) == UA_ORDER_EQ);
})


/* HistoryUpdateRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t historyUpdateDetailsSize;
    UA_ExtensionObject *historyUpdateDetails;
} UA_HistoryUpdateRequest;

#define UA_TYPES_HISTORYUPDATEREQUEST 320

UA_INLINABLE( void
UA_HistoryUpdateRequest_init(UA_HistoryUpdateRequest *p), {
    memset(p, 0, sizeof(UA_HistoryUpdateRequest));
})

UA_INLINABLE( UA_HistoryUpdateRequest *
UA_HistoryUpdateRequest_new(void), {
    return (UA_HistoryUpdateRequest*)UA_new(&UA_TYPES[UA_TYPES_HISTORYUPDATEREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryUpdateRequest_copy(const UA_HistoryUpdateRequest *src, UA_HistoryUpdateRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYUPDATEREQUEST]);
})

UA_INLINABLE( void
UA_HistoryUpdateRequest_clear(UA_HistoryUpdateRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYUPDATEREQUEST]);
})

UA_INLINABLE( void
UA_HistoryUpdateRequest_delete(UA_HistoryUpdateRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYUPDATEREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryUpdateRequest_equal(const UA_HistoryUpdateRequest *p1, const UA_HistoryUpdateRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYUPDATEREQUEST]) == UA_ORDER_EQ);
})


/* HistoryUpdateResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_HistoryUpdateResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_HistoryUpdateResponse;

#define UA_TYPES_HISTORYUPDATERESPONSE 321

UA_INLINABLE( void
UA_HistoryUpdateResponse_init(UA_HistoryUpdateResponse *p), {
    memset(p, 0, sizeof(UA_HistoryUpdateResponse));
})

UA_INLINABLE( UA_HistoryUpdateResponse *
UA_HistoryUpdateResponse_new(void), {
    return (UA_HistoryUpdateResponse*)UA_new(&UA_TYPES[UA_TYPES_HISTORYUPDATERESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryUpdateResponse_copy(const UA_HistoryUpdateResponse *src, UA_HistoryUpdateResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYUPDATERESPONSE]);
})

UA_INLINABLE( void
UA_HistoryUpdateResponse_clear(UA_HistoryUpdateResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYUPDATERESPONSE]);
})

UA_INLINABLE( void
UA_HistoryUpdateResponse_delete(UA_HistoryUpdateResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYUPDATERESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryUpdateResponse_equal(const UA_HistoryUpdateResponse *p1, const UA_HistoryUpdateResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYUPDATERESPONSE]) == UA_ORDER_EQ);
})


/* CallMethodRequest */
typedef struct {
    UA_NodeId objectId;
    UA_NodeId methodId;
    size_t inputArgumentsSize;
    UA_Variant *inputArguments;
} UA_CallMethodRequest;

#define UA_TYPES_CALLMETHODREQUEST 322

UA_INLINABLE( void
UA_CallMethodRequest_init(UA_CallMethodRequest *p), {
    memset(p, 0, sizeof(UA_CallMethodRequest));
})

UA_INLINABLE( UA_CallMethodRequest *
UA_CallMethodRequest_new(void), {
    return (UA_CallMethodRequest*)UA_new(&UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_CallMethodRequest_copy(const UA_CallMethodRequest *src, UA_CallMethodRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
})

UA_INLINABLE( void
UA_CallMethodRequest_clear(UA_CallMethodRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
})

UA_INLINABLE( void
UA_CallMethodRequest_delete(UA_CallMethodRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_CallMethodRequest_equal(const UA_CallMethodRequest *p1, const UA_CallMethodRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]) == UA_ORDER_EQ);
})


/* CallMethodResult */
typedef struct {
    UA_StatusCode statusCode;
    size_t inputArgumentResultsSize;
    UA_StatusCode *inputArgumentResults;
    size_t inputArgumentDiagnosticInfosSize;
    UA_DiagnosticInfo *inputArgumentDiagnosticInfos;
    size_t outputArgumentsSize;
    UA_Variant *outputArguments;
} UA_CallMethodResult;

#define UA_TYPES_CALLMETHODRESULT 323

UA_INLINABLE( void
UA_CallMethodResult_init(UA_CallMethodResult *p), {
    memset(p, 0, sizeof(UA_CallMethodResult));
})

UA_INLINABLE( UA_CallMethodResult *
UA_CallMethodResult_new(void), {
    return (UA_CallMethodResult*)UA_new(&UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_CallMethodResult_copy(const UA_CallMethodResult *src, UA_CallMethodResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
})

UA_INLINABLE( void
UA_CallMethodResult_clear(UA_CallMethodResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
})

UA_INLINABLE( void
UA_CallMethodResult_delete(UA_CallMethodResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_CallMethodResult_equal(const UA_CallMethodResult *p1, const UA_CallMethodResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]) == UA_ORDER_EQ);
})


/* CallRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t methodsToCallSize;
    UA_CallMethodRequest *methodsToCall;
} UA_CallRequest;

#define UA_TYPES_CALLREQUEST 324

UA_INLINABLE( void
UA_CallRequest_init(UA_CallRequest *p), {
    memset(p, 0, sizeof(UA_CallRequest));
})

UA_INLINABLE( UA_CallRequest *
UA_CallRequest_new(void), {
    return (UA_CallRequest*)UA_new(&UA_TYPES[UA_TYPES_CALLREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_CallRequest_copy(const UA_CallRequest *src, UA_CallRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLREQUEST]);
})

UA_INLINABLE( void
UA_CallRequest_clear(UA_CallRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLREQUEST]);
})

UA_INLINABLE( void
UA_CallRequest_delete(UA_CallRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CALLREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_CallRequest_equal(const UA_CallRequest *p1, const UA_CallRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CALLREQUEST]) == UA_ORDER_EQ);
})


/* CallResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_CallMethodResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_CallResponse;

#define UA_TYPES_CALLRESPONSE 325

UA_INLINABLE( void
UA_CallResponse_init(UA_CallResponse *p), {
    memset(p, 0, sizeof(UA_CallResponse));
})

UA_INLINABLE( UA_CallResponse *
UA_CallResponse_new(void), {
    return (UA_CallResponse*)UA_new(&UA_TYPES[UA_TYPES_CALLRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_CallResponse_copy(const UA_CallResponse *src, UA_CallResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLRESPONSE]);
})

UA_INLINABLE( void
UA_CallResponse_clear(UA_CallResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CALLRESPONSE]);
})

UA_INLINABLE( void
UA_CallResponse_delete(UA_CallResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CALLRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_CallResponse_equal(const UA_CallResponse *p1, const UA_CallResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CALLRESPONSE]) == UA_ORDER_EQ);
})


/* MonitoringMode */
typedef enum {
    UA_MONITORINGMODE_DISABLED = 0,
    UA_MONITORINGMODE_SAMPLING = 1,
    UA_MONITORINGMODE_REPORTING = 2,
    __UA_MONITORINGMODE_FORCE32BIT = 0x7fffffff
} UA_MonitoringMode;

UA_STATIC_ASSERT(sizeof(UA_MonitoringMode) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_MONITORINGMODE 326

UA_INLINABLE( void
UA_MonitoringMode_init(UA_MonitoringMode *p), {
    memset(p, 0, sizeof(UA_MonitoringMode));
})

UA_INLINABLE( UA_MonitoringMode *
UA_MonitoringMode_new(void), {
    return (UA_MonitoringMode*)UA_new(&UA_TYPES[UA_TYPES_MONITORINGMODE]);
})

UA_INLINABLE( UA_StatusCode
UA_MonitoringMode_copy(const UA_MonitoringMode *src, UA_MonitoringMode *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITORINGMODE]);
})

UA_INLINABLE( void
UA_MonitoringMode_clear(UA_MonitoringMode *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGMODE]);
})

UA_INLINABLE( void
UA_MonitoringMode_delete(UA_MonitoringMode *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITORINGMODE]);
})

UA_INLINABLE( UA_Boolean
UA_MonitoringMode_equal(const UA_MonitoringMode *p1, const UA_MonitoringMode *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MONITORINGMODE]) == UA_ORDER_EQ);
})


/* DataChangeTrigger */
typedef enum {
    UA_DATACHANGETRIGGER_STATUS = 0,
    UA_DATACHANGETRIGGER_STATUSVALUE = 1,
    UA_DATACHANGETRIGGER_STATUSVALUETIMESTAMP = 2,
    __UA_DATACHANGETRIGGER_FORCE32BIT = 0x7fffffff
} UA_DataChangeTrigger;

UA_STATIC_ASSERT(sizeof(UA_DataChangeTrigger) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_DATACHANGETRIGGER 327

UA_INLINABLE( void
UA_DataChangeTrigger_init(UA_DataChangeTrigger *p), {
    memset(p, 0, sizeof(UA_DataChangeTrigger));
})

UA_INLINABLE( UA_DataChangeTrigger *
UA_DataChangeTrigger_new(void), {
    return (UA_DataChangeTrigger*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
})

UA_INLINABLE( UA_StatusCode
UA_DataChangeTrigger_copy(const UA_DataChangeTrigger *src, UA_DataChangeTrigger *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
})

UA_INLINABLE( void
UA_DataChangeTrigger_clear(UA_DataChangeTrigger *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
})

UA_INLINABLE( void
UA_DataChangeTrigger_delete(UA_DataChangeTrigger *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]);
})

UA_INLINABLE( UA_Boolean
UA_DataChangeTrigger_equal(const UA_DataChangeTrigger *p1, const UA_DataChangeTrigger *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]) == UA_ORDER_EQ);
})


/* DeadbandType */
typedef enum {
    UA_DEADBANDTYPE_NONE = 0,
    UA_DEADBANDTYPE_ABSOLUTE = 1,
    UA_DEADBANDTYPE_PERCENT = 2,
    __UA_DEADBANDTYPE_FORCE32BIT = 0x7fffffff
} UA_DeadbandType;

UA_STATIC_ASSERT(sizeof(UA_DeadbandType) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_DEADBANDTYPE 328

UA_INLINABLE( void
UA_DeadbandType_init(UA_DeadbandType *p), {
    memset(p, 0, sizeof(UA_DeadbandType));
})

UA_INLINABLE( UA_DeadbandType *
UA_DeadbandType_new(void), {
    return (UA_DeadbandType*)UA_new(&UA_TYPES[UA_TYPES_DEADBANDTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DeadbandType_copy(const UA_DeadbandType *src, UA_DeadbandType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DEADBANDTYPE]);
})

UA_INLINABLE( void
UA_DeadbandType_clear(UA_DeadbandType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DEADBANDTYPE]);
})

UA_INLINABLE( void
UA_DeadbandType_delete(UA_DeadbandType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DEADBANDTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DeadbandType_equal(const UA_DeadbandType *p1, const UA_DeadbandType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DEADBANDTYPE]) == UA_ORDER_EQ);
})


/* DataChangeFilter */
typedef struct {
    UA_DataChangeTrigger trigger;
    UA_UInt32 deadbandType;
    UA_Double deadbandValue;
} UA_DataChangeFilter;

#define UA_TYPES_DATACHANGEFILTER 329

UA_INLINABLE( void
UA_DataChangeFilter_init(UA_DataChangeFilter *p), {
    memset(p, 0, sizeof(UA_DataChangeFilter));
})

UA_INLINABLE( UA_DataChangeFilter *
UA_DataChangeFilter_new(void), {
    return (UA_DataChangeFilter*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
})

UA_INLINABLE( UA_StatusCode
UA_DataChangeFilter_copy(const UA_DataChangeFilter *src, UA_DataChangeFilter *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
})

UA_INLINABLE( void
UA_DataChangeFilter_clear(UA_DataChangeFilter *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
})

UA_INLINABLE( void
UA_DataChangeFilter_delete(UA_DataChangeFilter *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]);
})

UA_INLINABLE( UA_Boolean
UA_DataChangeFilter_equal(const UA_DataChangeFilter *p1, const UA_DataChangeFilter *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]) == UA_ORDER_EQ);
})


/* EventFilter */
typedef struct {
    size_t selectClausesSize;
    UA_SimpleAttributeOperand *selectClauses;
    UA_ContentFilter whereClause;
} UA_EventFilter;

#define UA_TYPES_EVENTFILTER 330

UA_INLINABLE( void
UA_EventFilter_init(UA_EventFilter *p), {
    memset(p, 0, sizeof(UA_EventFilter));
})

UA_INLINABLE( UA_EventFilter *
UA_EventFilter_new(void), {
    return (UA_EventFilter*)UA_new(&UA_TYPES[UA_TYPES_EVENTFILTER]);
})

UA_INLINABLE( UA_StatusCode
UA_EventFilter_copy(const UA_EventFilter *src, UA_EventFilter *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFILTER]);
})

UA_INLINABLE( void
UA_EventFilter_clear(UA_EventFilter *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTER]);
})

UA_INLINABLE( void
UA_EventFilter_delete(UA_EventFilter *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFILTER]);
})

UA_INLINABLE( UA_Boolean
UA_EventFilter_equal(const UA_EventFilter *p1, const UA_EventFilter *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EVENTFILTER]) == UA_ORDER_EQ);
})


/* AggregateConfiguration */
typedef struct {
    UA_Boolean useServerCapabilitiesDefaults;
    UA_Boolean treatUncertainAsBad;
    UA_Byte percentDataBad;
    UA_Byte percentDataGood;
    UA_Boolean useSlopedExtrapolation;
} UA_AggregateConfiguration;

#define UA_TYPES_AGGREGATECONFIGURATION 331

UA_INLINABLE( void
UA_AggregateConfiguration_init(UA_AggregateConfiguration *p), {
    memset(p, 0, sizeof(UA_AggregateConfiguration));
})

UA_INLINABLE( UA_AggregateConfiguration *
UA_AggregateConfiguration_new(void), {
    return (UA_AggregateConfiguration*)UA_new(&UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
})

UA_INLINABLE( UA_StatusCode
UA_AggregateConfiguration_copy(const UA_AggregateConfiguration *src, UA_AggregateConfiguration *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
})

UA_INLINABLE( void
UA_AggregateConfiguration_clear(UA_AggregateConfiguration *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
})

UA_INLINABLE( void
UA_AggregateConfiguration_delete(UA_AggregateConfiguration *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]);
})

UA_INLINABLE( UA_Boolean
UA_AggregateConfiguration_equal(const UA_AggregateConfiguration *p1, const UA_AggregateConfiguration *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]) == UA_ORDER_EQ);
})


/* AggregateFilter */
typedef struct {
    UA_DateTime startTime;
    UA_NodeId aggregateType;
    UA_Double processingInterval;
    UA_AggregateConfiguration aggregateConfiguration;
} UA_AggregateFilter;

#define UA_TYPES_AGGREGATEFILTER 332

UA_INLINABLE( void
UA_AggregateFilter_init(UA_AggregateFilter *p), {
    memset(p, 0, sizeof(UA_AggregateFilter));
})

UA_INLINABLE( UA_AggregateFilter *
UA_AggregateFilter_new(void), {
    return (UA_AggregateFilter*)UA_new(&UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
})

UA_INLINABLE( UA_StatusCode
UA_AggregateFilter_copy(const UA_AggregateFilter *src, UA_AggregateFilter *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
})

UA_INLINABLE( void
UA_AggregateFilter_clear(UA_AggregateFilter *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
})

UA_INLINABLE( void
UA_AggregateFilter_delete(UA_AggregateFilter *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]);
})

UA_INLINABLE( UA_Boolean
UA_AggregateFilter_equal(const UA_AggregateFilter *p1, const UA_AggregateFilter *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]) == UA_ORDER_EQ);
})


/* EventFilterResult */
typedef struct {
    size_t selectClauseResultsSize;
    UA_StatusCode *selectClauseResults;
    size_t selectClauseDiagnosticInfosSize;
    UA_DiagnosticInfo *selectClauseDiagnosticInfos;
    UA_ContentFilterResult whereClauseResult;
} UA_EventFilterResult;

#define UA_TYPES_EVENTFILTERRESULT 333

UA_INLINABLE( void
UA_EventFilterResult_init(UA_EventFilterResult *p), {
    memset(p, 0, sizeof(UA_EventFilterResult));
})

UA_INLINABLE( UA_EventFilterResult *
UA_EventFilterResult_new(void), {
    return (UA_EventFilterResult*)UA_new(&UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_EventFilterResult_copy(const UA_EventFilterResult *src, UA_EventFilterResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
})

UA_INLINABLE( void
UA_EventFilterResult_clear(UA_EventFilterResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
})

UA_INLINABLE( void
UA_EventFilterResult_delete(UA_EventFilterResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_EventFilterResult_equal(const UA_EventFilterResult *p1, const UA_EventFilterResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]) == UA_ORDER_EQ);
})


/* AggregateFilterResult */
typedef struct {
    UA_DateTime revisedStartTime;
    UA_Double revisedProcessingInterval;
    UA_AggregateConfiguration revisedAggregateConfiguration;
} UA_AggregateFilterResult;

#define UA_TYPES_AGGREGATEFILTERRESULT 334

UA_INLINABLE( void
UA_AggregateFilterResult_init(UA_AggregateFilterResult *p), {
    memset(p, 0, sizeof(UA_AggregateFilterResult));
})

UA_INLINABLE( UA_AggregateFilterResult *
UA_AggregateFilterResult_new(void), {
    return (UA_AggregateFilterResult*)UA_new(&UA_TYPES[UA_TYPES_AGGREGATEFILTERRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_AggregateFilterResult_copy(const UA_AggregateFilterResult *src, UA_AggregateFilterResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AGGREGATEFILTERRESULT]);
})

UA_INLINABLE( void
UA_AggregateFilterResult_clear(UA_AggregateFilterResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTERRESULT]);
})

UA_INLINABLE( void
UA_AggregateFilterResult_delete(UA_AggregateFilterResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTERRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_AggregateFilterResult_equal(const UA_AggregateFilterResult *p1, const UA_AggregateFilterResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_AGGREGATEFILTERRESULT]) == UA_ORDER_EQ);
})


/* MonitoringParameters */
typedef struct {
    UA_UInt32 clientHandle;
    UA_Double samplingInterval;
    UA_ExtensionObject filter;
    UA_UInt32 queueSize;
    UA_Boolean discardOldest;
} UA_MonitoringParameters;

#define UA_TYPES_MONITORINGPARAMETERS 335

UA_INLINABLE( void
UA_MonitoringParameters_init(UA_MonitoringParameters *p), {
    memset(p, 0, sizeof(UA_MonitoringParameters));
})

UA_INLINABLE( UA_MonitoringParameters *
UA_MonitoringParameters_new(void), {
    return (UA_MonitoringParameters*)UA_new(&UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
})

UA_INLINABLE( UA_StatusCode
UA_MonitoringParameters_copy(const UA_MonitoringParameters *src, UA_MonitoringParameters *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
})

UA_INLINABLE( void
UA_MonitoringParameters_clear(UA_MonitoringParameters *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
})

UA_INLINABLE( void
UA_MonitoringParameters_delete(UA_MonitoringParameters *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]);
})

UA_INLINABLE( UA_Boolean
UA_MonitoringParameters_equal(const UA_MonitoringParameters *p1, const UA_MonitoringParameters *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]) == UA_ORDER_EQ);
})


/* MonitoredItemCreateRequest */
typedef struct {
    UA_ReadValueId itemToMonitor;
    UA_MonitoringMode monitoringMode;
    UA_MonitoringParameters requestedParameters;
} UA_MonitoredItemCreateRequest;

#define UA_TYPES_MONITOREDITEMCREATEREQUEST 336

UA_INLINABLE( void
UA_MonitoredItemCreateRequest_init(UA_MonitoredItemCreateRequest *p), {
    memset(p, 0, sizeof(UA_MonitoredItemCreateRequest));
})

UA_INLINABLE( UA_MonitoredItemCreateRequest *
UA_MonitoredItemCreateRequest_new(void), {
    return (UA_MonitoredItemCreateRequest*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_MonitoredItemCreateRequest_copy(const UA_MonitoredItemCreateRequest *src, UA_MonitoredItemCreateRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
})

UA_INLINABLE( void
UA_MonitoredItemCreateRequest_clear(UA_MonitoredItemCreateRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
})

UA_INLINABLE( void
UA_MonitoredItemCreateRequest_delete(UA_MonitoredItemCreateRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_MonitoredItemCreateRequest_equal(const UA_MonitoredItemCreateRequest *p1, const UA_MonitoredItemCreateRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]) == UA_ORDER_EQ);
})


/* MonitoredItemCreateResult */
typedef struct {
    UA_StatusCode statusCode;
    UA_UInt32 monitoredItemId;
    UA_Double revisedSamplingInterval;
    UA_UInt32 revisedQueueSize;
    UA_ExtensionObject filterResult;
} UA_MonitoredItemCreateResult;

#define UA_TYPES_MONITOREDITEMCREATERESULT 337

UA_INLINABLE( void
UA_MonitoredItemCreateResult_init(UA_MonitoredItemCreateResult *p), {
    memset(p, 0, sizeof(UA_MonitoredItemCreateResult));
})

UA_INLINABLE( UA_MonitoredItemCreateResult *
UA_MonitoredItemCreateResult_new(void), {
    return (UA_MonitoredItemCreateResult*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_MonitoredItemCreateResult_copy(const UA_MonitoredItemCreateResult *src, UA_MonitoredItemCreateResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
})

UA_INLINABLE( void
UA_MonitoredItemCreateResult_clear(UA_MonitoredItemCreateResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
})

UA_INLINABLE( void
UA_MonitoredItemCreateResult_delete(UA_MonitoredItemCreateResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]);
})

UA_INLINABLE( UA_Boolean
UA_MonitoredItemCreateResult_equal(const UA_MonitoredItemCreateResult *p1, const UA_MonitoredItemCreateResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]) == UA_ORDER_EQ);
})


/* CreateMonitoredItemsRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 subscriptionId;
    UA_TimestampsToReturn timestampsToReturn;
    size_t itemsToCreateSize;
    UA_MonitoredItemCreateRequest *itemsToCreate;
} UA_CreateMonitoredItemsRequest;

#define UA_TYPES_CREATEMONITOREDITEMSREQUEST 338

UA_INLINABLE( void
UA_CreateMonitoredItemsRequest_init(UA_CreateMonitoredItemsRequest *p), {
    memset(p, 0, sizeof(UA_CreateMonitoredItemsRequest));
})

UA_INLINABLE( UA_CreateMonitoredItemsRequest *
UA_CreateMonitoredItemsRequest_new(void), {
    return (UA_CreateMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_CreateMonitoredItemsRequest_copy(const UA_CreateMonitoredItemsRequest *src, UA_CreateMonitoredItemsRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( void
UA_CreateMonitoredItemsRequest_clear(UA_CreateMonitoredItemsRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( void
UA_CreateMonitoredItemsRequest_delete(UA_CreateMonitoredItemsRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_CreateMonitoredItemsRequest_equal(const UA_CreateMonitoredItemsRequest *p1, const UA_CreateMonitoredItemsRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]) == UA_ORDER_EQ);
})


/* CreateMonitoredItemsResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_MonitoredItemCreateResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_CreateMonitoredItemsResponse;

#define UA_TYPES_CREATEMONITOREDITEMSRESPONSE 339

UA_INLINABLE( void
UA_CreateMonitoredItemsResponse_init(UA_CreateMonitoredItemsResponse *p), {
    memset(p, 0, sizeof(UA_CreateMonitoredItemsResponse));
})

UA_INLINABLE( UA_CreateMonitoredItemsResponse *
UA_CreateMonitoredItemsResponse_new(void), {
    return (UA_CreateMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_CreateMonitoredItemsResponse_copy(const UA_CreateMonitoredItemsResponse *src, UA_CreateMonitoredItemsResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( void
UA_CreateMonitoredItemsResponse_clear(UA_CreateMonitoredItemsResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( void
UA_CreateMonitoredItemsResponse_delete(UA_CreateMonitoredItemsResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_CreateMonitoredItemsResponse_equal(const UA_CreateMonitoredItemsResponse *p1, const UA_CreateMonitoredItemsResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]) == UA_ORDER_EQ);
})


/* MonitoredItemModifyRequest */
typedef struct {
    UA_UInt32 monitoredItemId;
    UA_MonitoringParameters requestedParameters;
} UA_MonitoredItemModifyRequest;

#define UA_TYPES_MONITOREDITEMMODIFYREQUEST 340

UA_INLINABLE( void
UA_MonitoredItemModifyRequest_init(UA_MonitoredItemModifyRequest *p), {
    memset(p, 0, sizeof(UA_MonitoredItemModifyRequest));
})

UA_INLINABLE( UA_MonitoredItemModifyRequest *
UA_MonitoredItemModifyRequest_new(void), {
    return (UA_MonitoredItemModifyRequest*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_MonitoredItemModifyRequest_copy(const UA_MonitoredItemModifyRequest *src, UA_MonitoredItemModifyRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
})

UA_INLINABLE( void
UA_MonitoredItemModifyRequest_clear(UA_MonitoredItemModifyRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
})

UA_INLINABLE( void
UA_MonitoredItemModifyRequest_delete(UA_MonitoredItemModifyRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_MonitoredItemModifyRequest_equal(const UA_MonitoredItemModifyRequest *p1, const UA_MonitoredItemModifyRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]) == UA_ORDER_EQ);
})


/* MonitoredItemModifyResult */
typedef struct {
    UA_StatusCode statusCode;
    UA_Double revisedSamplingInterval;
    UA_UInt32 revisedQueueSize;
    UA_ExtensionObject filterResult;
} UA_MonitoredItemModifyResult;

#define UA_TYPES_MONITOREDITEMMODIFYRESULT 341

UA_INLINABLE( void
UA_MonitoredItemModifyResult_init(UA_MonitoredItemModifyResult *p), {
    memset(p, 0, sizeof(UA_MonitoredItemModifyResult));
})

UA_INLINABLE( UA_MonitoredItemModifyResult *
UA_MonitoredItemModifyResult_new(void), {
    return (UA_MonitoredItemModifyResult*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_MonitoredItemModifyResult_copy(const UA_MonitoredItemModifyResult *src, UA_MonitoredItemModifyResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
})

UA_INLINABLE( void
UA_MonitoredItemModifyResult_clear(UA_MonitoredItemModifyResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
})

UA_INLINABLE( void
UA_MonitoredItemModifyResult_delete(UA_MonitoredItemModifyResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_MonitoredItemModifyResult_equal(const UA_MonitoredItemModifyResult *p1, const UA_MonitoredItemModifyResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]) == UA_ORDER_EQ);
})


/* ModifyMonitoredItemsRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 subscriptionId;
    UA_TimestampsToReturn timestampsToReturn;
    size_t itemsToModifySize;
    UA_MonitoredItemModifyRequest *itemsToModify;
} UA_ModifyMonitoredItemsRequest;

#define UA_TYPES_MODIFYMONITOREDITEMSREQUEST 342

UA_INLINABLE( void
UA_ModifyMonitoredItemsRequest_init(UA_ModifyMonitoredItemsRequest *p), {
    memset(p, 0, sizeof(UA_ModifyMonitoredItemsRequest));
})

UA_INLINABLE( UA_ModifyMonitoredItemsRequest *
UA_ModifyMonitoredItemsRequest_new(void), {
    return (UA_ModifyMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_ModifyMonitoredItemsRequest_copy(const UA_ModifyMonitoredItemsRequest *src, UA_ModifyMonitoredItemsRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( void
UA_ModifyMonitoredItemsRequest_clear(UA_ModifyMonitoredItemsRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( void
UA_ModifyMonitoredItemsRequest_delete(UA_ModifyMonitoredItemsRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_ModifyMonitoredItemsRequest_equal(const UA_ModifyMonitoredItemsRequest *p1, const UA_ModifyMonitoredItemsRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]) == UA_ORDER_EQ);
})


/* ModifyMonitoredItemsResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_MonitoredItemModifyResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_ModifyMonitoredItemsResponse;

#define UA_TYPES_MODIFYMONITOREDITEMSRESPONSE 343

UA_INLINABLE( void
UA_ModifyMonitoredItemsResponse_init(UA_ModifyMonitoredItemsResponse *p), {
    memset(p, 0, sizeof(UA_ModifyMonitoredItemsResponse));
})

UA_INLINABLE( UA_ModifyMonitoredItemsResponse *
UA_ModifyMonitoredItemsResponse_new(void), {
    return (UA_ModifyMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_ModifyMonitoredItemsResponse_copy(const UA_ModifyMonitoredItemsResponse *src, UA_ModifyMonitoredItemsResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( void
UA_ModifyMonitoredItemsResponse_clear(UA_ModifyMonitoredItemsResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( void
UA_ModifyMonitoredItemsResponse_delete(UA_ModifyMonitoredItemsResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_ModifyMonitoredItemsResponse_equal(const UA_ModifyMonitoredItemsResponse *p1, const UA_ModifyMonitoredItemsResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]) == UA_ORDER_EQ);
})


/* SetMonitoringModeRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 subscriptionId;
    UA_MonitoringMode monitoringMode;
    size_t monitoredItemIdsSize;
    UA_UInt32 *monitoredItemIds;
} UA_SetMonitoringModeRequest;

#define UA_TYPES_SETMONITORINGMODEREQUEST 344

UA_INLINABLE( void
UA_SetMonitoringModeRequest_init(UA_SetMonitoringModeRequest *p), {
    memset(p, 0, sizeof(UA_SetMonitoringModeRequest));
})

UA_INLINABLE( UA_SetMonitoringModeRequest *
UA_SetMonitoringModeRequest_new(void), {
    return (UA_SetMonitoringModeRequest*)UA_new(&UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_SetMonitoringModeRequest_copy(const UA_SetMonitoringModeRequest *src, UA_SetMonitoringModeRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
})

UA_INLINABLE( void
UA_SetMonitoringModeRequest_clear(UA_SetMonitoringModeRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
})

UA_INLINABLE( void
UA_SetMonitoringModeRequest_delete(UA_SetMonitoringModeRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_SetMonitoringModeRequest_equal(const UA_SetMonitoringModeRequest *p1, const UA_SetMonitoringModeRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]) == UA_ORDER_EQ);
})


/* SetMonitoringModeResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_SetMonitoringModeResponse;

#define UA_TYPES_SETMONITORINGMODERESPONSE 345

UA_INLINABLE( void
UA_SetMonitoringModeResponse_init(UA_SetMonitoringModeResponse *p), {
    memset(p, 0, sizeof(UA_SetMonitoringModeResponse));
})

UA_INLINABLE( UA_SetMonitoringModeResponse *
UA_SetMonitoringModeResponse_new(void), {
    return (UA_SetMonitoringModeResponse*)UA_new(&UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_SetMonitoringModeResponse_copy(const UA_SetMonitoringModeResponse *src, UA_SetMonitoringModeResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
})

UA_INLINABLE( void
UA_SetMonitoringModeResponse_clear(UA_SetMonitoringModeResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
})

UA_INLINABLE( void
UA_SetMonitoringModeResponse_delete(UA_SetMonitoringModeResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_SetMonitoringModeResponse_equal(const UA_SetMonitoringModeResponse *p1, const UA_SetMonitoringModeResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]) == UA_ORDER_EQ);
})


/* SetTriggeringRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 subscriptionId;
    UA_UInt32 triggeringItemId;
    size_t linksToAddSize;
    UA_UInt32 *linksToAdd;
    size_t linksToRemoveSize;
    UA_UInt32 *linksToRemove;
} UA_SetTriggeringRequest;

#define UA_TYPES_SETTRIGGERINGREQUEST 346

UA_INLINABLE( void
UA_SetTriggeringRequest_init(UA_SetTriggeringRequest *p), {
    memset(p, 0, sizeof(UA_SetTriggeringRequest));
})

UA_INLINABLE( UA_SetTriggeringRequest *
UA_SetTriggeringRequest_new(void), {
    return (UA_SetTriggeringRequest*)UA_new(&UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_SetTriggeringRequest_copy(const UA_SetTriggeringRequest *src, UA_SetTriggeringRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
})

UA_INLINABLE( void
UA_SetTriggeringRequest_clear(UA_SetTriggeringRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
})

UA_INLINABLE( void
UA_SetTriggeringRequest_delete(UA_SetTriggeringRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_SetTriggeringRequest_equal(const UA_SetTriggeringRequest *p1, const UA_SetTriggeringRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]) == UA_ORDER_EQ);
})


/* SetTriggeringResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t addResultsSize;
    UA_StatusCode *addResults;
    size_t addDiagnosticInfosSize;
    UA_DiagnosticInfo *addDiagnosticInfos;
    size_t removeResultsSize;
    UA_StatusCode *removeResults;
    size_t removeDiagnosticInfosSize;
    UA_DiagnosticInfo *removeDiagnosticInfos;
} UA_SetTriggeringResponse;

#define UA_TYPES_SETTRIGGERINGRESPONSE 347

UA_INLINABLE( void
UA_SetTriggeringResponse_init(UA_SetTriggeringResponse *p), {
    memset(p, 0, sizeof(UA_SetTriggeringResponse));
})

UA_INLINABLE( UA_SetTriggeringResponse *
UA_SetTriggeringResponse_new(void), {
    return (UA_SetTriggeringResponse*)UA_new(&UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_SetTriggeringResponse_copy(const UA_SetTriggeringResponse *src, UA_SetTriggeringResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
})

UA_INLINABLE( void
UA_SetTriggeringResponse_clear(UA_SetTriggeringResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
})

UA_INLINABLE( void
UA_SetTriggeringResponse_delete(UA_SetTriggeringResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_SetTriggeringResponse_equal(const UA_SetTriggeringResponse *p1, const UA_SetTriggeringResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]) == UA_ORDER_EQ);
})


/* DeleteMonitoredItemsRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 subscriptionId;
    size_t monitoredItemIdsSize;
    UA_UInt32 *monitoredItemIds;
} UA_DeleteMonitoredItemsRequest;

#define UA_TYPES_DELETEMONITOREDITEMSREQUEST 348

UA_INLINABLE( void
UA_DeleteMonitoredItemsRequest_init(UA_DeleteMonitoredItemsRequest *p), {
    memset(p, 0, sizeof(UA_DeleteMonitoredItemsRequest));
})

UA_INLINABLE( UA_DeleteMonitoredItemsRequest *
UA_DeleteMonitoredItemsRequest_new(void), {
    return (UA_DeleteMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteMonitoredItemsRequest_copy(const UA_DeleteMonitoredItemsRequest *src, UA_DeleteMonitoredItemsRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( void
UA_DeleteMonitoredItemsRequest_clear(UA_DeleteMonitoredItemsRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( void
UA_DeleteMonitoredItemsRequest_delete(UA_DeleteMonitoredItemsRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteMonitoredItemsRequest_equal(const UA_DeleteMonitoredItemsRequest *p1, const UA_DeleteMonitoredItemsRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]) == UA_ORDER_EQ);
})


/* DeleteMonitoredItemsResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_DeleteMonitoredItemsResponse;

#define UA_TYPES_DELETEMONITOREDITEMSRESPONSE 349

UA_INLINABLE( void
UA_DeleteMonitoredItemsResponse_init(UA_DeleteMonitoredItemsResponse *p), {
    memset(p, 0, sizeof(UA_DeleteMonitoredItemsResponse));
})

UA_INLINABLE( UA_DeleteMonitoredItemsResponse *
UA_DeleteMonitoredItemsResponse_new(void), {
    return (UA_DeleteMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteMonitoredItemsResponse_copy(const UA_DeleteMonitoredItemsResponse *src, UA_DeleteMonitoredItemsResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( void
UA_DeleteMonitoredItemsResponse_clear(UA_DeleteMonitoredItemsResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( void
UA_DeleteMonitoredItemsResponse_delete(UA_DeleteMonitoredItemsResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteMonitoredItemsResponse_equal(const UA_DeleteMonitoredItemsResponse *p1, const UA_DeleteMonitoredItemsResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]) == UA_ORDER_EQ);
})


/* CreateSubscriptionRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_Double requestedPublishingInterval;
    UA_UInt32 requestedLifetimeCount;
    UA_UInt32 requestedMaxKeepAliveCount;
    UA_UInt32 maxNotificationsPerPublish;
    UA_Boolean publishingEnabled;
    UA_Byte priority;
} UA_CreateSubscriptionRequest;

#define UA_TYPES_CREATESUBSCRIPTIONREQUEST 350

UA_INLINABLE( void
UA_CreateSubscriptionRequest_init(UA_CreateSubscriptionRequest *p), {
    memset(p, 0, sizeof(UA_CreateSubscriptionRequest));
})

UA_INLINABLE( UA_CreateSubscriptionRequest *
UA_CreateSubscriptionRequest_new(void), {
    return (UA_CreateSubscriptionRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_CreateSubscriptionRequest_copy(const UA_CreateSubscriptionRequest *src, UA_CreateSubscriptionRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
})

UA_INLINABLE( void
UA_CreateSubscriptionRequest_clear(UA_CreateSubscriptionRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
})

UA_INLINABLE( void
UA_CreateSubscriptionRequest_delete(UA_CreateSubscriptionRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_CreateSubscriptionRequest_equal(const UA_CreateSubscriptionRequest *p1, const UA_CreateSubscriptionRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]) == UA_ORDER_EQ);
})


/* CreateSubscriptionResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_UInt32 subscriptionId;
    UA_Double revisedPublishingInterval;
    UA_UInt32 revisedLifetimeCount;
    UA_UInt32 revisedMaxKeepAliveCount;
} UA_CreateSubscriptionResponse;

#define UA_TYPES_CREATESUBSCRIPTIONRESPONSE 351

UA_INLINABLE( void
UA_CreateSubscriptionResponse_init(UA_CreateSubscriptionResponse *p), {
    memset(p, 0, sizeof(UA_CreateSubscriptionResponse));
})

UA_INLINABLE( UA_CreateSubscriptionResponse *
UA_CreateSubscriptionResponse_new(void), {
    return (UA_CreateSubscriptionResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_CreateSubscriptionResponse_copy(const UA_CreateSubscriptionResponse *src, UA_CreateSubscriptionResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
})

UA_INLINABLE( void
UA_CreateSubscriptionResponse_clear(UA_CreateSubscriptionResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
})

UA_INLINABLE( void
UA_CreateSubscriptionResponse_delete(UA_CreateSubscriptionResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_CreateSubscriptionResponse_equal(const UA_CreateSubscriptionResponse *p1, const UA_CreateSubscriptionResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]) == UA_ORDER_EQ);
})


/* ModifySubscriptionRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 subscriptionId;
    UA_Double requestedPublishingInterval;
    UA_UInt32 requestedLifetimeCount;
    UA_UInt32 requestedMaxKeepAliveCount;
    UA_UInt32 maxNotificationsPerPublish;
    UA_Byte priority;
} UA_ModifySubscriptionRequest;

#define UA_TYPES_MODIFYSUBSCRIPTIONREQUEST 352

UA_INLINABLE( void
UA_ModifySubscriptionRequest_init(UA_ModifySubscriptionRequest *p), {
    memset(p, 0, sizeof(UA_ModifySubscriptionRequest));
})

UA_INLINABLE( UA_ModifySubscriptionRequest *
UA_ModifySubscriptionRequest_new(void), {
    return (UA_ModifySubscriptionRequest*)UA_new(&UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_ModifySubscriptionRequest_copy(const UA_ModifySubscriptionRequest *src, UA_ModifySubscriptionRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
})

UA_INLINABLE( void
UA_ModifySubscriptionRequest_clear(UA_ModifySubscriptionRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
})

UA_INLINABLE( void
UA_ModifySubscriptionRequest_delete(UA_ModifySubscriptionRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_ModifySubscriptionRequest_equal(const UA_ModifySubscriptionRequest *p1, const UA_ModifySubscriptionRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]) == UA_ORDER_EQ);
})


/* ModifySubscriptionResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_Double revisedPublishingInterval;
    UA_UInt32 revisedLifetimeCount;
    UA_UInt32 revisedMaxKeepAliveCount;
} UA_ModifySubscriptionResponse;

#define UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE 353

UA_INLINABLE( void
UA_ModifySubscriptionResponse_init(UA_ModifySubscriptionResponse *p), {
    memset(p, 0, sizeof(UA_ModifySubscriptionResponse));
})

UA_INLINABLE( UA_ModifySubscriptionResponse *
UA_ModifySubscriptionResponse_new(void), {
    return (UA_ModifySubscriptionResponse*)UA_new(&UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_ModifySubscriptionResponse_copy(const UA_ModifySubscriptionResponse *src, UA_ModifySubscriptionResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
})

UA_INLINABLE( void
UA_ModifySubscriptionResponse_clear(UA_ModifySubscriptionResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
})

UA_INLINABLE( void
UA_ModifySubscriptionResponse_delete(UA_ModifySubscriptionResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_ModifySubscriptionResponse_equal(const UA_ModifySubscriptionResponse *p1, const UA_ModifySubscriptionResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]) == UA_ORDER_EQ);
})


/* SetPublishingModeRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_Boolean publishingEnabled;
    size_t subscriptionIdsSize;
    UA_UInt32 *subscriptionIds;
} UA_SetPublishingModeRequest;

#define UA_TYPES_SETPUBLISHINGMODEREQUEST 354

UA_INLINABLE( void
UA_SetPublishingModeRequest_init(UA_SetPublishingModeRequest *p), {
    memset(p, 0, sizeof(UA_SetPublishingModeRequest));
})

UA_INLINABLE( UA_SetPublishingModeRequest *
UA_SetPublishingModeRequest_new(void), {
    return (UA_SetPublishingModeRequest*)UA_new(&UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_SetPublishingModeRequest_copy(const UA_SetPublishingModeRequest *src, UA_SetPublishingModeRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
})

UA_INLINABLE( void
UA_SetPublishingModeRequest_clear(UA_SetPublishingModeRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
})

UA_INLINABLE( void
UA_SetPublishingModeRequest_delete(UA_SetPublishingModeRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_SetPublishingModeRequest_equal(const UA_SetPublishingModeRequest *p1, const UA_SetPublishingModeRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]) == UA_ORDER_EQ);
})


/* SetPublishingModeResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_SetPublishingModeResponse;

#define UA_TYPES_SETPUBLISHINGMODERESPONSE 355

UA_INLINABLE( void
UA_SetPublishingModeResponse_init(UA_SetPublishingModeResponse *p), {
    memset(p, 0, sizeof(UA_SetPublishingModeResponse));
})

UA_INLINABLE( UA_SetPublishingModeResponse *
UA_SetPublishingModeResponse_new(void), {
    return (UA_SetPublishingModeResponse*)UA_new(&UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_SetPublishingModeResponse_copy(const UA_SetPublishingModeResponse *src, UA_SetPublishingModeResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
})

UA_INLINABLE( void
UA_SetPublishingModeResponse_clear(UA_SetPublishingModeResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
})

UA_INLINABLE( void
UA_SetPublishingModeResponse_delete(UA_SetPublishingModeResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_SetPublishingModeResponse_equal(const UA_SetPublishingModeResponse *p1, const UA_SetPublishingModeResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]) == UA_ORDER_EQ);
})


/* NotificationMessage */
typedef struct {
    UA_UInt32 sequenceNumber;
    UA_DateTime publishTime;
    size_t notificationDataSize;
    UA_ExtensionObject *notificationData;
} UA_NotificationMessage;

#define UA_TYPES_NOTIFICATIONMESSAGE 356

UA_INLINABLE( void
UA_NotificationMessage_init(UA_NotificationMessage *p), {
    memset(p, 0, sizeof(UA_NotificationMessage));
})

UA_INLINABLE( UA_NotificationMessage *
UA_NotificationMessage_new(void), {
    return (UA_NotificationMessage*)UA_new(&UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_NotificationMessage_copy(const UA_NotificationMessage *src, UA_NotificationMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
})

UA_INLINABLE( void
UA_NotificationMessage_clear(UA_NotificationMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
})

UA_INLINABLE( void
UA_NotificationMessage_delete(UA_NotificationMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_NotificationMessage_equal(const UA_NotificationMessage *p1, const UA_NotificationMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]) == UA_ORDER_EQ);
})


/* MonitoredItemNotification */
typedef struct {
    UA_UInt32 clientHandle;
    UA_DataValue value;
} UA_MonitoredItemNotification;

#define UA_TYPES_MONITOREDITEMNOTIFICATION 357

UA_INLINABLE( void
UA_MonitoredItemNotification_init(UA_MonitoredItemNotification *p), {
    memset(p, 0, sizeof(UA_MonitoredItemNotification));
})

UA_INLINABLE( UA_MonitoredItemNotification *
UA_MonitoredItemNotification_new(void), {
    return (UA_MonitoredItemNotification*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
})

UA_INLINABLE( UA_StatusCode
UA_MonitoredItemNotification_copy(const UA_MonitoredItemNotification *src, UA_MonitoredItemNotification *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
})

UA_INLINABLE( void
UA_MonitoredItemNotification_clear(UA_MonitoredItemNotification *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
})

UA_INLINABLE( void
UA_MonitoredItemNotification_delete(UA_MonitoredItemNotification *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]);
})

UA_INLINABLE( UA_Boolean
UA_MonitoredItemNotification_equal(const UA_MonitoredItemNotification *p1, const UA_MonitoredItemNotification *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]) == UA_ORDER_EQ);
})


/* EventFieldList */
typedef struct {
    UA_UInt32 clientHandle;
    size_t eventFieldsSize;
    UA_Variant *eventFields;
} UA_EventFieldList;

#define UA_TYPES_EVENTFIELDLIST 358

UA_INLINABLE( void
UA_EventFieldList_init(UA_EventFieldList *p), {
    memset(p, 0, sizeof(UA_EventFieldList));
})

UA_INLINABLE( UA_EventFieldList *
UA_EventFieldList_new(void), {
    return (UA_EventFieldList*)UA_new(&UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
})

UA_INLINABLE( UA_StatusCode
UA_EventFieldList_copy(const UA_EventFieldList *src, UA_EventFieldList *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
})

UA_INLINABLE( void
UA_EventFieldList_clear(UA_EventFieldList *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
})

UA_INLINABLE( void
UA_EventFieldList_delete(UA_EventFieldList *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]);
})

UA_INLINABLE( UA_Boolean
UA_EventFieldList_equal(const UA_EventFieldList *p1, const UA_EventFieldList *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]) == UA_ORDER_EQ);
})


/* HistoryEventFieldList */
typedef struct {
    size_t eventFieldsSize;
    UA_Variant *eventFields;
} UA_HistoryEventFieldList;

#define UA_TYPES_HISTORYEVENTFIELDLIST 359

UA_INLINABLE( void
UA_HistoryEventFieldList_init(UA_HistoryEventFieldList *p), {
    memset(p, 0, sizeof(UA_HistoryEventFieldList));
})

UA_INLINABLE( UA_HistoryEventFieldList *
UA_HistoryEventFieldList_new(void), {
    return (UA_HistoryEventFieldList*)UA_new(&UA_TYPES[UA_TYPES_HISTORYEVENTFIELDLIST]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryEventFieldList_copy(const UA_HistoryEventFieldList *src, UA_HistoryEventFieldList *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYEVENTFIELDLIST]);
})

UA_INLINABLE( void
UA_HistoryEventFieldList_clear(UA_HistoryEventFieldList *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYEVENTFIELDLIST]);
})

UA_INLINABLE( void
UA_HistoryEventFieldList_delete(UA_HistoryEventFieldList *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYEVENTFIELDLIST]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryEventFieldList_equal(const UA_HistoryEventFieldList *p1, const UA_HistoryEventFieldList *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYEVENTFIELDLIST]) == UA_ORDER_EQ);
})


/* StatusChangeNotification */
typedef struct {
    UA_StatusCode status;
    UA_DiagnosticInfo diagnosticInfo;
} UA_StatusChangeNotification;

#define UA_TYPES_STATUSCHANGENOTIFICATION 360

UA_INLINABLE( void
UA_StatusChangeNotification_init(UA_StatusChangeNotification *p), {
    memset(p, 0, sizeof(UA_StatusChangeNotification));
})

UA_INLINABLE( UA_StatusChangeNotification *
UA_StatusChangeNotification_new(void), {
    return (UA_StatusChangeNotification*)UA_new(&UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
})

UA_INLINABLE( UA_StatusCode
UA_StatusChangeNotification_copy(const UA_StatusChangeNotification *src, UA_StatusChangeNotification *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
})

UA_INLINABLE( void
UA_StatusChangeNotification_clear(UA_StatusChangeNotification *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
})

UA_INLINABLE( void
UA_StatusChangeNotification_delete(UA_StatusChangeNotification *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]);
})

UA_INLINABLE( UA_Boolean
UA_StatusChangeNotification_equal(const UA_StatusChangeNotification *p1, const UA_StatusChangeNotification *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]) == UA_ORDER_EQ);
})


/* SubscriptionAcknowledgement */
typedef struct {
    UA_UInt32 subscriptionId;
    UA_UInt32 sequenceNumber;
} UA_SubscriptionAcknowledgement;

#define UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT 361

UA_INLINABLE( void
UA_SubscriptionAcknowledgement_init(UA_SubscriptionAcknowledgement *p), {
    memset(p, 0, sizeof(UA_SubscriptionAcknowledgement));
})

UA_INLINABLE( UA_SubscriptionAcknowledgement *
UA_SubscriptionAcknowledgement_new(void), {
    return (UA_SubscriptionAcknowledgement*)UA_new(&UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
})

UA_INLINABLE( UA_StatusCode
UA_SubscriptionAcknowledgement_copy(const UA_SubscriptionAcknowledgement *src, UA_SubscriptionAcknowledgement *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
})

UA_INLINABLE( void
UA_SubscriptionAcknowledgement_clear(UA_SubscriptionAcknowledgement *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
})

UA_INLINABLE( void
UA_SubscriptionAcknowledgement_delete(UA_SubscriptionAcknowledgement *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]);
})

UA_INLINABLE( UA_Boolean
UA_SubscriptionAcknowledgement_equal(const UA_SubscriptionAcknowledgement *p1, const UA_SubscriptionAcknowledgement *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]) == UA_ORDER_EQ);
})


/* PublishRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t subscriptionAcknowledgementsSize;
    UA_SubscriptionAcknowledgement *subscriptionAcknowledgements;
} UA_PublishRequest;

#define UA_TYPES_PUBLISHREQUEST 362

UA_INLINABLE( void
UA_PublishRequest_init(UA_PublishRequest *p), {
    memset(p, 0, sizeof(UA_PublishRequest));
})

UA_INLINABLE( UA_PublishRequest *
UA_PublishRequest_new(void), {
    return (UA_PublishRequest*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishRequest_copy(const UA_PublishRequest *src, UA_PublishRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
})

UA_INLINABLE( void
UA_PublishRequest_clear(UA_PublishRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
})

UA_INLINABLE( void
UA_PublishRequest_delete(UA_PublishRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_PublishRequest_equal(const UA_PublishRequest *p1, const UA_PublishRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]) == UA_ORDER_EQ);
})


/* PublishResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_UInt32 subscriptionId;
    size_t availableSequenceNumbersSize;
    UA_UInt32 *availableSequenceNumbers;
    UA_Boolean moreNotifications;
    UA_NotificationMessage notificationMessage;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_PublishResponse;

#define UA_TYPES_PUBLISHRESPONSE 363

UA_INLINABLE( void
UA_PublishResponse_init(UA_PublishResponse *p), {
    memset(p, 0, sizeof(UA_PublishResponse));
})

UA_INLINABLE( UA_PublishResponse *
UA_PublishResponse_new(void), {
    return (UA_PublishResponse*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishResponse_copy(const UA_PublishResponse *src, UA_PublishResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
})

UA_INLINABLE( void
UA_PublishResponse_clear(UA_PublishResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
})

UA_INLINABLE( void
UA_PublishResponse_delete(UA_PublishResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_PublishResponse_equal(const UA_PublishResponse *p1, const UA_PublishResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]) == UA_ORDER_EQ);
})


/* RepublishRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    UA_UInt32 subscriptionId;
    UA_UInt32 retransmitSequenceNumber;
} UA_RepublishRequest;

#define UA_TYPES_REPUBLISHREQUEST 364

UA_INLINABLE( void
UA_RepublishRequest_init(UA_RepublishRequest *p), {
    memset(p, 0, sizeof(UA_RepublishRequest));
})

UA_INLINABLE( UA_RepublishRequest *
UA_RepublishRequest_new(void), {
    return (UA_RepublishRequest*)UA_new(&UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_RepublishRequest_copy(const UA_RepublishRequest *src, UA_RepublishRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
})

UA_INLINABLE( void
UA_RepublishRequest_clear(UA_RepublishRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
})

UA_INLINABLE( void
UA_RepublishRequest_delete(UA_RepublishRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_RepublishRequest_equal(const UA_RepublishRequest *p1, const UA_RepublishRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]) == UA_ORDER_EQ);
})


/* RepublishResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    UA_NotificationMessage notificationMessage;
} UA_RepublishResponse;

#define UA_TYPES_REPUBLISHRESPONSE 365

UA_INLINABLE( void
UA_RepublishResponse_init(UA_RepublishResponse *p), {
    memset(p, 0, sizeof(UA_RepublishResponse));
})

UA_INLINABLE( UA_RepublishResponse *
UA_RepublishResponse_new(void), {
    return (UA_RepublishResponse*)UA_new(&UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_RepublishResponse_copy(const UA_RepublishResponse *src, UA_RepublishResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
})

UA_INLINABLE( void
UA_RepublishResponse_clear(UA_RepublishResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
})

UA_INLINABLE( void
UA_RepublishResponse_delete(UA_RepublishResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_RepublishResponse_equal(const UA_RepublishResponse *p1, const UA_RepublishResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]) == UA_ORDER_EQ);
})


/* TransferResult */
typedef struct {
    UA_StatusCode statusCode;
    size_t availableSequenceNumbersSize;
    UA_UInt32 *availableSequenceNumbers;
} UA_TransferResult;

#define UA_TYPES_TRANSFERRESULT 366

UA_INLINABLE( void
UA_TransferResult_init(UA_TransferResult *p), {
    memset(p, 0, sizeof(UA_TransferResult));
})

UA_INLINABLE( UA_TransferResult *
UA_TransferResult_new(void), {
    return (UA_TransferResult*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_TransferResult_copy(const UA_TransferResult *src, UA_TransferResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERRESULT]);
})

UA_INLINABLE( void
UA_TransferResult_clear(UA_TransferResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERRESULT]);
})

UA_INLINABLE( void
UA_TransferResult_delete(UA_TransferResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_TransferResult_equal(const UA_TransferResult *p1, const UA_TransferResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRANSFERRESULT]) == UA_ORDER_EQ);
})


/* TransferSubscriptionsRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t subscriptionIdsSize;
    UA_UInt32 *subscriptionIds;
    UA_Boolean sendInitialValues;
} UA_TransferSubscriptionsRequest;

#define UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST 367

UA_INLINABLE( void
UA_TransferSubscriptionsRequest_init(UA_TransferSubscriptionsRequest *p), {
    memset(p, 0, sizeof(UA_TransferSubscriptionsRequest));
})

UA_INLINABLE( UA_TransferSubscriptionsRequest *
UA_TransferSubscriptionsRequest_new(void), {
    return (UA_TransferSubscriptionsRequest*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_TransferSubscriptionsRequest_copy(const UA_TransferSubscriptionsRequest *src, UA_TransferSubscriptionsRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
})

UA_INLINABLE( void
UA_TransferSubscriptionsRequest_clear(UA_TransferSubscriptionsRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
})

UA_INLINABLE( void
UA_TransferSubscriptionsRequest_delete(UA_TransferSubscriptionsRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_TransferSubscriptionsRequest_equal(const UA_TransferSubscriptionsRequest *p1, const UA_TransferSubscriptionsRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]) == UA_ORDER_EQ);
})


/* TransferSubscriptionsResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_TransferResult *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_TransferSubscriptionsResponse;

#define UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE 368

UA_INLINABLE( void
UA_TransferSubscriptionsResponse_init(UA_TransferSubscriptionsResponse *p), {
    memset(p, 0, sizeof(UA_TransferSubscriptionsResponse));
})

UA_INLINABLE( UA_TransferSubscriptionsResponse *
UA_TransferSubscriptionsResponse_new(void), {
    return (UA_TransferSubscriptionsResponse*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_TransferSubscriptionsResponse_copy(const UA_TransferSubscriptionsResponse *src, UA_TransferSubscriptionsResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
})

UA_INLINABLE( void
UA_TransferSubscriptionsResponse_clear(UA_TransferSubscriptionsResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
})

UA_INLINABLE( void
UA_TransferSubscriptionsResponse_delete(UA_TransferSubscriptionsResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_TransferSubscriptionsResponse_equal(const UA_TransferSubscriptionsResponse *p1, const UA_TransferSubscriptionsResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]) == UA_ORDER_EQ);
})


/* DeleteSubscriptionsRequest */
typedef struct {
    UA_RequestHeader requestHeader;
    size_t subscriptionIdsSize;
    UA_UInt32 *subscriptionIds;
} UA_DeleteSubscriptionsRequest;

#define UA_TYPES_DELETESUBSCRIPTIONSREQUEST 369

UA_INLINABLE( void
UA_DeleteSubscriptionsRequest_init(UA_DeleteSubscriptionsRequest *p), {
    memset(p, 0, sizeof(UA_DeleteSubscriptionsRequest));
})

UA_INLINABLE( UA_DeleteSubscriptionsRequest *
UA_DeleteSubscriptionsRequest_new(void), {
    return (UA_DeleteSubscriptionsRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteSubscriptionsRequest_copy(const UA_DeleteSubscriptionsRequest *src, UA_DeleteSubscriptionsRequest *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
})

UA_INLINABLE( void
UA_DeleteSubscriptionsRequest_clear(UA_DeleteSubscriptionsRequest *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
})

UA_INLINABLE( void
UA_DeleteSubscriptionsRequest_delete(UA_DeleteSubscriptionsRequest *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteSubscriptionsRequest_equal(const UA_DeleteSubscriptionsRequest *p1, const UA_DeleteSubscriptionsRequest *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]) == UA_ORDER_EQ);
})


/* DeleteSubscriptionsResponse */
typedef struct {
    UA_ResponseHeader responseHeader;
    size_t resultsSize;
    UA_StatusCode *results;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_DeleteSubscriptionsResponse;

#define UA_TYPES_DELETESUBSCRIPTIONSRESPONSE 370

UA_INLINABLE( void
UA_DeleteSubscriptionsResponse_init(UA_DeleteSubscriptionsResponse *p), {
    memset(p, 0, sizeof(UA_DeleteSubscriptionsResponse));
})

UA_INLINABLE( UA_DeleteSubscriptionsResponse *
UA_DeleteSubscriptionsResponse_new(void), {
    return (UA_DeleteSubscriptionsResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
})

UA_INLINABLE( UA_StatusCode
UA_DeleteSubscriptionsResponse_copy(const UA_DeleteSubscriptionsResponse *src, UA_DeleteSubscriptionsResponse *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
})

UA_INLINABLE( void
UA_DeleteSubscriptionsResponse_clear(UA_DeleteSubscriptionsResponse *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
})

UA_INLINABLE( void
UA_DeleteSubscriptionsResponse_delete(UA_DeleteSubscriptionsResponse *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]);
})

UA_INLINABLE( UA_Boolean
UA_DeleteSubscriptionsResponse_equal(const UA_DeleteSubscriptionsResponse *p1, const UA_DeleteSubscriptionsResponse *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]) == UA_ORDER_EQ);
})


/* BuildInfo */
typedef struct {
    UA_String productUri;
    UA_String manufacturerName;
    UA_String productName;
    UA_String softwareVersion;
    UA_String buildNumber;
    UA_DateTime buildDate;
} UA_BuildInfo;

#define UA_TYPES_BUILDINFO 371

UA_INLINABLE( void
UA_BuildInfo_init(UA_BuildInfo *p), {
    memset(p, 0, sizeof(UA_BuildInfo));
})

UA_INLINABLE( UA_BuildInfo *
UA_BuildInfo_new(void), {
    return (UA_BuildInfo*)UA_new(&UA_TYPES[UA_TYPES_BUILDINFO]);
})

UA_INLINABLE( UA_StatusCode
UA_BuildInfo_copy(const UA_BuildInfo *src, UA_BuildInfo *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BUILDINFO]);
})

UA_INLINABLE( void
UA_BuildInfo_clear(UA_BuildInfo *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_BUILDINFO]);
})

UA_INLINABLE( void
UA_BuildInfo_delete(UA_BuildInfo *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_BUILDINFO]);
})

UA_INLINABLE( UA_Boolean
UA_BuildInfo_equal(const UA_BuildInfo *p1, const UA_BuildInfo *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_BUILDINFO]) == UA_ORDER_EQ);
})


/* RedundancySupport */
typedef enum {
    UA_REDUNDANCYSUPPORT_NONE = 0,
    UA_REDUNDANCYSUPPORT_COLD = 1,
    UA_REDUNDANCYSUPPORT_WARM = 2,
    UA_REDUNDANCYSUPPORT_HOT = 3,
    UA_REDUNDANCYSUPPORT_TRANSPARENT = 4,
    UA_REDUNDANCYSUPPORT_HOTANDMIRRORED = 5,
    __UA_REDUNDANCYSUPPORT_FORCE32BIT = 0x7fffffff
} UA_RedundancySupport;

UA_STATIC_ASSERT(sizeof(UA_RedundancySupport) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_REDUNDANCYSUPPORT 372

UA_INLINABLE( void
UA_RedundancySupport_init(UA_RedundancySupport *p), {
    memset(p, 0, sizeof(UA_RedundancySupport));
})

UA_INLINABLE( UA_RedundancySupport *
UA_RedundancySupport_new(void), {
    return (UA_RedundancySupport*)UA_new(&UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
})

UA_INLINABLE( UA_StatusCode
UA_RedundancySupport_copy(const UA_RedundancySupport *src, UA_RedundancySupport *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
})

UA_INLINABLE( void
UA_RedundancySupport_clear(UA_RedundancySupport *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
})

UA_INLINABLE( void
UA_RedundancySupport_delete(UA_RedundancySupport *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]);
})

UA_INLINABLE( UA_Boolean
UA_RedundancySupport_equal(const UA_RedundancySupport *p1, const UA_RedundancySupport *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]) == UA_ORDER_EQ);
})


/* ServerState */
typedef enum {
    UA_SERVERSTATE_RUNNING = 0,
    UA_SERVERSTATE_FAILED = 1,
    UA_SERVERSTATE_NOCONFIGURATION = 2,
    UA_SERVERSTATE_SUSPENDED = 3,
    UA_SERVERSTATE_SHUTDOWN = 4,
    UA_SERVERSTATE_TEST = 5,
    UA_SERVERSTATE_COMMUNICATIONFAULT = 6,
    UA_SERVERSTATE_UNKNOWN = 7,
    __UA_SERVERSTATE_FORCE32BIT = 0x7fffffff
} UA_ServerState;

UA_STATIC_ASSERT(sizeof(UA_ServerState) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_SERVERSTATE 373

UA_INLINABLE( void
UA_ServerState_init(UA_ServerState *p), {
    memset(p, 0, sizeof(UA_ServerState));
})

UA_INLINABLE( UA_ServerState *
UA_ServerState_new(void), {
    return (UA_ServerState*)UA_new(&UA_TYPES[UA_TYPES_SERVERSTATE]);
})

UA_INLINABLE( UA_StatusCode
UA_ServerState_copy(const UA_ServerState *src, UA_ServerState *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERSTATE]);
})

UA_INLINABLE( void
UA_ServerState_clear(UA_ServerState *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATE]);
})

UA_INLINABLE( void
UA_ServerState_delete(UA_ServerState *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVERSTATE]);
})

UA_INLINABLE( UA_Boolean
UA_ServerState_equal(const UA_ServerState *p1, const UA_ServerState *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SERVERSTATE]) == UA_ORDER_EQ);
})


/* RedundantServerDataType */
typedef struct {
    UA_String serverId;
    UA_Byte serviceLevel;
    UA_ServerState serverState;
} UA_RedundantServerDataType;

#define UA_TYPES_REDUNDANTSERVERDATATYPE 374

UA_INLINABLE( void
UA_RedundantServerDataType_init(UA_RedundantServerDataType *p), {
    memset(p, 0, sizeof(UA_RedundantServerDataType));
})

UA_INLINABLE( UA_RedundantServerDataType *
UA_RedundantServerDataType_new(void), {
    return (UA_RedundantServerDataType*)UA_new(&UA_TYPES[UA_TYPES_REDUNDANTSERVERDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_RedundantServerDataType_copy(const UA_RedundantServerDataType *src, UA_RedundantServerDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REDUNDANTSERVERDATATYPE]);
})

UA_INLINABLE( void
UA_RedundantServerDataType_clear(UA_RedundantServerDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_REDUNDANTSERVERDATATYPE]);
})

UA_INLINABLE( void
UA_RedundantServerDataType_delete(UA_RedundantServerDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_REDUNDANTSERVERDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_RedundantServerDataType_equal(const UA_RedundantServerDataType *p1, const UA_RedundantServerDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_REDUNDANTSERVERDATATYPE]) == UA_ORDER_EQ);
})


/* EndpointUrlListDataType */
typedef struct {
    size_t endpointUrlListSize;
    UA_String *endpointUrlList;
} UA_EndpointUrlListDataType;

#define UA_TYPES_ENDPOINTURLLISTDATATYPE 375

UA_INLINABLE( void
UA_EndpointUrlListDataType_init(UA_EndpointUrlListDataType *p), {
    memset(p, 0, sizeof(UA_EndpointUrlListDataType));
})

UA_INLINABLE( UA_EndpointUrlListDataType *
UA_EndpointUrlListDataType_new(void), {
    return (UA_EndpointUrlListDataType*)UA_new(&UA_TYPES[UA_TYPES_ENDPOINTURLLISTDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_EndpointUrlListDataType_copy(const UA_EndpointUrlListDataType *src, UA_EndpointUrlListDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENDPOINTURLLISTDATATYPE]);
})

UA_INLINABLE( void
UA_EndpointUrlListDataType_clear(UA_EndpointUrlListDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTURLLISTDATATYPE]);
})

UA_INLINABLE( void
UA_EndpointUrlListDataType_delete(UA_EndpointUrlListDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENDPOINTURLLISTDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_EndpointUrlListDataType_equal(const UA_EndpointUrlListDataType *p1, const UA_EndpointUrlListDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENDPOINTURLLISTDATATYPE]) == UA_ORDER_EQ);
})


/* NetworkGroupDataType */
typedef struct {
    UA_String serverUri;
    size_t networkPathsSize;
    UA_EndpointUrlListDataType *networkPaths;
} UA_NetworkGroupDataType;

#define UA_TYPES_NETWORKGROUPDATATYPE 376

UA_INLINABLE( void
UA_NetworkGroupDataType_init(UA_NetworkGroupDataType *p), {
    memset(p, 0, sizeof(UA_NetworkGroupDataType));
})

UA_INLINABLE( UA_NetworkGroupDataType *
UA_NetworkGroupDataType_new(void), {
    return (UA_NetworkGroupDataType*)UA_new(&UA_TYPES[UA_TYPES_NETWORKGROUPDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_NetworkGroupDataType_copy(const UA_NetworkGroupDataType *src, UA_NetworkGroupDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NETWORKGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_NetworkGroupDataType_clear(UA_NetworkGroupDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_NETWORKGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_NetworkGroupDataType_delete(UA_NetworkGroupDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_NETWORKGROUPDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_NetworkGroupDataType_equal(const UA_NetworkGroupDataType *p1, const UA_NetworkGroupDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_NETWORKGROUPDATATYPE]) == UA_ORDER_EQ);
})


/* SamplingIntervalDiagnosticsDataType */
typedef struct {
    UA_Double samplingInterval;
    UA_UInt32 monitoredItemCount;
    UA_UInt32 maxMonitoredItemCount;
    UA_UInt32 disabledMonitoredItemCount;
} UA_SamplingIntervalDiagnosticsDataType;

#define UA_TYPES_SAMPLINGINTERVALDIAGNOSTICSDATATYPE 377

UA_INLINABLE( void
UA_SamplingIntervalDiagnosticsDataType_init(UA_SamplingIntervalDiagnosticsDataType *p), {
    memset(p, 0, sizeof(UA_SamplingIntervalDiagnosticsDataType));
})

UA_INLINABLE( UA_SamplingIntervalDiagnosticsDataType *
UA_SamplingIntervalDiagnosticsDataType_new(void), {
    return (UA_SamplingIntervalDiagnosticsDataType*)UA_new(&UA_TYPES[UA_TYPES_SAMPLINGINTERVALDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SamplingIntervalDiagnosticsDataType_copy(const UA_SamplingIntervalDiagnosticsDataType *src, UA_SamplingIntervalDiagnosticsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SAMPLINGINTERVALDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( void
UA_SamplingIntervalDiagnosticsDataType_clear(UA_SamplingIntervalDiagnosticsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SAMPLINGINTERVALDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( void
UA_SamplingIntervalDiagnosticsDataType_delete(UA_SamplingIntervalDiagnosticsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SAMPLINGINTERVALDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SamplingIntervalDiagnosticsDataType_equal(const UA_SamplingIntervalDiagnosticsDataType *p1, const UA_SamplingIntervalDiagnosticsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SAMPLINGINTERVALDIAGNOSTICSDATATYPE]) == UA_ORDER_EQ);
})


/* ServerDiagnosticsSummaryDataType */
typedef struct {
    UA_UInt32 serverViewCount;
    UA_UInt32 currentSessionCount;
    UA_UInt32 cumulatedSessionCount;
    UA_UInt32 securityRejectedSessionCount;
    UA_UInt32 rejectedSessionCount;
    UA_UInt32 sessionTimeoutCount;
    UA_UInt32 sessionAbortCount;
    UA_UInt32 currentSubscriptionCount;
    UA_UInt32 cumulatedSubscriptionCount;
    UA_UInt32 publishingIntervalCount;
    UA_UInt32 securityRejectedRequestsCount;
    UA_UInt32 rejectedRequestsCount;
} UA_ServerDiagnosticsSummaryDataType;

#define UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE 378

UA_INLINABLE( void
UA_ServerDiagnosticsSummaryDataType_init(UA_ServerDiagnosticsSummaryDataType *p), {
    memset(p, 0, sizeof(UA_ServerDiagnosticsSummaryDataType));
})

UA_INLINABLE( UA_ServerDiagnosticsSummaryDataType *
UA_ServerDiagnosticsSummaryDataType_new(void), {
    return (UA_ServerDiagnosticsSummaryDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ServerDiagnosticsSummaryDataType_copy(const UA_ServerDiagnosticsSummaryDataType *src, UA_ServerDiagnosticsSummaryDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
})

UA_INLINABLE( void
UA_ServerDiagnosticsSummaryDataType_clear(UA_ServerDiagnosticsSummaryDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
})

UA_INLINABLE( void
UA_ServerDiagnosticsSummaryDataType_delete(UA_ServerDiagnosticsSummaryDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ServerDiagnosticsSummaryDataType_equal(const UA_ServerDiagnosticsSummaryDataType *p1, const UA_ServerDiagnosticsSummaryDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]) == UA_ORDER_EQ);
})


/* ServerStatusDataType */
typedef struct {
    UA_DateTime startTime;
    UA_DateTime currentTime;
    UA_ServerState state;
    UA_BuildInfo buildInfo;
    UA_UInt32 secondsTillShutdown;
    UA_LocalizedText shutdownReason;
} UA_ServerStatusDataType;

#define UA_TYPES_SERVERSTATUSDATATYPE 379

UA_INLINABLE( void
UA_ServerStatusDataType_init(UA_ServerStatusDataType *p), {
    memset(p, 0, sizeof(UA_ServerStatusDataType));
})

UA_INLINABLE( UA_ServerStatusDataType *
UA_ServerStatusDataType_new(void), {
    return (UA_ServerStatusDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ServerStatusDataType_copy(const UA_ServerStatusDataType *src, UA_ServerStatusDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
})

UA_INLINABLE( void
UA_ServerStatusDataType_clear(UA_ServerStatusDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
})

UA_INLINABLE( void
UA_ServerStatusDataType_delete(UA_ServerStatusDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ServerStatusDataType_equal(const UA_ServerStatusDataType *p1, const UA_ServerStatusDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]) == UA_ORDER_EQ);
})


/* SessionSecurityDiagnosticsDataType */
typedef struct {
    UA_NodeId sessionId;
    UA_String clientUserIdOfSession;
    size_t clientUserIdHistorySize;
    UA_String *clientUserIdHistory;
    UA_String authenticationMechanism;
    UA_String encoding;
    UA_String transportProtocol;
    UA_MessageSecurityMode securityMode;
    UA_String securityPolicyUri;
    UA_ByteString clientCertificate;
} UA_SessionSecurityDiagnosticsDataType;

#define UA_TYPES_SESSIONSECURITYDIAGNOSTICSDATATYPE 380

UA_INLINABLE( void
UA_SessionSecurityDiagnosticsDataType_init(UA_SessionSecurityDiagnosticsDataType *p), {
    memset(p, 0, sizeof(UA_SessionSecurityDiagnosticsDataType));
})

UA_INLINABLE( UA_SessionSecurityDiagnosticsDataType *
UA_SessionSecurityDiagnosticsDataType_new(void), {
    return (UA_SessionSecurityDiagnosticsDataType*)UA_new(&UA_TYPES[UA_TYPES_SESSIONSECURITYDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SessionSecurityDiagnosticsDataType_copy(const UA_SessionSecurityDiagnosticsDataType *src, UA_SessionSecurityDiagnosticsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SESSIONSECURITYDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( void
UA_SessionSecurityDiagnosticsDataType_clear(UA_SessionSecurityDiagnosticsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SESSIONSECURITYDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( void
UA_SessionSecurityDiagnosticsDataType_delete(UA_SessionSecurityDiagnosticsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SESSIONSECURITYDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SessionSecurityDiagnosticsDataType_equal(const UA_SessionSecurityDiagnosticsDataType *p1, const UA_SessionSecurityDiagnosticsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SESSIONSECURITYDIAGNOSTICSDATATYPE]) == UA_ORDER_EQ);
})


/* ServiceCounterDataType */
typedef struct {
    UA_UInt32 totalCount;
    UA_UInt32 errorCount;
} UA_ServiceCounterDataType;

#define UA_TYPES_SERVICECOUNTERDATATYPE 381

UA_INLINABLE( void
UA_ServiceCounterDataType_init(UA_ServiceCounterDataType *p), {
    memset(p, 0, sizeof(UA_ServiceCounterDataType));
})

UA_INLINABLE( UA_ServiceCounterDataType *
UA_ServiceCounterDataType_new(void), {
    return (UA_ServiceCounterDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVICECOUNTERDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ServiceCounterDataType_copy(const UA_ServiceCounterDataType *src, UA_ServiceCounterDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVICECOUNTERDATATYPE]);
})

UA_INLINABLE( void
UA_ServiceCounterDataType_clear(UA_ServiceCounterDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SERVICECOUNTERDATATYPE]);
})

UA_INLINABLE( void
UA_ServiceCounterDataType_delete(UA_ServiceCounterDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SERVICECOUNTERDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ServiceCounterDataType_equal(const UA_ServiceCounterDataType *p1, const UA_ServiceCounterDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SERVICECOUNTERDATATYPE]) == UA_ORDER_EQ);
})


/* StatusResult */
typedef struct {
    UA_StatusCode statusCode;
    UA_DiagnosticInfo diagnosticInfo;
} UA_StatusResult;

#define UA_TYPES_STATUSRESULT 382

UA_INLINABLE( void
UA_StatusResult_init(UA_StatusResult *p), {
    memset(p, 0, sizeof(UA_StatusResult));
})

UA_INLINABLE( UA_StatusResult *
UA_StatusResult_new(void), {
    return (UA_StatusResult*)UA_new(&UA_TYPES[UA_TYPES_STATUSRESULT]);
})

UA_INLINABLE( UA_StatusCode
UA_StatusResult_copy(const UA_StatusResult *src, UA_StatusResult *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STATUSRESULT]);
})

UA_INLINABLE( void
UA_StatusResult_clear(UA_StatusResult *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STATUSRESULT]);
})

UA_INLINABLE( void
UA_StatusResult_delete(UA_StatusResult *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STATUSRESULT]);
})

UA_INLINABLE( UA_Boolean
UA_StatusResult_equal(const UA_StatusResult *p1, const UA_StatusResult *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STATUSRESULT]) == UA_ORDER_EQ);
})


/* SubscriptionDiagnosticsDataType */
typedef struct {
    UA_NodeId sessionId;
    UA_UInt32 subscriptionId;
    UA_Byte priority;
    UA_Double publishingInterval;
    UA_UInt32 maxKeepAliveCount;
    UA_UInt32 maxLifetimeCount;
    UA_UInt32 maxNotificationsPerPublish;
    UA_Boolean publishingEnabled;
    UA_UInt32 modifyCount;
    UA_UInt32 enableCount;
    UA_UInt32 disableCount;
    UA_UInt32 republishRequestCount;
    UA_UInt32 republishMessageRequestCount;
    UA_UInt32 republishMessageCount;
    UA_UInt32 transferRequestCount;
    UA_UInt32 transferredToAltClientCount;
    UA_UInt32 transferredToSameClientCount;
    UA_UInt32 publishRequestCount;
    UA_UInt32 dataChangeNotificationsCount;
    UA_UInt32 eventNotificationsCount;
    UA_UInt32 notificationsCount;
    UA_UInt32 latePublishRequestCount;
    UA_UInt32 currentKeepAliveCount;
    UA_UInt32 currentLifetimeCount;
    UA_UInt32 unacknowledgedMessageCount;
    UA_UInt32 discardedMessageCount;
    UA_UInt32 monitoredItemCount;
    UA_UInt32 disabledMonitoredItemCount;
    UA_UInt32 monitoringQueueOverflowCount;
    UA_UInt32 nextSequenceNumber;
    UA_UInt32 eventQueueOverflowCount;
} UA_SubscriptionDiagnosticsDataType;

#define UA_TYPES_SUBSCRIPTIONDIAGNOSTICSDATATYPE 383

UA_INLINABLE( void
UA_SubscriptionDiagnosticsDataType_init(UA_SubscriptionDiagnosticsDataType *p), {
    memset(p, 0, sizeof(UA_SubscriptionDiagnosticsDataType));
})

UA_INLINABLE( UA_SubscriptionDiagnosticsDataType *
UA_SubscriptionDiagnosticsDataType_new(void), {
    return (UA_SubscriptionDiagnosticsDataType*)UA_new(&UA_TYPES[UA_TYPES_SUBSCRIPTIONDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SubscriptionDiagnosticsDataType_copy(const UA_SubscriptionDiagnosticsDataType *src, UA_SubscriptionDiagnosticsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SUBSCRIPTIONDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( void
UA_SubscriptionDiagnosticsDataType_clear(UA_SubscriptionDiagnosticsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( void
UA_SubscriptionDiagnosticsDataType_delete(UA_SubscriptionDiagnosticsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SubscriptionDiagnosticsDataType_equal(const UA_SubscriptionDiagnosticsDataType *p1, const UA_SubscriptionDiagnosticsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SUBSCRIPTIONDIAGNOSTICSDATATYPE]) == UA_ORDER_EQ);
})


/* ModelChangeStructureVerbMask */
typedef enum {
    UA_MODELCHANGESTRUCTUREVERBMASK_NODEADDED = 1,
    UA_MODELCHANGESTRUCTUREVERBMASK_NODEDELETED = 2,
    UA_MODELCHANGESTRUCTUREVERBMASK_REFERENCEADDED = 4,
    UA_MODELCHANGESTRUCTUREVERBMASK_REFERENCEDELETED = 8,
    UA_MODELCHANGESTRUCTUREVERBMASK_DATATYPECHANGED = 16,
    __UA_MODELCHANGESTRUCTUREVERBMASK_FORCE32BIT = 0x7fffffff
} UA_ModelChangeStructureVerbMask;

UA_STATIC_ASSERT(sizeof(UA_ModelChangeStructureVerbMask) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_MODELCHANGESTRUCTUREVERBMASK 384

UA_INLINABLE( void
UA_ModelChangeStructureVerbMask_init(UA_ModelChangeStructureVerbMask *p), {
    memset(p, 0, sizeof(UA_ModelChangeStructureVerbMask));
})

UA_INLINABLE( UA_ModelChangeStructureVerbMask *
UA_ModelChangeStructureVerbMask_new(void), {
    return (UA_ModelChangeStructureVerbMask*)UA_new(&UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREVERBMASK]);
})

UA_INLINABLE( UA_StatusCode
UA_ModelChangeStructureVerbMask_copy(const UA_ModelChangeStructureVerbMask *src, UA_ModelChangeStructureVerbMask *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREVERBMASK]);
})

UA_INLINABLE( void
UA_ModelChangeStructureVerbMask_clear(UA_ModelChangeStructureVerbMask *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREVERBMASK]);
})

UA_INLINABLE( void
UA_ModelChangeStructureVerbMask_delete(UA_ModelChangeStructureVerbMask *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREVERBMASK]);
})

UA_INLINABLE( UA_Boolean
UA_ModelChangeStructureVerbMask_equal(const UA_ModelChangeStructureVerbMask *p1, const UA_ModelChangeStructureVerbMask *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREVERBMASK]) == UA_ORDER_EQ);
})


/* ModelChangeStructureDataType */
typedef struct {
    UA_NodeId affected;
    UA_NodeId affectedType;
    UA_Byte verb;
} UA_ModelChangeStructureDataType;

#define UA_TYPES_MODELCHANGESTRUCTUREDATATYPE 385

UA_INLINABLE( void
UA_ModelChangeStructureDataType_init(UA_ModelChangeStructureDataType *p), {
    memset(p, 0, sizeof(UA_ModelChangeStructureDataType));
})

UA_INLINABLE( UA_ModelChangeStructureDataType *
UA_ModelChangeStructureDataType_new(void), {
    return (UA_ModelChangeStructureDataType*)UA_new(&UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ModelChangeStructureDataType_copy(const UA_ModelChangeStructureDataType *src, UA_ModelChangeStructureDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREDATATYPE]);
})

UA_INLINABLE( void
UA_ModelChangeStructureDataType_clear(UA_ModelChangeStructureDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREDATATYPE]);
})

UA_INLINABLE( void
UA_ModelChangeStructureDataType_delete(UA_ModelChangeStructureDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ModelChangeStructureDataType_equal(const UA_ModelChangeStructureDataType *p1, const UA_ModelChangeStructureDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MODELCHANGESTRUCTUREDATATYPE]) == UA_ORDER_EQ);
})


/* SemanticChangeStructureDataType */
typedef struct {
    UA_NodeId affected;
    UA_NodeId affectedType;
} UA_SemanticChangeStructureDataType;

#define UA_TYPES_SEMANTICCHANGESTRUCTUREDATATYPE 386

UA_INLINABLE( void
UA_SemanticChangeStructureDataType_init(UA_SemanticChangeStructureDataType *p), {
    memset(p, 0, sizeof(UA_SemanticChangeStructureDataType));
})

UA_INLINABLE( UA_SemanticChangeStructureDataType *
UA_SemanticChangeStructureDataType_new(void), {
    return (UA_SemanticChangeStructureDataType*)UA_new(&UA_TYPES[UA_TYPES_SEMANTICCHANGESTRUCTUREDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SemanticChangeStructureDataType_copy(const UA_SemanticChangeStructureDataType *src, UA_SemanticChangeStructureDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SEMANTICCHANGESTRUCTUREDATATYPE]);
})

UA_INLINABLE( void
UA_SemanticChangeStructureDataType_clear(UA_SemanticChangeStructureDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SEMANTICCHANGESTRUCTUREDATATYPE]);
})

UA_INLINABLE( void
UA_SemanticChangeStructureDataType_delete(UA_SemanticChangeStructureDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SEMANTICCHANGESTRUCTUREDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SemanticChangeStructureDataType_equal(const UA_SemanticChangeStructureDataType *p1, const UA_SemanticChangeStructureDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SEMANTICCHANGESTRUCTUREDATATYPE]) == UA_ORDER_EQ);
})


/* Range */
typedef struct {
    UA_Double low;
    UA_Double high;
} UA_Range;

#define UA_TYPES_RANGE 387

UA_INLINABLE( void
UA_Range_init(UA_Range *p), {
    memset(p, 0, sizeof(UA_Range));
})

UA_INLINABLE( UA_Range *
UA_Range_new(void), {
    return (UA_Range*)UA_new(&UA_TYPES[UA_TYPES_RANGE]);
})

UA_INLINABLE( UA_StatusCode
UA_Range_copy(const UA_Range *src, UA_Range *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RANGE]);
})

UA_INLINABLE( void
UA_Range_clear(UA_Range *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_RANGE]);
})

UA_INLINABLE( void
UA_Range_delete(UA_Range *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_RANGE]);
})

UA_INLINABLE( UA_Boolean
UA_Range_equal(const UA_Range *p1, const UA_Range *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_RANGE]) == UA_ORDER_EQ);
})


/* EUInformation */
typedef struct {
    UA_String namespaceUri;
    UA_Int32 unitId;
    UA_LocalizedText displayName;
    UA_LocalizedText description;
} UA_EUInformation;

#define UA_TYPES_EUINFORMATION 388

UA_INLINABLE( void
UA_EUInformation_init(UA_EUInformation *p), {
    memset(p, 0, sizeof(UA_EUInformation));
})

UA_INLINABLE( UA_EUInformation *
UA_EUInformation_new(void), {
    return (UA_EUInformation*)UA_new(&UA_TYPES[UA_TYPES_EUINFORMATION]);
})

UA_INLINABLE( UA_StatusCode
UA_EUInformation_copy(const UA_EUInformation *src, UA_EUInformation *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EUINFORMATION]);
})

UA_INLINABLE( void
UA_EUInformation_clear(UA_EUInformation *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EUINFORMATION]);
})

UA_INLINABLE( void
UA_EUInformation_delete(UA_EUInformation *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EUINFORMATION]);
})

UA_INLINABLE( UA_Boolean
UA_EUInformation_equal(const UA_EUInformation *p1, const UA_EUInformation *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EUINFORMATION]) == UA_ORDER_EQ);
})


/* AxisScaleEnumeration */
typedef enum {
    UA_AXISSCALEENUMERATION_LINEAR = 0,
    UA_AXISSCALEENUMERATION_LOG = 1,
    UA_AXISSCALEENUMERATION_LN = 2,
    __UA_AXISSCALEENUMERATION_FORCE32BIT = 0x7fffffff
} UA_AxisScaleEnumeration;

UA_STATIC_ASSERT(sizeof(UA_AxisScaleEnumeration) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_AXISSCALEENUMERATION 389

UA_INLINABLE( void
UA_AxisScaleEnumeration_init(UA_AxisScaleEnumeration *p), {
    memset(p, 0, sizeof(UA_AxisScaleEnumeration));
})

UA_INLINABLE( UA_AxisScaleEnumeration *
UA_AxisScaleEnumeration_new(void), {
    return (UA_AxisScaleEnumeration*)UA_new(&UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
})

UA_INLINABLE( UA_StatusCode
UA_AxisScaleEnumeration_copy(const UA_AxisScaleEnumeration *src, UA_AxisScaleEnumeration *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
})

UA_INLINABLE( void
UA_AxisScaleEnumeration_clear(UA_AxisScaleEnumeration *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
})

UA_INLINABLE( void
UA_AxisScaleEnumeration_delete(UA_AxisScaleEnumeration *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]);
})

UA_INLINABLE( UA_Boolean
UA_AxisScaleEnumeration_equal(const UA_AxisScaleEnumeration *p1, const UA_AxisScaleEnumeration *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]) == UA_ORDER_EQ);
})


/* ComplexNumberType */
typedef struct {
    UA_Float real;
    UA_Float imaginary;
} UA_ComplexNumberType;

#define UA_TYPES_COMPLEXNUMBERTYPE 390

UA_INLINABLE( void
UA_ComplexNumberType_init(UA_ComplexNumberType *p), {
    memset(p, 0, sizeof(UA_ComplexNumberType));
})

UA_INLINABLE( UA_ComplexNumberType *
UA_ComplexNumberType_new(void), {
    return (UA_ComplexNumberType*)UA_new(&UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ComplexNumberType_copy(const UA_ComplexNumberType *src, UA_ComplexNumberType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
})

UA_INLINABLE( void
UA_ComplexNumberType_clear(UA_ComplexNumberType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
})

UA_INLINABLE( void
UA_ComplexNumberType_delete(UA_ComplexNumberType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ComplexNumberType_equal(const UA_ComplexNumberType *p1, const UA_ComplexNumberType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]) == UA_ORDER_EQ);
})


/* DoubleComplexNumberType */
typedef struct {
    UA_Double real;
    UA_Double imaginary;
} UA_DoubleComplexNumberType;

#define UA_TYPES_DOUBLECOMPLEXNUMBERTYPE 391

UA_INLINABLE( void
UA_DoubleComplexNumberType_init(UA_DoubleComplexNumberType *p), {
    memset(p, 0, sizeof(UA_DoubleComplexNumberType));
})

UA_INLINABLE( UA_DoubleComplexNumberType *
UA_DoubleComplexNumberType_new(void), {
    return (UA_DoubleComplexNumberType*)UA_new(&UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DoubleComplexNumberType_copy(const UA_DoubleComplexNumberType *src, UA_DoubleComplexNumberType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
})

UA_INLINABLE( void
UA_DoubleComplexNumberType_clear(UA_DoubleComplexNumberType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
})

UA_INLINABLE( void
UA_DoubleComplexNumberType_delete(UA_DoubleComplexNumberType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DoubleComplexNumberType_equal(const UA_DoubleComplexNumberType *p1, const UA_DoubleComplexNumberType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]) == UA_ORDER_EQ);
})


/* AxisInformation */
typedef struct {
    UA_EUInformation engineeringUnits;
    UA_Range eURange;
    UA_LocalizedText title;
    UA_AxisScaleEnumeration axisScaleType;
    size_t axisStepsSize;
    UA_Double *axisSteps;
} UA_AxisInformation;

#define UA_TYPES_AXISINFORMATION 392

UA_INLINABLE( void
UA_AxisInformation_init(UA_AxisInformation *p), {
    memset(p, 0, sizeof(UA_AxisInformation));
})

UA_INLINABLE( UA_AxisInformation *
UA_AxisInformation_new(void), {
    return (UA_AxisInformation*)UA_new(&UA_TYPES[UA_TYPES_AXISINFORMATION]);
})

UA_INLINABLE( UA_StatusCode
UA_AxisInformation_copy(const UA_AxisInformation *src, UA_AxisInformation *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AXISINFORMATION]);
})

UA_INLINABLE( void
UA_AxisInformation_clear(UA_AxisInformation *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_AXISINFORMATION]);
})

UA_INLINABLE( void
UA_AxisInformation_delete(UA_AxisInformation *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_AXISINFORMATION]);
})

UA_INLINABLE( UA_Boolean
UA_AxisInformation_equal(const UA_AxisInformation *p1, const UA_AxisInformation *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_AXISINFORMATION]) == UA_ORDER_EQ);
})


/* XVType */
typedef struct {
    UA_Double x;
    UA_Float value;
} UA_XVType;

#define UA_TYPES_XVTYPE 393

UA_INLINABLE( void
UA_XVType_init(UA_XVType *p), {
    memset(p, 0, sizeof(UA_XVType));
})

UA_INLINABLE( UA_XVType *
UA_XVType_new(void), {
    return (UA_XVType*)UA_new(&UA_TYPES[UA_TYPES_XVTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_XVType_copy(const UA_XVType *src, UA_XVType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_XVTYPE]);
})

UA_INLINABLE( void
UA_XVType_clear(UA_XVType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_XVTYPE]);
})

UA_INLINABLE( void
UA_XVType_delete(UA_XVType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_XVTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_XVType_equal(const UA_XVType *p1, const UA_XVType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_XVTYPE]) == UA_ORDER_EQ);
})


/* ProgramDiagnosticDataType */
typedef struct {
    UA_NodeId createSessionId;
    UA_String createClientName;
    UA_DateTime invocationCreationTime;
    UA_DateTime lastTransitionTime;
    UA_String lastMethodCall;
    UA_NodeId lastMethodSessionId;
    size_t lastMethodInputArgumentsSize;
    UA_Argument *lastMethodInputArguments;
    size_t lastMethodOutputArgumentsSize;
    UA_Argument *lastMethodOutputArguments;
    UA_DateTime lastMethodCallTime;
    UA_StatusResult lastMethodReturnStatus;
} UA_ProgramDiagnosticDataType;

#define UA_TYPES_PROGRAMDIAGNOSTICDATATYPE 394

UA_INLINABLE( void
UA_ProgramDiagnosticDataType_init(UA_ProgramDiagnosticDataType *p), {
    memset(p, 0, sizeof(UA_ProgramDiagnosticDataType));
})

UA_INLINABLE( UA_ProgramDiagnosticDataType *
UA_ProgramDiagnosticDataType_new(void), {
    return (UA_ProgramDiagnosticDataType*)UA_new(&UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTICDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ProgramDiagnosticDataType_copy(const UA_ProgramDiagnosticDataType *src, UA_ProgramDiagnosticDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTICDATATYPE]);
})

UA_INLINABLE( void
UA_ProgramDiagnosticDataType_clear(UA_ProgramDiagnosticDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTICDATATYPE]);
})

UA_INLINABLE( void
UA_ProgramDiagnosticDataType_delete(UA_ProgramDiagnosticDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTICDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ProgramDiagnosticDataType_equal(const UA_ProgramDiagnosticDataType *p1, const UA_ProgramDiagnosticDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTICDATATYPE]) == UA_ORDER_EQ);
})


/* ProgramDiagnostic2DataType */
typedef struct {
    UA_NodeId createSessionId;
    UA_String createClientName;
    UA_DateTime invocationCreationTime;
    UA_DateTime lastTransitionTime;
    UA_String lastMethodCall;
    UA_NodeId lastMethodSessionId;
    size_t lastMethodInputArgumentsSize;
    UA_Argument *lastMethodInputArguments;
    size_t lastMethodOutputArgumentsSize;
    UA_Argument *lastMethodOutputArguments;
    size_t lastMethodInputValuesSize;
    UA_Variant *lastMethodInputValues;
    size_t lastMethodOutputValuesSize;
    UA_Variant *lastMethodOutputValues;
    UA_DateTime lastMethodCallTime;
    UA_StatusCode lastMethodReturnStatus;
} UA_ProgramDiagnostic2DataType;

#define UA_TYPES_PROGRAMDIAGNOSTIC2DATATYPE 395

UA_INLINABLE( void
UA_ProgramDiagnostic2DataType_init(UA_ProgramDiagnostic2DataType *p), {
    memset(p, 0, sizeof(UA_ProgramDiagnostic2DataType));
})

UA_INLINABLE( UA_ProgramDiagnostic2DataType *
UA_ProgramDiagnostic2DataType_new(void), {
    return (UA_ProgramDiagnostic2DataType*)UA_new(&UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTIC2DATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ProgramDiagnostic2DataType_copy(const UA_ProgramDiagnostic2DataType *src, UA_ProgramDiagnostic2DataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTIC2DATATYPE]);
})

UA_INLINABLE( void
UA_ProgramDiagnostic2DataType_clear(UA_ProgramDiagnostic2DataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTIC2DATATYPE]);
})

UA_INLINABLE( void
UA_ProgramDiagnostic2DataType_delete(UA_ProgramDiagnostic2DataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTIC2DATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ProgramDiagnostic2DataType_equal(const UA_ProgramDiagnostic2DataType *p1, const UA_ProgramDiagnostic2DataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PROGRAMDIAGNOSTIC2DATATYPE]) == UA_ORDER_EQ);
})


/* Annotation */
typedef struct {
    UA_String message;
    UA_String userName;
    UA_DateTime annotationTime;
} UA_Annotation;

#define UA_TYPES_ANNOTATION 396

UA_INLINABLE( void
UA_Annotation_init(UA_Annotation *p), {
    memset(p, 0, sizeof(UA_Annotation));
})

UA_INLINABLE( UA_Annotation *
UA_Annotation_new(void), {
    return (UA_Annotation*)UA_new(&UA_TYPES[UA_TYPES_ANNOTATION]);
})

UA_INLINABLE( UA_StatusCode
UA_Annotation_copy(const UA_Annotation *src, UA_Annotation *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ANNOTATION]);
})

UA_INLINABLE( void
UA_Annotation_clear(UA_Annotation *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ANNOTATION]);
})

UA_INLINABLE( void
UA_Annotation_delete(UA_Annotation *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ANNOTATION]);
})

UA_INLINABLE( UA_Boolean
UA_Annotation_equal(const UA_Annotation *p1, const UA_Annotation *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ANNOTATION]) == UA_ORDER_EQ);
})


/* ExceptionDeviationFormat */
typedef enum {
    UA_EXCEPTIONDEVIATIONFORMAT_ABSOLUTEVALUE = 0,
    UA_EXCEPTIONDEVIATIONFORMAT_PERCENTOFVALUE = 1,
    UA_EXCEPTIONDEVIATIONFORMAT_PERCENTOFRANGE = 2,
    UA_EXCEPTIONDEVIATIONFORMAT_PERCENTOFEURANGE = 3,
    UA_EXCEPTIONDEVIATIONFORMAT_UNKNOWN = 4,
    __UA_EXCEPTIONDEVIATIONFORMAT_FORCE32BIT = 0x7fffffff
} UA_ExceptionDeviationFormat;

UA_STATIC_ASSERT(sizeof(UA_ExceptionDeviationFormat) == sizeof(UA_Int32), enum_must_be_32bit);

#define UA_TYPES_EXCEPTIONDEVIATIONFORMAT 397

UA_INLINABLE( void
UA_ExceptionDeviationFormat_init(UA_ExceptionDeviationFormat *p), {
    memset(p, 0, sizeof(UA_ExceptionDeviationFormat));
})

UA_INLINABLE( UA_ExceptionDeviationFormat *
UA_ExceptionDeviationFormat_new(void), {
    return (UA_ExceptionDeviationFormat*)UA_new(&UA_TYPES[UA_TYPES_EXCEPTIONDEVIATIONFORMAT]);
})

UA_INLINABLE( UA_StatusCode
UA_ExceptionDeviationFormat_copy(const UA_ExceptionDeviationFormat *src, UA_ExceptionDeviationFormat *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXCEPTIONDEVIATIONFORMAT]);
})

UA_INLINABLE( void
UA_ExceptionDeviationFormat_clear(UA_ExceptionDeviationFormat *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EXCEPTIONDEVIATIONFORMAT]);
})

UA_INLINABLE( void
UA_ExceptionDeviationFormat_delete(UA_ExceptionDeviationFormat *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EXCEPTIONDEVIATIONFORMAT]);
})

UA_INLINABLE( UA_Boolean
UA_ExceptionDeviationFormat_equal(const UA_ExceptionDeviationFormat *p1, const UA_ExceptionDeviationFormat *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EXCEPTIONDEVIATIONFORMAT]) == UA_ORDER_EQ);
})


/* EndpointType */
typedef struct {
    UA_String endpointUrl;
    UA_MessageSecurityMode securityMode;
    UA_String securityPolicyUri;
    UA_String transportProfileUri;
} UA_EndpointType;

#define UA_TYPES_ENDPOINTTYPE 398

UA_INLINABLE( void
UA_EndpointType_init(UA_EndpointType *p), {
    memset(p, 0, sizeof(UA_EndpointType));
})

UA_INLINABLE( UA_EndpointType *
UA_EndpointType_new(void), {
    return (UA_EndpointType*)UA_new(&UA_TYPES[UA_TYPES_ENDPOINTTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_EndpointType_copy(const UA_EndpointType *src, UA_EndpointType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENDPOINTTYPE]);
})

UA_INLINABLE( void
UA_EndpointType_clear(UA_EndpointType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTTYPE]);
})

UA_INLINABLE( void
UA_EndpointType_delete(UA_EndpointType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENDPOINTTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_EndpointType_equal(const UA_EndpointType *p1, const UA_EndpointType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENDPOINTTYPE]) == UA_ORDER_EQ);
})


/* ConfigurationUpdateTargetType */
typedef struct {
    UA_String path;
    UA_ConfigurationUpdateType updateType;
} UA_ConfigurationUpdateTargetType;

#define UA_TYPES_CONFIGURATIONUPDATETARGETTYPE 399

UA_INLINABLE( void
UA_ConfigurationUpdateTargetType_init(UA_ConfigurationUpdateTargetType *p), {
    memset(p, 0, sizeof(UA_ConfigurationUpdateTargetType));
})

UA_INLINABLE( UA_ConfigurationUpdateTargetType *
UA_ConfigurationUpdateTargetType_new(void), {
    return (UA_ConfigurationUpdateTargetType*)UA_new(&UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETARGETTYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ConfigurationUpdateTargetType_copy(const UA_ConfigurationUpdateTargetType *src, UA_ConfigurationUpdateTargetType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETARGETTYPE]);
})

UA_INLINABLE( void
UA_ConfigurationUpdateTargetType_clear(UA_ConfigurationUpdateTargetType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETARGETTYPE]);
})

UA_INLINABLE( void
UA_ConfigurationUpdateTargetType_delete(UA_ConfigurationUpdateTargetType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETARGETTYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ConfigurationUpdateTargetType_equal(const UA_ConfigurationUpdateTargetType *p1, const UA_ConfigurationUpdateTargetType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_CONFIGURATIONUPDATETARGETTYPE]) == UA_ORDER_EQ);
})


/* ApplicationIdentityDataType */
typedef struct {
    UA_String name;
    size_t recordPropertiesSize;
    UA_KeyValuePair *recordProperties;
    UA_String applicationUri;
    size_t applicationNamesSize;
    UA_LocalizedText *applicationNames;
    size_t additionalServersSize;
    UA_ApplicationDescription *additionalServers;
} UA_ApplicationIdentityDataType;

#define UA_TYPES_APPLICATIONIDENTITYDATATYPE 400

UA_INLINABLE( void
UA_ApplicationIdentityDataType_init(UA_ApplicationIdentityDataType *p), {
    memset(p, 0, sizeof(UA_ApplicationIdentityDataType));
})

UA_INLINABLE( UA_ApplicationIdentityDataType *
UA_ApplicationIdentityDataType_new(void), {
    return (UA_ApplicationIdentityDataType*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONIDENTITYDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ApplicationIdentityDataType_copy(const UA_ApplicationIdentityDataType *src, UA_ApplicationIdentityDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONIDENTITYDATATYPE]);
})

UA_INLINABLE( void
UA_ApplicationIdentityDataType_clear(UA_ApplicationIdentityDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONIDENTITYDATATYPE]);
})

UA_INLINABLE( void
UA_ApplicationIdentityDataType_delete(UA_ApplicationIdentityDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONIDENTITYDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ApplicationIdentityDataType_equal(const UA_ApplicationIdentityDataType *p1, const UA_ApplicationIdentityDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_APPLICATIONIDENTITYDATATYPE]) == UA_ORDER_EQ);
})


/* SecuritySettingsDataType */
typedef struct {
    UA_String name;
    size_t recordPropertiesSize;
    UA_KeyValuePair *recordProperties;
    size_t securityModesSize;
    UA_MessageSecurityMode *securityModes;
    size_t securityPolicyUrisSize;
    UA_String *securityPolicyUris;
    UA_String certificateGroupName;
} UA_SecuritySettingsDataType;

#define UA_TYPES_SECURITYSETTINGSDATATYPE 401

UA_INLINABLE( void
UA_SecuritySettingsDataType_init(UA_SecuritySettingsDataType *p), {
    memset(p, 0, sizeof(UA_SecuritySettingsDataType));
})

UA_INLINABLE( UA_SecuritySettingsDataType *
UA_SecuritySettingsDataType_new(void), {
    return (UA_SecuritySettingsDataType*)UA_new(&UA_TYPES[UA_TYPES_SECURITYSETTINGSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SecuritySettingsDataType_copy(const UA_SecuritySettingsDataType *src, UA_SecuritySettingsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SECURITYSETTINGSDATATYPE]);
})

UA_INLINABLE( void
UA_SecuritySettingsDataType_clear(UA_SecuritySettingsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SECURITYSETTINGSDATATYPE]);
})

UA_INLINABLE( void
UA_SecuritySettingsDataType_delete(UA_SecuritySettingsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SECURITYSETTINGSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SecuritySettingsDataType_equal(const UA_SecuritySettingsDataType *p1, const UA_SecuritySettingsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SECURITYSETTINGSDATATYPE]) == UA_ORDER_EQ);
})


/* UserTokenSettingsDataType */
typedef struct {
    UA_String name;
    size_t recordPropertiesSize;
    UA_KeyValuePair *recordProperties;
    UA_UserTokenType tokenType;
    UA_String issuedTokenType;
    UA_String issuerEndpointUrl;
    UA_String securityPolicyUri;
    UA_String certificateGroupName;
    UA_String authorizationServiceName;
} UA_UserTokenSettingsDataType;

#define UA_TYPES_USERTOKENSETTINGSDATATYPE 402

UA_INLINABLE( void
UA_UserTokenSettingsDataType_init(UA_UserTokenSettingsDataType *p), {
    memset(p, 0, sizeof(UA_UserTokenSettingsDataType));
})

UA_INLINABLE( UA_UserTokenSettingsDataType *
UA_UserTokenSettingsDataType_new(void), {
    return (UA_UserTokenSettingsDataType*)UA_new(&UA_TYPES[UA_TYPES_USERTOKENSETTINGSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_UserTokenSettingsDataType_copy(const UA_UserTokenSettingsDataType *src, UA_UserTokenSettingsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERTOKENSETTINGSDATATYPE]);
})

UA_INLINABLE( void
UA_UserTokenSettingsDataType_clear(UA_UserTokenSettingsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENSETTINGSDATATYPE]);
})

UA_INLINABLE( void
UA_UserTokenSettingsDataType_delete(UA_UserTokenSettingsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_USERTOKENSETTINGSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_UserTokenSettingsDataType_equal(const UA_UserTokenSettingsDataType *p1, const UA_UserTokenSettingsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_USERTOKENSETTINGSDATATYPE]) == UA_ORDER_EQ);
})


/* StructureDescription */
typedef struct {
    UA_NodeId dataTypeId;
    UA_QualifiedName name;
    UA_StructureDefinition structureDefinition;
} UA_StructureDescription;

#define UA_TYPES_STRUCTUREDESCRIPTION 403

UA_INLINABLE( void
UA_StructureDescription_init(UA_StructureDescription *p), {
    memset(p, 0, sizeof(UA_StructureDescription));
})

UA_INLINABLE( UA_StructureDescription *
UA_StructureDescription_new(void), {
    return (UA_StructureDescription*)UA_new(&UA_TYPES[UA_TYPES_STRUCTUREDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_StructureDescription_copy(const UA_StructureDescription *src, UA_StructureDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTUREDESCRIPTION]);
})

UA_INLINABLE( void
UA_StructureDescription_clear(UA_StructureDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREDESCRIPTION]);
})

UA_INLINABLE( void
UA_StructureDescription_delete(UA_StructureDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTUREDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_StructureDescription_equal(const UA_StructureDescription *p1, const UA_StructureDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STRUCTUREDESCRIPTION]) == UA_ORDER_EQ);
})


/* FieldMetaData */
typedef struct {
    UA_String name;
    UA_LocalizedText description;
    UA_DataSetFieldFlags fieldFlags;
    UA_Byte builtInType;
    UA_NodeId dataType;
    UA_Int32 valueRank;
    size_t arrayDimensionsSize;
    UA_UInt32 *arrayDimensions;
    UA_UInt32 maxStringLength;
    UA_Guid dataSetFieldId;
    size_t propertiesSize;
    UA_KeyValuePair *properties;
} UA_FieldMetaData;

#define UA_TYPES_FIELDMETADATA 404

UA_INLINABLE( void
UA_FieldMetaData_init(UA_FieldMetaData *p), {
    memset(p, 0, sizeof(UA_FieldMetaData));
})

UA_INLINABLE( UA_FieldMetaData *
UA_FieldMetaData_new(void), {
    return (UA_FieldMetaData*)UA_new(&UA_TYPES[UA_TYPES_FIELDMETADATA]);
})

UA_INLINABLE( UA_StatusCode
UA_FieldMetaData_copy(const UA_FieldMetaData *src, UA_FieldMetaData *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FIELDMETADATA]);
})

UA_INLINABLE( void
UA_FieldMetaData_clear(UA_FieldMetaData *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_FIELDMETADATA]);
})

UA_INLINABLE( void
UA_FieldMetaData_delete(UA_FieldMetaData *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_FIELDMETADATA]);
})

UA_INLINABLE( UA_Boolean
UA_FieldMetaData_equal(const UA_FieldMetaData *p1, const UA_FieldMetaData *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_FIELDMETADATA]) == UA_ORDER_EQ);
})


/* PublishedEventsDataType */
typedef struct {
    UA_NodeId eventNotifier;
    size_t selectedFieldsSize;
    UA_SimpleAttributeOperand *selectedFields;
    UA_ContentFilter filter;
} UA_PublishedEventsDataType;

#define UA_TYPES_PUBLISHEDEVENTSDATATYPE 405

UA_INLINABLE( void
UA_PublishedEventsDataType_init(UA_PublishedEventsDataType *p), {
    memset(p, 0, sizeof(UA_PublishedEventsDataType));
})

UA_INLINABLE( UA_PublishedEventsDataType *
UA_PublishedEventsDataType_new(void), {
    return (UA_PublishedEventsDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHEDEVENTSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishedEventsDataType_copy(const UA_PublishedEventsDataType *src, UA_PublishedEventsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHEDEVENTSDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedEventsDataType_clear(UA_PublishedEventsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHEDEVENTSDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedEventsDataType_delete(UA_PublishedEventsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHEDEVENTSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PublishedEventsDataType_equal(const UA_PublishedEventsDataType *p1, const UA_PublishedEventsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHEDEVENTSDATATYPE]) == UA_ORDER_EQ);
})


/* PubSubGroupDataType */
typedef struct {
    UA_String name;
    UA_Boolean enabled;
    UA_MessageSecurityMode securityMode;
    UA_String securityGroupId;
    size_t securityKeyServicesSize;
    UA_EndpointDescription *securityKeyServices;
    UA_UInt32 maxNetworkMessageSize;
    size_t groupPropertiesSize;
    UA_KeyValuePair *groupProperties;
} UA_PubSubGroupDataType;

#define UA_TYPES_PUBSUBGROUPDATATYPE 406

UA_INLINABLE( void
UA_PubSubGroupDataType_init(UA_PubSubGroupDataType *p), {
    memset(p, 0, sizeof(UA_PubSubGroupDataType));
})

UA_INLINABLE( UA_PubSubGroupDataType *
UA_PubSubGroupDataType_new(void), {
    return (UA_PubSubGroupDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBGROUPDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubGroupDataType_copy(const UA_PubSubGroupDataType *src, UA_PubSubGroupDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubGroupDataType_clear(UA_PubSubGroupDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubGroupDataType_delete(UA_PubSubGroupDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBGROUPDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubGroupDataType_equal(const UA_PubSubGroupDataType *p1, const UA_PubSubGroupDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBGROUPDATATYPE]) == UA_ORDER_EQ);
})


/* WriterGroupDataType */
typedef struct {
    UA_String name;
    UA_Boolean enabled;
    UA_MessageSecurityMode securityMode;
    UA_String securityGroupId;
    size_t securityKeyServicesSize;
    UA_EndpointDescription *securityKeyServices;
    UA_UInt32 maxNetworkMessageSize;
    size_t groupPropertiesSize;
    UA_KeyValuePair *groupProperties;
    UA_UInt16 writerGroupId;
    UA_Double publishingInterval;
    UA_Double keepAliveTime;
    UA_Byte priority;
    size_t localeIdsSize;
    UA_String *localeIds;
    UA_String headerLayoutUri;
    UA_ExtensionObject transportSettings;
    UA_ExtensionObject messageSettings;
    size_t dataSetWritersSize;
    UA_DataSetWriterDataType *dataSetWriters;
} UA_WriterGroupDataType;

#define UA_TYPES_WRITERGROUPDATATYPE 407

UA_INLINABLE( void
UA_WriterGroupDataType_init(UA_WriterGroupDataType *p), {
    memset(p, 0, sizeof(UA_WriterGroupDataType));
})

UA_INLINABLE( UA_WriterGroupDataType *
UA_WriterGroupDataType_new(void), {
    return (UA_WriterGroupDataType*)UA_new(&UA_TYPES[UA_TYPES_WRITERGROUPDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_WriterGroupDataType_copy(const UA_WriterGroupDataType *src, UA_WriterGroupDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITERGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_WriterGroupDataType_clear(UA_WriterGroupDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_WRITERGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_WriterGroupDataType_delete(UA_WriterGroupDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_WRITERGROUPDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_WriterGroupDataType_equal(const UA_WriterGroupDataType *p1, const UA_WriterGroupDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_WRITERGROUPDATATYPE]) == UA_ORDER_EQ);
})


/* FieldTargetDataType */
typedef struct {
    UA_Guid dataSetFieldId;
    UA_String receiverIndexRange;
    UA_NodeId targetNodeId;
    UA_UInt32 attributeId;
    UA_String writeIndexRange;
    UA_OverrideValueHandling overrideValueHandling;
    UA_Variant overrideValue;
} UA_FieldTargetDataType;

#define UA_TYPES_FIELDTARGETDATATYPE 408

UA_INLINABLE( void
UA_FieldTargetDataType_init(UA_FieldTargetDataType *p), {
    memset(p, 0, sizeof(UA_FieldTargetDataType));
})

UA_INLINABLE( UA_FieldTargetDataType *
UA_FieldTargetDataType_new(void), {
    return (UA_FieldTargetDataType*)UA_new(&UA_TYPES[UA_TYPES_FIELDTARGETDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_FieldTargetDataType_copy(const UA_FieldTargetDataType *src, UA_FieldTargetDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FIELDTARGETDATATYPE]);
})

UA_INLINABLE( void
UA_FieldTargetDataType_clear(UA_FieldTargetDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_FIELDTARGETDATATYPE]);
})

UA_INLINABLE( void
UA_FieldTargetDataType_delete(UA_FieldTargetDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_FIELDTARGETDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_FieldTargetDataType_equal(const UA_FieldTargetDataType *p1, const UA_FieldTargetDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_FIELDTARGETDATATYPE]) == UA_ORDER_EQ);
})


/* SubscribedDataSetMirrorDataType */
typedef struct {
    UA_String parentNodeName;
    size_t rolePermissionsSize;
    UA_RolePermissionType *rolePermissions;
} UA_SubscribedDataSetMirrorDataType;

#define UA_TYPES_SUBSCRIBEDDATASETMIRRORDATATYPE 409

UA_INLINABLE( void
UA_SubscribedDataSetMirrorDataType_init(UA_SubscribedDataSetMirrorDataType *p), {
    memset(p, 0, sizeof(UA_SubscribedDataSetMirrorDataType));
})

UA_INLINABLE( UA_SubscribedDataSetMirrorDataType *
UA_SubscribedDataSetMirrorDataType_new(void), {
    return (UA_SubscribedDataSetMirrorDataType*)UA_new(&UA_TYPES[UA_TYPES_SUBSCRIBEDDATASETMIRRORDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SubscribedDataSetMirrorDataType_copy(const UA_SubscribedDataSetMirrorDataType *src, UA_SubscribedDataSetMirrorDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SUBSCRIBEDDATASETMIRRORDATATYPE]);
})

UA_INLINABLE( void
UA_SubscribedDataSetMirrorDataType_clear(UA_SubscribedDataSetMirrorDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SUBSCRIBEDDATASETMIRRORDATATYPE]);
})

UA_INLINABLE( void
UA_SubscribedDataSetMirrorDataType_delete(UA_SubscribedDataSetMirrorDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SUBSCRIBEDDATASETMIRRORDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SubscribedDataSetMirrorDataType_equal(const UA_SubscribedDataSetMirrorDataType *p1, const UA_SubscribedDataSetMirrorDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SUBSCRIBEDDATASETMIRRORDATATYPE]) == UA_ORDER_EQ);
})


/* SecurityGroupDataType */
typedef struct {
    UA_String name;
    size_t securityGroupFolderSize;
    UA_String *securityGroupFolder;
    UA_Double keyLifetime;
    UA_String securityPolicyUri;
    UA_UInt32 maxFutureKeyCount;
    UA_UInt32 maxPastKeyCount;
    UA_String securityGroupId;
    size_t rolePermissionsSize;
    UA_RolePermissionType *rolePermissions;
    size_t groupPropertiesSize;
    UA_KeyValuePair *groupProperties;
} UA_SecurityGroupDataType;

#define UA_TYPES_SECURITYGROUPDATATYPE 410

UA_INLINABLE( void
UA_SecurityGroupDataType_init(UA_SecurityGroupDataType *p), {
    memset(p, 0, sizeof(UA_SecurityGroupDataType));
})

UA_INLINABLE( UA_SecurityGroupDataType *
UA_SecurityGroupDataType_new(void), {
    return (UA_SecurityGroupDataType*)UA_new(&UA_TYPES[UA_TYPES_SECURITYGROUPDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SecurityGroupDataType_copy(const UA_SecurityGroupDataType *src, UA_SecurityGroupDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SECURITYGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_SecurityGroupDataType_clear(UA_SecurityGroupDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SECURITYGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_SecurityGroupDataType_delete(UA_SecurityGroupDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SECURITYGROUPDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SecurityGroupDataType_equal(const UA_SecurityGroupDataType *p1, const UA_SecurityGroupDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SECURITYGROUPDATATYPE]) == UA_ORDER_EQ);
})


/* PubSubKeyPushTargetDataType */
typedef struct {
    UA_String applicationUri;
    size_t pushTargetFolderSize;
    UA_String *pushTargetFolder;
    UA_String endpointUrl;
    UA_String securityPolicyUri;
    UA_UserTokenPolicy userTokenType;
    UA_UInt16 requestedKeyCount;
    UA_Double retryInterval;
    size_t pushTargetPropertiesSize;
    UA_KeyValuePair *pushTargetProperties;
    size_t securityGroupsSize;
    UA_String *securityGroups;
} UA_PubSubKeyPushTargetDataType;

#define UA_TYPES_PUBSUBKEYPUSHTARGETDATATYPE 411

UA_INLINABLE( void
UA_PubSubKeyPushTargetDataType_init(UA_PubSubKeyPushTargetDataType *p), {
    memset(p, 0, sizeof(UA_PubSubKeyPushTargetDataType));
})

UA_INLINABLE( UA_PubSubKeyPushTargetDataType *
UA_PubSubKeyPushTargetDataType_new(void), {
    return (UA_PubSubKeyPushTargetDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBKEYPUSHTARGETDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubKeyPushTargetDataType_copy(const UA_PubSubKeyPushTargetDataType *src, UA_PubSubKeyPushTargetDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBKEYPUSHTARGETDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubKeyPushTargetDataType_clear(UA_PubSubKeyPushTargetDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBKEYPUSHTARGETDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubKeyPushTargetDataType_delete(UA_PubSubKeyPushTargetDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBKEYPUSHTARGETDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubKeyPushTargetDataType_equal(const UA_PubSubKeyPushTargetDataType *p1, const UA_PubSubKeyPushTargetDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBKEYPUSHTARGETDATATYPE]) == UA_ORDER_EQ);
})


/* JsonApplicationDescriptionMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_DateTime timestamp;
    UA_ApplicationDescription description;
    size_t serverCapabilitiesSize;
    UA_String *serverCapabilities;
} UA_JsonApplicationDescriptionMessage;

#define UA_TYPES_JSONAPPLICATIONDESCRIPTIONMESSAGE 412

UA_INLINABLE( void
UA_JsonApplicationDescriptionMessage_init(UA_JsonApplicationDescriptionMessage *p), {
    memset(p, 0, sizeof(UA_JsonApplicationDescriptionMessage));
})

UA_INLINABLE( UA_JsonApplicationDescriptionMessage *
UA_JsonApplicationDescriptionMessage_new(void), {
    return (UA_JsonApplicationDescriptionMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONAPPLICATIONDESCRIPTIONMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonApplicationDescriptionMessage_copy(const UA_JsonApplicationDescriptionMessage *src, UA_JsonApplicationDescriptionMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONAPPLICATIONDESCRIPTIONMESSAGE]);
})

UA_INLINABLE( void
UA_JsonApplicationDescriptionMessage_clear(UA_JsonApplicationDescriptionMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONAPPLICATIONDESCRIPTIONMESSAGE]);
})

UA_INLINABLE( void
UA_JsonApplicationDescriptionMessage_delete(UA_JsonApplicationDescriptionMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONAPPLICATIONDESCRIPTIONMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonApplicationDescriptionMessage_equal(const UA_JsonApplicationDescriptionMessage *p1, const UA_JsonApplicationDescriptionMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONAPPLICATIONDESCRIPTIONMESSAGE]) == UA_ORDER_EQ);
})


/* JsonServerEndpointsMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_DateTime timestamp;
    UA_ApplicationDescription description;
    size_t endpointsSize;
    UA_EndpointDescription *endpoints;
} UA_JsonServerEndpointsMessage;

#define UA_TYPES_JSONSERVERENDPOINTSMESSAGE 413

UA_INLINABLE( void
UA_JsonServerEndpointsMessage_init(UA_JsonServerEndpointsMessage *p), {
    memset(p, 0, sizeof(UA_JsonServerEndpointsMessage));
})

UA_INLINABLE( UA_JsonServerEndpointsMessage *
UA_JsonServerEndpointsMessage_new(void), {
    return (UA_JsonServerEndpointsMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONSERVERENDPOINTSMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonServerEndpointsMessage_copy(const UA_JsonServerEndpointsMessage *src, UA_JsonServerEndpointsMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONSERVERENDPOINTSMESSAGE]);
})

UA_INLINABLE( void
UA_JsonServerEndpointsMessage_clear(UA_JsonServerEndpointsMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONSERVERENDPOINTSMESSAGE]);
})

UA_INLINABLE( void
UA_JsonServerEndpointsMessage_delete(UA_JsonServerEndpointsMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONSERVERENDPOINTSMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonServerEndpointsMessage_equal(const UA_JsonServerEndpointsMessage *p1, const UA_JsonServerEndpointsMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONSERVERENDPOINTSMESSAGE]) == UA_ORDER_EQ);
})


/* LogRecord */
typedef struct {
    UA_DateTime time;
    UA_UInt16 severity;
    UA_NodeId eventType;
    UA_NodeId sourceNode;
    UA_String sourceName;
    UA_LocalizedText message;
    UA_TraceContextDataType traceContext;
    size_t additionalDataSize;
    UA_NameValuePair *additionalData;
} UA_LogRecord;

#define UA_TYPES_LOGRECORD 414

UA_INLINABLE( void
UA_LogRecord_init(UA_LogRecord *p), {
    memset(p, 0, sizeof(UA_LogRecord));
})

UA_INLINABLE( UA_LogRecord *
UA_LogRecord_new(void), {
    return (UA_LogRecord*)UA_new(&UA_TYPES[UA_TYPES_LOGRECORD]);
})

UA_INLINABLE( UA_StatusCode
UA_LogRecord_copy(const UA_LogRecord *src, UA_LogRecord *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOGRECORD]);
})

UA_INLINABLE( void
UA_LogRecord_clear(UA_LogRecord *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOGRECORD]);
})

UA_INLINABLE( void
UA_LogRecord_delete(UA_LogRecord *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LOGRECORD]);
})

UA_INLINABLE( UA_Boolean
UA_LogRecord_equal(const UA_LogRecord *p1, const UA_LogRecord *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LOGRECORD]) == UA_ORDER_EQ);
})


/* LogRecordsDataType */
typedef struct {
    size_t logRecordArraySize;
    UA_LogRecord *logRecordArray;
} UA_LogRecordsDataType;

#define UA_TYPES_LOGRECORDSDATATYPE 415

UA_INLINABLE( void
UA_LogRecordsDataType_init(UA_LogRecordsDataType *p), {
    memset(p, 0, sizeof(UA_LogRecordsDataType));
})

UA_INLINABLE( UA_LogRecordsDataType *
UA_LogRecordsDataType_new(void), {
    return (UA_LogRecordsDataType*)UA_new(&UA_TYPES[UA_TYPES_LOGRECORDSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_LogRecordsDataType_copy(const UA_LogRecordsDataType *src, UA_LogRecordsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOGRECORDSDATATYPE]);
})

UA_INLINABLE( void
UA_LogRecordsDataType_clear(UA_LogRecordsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_LOGRECORDSDATATYPE]);
})

UA_INLINABLE( void
UA_LogRecordsDataType_delete(UA_LogRecordsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_LOGRECORDSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_LogRecordsDataType_equal(const UA_LogRecordsDataType *p1, const UA_LogRecordsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_LOGRECORDSDATATYPE]) == UA_ORDER_EQ);
})


/* EnumDefinition */
typedef struct {
    size_t fieldsSize;
    UA_EnumField *fields;
} UA_EnumDefinition;

#define UA_TYPES_ENUMDEFINITION 416

UA_INLINABLE( void
UA_EnumDefinition_init(UA_EnumDefinition *p), {
    memset(p, 0, sizeof(UA_EnumDefinition));
})

UA_INLINABLE( UA_EnumDefinition *
UA_EnumDefinition_new(void), {
    return (UA_EnumDefinition*)UA_new(&UA_TYPES[UA_TYPES_ENUMDEFINITION]);
})

UA_INLINABLE( UA_StatusCode
UA_EnumDefinition_copy(const UA_EnumDefinition *src, UA_EnumDefinition *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMDEFINITION]);
})

UA_INLINABLE( void
UA_EnumDefinition_clear(UA_EnumDefinition *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMDEFINITION]);
})

UA_INLINABLE( void
UA_EnumDefinition_delete(UA_EnumDefinition *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENUMDEFINITION]);
})

UA_INLINABLE( UA_Boolean
UA_EnumDefinition_equal(const UA_EnumDefinition *p1, const UA_EnumDefinition *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENUMDEFINITION]) == UA_ORDER_EQ);
})


/* ReadEventDetails */
typedef struct {
    UA_UInt32 numValuesPerNode;
    UA_DateTime startTime;
    UA_DateTime endTime;
    UA_EventFilter filter;
} UA_ReadEventDetails;

#define UA_TYPES_READEVENTDETAILS 417

UA_INLINABLE( void
UA_ReadEventDetails_init(UA_ReadEventDetails *p), {
    memset(p, 0, sizeof(UA_ReadEventDetails));
})

UA_INLINABLE( UA_ReadEventDetails *
UA_ReadEventDetails_new(void), {
    return (UA_ReadEventDetails*)UA_new(&UA_TYPES[UA_TYPES_READEVENTDETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadEventDetails_copy(const UA_ReadEventDetails *src, UA_ReadEventDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READEVENTDETAILS]);
})

UA_INLINABLE( void
UA_ReadEventDetails_clear(UA_ReadEventDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READEVENTDETAILS]);
})

UA_INLINABLE( void
UA_ReadEventDetails_delete(UA_ReadEventDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READEVENTDETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_ReadEventDetails_equal(const UA_ReadEventDetails *p1, const UA_ReadEventDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READEVENTDETAILS]) == UA_ORDER_EQ);
})


/* ReadEventDetails2 */
typedef struct {
    UA_UInt32 numValuesPerNode;
    UA_DateTime startTime;
    UA_DateTime endTime;
    UA_EventFilter filter;
    UA_Boolean readModified;
} UA_ReadEventDetails2;

#define UA_TYPES_READEVENTDETAILS2 418

UA_INLINABLE( void
UA_ReadEventDetails2_init(UA_ReadEventDetails2 *p), {
    memset(p, 0, sizeof(UA_ReadEventDetails2));
})

UA_INLINABLE( UA_ReadEventDetails2 *
UA_ReadEventDetails2_new(void), {
    return (UA_ReadEventDetails2*)UA_new(&UA_TYPES[UA_TYPES_READEVENTDETAILS2]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadEventDetails2_copy(const UA_ReadEventDetails2 *src, UA_ReadEventDetails2 *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READEVENTDETAILS2]);
})

UA_INLINABLE( void
UA_ReadEventDetails2_clear(UA_ReadEventDetails2 *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READEVENTDETAILS2]);
})

UA_INLINABLE( void
UA_ReadEventDetails2_delete(UA_ReadEventDetails2 *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READEVENTDETAILS2]);
})

UA_INLINABLE( UA_Boolean
UA_ReadEventDetails2_equal(const UA_ReadEventDetails2 *p1, const UA_ReadEventDetails2 *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READEVENTDETAILS2]) == UA_ORDER_EQ);
})


/* ReadEventDetailsSorted */
typedef struct {
    UA_UInt32 numValuesPerNode;
    UA_DateTime startTime;
    UA_DateTime endTime;
    UA_EventFilter filter;
    size_t sortClauseSize;
    UA_SortRuleElement *sortClause;
} UA_ReadEventDetailsSorted;

#define UA_TYPES_READEVENTDETAILSSORTED 419

UA_INLINABLE( void
UA_ReadEventDetailsSorted_init(UA_ReadEventDetailsSorted *p), {
    memset(p, 0, sizeof(UA_ReadEventDetailsSorted));
})

UA_INLINABLE( UA_ReadEventDetailsSorted *
UA_ReadEventDetailsSorted_new(void), {
    return (UA_ReadEventDetailsSorted*)UA_new(&UA_TYPES[UA_TYPES_READEVENTDETAILSSORTED]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadEventDetailsSorted_copy(const UA_ReadEventDetailsSorted *src, UA_ReadEventDetailsSorted *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READEVENTDETAILSSORTED]);
})

UA_INLINABLE( void
UA_ReadEventDetailsSorted_clear(UA_ReadEventDetailsSorted *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READEVENTDETAILSSORTED]);
})

UA_INLINABLE( void
UA_ReadEventDetailsSorted_delete(UA_ReadEventDetailsSorted *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READEVENTDETAILSSORTED]);
})

UA_INLINABLE( UA_Boolean
UA_ReadEventDetailsSorted_equal(const UA_ReadEventDetailsSorted *p1, const UA_ReadEventDetailsSorted *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READEVENTDETAILSSORTED]) == UA_ORDER_EQ);
})


/* ReadProcessedDetails */
typedef struct {
    UA_DateTime startTime;
    UA_DateTime endTime;
    UA_Double processingInterval;
    size_t aggregateTypeSize;
    UA_NodeId *aggregateType;
    UA_AggregateConfiguration aggregateConfiguration;
} UA_ReadProcessedDetails;

#define UA_TYPES_READPROCESSEDDETAILS 420

UA_INLINABLE( void
UA_ReadProcessedDetails_init(UA_ReadProcessedDetails *p), {
    memset(p, 0, sizeof(UA_ReadProcessedDetails));
})

UA_INLINABLE( UA_ReadProcessedDetails *
UA_ReadProcessedDetails_new(void), {
    return (UA_ReadProcessedDetails*)UA_new(&UA_TYPES[UA_TYPES_READPROCESSEDDETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_ReadProcessedDetails_copy(const UA_ReadProcessedDetails *src, UA_ReadProcessedDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READPROCESSEDDETAILS]);
})

UA_INLINABLE( void
UA_ReadProcessedDetails_clear(UA_ReadProcessedDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READPROCESSEDDETAILS]);
})

UA_INLINABLE( void
UA_ReadProcessedDetails_delete(UA_ReadProcessedDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READPROCESSEDDETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_ReadProcessedDetails_equal(const UA_ReadProcessedDetails *p1, const UA_ReadProcessedDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READPROCESSEDDETAILS]) == UA_ORDER_EQ);
})


/* ModificationInfo */
typedef struct {
    UA_DateTime modificationTime;
    UA_HistoryUpdateType updateType;
    UA_String userName;
} UA_ModificationInfo;

#define UA_TYPES_MODIFICATIONINFO 421

UA_INLINABLE( void
UA_ModificationInfo_init(UA_ModificationInfo *p), {
    memset(p, 0, sizeof(UA_ModificationInfo));
})

UA_INLINABLE( UA_ModificationInfo *
UA_ModificationInfo_new(void), {
    return (UA_ModificationInfo*)UA_new(&UA_TYPES[UA_TYPES_MODIFICATIONINFO]);
})

UA_INLINABLE( UA_StatusCode
UA_ModificationInfo_copy(const UA_ModificationInfo *src, UA_ModificationInfo *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFICATIONINFO]);
})

UA_INLINABLE( void
UA_ModificationInfo_clear(UA_ModificationInfo *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_MODIFICATIONINFO]);
})

UA_INLINABLE( void
UA_ModificationInfo_delete(UA_ModificationInfo *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_MODIFICATIONINFO]);
})

UA_INLINABLE( UA_Boolean
UA_ModificationInfo_equal(const UA_ModificationInfo *p1, const UA_ModificationInfo *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_MODIFICATIONINFO]) == UA_ORDER_EQ);
})


/* HistoryModifiedData */
typedef struct {
    size_t dataValuesSize;
    UA_DataValue *dataValues;
    size_t modificationInfosSize;
    UA_ModificationInfo *modificationInfos;
} UA_HistoryModifiedData;

#define UA_TYPES_HISTORYMODIFIEDDATA 422

UA_INLINABLE( void
UA_HistoryModifiedData_init(UA_HistoryModifiedData *p), {
    memset(p, 0, sizeof(UA_HistoryModifiedData));
})

UA_INLINABLE( UA_HistoryModifiedData *
UA_HistoryModifiedData_new(void), {
    return (UA_HistoryModifiedData*)UA_new(&UA_TYPES[UA_TYPES_HISTORYMODIFIEDDATA]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryModifiedData_copy(const UA_HistoryModifiedData *src, UA_HistoryModifiedData *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYMODIFIEDDATA]);
})

UA_INLINABLE( void
UA_HistoryModifiedData_clear(UA_HistoryModifiedData *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYMODIFIEDDATA]);
})

UA_INLINABLE( void
UA_HistoryModifiedData_delete(UA_HistoryModifiedData *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYMODIFIEDDATA]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryModifiedData_equal(const UA_HistoryModifiedData *p1, const UA_HistoryModifiedData *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYMODIFIEDDATA]) == UA_ORDER_EQ);
})


/* HistoryEvent */
typedef struct {
    size_t eventsSize;
    UA_HistoryEventFieldList *events;
} UA_HistoryEvent;

#define UA_TYPES_HISTORYEVENT 423

UA_INLINABLE( void
UA_HistoryEvent_init(UA_HistoryEvent *p), {
    memset(p, 0, sizeof(UA_HistoryEvent));
})

UA_INLINABLE( UA_HistoryEvent *
UA_HistoryEvent_new(void), {
    return (UA_HistoryEvent*)UA_new(&UA_TYPES[UA_TYPES_HISTORYEVENT]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryEvent_copy(const UA_HistoryEvent *src, UA_HistoryEvent *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYEVENT]);
})

UA_INLINABLE( void
UA_HistoryEvent_clear(UA_HistoryEvent *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYEVENT]);
})

UA_INLINABLE( void
UA_HistoryEvent_delete(UA_HistoryEvent *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYEVENT]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryEvent_equal(const UA_HistoryEvent *p1, const UA_HistoryEvent *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYEVENT]) == UA_ORDER_EQ);
})


/* HistoryModifiedEvent */
typedef struct {
    size_t eventsSize;
    UA_HistoryEventFieldList *events;
    size_t modificationInfosSize;
    UA_ModificationInfo *modificationInfos;
} UA_HistoryModifiedEvent;

#define UA_TYPES_HISTORYMODIFIEDEVENT 424

UA_INLINABLE( void
UA_HistoryModifiedEvent_init(UA_HistoryModifiedEvent *p), {
    memset(p, 0, sizeof(UA_HistoryModifiedEvent));
})

UA_INLINABLE( UA_HistoryModifiedEvent *
UA_HistoryModifiedEvent_new(void), {
    return (UA_HistoryModifiedEvent*)UA_new(&UA_TYPES[UA_TYPES_HISTORYMODIFIEDEVENT]);
})

UA_INLINABLE( UA_StatusCode
UA_HistoryModifiedEvent_copy(const UA_HistoryModifiedEvent *src, UA_HistoryModifiedEvent *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_HISTORYMODIFIEDEVENT]);
})

UA_INLINABLE( void
UA_HistoryModifiedEvent_clear(UA_HistoryModifiedEvent *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_HISTORYMODIFIEDEVENT]);
})

UA_INLINABLE( void
UA_HistoryModifiedEvent_delete(UA_HistoryModifiedEvent *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_HISTORYMODIFIEDEVENT]);
})

UA_INLINABLE( UA_Boolean
UA_HistoryModifiedEvent_equal(const UA_HistoryModifiedEvent *p1, const UA_HistoryModifiedEvent *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_HISTORYMODIFIEDEVENT]) == UA_ORDER_EQ);
})


/* UpdateEventDetails */
typedef struct {
    UA_NodeId nodeId;
    UA_PerformUpdateType performInsertReplace;
    UA_EventFilter filter;
    size_t eventDataSize;
    UA_HistoryEventFieldList *eventData;
} UA_UpdateEventDetails;

#define UA_TYPES_UPDATEEVENTDETAILS 425

UA_INLINABLE( void
UA_UpdateEventDetails_init(UA_UpdateEventDetails *p), {
    memset(p, 0, sizeof(UA_UpdateEventDetails));
})

UA_INLINABLE( UA_UpdateEventDetails *
UA_UpdateEventDetails_new(void), {
    return (UA_UpdateEventDetails*)UA_new(&UA_TYPES[UA_TYPES_UPDATEEVENTDETAILS]);
})

UA_INLINABLE( UA_StatusCode
UA_UpdateEventDetails_copy(const UA_UpdateEventDetails *src, UA_UpdateEventDetails *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UPDATEEVENTDETAILS]);
})

UA_INLINABLE( void
UA_UpdateEventDetails_clear(UA_UpdateEventDetails *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UPDATEEVENTDETAILS]);
})

UA_INLINABLE( void
UA_UpdateEventDetails_delete(UA_UpdateEventDetails *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UPDATEEVENTDETAILS]);
})

UA_INLINABLE( UA_Boolean
UA_UpdateEventDetails_equal(const UA_UpdateEventDetails *p1, const UA_UpdateEventDetails *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UPDATEEVENTDETAILS]) == UA_ORDER_EQ);
})


/* DataChangeNotification */
typedef struct {
    size_t monitoredItemsSize;
    UA_MonitoredItemNotification *monitoredItems;
    size_t diagnosticInfosSize;
    UA_DiagnosticInfo *diagnosticInfos;
} UA_DataChangeNotification;

#define UA_TYPES_DATACHANGENOTIFICATION 426

UA_INLINABLE( void
UA_DataChangeNotification_init(UA_DataChangeNotification *p), {
    memset(p, 0, sizeof(UA_DataChangeNotification));
})

UA_INLINABLE( UA_DataChangeNotification *
UA_DataChangeNotification_new(void), {
    return (UA_DataChangeNotification*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
})

UA_INLINABLE( UA_StatusCode
UA_DataChangeNotification_copy(const UA_DataChangeNotification *src, UA_DataChangeNotification *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
})

UA_INLINABLE( void
UA_DataChangeNotification_clear(UA_DataChangeNotification *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
})

UA_INLINABLE( void
UA_DataChangeNotification_delete(UA_DataChangeNotification *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]);
})

UA_INLINABLE( UA_Boolean
UA_DataChangeNotification_equal(const UA_DataChangeNotification *p1, const UA_DataChangeNotification *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]) == UA_ORDER_EQ);
})


/* EventNotificationList */
typedef struct {
    size_t eventsSize;
    UA_EventFieldList *events;
} UA_EventNotificationList;

#define UA_TYPES_EVENTNOTIFICATIONLIST 427

UA_INLINABLE( void
UA_EventNotificationList_init(UA_EventNotificationList *p), {
    memset(p, 0, sizeof(UA_EventNotificationList));
})

UA_INLINABLE( UA_EventNotificationList *
UA_EventNotificationList_new(void), {
    return (UA_EventNotificationList*)UA_new(&UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
})

UA_INLINABLE( UA_StatusCode
UA_EventNotificationList_copy(const UA_EventNotificationList *src, UA_EventNotificationList *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
})

UA_INLINABLE( void
UA_EventNotificationList_clear(UA_EventNotificationList *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
})

UA_INLINABLE( void
UA_EventNotificationList_delete(UA_EventNotificationList *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]);
})

UA_INLINABLE( UA_Boolean
UA_EventNotificationList_equal(const UA_EventNotificationList *p1, const UA_EventNotificationList *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]) == UA_ORDER_EQ);
})


/* SessionDiagnosticsDataType */
typedef struct {
    UA_NodeId sessionId;
    UA_String sessionName;
    UA_ApplicationDescription clientDescription;
    UA_String serverUri;
    UA_String endpointUrl;
    size_t localeIdsSize;
    UA_String *localeIds;
    UA_Double actualSessionTimeout;
    UA_UInt32 maxResponseMessageSize;
    UA_DateTime clientConnectionTime;
    UA_DateTime clientLastContactTime;
    UA_UInt32 currentSubscriptionsCount;
    UA_UInt32 currentMonitoredItemsCount;
    UA_UInt32 currentPublishRequestsInQueue;
    UA_ServiceCounterDataType totalRequestCount;
    UA_UInt32 unauthorizedRequestCount;
    UA_ServiceCounterDataType readCount;
    UA_ServiceCounterDataType historyReadCount;
    UA_ServiceCounterDataType writeCount;
    UA_ServiceCounterDataType historyUpdateCount;
    UA_ServiceCounterDataType callCount;
    UA_ServiceCounterDataType createMonitoredItemsCount;
    UA_ServiceCounterDataType modifyMonitoredItemsCount;
    UA_ServiceCounterDataType setMonitoringModeCount;
    UA_ServiceCounterDataType setTriggeringCount;
    UA_ServiceCounterDataType deleteMonitoredItemsCount;
    UA_ServiceCounterDataType createSubscriptionCount;
    UA_ServiceCounterDataType modifySubscriptionCount;
    UA_ServiceCounterDataType setPublishingModeCount;
    UA_ServiceCounterDataType publishCount;
    UA_ServiceCounterDataType republishCount;
    UA_ServiceCounterDataType transferSubscriptionsCount;
    UA_ServiceCounterDataType deleteSubscriptionsCount;
    UA_ServiceCounterDataType addNodesCount;
    UA_ServiceCounterDataType addReferencesCount;
    UA_ServiceCounterDataType deleteNodesCount;
    UA_ServiceCounterDataType deleteReferencesCount;
    UA_ServiceCounterDataType browseCount;
    UA_ServiceCounterDataType browseNextCount;
    UA_ServiceCounterDataType translateBrowsePathsToNodeIdsCount;
    UA_ServiceCounterDataType queryFirstCount;
    UA_ServiceCounterDataType queryNextCount;
    UA_ServiceCounterDataType registerNodesCount;
    UA_ServiceCounterDataType unregisterNodesCount;
} UA_SessionDiagnosticsDataType;

#define UA_TYPES_SESSIONDIAGNOSTICSDATATYPE 428

UA_INLINABLE( void
UA_SessionDiagnosticsDataType_init(UA_SessionDiagnosticsDataType *p), {
    memset(p, 0, sizeof(UA_SessionDiagnosticsDataType));
})

UA_INLINABLE( UA_SessionDiagnosticsDataType *
UA_SessionDiagnosticsDataType_new(void), {
    return (UA_SessionDiagnosticsDataType*)UA_new(&UA_TYPES[UA_TYPES_SESSIONDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_SessionDiagnosticsDataType_copy(const UA_SessionDiagnosticsDataType *src, UA_SessionDiagnosticsDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SESSIONDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( void
UA_SessionDiagnosticsDataType_clear(UA_SessionDiagnosticsDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_SESSIONDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( void
UA_SessionDiagnosticsDataType_delete(UA_SessionDiagnosticsDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_SESSIONDIAGNOSTICSDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_SessionDiagnosticsDataType_equal(const UA_SessionDiagnosticsDataType *p1, const UA_SessionDiagnosticsDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_SESSIONDIAGNOSTICSDATATYPE]) == UA_ORDER_EQ);
})


/* ApplicationConfigurationDataType */
typedef struct {
    UA_UInt32 configurationVersion;
    size_t configurationPropertiesSize;
    UA_KeyValuePair *configurationProperties;
    UA_ApplicationIdentityDataType applicationIdentity;
    size_t certificateGroupsSize;
    UA_CertificateGroupDataType *certificateGroups;
    size_t serverEndpointsSize;
    UA_ServerEndpointDataType *serverEndpoints;
    size_t clientEndpointsSize;
    UA_EndpointDataType *clientEndpoints;
    size_t securitySettingsSize;
    UA_SecuritySettingsDataType *securitySettings;
    size_t userTokenSettingsSize;
    UA_UserTokenSettingsDataType *userTokenSettings;
    size_t authorizationServicesSize;
    UA_AuthorizationServiceConfigurationDataType *authorizationServices;
} UA_ApplicationConfigurationDataType;

#define UA_TYPES_APPLICATIONCONFIGURATIONDATATYPE 429

UA_INLINABLE( void
UA_ApplicationConfigurationDataType_init(UA_ApplicationConfigurationDataType *p), {
    memset(p, 0, sizeof(UA_ApplicationConfigurationDataType));
})

UA_INLINABLE( UA_ApplicationConfigurationDataType *
UA_ApplicationConfigurationDataType_new(void), {
    return (UA_ApplicationConfigurationDataType*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONCONFIGURATIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ApplicationConfigurationDataType_copy(const UA_ApplicationConfigurationDataType *src, UA_ApplicationConfigurationDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONCONFIGURATIONDATATYPE]);
})

UA_INLINABLE( void
UA_ApplicationConfigurationDataType_clear(UA_ApplicationConfigurationDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONCONFIGURATIONDATATYPE]);
})

UA_INLINABLE( void
UA_ApplicationConfigurationDataType_delete(UA_ApplicationConfigurationDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONCONFIGURATIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ApplicationConfigurationDataType_equal(const UA_ApplicationConfigurationDataType *p1, const UA_ApplicationConfigurationDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_APPLICATIONCONFIGURATIONDATATYPE]) == UA_ORDER_EQ);
})


/* EnumDescription */
typedef struct {
    UA_NodeId dataTypeId;
    UA_QualifiedName name;
    UA_EnumDefinition enumDefinition;
    UA_Byte builtInType;
} UA_EnumDescription;

#define UA_TYPES_ENUMDESCRIPTION 430

UA_INLINABLE( void
UA_EnumDescription_init(UA_EnumDescription *p), {
    memset(p, 0, sizeof(UA_EnumDescription));
})

UA_INLINABLE( UA_EnumDescription *
UA_EnumDescription_new(void), {
    return (UA_EnumDescription*)UA_new(&UA_TYPES[UA_TYPES_ENUMDESCRIPTION]);
})

UA_INLINABLE( UA_StatusCode
UA_EnumDescription_copy(const UA_EnumDescription *src, UA_EnumDescription *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMDESCRIPTION]);
})

UA_INLINABLE( void
UA_EnumDescription_clear(UA_EnumDescription *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_ENUMDESCRIPTION]);
})

UA_INLINABLE( void
UA_EnumDescription_delete(UA_EnumDescription *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_ENUMDESCRIPTION]);
})

UA_INLINABLE( UA_Boolean
UA_EnumDescription_equal(const UA_EnumDescription *p1, const UA_EnumDescription *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_ENUMDESCRIPTION]) == UA_ORDER_EQ);
})


/* UABinaryFileDataType */
typedef struct {
    size_t namespacesSize;
    UA_String *namespaces;
    size_t structureDataTypesSize;
    UA_StructureDescription *structureDataTypes;
    size_t enumDataTypesSize;
    UA_EnumDescription *enumDataTypes;
    size_t simpleDataTypesSize;
    UA_SimpleTypeDescription *simpleDataTypes;
    UA_String schemaLocation;
    size_t fileHeaderSize;
    UA_KeyValuePair *fileHeader;
    UA_Variant body;
} UA_UABinaryFileDataType;

#define UA_TYPES_UABINARYFILEDATATYPE 431

UA_INLINABLE( void
UA_UABinaryFileDataType_init(UA_UABinaryFileDataType *p), {
    memset(p, 0, sizeof(UA_UABinaryFileDataType));
})

UA_INLINABLE( UA_UABinaryFileDataType *
UA_UABinaryFileDataType_new(void), {
    return (UA_UABinaryFileDataType*)UA_new(&UA_TYPES[UA_TYPES_UABINARYFILEDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_UABinaryFileDataType_copy(const UA_UABinaryFileDataType *src, UA_UABinaryFileDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UABINARYFILEDATATYPE]);
})

UA_INLINABLE( void
UA_UABinaryFileDataType_clear(UA_UABinaryFileDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_UABINARYFILEDATATYPE]);
})

UA_INLINABLE( void
UA_UABinaryFileDataType_delete(UA_UABinaryFileDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_UABINARYFILEDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_UABinaryFileDataType_equal(const UA_UABinaryFileDataType *p1, const UA_UABinaryFileDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_UABINARYFILEDATATYPE]) == UA_ORDER_EQ);
})


/* DataSetMetaDataType */
typedef struct {
    size_t namespacesSize;
    UA_String *namespaces;
    size_t structureDataTypesSize;
    UA_StructureDescription *structureDataTypes;
    size_t enumDataTypesSize;
    UA_EnumDescription *enumDataTypes;
    size_t simpleDataTypesSize;
    UA_SimpleTypeDescription *simpleDataTypes;
    UA_String name;
    UA_LocalizedText description;
    size_t fieldsSize;
    UA_FieldMetaData *fields;
    UA_Guid dataSetClassId;
    UA_ConfigurationVersionDataType configurationVersion;
} UA_DataSetMetaDataType;

#define UA_TYPES_DATASETMETADATATYPE 432

UA_INLINABLE( void
UA_DataSetMetaDataType_init(UA_DataSetMetaDataType *p), {
    memset(p, 0, sizeof(UA_DataSetMetaDataType));
})

UA_INLINABLE( UA_DataSetMetaDataType *
UA_DataSetMetaDataType_new(void), {
    return (UA_DataSetMetaDataType*)UA_new(&UA_TYPES[UA_TYPES_DATASETMETADATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DataSetMetaDataType_copy(const UA_DataSetMetaDataType *src, UA_DataSetMetaDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATASETMETADATATYPE]);
})

UA_INLINABLE( void
UA_DataSetMetaDataType_clear(UA_DataSetMetaDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATASETMETADATATYPE]);
})

UA_INLINABLE( void
UA_DataSetMetaDataType_delete(UA_DataSetMetaDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATASETMETADATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DataSetMetaDataType_equal(const UA_DataSetMetaDataType *p1, const UA_DataSetMetaDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATASETMETADATATYPE]) == UA_ORDER_EQ);
})


/* PublishedDataSetDataType */
typedef struct {
    UA_String name;
    size_t dataSetFolderSize;
    UA_String *dataSetFolder;
    UA_DataSetMetaDataType dataSetMetaData;
    size_t extensionFieldsSize;
    UA_KeyValuePair *extensionFields;
    UA_ExtensionObject dataSetSource;
} UA_PublishedDataSetDataType;

#define UA_TYPES_PUBLISHEDDATASETDATATYPE 433

UA_INLINABLE( void
UA_PublishedDataSetDataType_init(UA_PublishedDataSetDataType *p), {
    memset(p, 0, sizeof(UA_PublishedDataSetDataType));
})

UA_INLINABLE( UA_PublishedDataSetDataType *
UA_PublishedDataSetDataType_new(void), {
    return (UA_PublishedDataSetDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHEDDATASETDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishedDataSetDataType_copy(const UA_PublishedDataSetDataType *src, UA_PublishedDataSetDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHEDDATASETDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedDataSetDataType_clear(UA_PublishedDataSetDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHEDDATASETDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedDataSetDataType_delete(UA_PublishedDataSetDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHEDDATASETDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PublishedDataSetDataType_equal(const UA_PublishedDataSetDataType *p1, const UA_PublishedDataSetDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHEDDATASETDATATYPE]) == UA_ORDER_EQ);
})


/* PublishedActionDataType */
typedef struct {
    UA_DataSetMetaDataType requestDataSetMetaData;
    size_t actionTargetsSize;
    UA_ActionTargetDataType *actionTargets;
} UA_PublishedActionDataType;

#define UA_TYPES_PUBLISHEDACTIONDATATYPE 434

UA_INLINABLE( void
UA_PublishedActionDataType_init(UA_PublishedActionDataType *p), {
    memset(p, 0, sizeof(UA_PublishedActionDataType));
})

UA_INLINABLE( UA_PublishedActionDataType *
UA_PublishedActionDataType_new(void), {
    return (UA_PublishedActionDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHEDACTIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishedActionDataType_copy(const UA_PublishedActionDataType *src, UA_PublishedActionDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHEDACTIONDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedActionDataType_clear(UA_PublishedActionDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHEDACTIONDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedActionDataType_delete(UA_PublishedActionDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHEDACTIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PublishedActionDataType_equal(const UA_PublishedActionDataType *p1, const UA_PublishedActionDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHEDACTIONDATATYPE]) == UA_ORDER_EQ);
})


/* PublishedActionMethodDataType */
typedef struct {
    UA_DataSetMetaDataType requestDataSetMetaData;
    size_t actionTargetsSize;
    UA_ActionTargetDataType *actionTargets;
    size_t actionMethodsSize;
    UA_ActionMethodDataType *actionMethods;
} UA_PublishedActionMethodDataType;

#define UA_TYPES_PUBLISHEDACTIONMETHODDATATYPE 435

UA_INLINABLE( void
UA_PublishedActionMethodDataType_init(UA_PublishedActionMethodDataType *p), {
    memset(p, 0, sizeof(UA_PublishedActionMethodDataType));
})

UA_INLINABLE( UA_PublishedActionMethodDataType *
UA_PublishedActionMethodDataType_new(void), {
    return (UA_PublishedActionMethodDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHEDACTIONMETHODDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PublishedActionMethodDataType_copy(const UA_PublishedActionMethodDataType *src, UA_PublishedActionMethodDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHEDACTIONMETHODDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedActionMethodDataType_clear(UA_PublishedActionMethodDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHEDACTIONMETHODDATATYPE]);
})

UA_INLINABLE( void
UA_PublishedActionMethodDataType_delete(UA_PublishedActionMethodDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHEDACTIONMETHODDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PublishedActionMethodDataType_equal(const UA_PublishedActionMethodDataType *p1, const UA_PublishedActionMethodDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBLISHEDACTIONMETHODDATATYPE]) == UA_ORDER_EQ);
})


/* DataSetReaderDataType */
typedef struct {
    UA_String name;
    UA_Boolean enabled;
    UA_Variant publisherId;
    UA_UInt16 writerGroupId;
    UA_UInt16 dataSetWriterId;
    UA_DataSetMetaDataType dataSetMetaData;
    UA_DataSetFieldContentMask dataSetFieldContentMask;
    UA_Double messageReceiveTimeout;
    UA_UInt32 keyFrameCount;
    UA_String headerLayoutUri;
    UA_MessageSecurityMode securityMode;
    UA_String securityGroupId;
    size_t securityKeyServicesSize;
    UA_EndpointDescription *securityKeyServices;
    size_t dataSetReaderPropertiesSize;
    UA_KeyValuePair *dataSetReaderProperties;
    UA_ExtensionObject transportSettings;
    UA_ExtensionObject messageSettings;
    UA_ExtensionObject subscribedDataSet;
} UA_DataSetReaderDataType;

#define UA_TYPES_DATASETREADERDATATYPE 436

UA_INLINABLE( void
UA_DataSetReaderDataType_init(UA_DataSetReaderDataType *p), {
    memset(p, 0, sizeof(UA_DataSetReaderDataType));
})

UA_INLINABLE( UA_DataSetReaderDataType *
UA_DataSetReaderDataType_new(void), {
    return (UA_DataSetReaderDataType*)UA_new(&UA_TYPES[UA_TYPES_DATASETREADERDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_DataSetReaderDataType_copy(const UA_DataSetReaderDataType *src, UA_DataSetReaderDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATASETREADERDATATYPE]);
})

UA_INLINABLE( void
UA_DataSetReaderDataType_clear(UA_DataSetReaderDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATASETREADERDATATYPE]);
})

UA_INLINABLE( void
UA_DataSetReaderDataType_delete(UA_DataSetReaderDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATASETREADERDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_DataSetReaderDataType_equal(const UA_DataSetReaderDataType *p1, const UA_DataSetReaderDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATASETREADERDATATYPE]) == UA_ORDER_EQ);
})


/* TargetVariablesDataType */
typedef struct {
    size_t targetVariablesSize;
    UA_FieldTargetDataType *targetVariables;
} UA_TargetVariablesDataType;

#define UA_TYPES_TARGETVARIABLESDATATYPE 437

UA_INLINABLE( void
UA_TargetVariablesDataType_init(UA_TargetVariablesDataType *p), {
    memset(p, 0, sizeof(UA_TargetVariablesDataType));
})

UA_INLINABLE( UA_TargetVariablesDataType *
UA_TargetVariablesDataType_new(void), {
    return (UA_TargetVariablesDataType*)UA_new(&UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_TargetVariablesDataType_copy(const UA_TargetVariablesDataType *src, UA_TargetVariablesDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]);
})

UA_INLINABLE( void
UA_TargetVariablesDataType_clear(UA_TargetVariablesDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]);
})

UA_INLINABLE( void
UA_TargetVariablesDataType_delete(UA_TargetVariablesDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_TargetVariablesDataType_equal(const UA_TargetVariablesDataType *p1, const UA_TargetVariablesDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]) == UA_ORDER_EQ);
})


/* StandaloneSubscribedDataSetDataType */
typedef struct {
    UA_String name;
    size_t dataSetFolderSize;
    UA_String *dataSetFolder;
    UA_DataSetMetaDataType dataSetMetaData;
    UA_ExtensionObject subscribedDataSet;
} UA_StandaloneSubscribedDataSetDataType;

#define UA_TYPES_STANDALONESUBSCRIBEDDATASETDATATYPE 438

UA_INLINABLE( void
UA_StandaloneSubscribedDataSetDataType_init(UA_StandaloneSubscribedDataSetDataType *p), {
    memset(p, 0, sizeof(UA_StandaloneSubscribedDataSetDataType));
})

UA_INLINABLE( UA_StandaloneSubscribedDataSetDataType *
UA_StandaloneSubscribedDataSetDataType_new(void), {
    return (UA_StandaloneSubscribedDataSetDataType*)UA_new(&UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_StandaloneSubscribedDataSetDataType_copy(const UA_StandaloneSubscribedDataSetDataType *src, UA_StandaloneSubscribedDataSetDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETDATATYPE]);
})

UA_INLINABLE( void
UA_StandaloneSubscribedDataSetDataType_clear(UA_StandaloneSubscribedDataSetDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETDATATYPE]);
})

UA_INLINABLE( void
UA_StandaloneSubscribedDataSetDataType_delete(UA_StandaloneSubscribedDataSetDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_StandaloneSubscribedDataSetDataType_equal(const UA_StandaloneSubscribedDataSetDataType *p1, const UA_StandaloneSubscribedDataSetDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_STANDALONESUBSCRIBEDDATASETDATATYPE]) == UA_ORDER_EQ);
})


/* JsonDataSetMetaDataMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_UInt16 dataSetWriterId;
    UA_String writerGroupName;
    UA_String dataSetWriterName;
    UA_DateTime timestamp;
    UA_DataSetMetaDataType metaData;
} UA_JsonDataSetMetaDataMessage;

#define UA_TYPES_JSONDATASETMETADATAMESSAGE 439

UA_INLINABLE( void
UA_JsonDataSetMetaDataMessage_init(UA_JsonDataSetMetaDataMessage *p), {
    memset(p, 0, sizeof(UA_JsonDataSetMetaDataMessage));
})

UA_INLINABLE( UA_JsonDataSetMetaDataMessage *
UA_JsonDataSetMetaDataMessage_new(void), {
    return (UA_JsonDataSetMetaDataMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONDATASETMETADATAMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonDataSetMetaDataMessage_copy(const UA_JsonDataSetMetaDataMessage *src, UA_JsonDataSetMetaDataMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONDATASETMETADATAMESSAGE]);
})

UA_INLINABLE( void
UA_JsonDataSetMetaDataMessage_clear(UA_JsonDataSetMetaDataMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONDATASETMETADATAMESSAGE]);
})

UA_INLINABLE( void
UA_JsonDataSetMetaDataMessage_delete(UA_JsonDataSetMetaDataMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONDATASETMETADATAMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonDataSetMetaDataMessage_equal(const UA_JsonDataSetMetaDataMessage *p1, const UA_JsonDataSetMetaDataMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONDATASETMETADATAMESSAGE]) == UA_ORDER_EQ);
})


/* JsonActionMetaDataMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_UInt16 dataSetWriterId;
    UA_String dataSetWriterName;
    UA_DateTime timestamp;
    size_t actionTargetsSize;
    UA_ActionTargetDataType *actionTargets;
    UA_DataSetMetaDataType request;
    UA_DataSetMetaDataType response;
    size_t actionMethodsSize;
    UA_ActionMethodDataType *actionMethods;
} UA_JsonActionMetaDataMessage;

#define UA_TYPES_JSONACTIONMETADATAMESSAGE 440

UA_INLINABLE( void
UA_JsonActionMetaDataMessage_init(UA_JsonActionMetaDataMessage *p), {
    memset(p, 0, sizeof(UA_JsonActionMetaDataMessage));
})

UA_INLINABLE( UA_JsonActionMetaDataMessage *
UA_JsonActionMetaDataMessage_new(void), {
    return (UA_JsonActionMetaDataMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONACTIONMETADATAMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonActionMetaDataMessage_copy(const UA_JsonActionMetaDataMessage *src, UA_JsonActionMetaDataMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONACTIONMETADATAMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionMetaDataMessage_clear(UA_JsonActionMetaDataMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONACTIONMETADATAMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionMetaDataMessage_delete(UA_JsonActionMetaDataMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONACTIONMETADATAMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonActionMetaDataMessage_equal(const UA_JsonActionMetaDataMessage *p1, const UA_JsonActionMetaDataMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONACTIONMETADATAMESSAGE]) == UA_ORDER_EQ);
})


/* DataTypeSchemaHeader */
typedef struct {
    size_t namespacesSize;
    UA_String *namespaces;
    size_t structureDataTypesSize;
    UA_StructureDescription *structureDataTypes;
    size_t enumDataTypesSize;
    UA_EnumDescription *enumDataTypes;
    size_t simpleDataTypesSize;
    UA_SimpleTypeDescription *simpleDataTypes;
} UA_DataTypeSchemaHeader;

#define UA_TYPES_DATATYPESCHEMAHEADER 441

UA_INLINABLE( void
UA_DataTypeSchemaHeader_init(UA_DataTypeSchemaHeader *p), {
    memset(p, 0, sizeof(UA_DataTypeSchemaHeader));
})

UA_INLINABLE( UA_DataTypeSchemaHeader *
UA_DataTypeSchemaHeader_new(void), {
    return (UA_DataTypeSchemaHeader*)UA_new(&UA_TYPES[UA_TYPES_DATATYPESCHEMAHEADER]);
})

UA_INLINABLE( UA_StatusCode
UA_DataTypeSchemaHeader_copy(const UA_DataTypeSchemaHeader *src, UA_DataTypeSchemaHeader *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATATYPESCHEMAHEADER]);
})

UA_INLINABLE( void
UA_DataTypeSchemaHeader_clear(UA_DataTypeSchemaHeader *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_DATATYPESCHEMAHEADER]);
})

UA_INLINABLE( void
UA_DataTypeSchemaHeader_delete(UA_DataTypeSchemaHeader *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_DATATYPESCHEMAHEADER]);
})

UA_INLINABLE( UA_Boolean
UA_DataTypeSchemaHeader_equal(const UA_DataTypeSchemaHeader *p1, const UA_DataTypeSchemaHeader *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_DATATYPESCHEMAHEADER]) == UA_ORDER_EQ);
})


/* ReaderGroupDataType */
typedef struct {
    UA_String name;
    UA_Boolean enabled;
    UA_MessageSecurityMode securityMode;
    UA_String securityGroupId;
    size_t securityKeyServicesSize;
    UA_EndpointDescription *securityKeyServices;
    UA_UInt32 maxNetworkMessageSize;
    size_t groupPropertiesSize;
    UA_KeyValuePair *groupProperties;
    UA_ExtensionObject transportSettings;
    UA_ExtensionObject messageSettings;
    size_t dataSetReadersSize;
    UA_DataSetReaderDataType *dataSetReaders;
} UA_ReaderGroupDataType;

#define UA_TYPES_READERGROUPDATATYPE 442

UA_INLINABLE( void
UA_ReaderGroupDataType_init(UA_ReaderGroupDataType *p), {
    memset(p, 0, sizeof(UA_ReaderGroupDataType));
})

UA_INLINABLE( UA_ReaderGroupDataType *
UA_ReaderGroupDataType_new(void), {
    return (UA_ReaderGroupDataType*)UA_new(&UA_TYPES[UA_TYPES_READERGROUPDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_ReaderGroupDataType_copy(const UA_ReaderGroupDataType *src, UA_ReaderGroupDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READERGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_ReaderGroupDataType_clear(UA_ReaderGroupDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_READERGROUPDATATYPE]);
})

UA_INLINABLE( void
UA_ReaderGroupDataType_delete(UA_ReaderGroupDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_READERGROUPDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_ReaderGroupDataType_equal(const UA_ReaderGroupDataType *p1, const UA_ReaderGroupDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_READERGROUPDATATYPE]) == UA_ORDER_EQ);
})


/* PubSubConnectionDataType */
typedef struct {
    UA_String name;
    UA_Boolean enabled;
    UA_Variant publisherId;
    UA_String transportProfileUri;
    UA_ExtensionObject address;
    size_t connectionPropertiesSize;
    UA_KeyValuePair *connectionProperties;
    UA_ExtensionObject transportSettings;
    size_t writerGroupsSize;
    UA_WriterGroupDataType *writerGroups;
    size_t readerGroupsSize;
    UA_ReaderGroupDataType *readerGroups;
} UA_PubSubConnectionDataType;

#define UA_TYPES_PUBSUBCONNECTIONDATATYPE 443

UA_INLINABLE( void
UA_PubSubConnectionDataType_init(UA_PubSubConnectionDataType *p), {
    memset(p, 0, sizeof(UA_PubSubConnectionDataType));
})

UA_INLINABLE( UA_PubSubConnectionDataType *
UA_PubSubConnectionDataType_new(void), {
    return (UA_PubSubConnectionDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBCONNECTIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubConnectionDataType_copy(const UA_PubSubConnectionDataType *src, UA_PubSubConnectionDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBCONNECTIONDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConnectionDataType_clear(UA_PubSubConnectionDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBCONNECTIONDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConnectionDataType_delete(UA_PubSubConnectionDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBCONNECTIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubConnectionDataType_equal(const UA_PubSubConnectionDataType *p1, const UA_PubSubConnectionDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBCONNECTIONDATATYPE]) == UA_ORDER_EQ);
})


/* PubSubConfigurationDataType */
typedef struct {
    size_t publishedDataSetsSize;
    UA_PublishedDataSetDataType *publishedDataSets;
    size_t connectionsSize;
    UA_PubSubConnectionDataType *connections;
    UA_Boolean enabled;
} UA_PubSubConfigurationDataType;

#define UA_TYPES_PUBSUBCONFIGURATIONDATATYPE 444

UA_INLINABLE( void
UA_PubSubConfigurationDataType_init(UA_PubSubConfigurationDataType *p), {
    memset(p, 0, sizeof(UA_PubSubConfigurationDataType));
})

UA_INLINABLE( UA_PubSubConfigurationDataType *
UA_PubSubConfigurationDataType_new(void), {
    return (UA_PubSubConfigurationDataType*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONDATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubConfigurationDataType_copy(const UA_PubSubConfigurationDataType *src, UA_PubSubConfigurationDataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConfigurationDataType_clear(UA_PubSubConfigurationDataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONDATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConfigurationDataType_delete(UA_PubSubConfigurationDataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONDATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubConfigurationDataType_equal(const UA_PubSubConfigurationDataType *p1, const UA_PubSubConfigurationDataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONDATATYPE]) == UA_ORDER_EQ);
})


/* PubSubConfiguration2DataType */
typedef struct {
    size_t publishedDataSetsSize;
    UA_PublishedDataSetDataType *publishedDataSets;
    size_t connectionsSize;
    UA_PubSubConnectionDataType *connections;
    UA_Boolean enabled;
    size_t subscribedDataSetsSize;
    UA_StandaloneSubscribedDataSetDataType *subscribedDataSets;
    size_t dataSetClassesSize;
    UA_DataSetMetaDataType *dataSetClasses;
    size_t defaultSecurityKeyServicesSize;
    UA_EndpointDescription *defaultSecurityKeyServices;
    size_t securityGroupsSize;
    UA_SecurityGroupDataType *securityGroups;
    size_t pubSubKeyPushTargetsSize;
    UA_PubSubKeyPushTargetDataType *pubSubKeyPushTargets;
    UA_UInt32 configurationVersion;
    size_t configurationPropertiesSize;
    UA_KeyValuePair *configurationProperties;
} UA_PubSubConfiguration2DataType;

#define UA_TYPES_PUBSUBCONFIGURATION2DATATYPE 445

UA_INLINABLE( void
UA_PubSubConfiguration2DataType_init(UA_PubSubConfiguration2DataType *p), {
    memset(p, 0, sizeof(UA_PubSubConfiguration2DataType));
})

UA_INLINABLE( UA_PubSubConfiguration2DataType *
UA_PubSubConfiguration2DataType_new(void), {
    return (UA_PubSubConfiguration2DataType*)UA_new(&UA_TYPES[UA_TYPES_PUBSUBCONFIGURATION2DATATYPE]);
})

UA_INLINABLE( UA_StatusCode
UA_PubSubConfiguration2DataType_copy(const UA_PubSubConfiguration2DataType *src, UA_PubSubConfiguration2DataType *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATION2DATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConfiguration2DataType_clear(UA_PubSubConfiguration2DataType *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATION2DATATYPE]);
})

UA_INLINABLE( void
UA_PubSubConfiguration2DataType_delete(UA_PubSubConfiguration2DataType *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATION2DATATYPE]);
})

UA_INLINABLE( UA_Boolean
UA_PubSubConfiguration2DataType_equal(const UA_PubSubConfiguration2DataType *p1, const UA_PubSubConfiguration2DataType *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATION2DATATYPE]) == UA_ORDER_EQ);
})


/* JsonPubSubConnectionMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_DateTime timestamp;
    UA_PubSubConnectionDataType connection;
} UA_JsonPubSubConnectionMessage;

#define UA_TYPES_JSONPUBSUBCONNECTIONMESSAGE 446

UA_INLINABLE( void
UA_JsonPubSubConnectionMessage_init(UA_JsonPubSubConnectionMessage *p), {
    memset(p, 0, sizeof(UA_JsonPubSubConnectionMessage));
})

UA_INLINABLE( UA_JsonPubSubConnectionMessage *
UA_JsonPubSubConnectionMessage_new(void), {
    return (UA_JsonPubSubConnectionMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONPUBSUBCONNECTIONMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonPubSubConnectionMessage_copy(const UA_JsonPubSubConnectionMessage *src, UA_JsonPubSubConnectionMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONPUBSUBCONNECTIONMESSAGE]);
})

UA_INLINABLE( void
UA_JsonPubSubConnectionMessage_clear(UA_JsonPubSubConnectionMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONPUBSUBCONNECTIONMESSAGE]);
})

UA_INLINABLE( void
UA_JsonPubSubConnectionMessage_delete(UA_JsonPubSubConnectionMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONPUBSUBCONNECTIONMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonPubSubConnectionMessage_equal(const UA_JsonPubSubConnectionMessage *p1, const UA_JsonPubSubConnectionMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONPUBSUBCONNECTIONMESSAGE]) == UA_ORDER_EQ);
})


/* JsonActionResponderMessage */
typedef struct {
    UA_String messageId;
    UA_String messageType;
    UA_String publisherId;
    UA_DateTime timestamp;
    UA_PubSubConnectionDataType connection;
} UA_JsonActionResponderMessage;

#define UA_TYPES_JSONACTIONRESPONDERMESSAGE 447

UA_INLINABLE( void
UA_JsonActionResponderMessage_init(UA_JsonActionResponderMessage *p), {
    memset(p, 0, sizeof(UA_JsonActionResponderMessage));
})

UA_INLINABLE( UA_JsonActionResponderMessage *
UA_JsonActionResponderMessage_new(void), {
    return (UA_JsonActionResponderMessage*)UA_new(&UA_TYPES[UA_TYPES_JSONACTIONRESPONDERMESSAGE]);
})

UA_INLINABLE( UA_StatusCode
UA_JsonActionResponderMessage_copy(const UA_JsonActionResponderMessage *src, UA_JsonActionResponderMessage *dst), {
    return UA_copy(src, dst, &UA_TYPES[UA_TYPES_JSONACTIONRESPONDERMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionResponderMessage_clear(UA_JsonActionResponderMessage *p), {
    UA_clear(p, &UA_TYPES[UA_TYPES_JSONACTIONRESPONDERMESSAGE]);
})

UA_INLINABLE( void
UA_JsonActionResponderMessage_delete(UA_JsonActionResponderMessage *p), {
    UA_delete(p, &UA_TYPES[UA_TYPES_JSONACTIONRESPONDERMESSAGE]);
})

UA_INLINABLE( UA_Boolean
UA_JsonActionResponderMessage_equal(const UA_JsonActionResponderMessage *p1, const UA_JsonActionResponderMessage *p2), {
    return (UA_order(p1, p2, &UA_TYPES[UA_TYPES_JSONACTIONRESPONDERMESSAGE]) == UA_ORDER_EQ);
})


_UA_END_DECLS

#endif /* TYPES_GENERATED_H_ */

