ros_opcua_impl_freeopcua: standard_address_space

Go to the documentation of this file.
00001 
00002 // DO NOT EDIT THIS FILE!
00003 // It is automatically generated from opcfoundation.org schemas.
00004 //
00005 
00006 #include "standard_address_space_parts.h"
00007 #include <opc/ua/protocol/string_utils.h>
00008 #include <opc/common/addons_core/addon.h>
00009 #include <opc/ua/protocol/strings.h>
00010 #include <opc/ua/protocol/variable_access_level.h>
00011 #include <opc/ua/services/node_management.h>
00012 
00013 #include <algorithm>
00014 #include <iostream>
00015 #include <map>
00016 
00017 namespace OpcUa
00018 {
00019   void CreateAddressSpacePart9(OpcUa::NodeManagementServices& registry)
00020   {
00021        
00022         {
00023         AddNodesItem node;
00024         node.RequestedNewNodeId = ToNodeId("i=8995");
00025         node.BrowseName = ToQualifiedName("TwoStateVariableType");
00026         node.Class = NodeClass::VariableType;
00027         node.ParentNodeId = ToNodeId("i=2755");
00028         node.ReferenceTypeId = ReferenceId::HasSubtype;
00029         VariableTypeAttributes attrs;
00030         attrs.DisplayName = LocalizedText("TwoStateVariableType");
00031         attrs.Type = ObjectId::LocalizedText;
00032         attrs.Rank = -1;
00033         attrs.IsAbstract = false;
00034         node.Attributes = attrs;
00035         registry.AddNodes(std::vector<AddNodesItem>{node});
00036         std::vector<AddReferencesItem> refs;
00037         {
00038         AddReferencesItem ref;
00039         ref.IsForward = true;
00040         ref.ReferenceTypeId = ReferenceId::HasProperty;
00041         ref.SourceNodeId = ToNodeId("i=8995");
00042         ref.TargetNodeClass = NodeClass::DataType;
00043         ref.TargetNodeId = ToNodeId("i=8996");
00044         refs.push_back(ref);
00045         }
00046         {
00047         AddReferencesItem ref;
00048         ref.IsForward = true;
00049         ref.ReferenceTypeId = ReferenceId::HasProperty;
00050         ref.SourceNodeId = ToNodeId("i=8995");
00051         ref.TargetNodeClass = NodeClass::DataType;
00052         ref.TargetNodeId = ToNodeId("i=9000");
00053         refs.push_back(ref);
00054         }
00055         {
00056         AddReferencesItem ref;
00057         ref.IsForward = true;
00058         ref.ReferenceTypeId = ReferenceId::HasProperty;
00059         ref.SourceNodeId = ToNodeId("i=8995");
00060         ref.TargetNodeClass = NodeClass::DataType;
00061         ref.TargetNodeId = ToNodeId("i=9001");
00062         refs.push_back(ref);
00063         }
00064         {
00065         AddReferencesItem ref;
00066         ref.IsForward = true;
00067         ref.ReferenceTypeId = ReferenceId::HasProperty;
00068         ref.SourceNodeId = ToNodeId("i=8995");
00069         ref.TargetNodeClass = NodeClass::DataType;
00070         ref.TargetNodeId = ToNodeId("i=11110");
00071         refs.push_back(ref);
00072         }
00073         {
00074         AddReferencesItem ref;
00075         ref.IsForward = true;
00076         ref.ReferenceTypeId = ReferenceId::HasProperty;
00077         ref.SourceNodeId = ToNodeId("i=8995");
00078         ref.TargetNodeClass = NodeClass::DataType;
00079         ref.TargetNodeId = ToNodeId("i=11111");
00080         refs.push_back(ref);
00081         }
00082         registry.AddReferences(refs);
00083         }
00084        
00085         {
00086         AddNodesItem node;
00087         node.RequestedNewNodeId = ToNodeId("i=8996");
00088         node.BrowseName = ToQualifiedName("Id");
00089         node.Class = NodeClass::Variable;
00090         node.ParentNodeId = ToNodeId("i=8995");
00091         node.ReferenceTypeId = ReferenceId::HasProperty;
00092         node.TypeDefinition = ToNodeId("i=68");
00093         VariableAttributes attrs;
00094         attrs.DisplayName = LocalizedText("Id");
00095         attrs.Type = ObjectId::Boolean;
00096         attrs.Rank = -1;
00097         node.Attributes = attrs;
00098         registry.AddNodes(std::vector<AddNodesItem>{node});
00099         std::vector<AddReferencesItem> refs;
00100         {
00101         AddReferencesItem ref;
00102         ref.IsForward = true;
00103         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00104         ref.SourceNodeId = ToNodeId("i=8996");
00105         ref.TargetNodeClass = NodeClass::DataType;
00106         ref.TargetNodeId = ToNodeId("i=78");
00107         refs.push_back(ref);
00108         }
00109         registry.AddReferences(refs);
00110         }
00111        
00112         {
00113         AddNodesItem node;
00114         node.RequestedNewNodeId = ToNodeId("i=9000");
00115         node.BrowseName = ToQualifiedName("TransitionTime");
00116         node.Class = NodeClass::Variable;
00117         node.ParentNodeId = ToNodeId("i=8995");
00118         node.ReferenceTypeId = ReferenceId::HasProperty;
00119         node.TypeDefinition = ToNodeId("i=68");
00120         VariableAttributes attrs;
00121         attrs.DisplayName = LocalizedText("TransitionTime");
00122         attrs.Type = ToNodeId("i=294");
00123         attrs.Rank = -1;
00124         node.Attributes = attrs;
00125         registry.AddNodes(std::vector<AddNodesItem>{node});
00126         std::vector<AddReferencesItem> refs;
00127         {
00128         AddReferencesItem ref;
00129         ref.IsForward = true;
00130         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00131         ref.SourceNodeId = ToNodeId("i=9000");
00132         ref.TargetNodeClass = NodeClass::DataType;
00133         ref.TargetNodeId = ToNodeId("i=80");
00134         refs.push_back(ref);
00135         }
00136         registry.AddReferences(refs);
00137         }
00138        
00139         {
00140         AddNodesItem node;
00141         node.RequestedNewNodeId = ToNodeId("i=9001");
00142         node.BrowseName = ToQualifiedName("EffectiveTransitionTime");
00143         node.Class = NodeClass::Variable;
00144         node.ParentNodeId = ToNodeId("i=8995");
00145         node.ReferenceTypeId = ReferenceId::HasProperty;
00146         node.TypeDefinition = ToNodeId("i=68");
00147         VariableAttributes attrs;
00148         attrs.DisplayName = LocalizedText("EffectiveTransitionTime");
00149         attrs.Type = ToNodeId("i=294");
00150         attrs.Rank = -1;
00151         node.Attributes = attrs;
00152         registry.AddNodes(std::vector<AddNodesItem>{node});
00153         std::vector<AddReferencesItem> refs;
00154         {
00155         AddReferencesItem ref;
00156         ref.IsForward = true;
00157         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00158         ref.SourceNodeId = ToNodeId("i=9001");
00159         ref.TargetNodeClass = NodeClass::DataType;
00160         ref.TargetNodeId = ToNodeId("i=80");
00161         refs.push_back(ref);
00162         }
00163         registry.AddReferences(refs);
00164         }
00165        
00166         {
00167         AddNodesItem node;
00168         node.RequestedNewNodeId = ToNodeId("i=11110");
00169         node.BrowseName = ToQualifiedName("TrueState");
00170         node.Class = NodeClass::Variable;
00171         node.ParentNodeId = ToNodeId("i=8995");
00172         node.ReferenceTypeId = ReferenceId::HasProperty;
00173         node.TypeDefinition = ToNodeId("i=68");
00174         VariableAttributes attrs;
00175         attrs.DisplayName = LocalizedText("TrueState");
00176         attrs.Type = ObjectId::LocalizedText;
00177         attrs.Rank = -1;
00178         node.Attributes = attrs;
00179         registry.AddNodes(std::vector<AddNodesItem>{node});
00180         std::vector<AddReferencesItem> refs;
00181         {
00182         AddReferencesItem ref;
00183         ref.IsForward = true;
00184         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00185         ref.SourceNodeId = ToNodeId("i=11110");
00186         ref.TargetNodeClass = NodeClass::DataType;
00187         ref.TargetNodeId = ToNodeId("i=80");
00188         refs.push_back(ref);
00189         }
00190         registry.AddReferences(refs);
00191         }
00192        
00193         {
00194         AddNodesItem node;
00195         node.RequestedNewNodeId = ToNodeId("i=11111");
00196         node.BrowseName = ToQualifiedName("FalseState");
00197         node.Class = NodeClass::Variable;
00198         node.ParentNodeId = ToNodeId("i=8995");
00199         node.ReferenceTypeId = ReferenceId::HasProperty;
00200         node.TypeDefinition = ToNodeId("i=68");
00201         VariableAttributes attrs;
00202         attrs.DisplayName = LocalizedText("FalseState");
00203         attrs.Type = ObjectId::LocalizedText;
00204         attrs.Rank = -1;
00205         node.Attributes = attrs;
00206         registry.AddNodes(std::vector<AddNodesItem>{node});
00207         std::vector<AddReferencesItem> refs;
00208         {
00209         AddReferencesItem ref;
00210         ref.IsForward = true;
00211         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00212         ref.SourceNodeId = ToNodeId("i=11111");
00213         ref.TargetNodeClass = NodeClass::DataType;
00214         ref.TargetNodeId = ToNodeId("i=80");
00215         refs.push_back(ref);
00216         }
00217         registry.AddReferences(refs);
00218         }
00219        
00220         {
00221         AddNodesItem node;
00222         node.RequestedNewNodeId = ToNodeId("i=9002");
00223         node.BrowseName = ToQualifiedName("ConditionVariableType");
00224         node.Class = NodeClass::VariableType;
00225         node.ParentNodeId = ToNodeId("i=63");
00226         node.ReferenceTypeId = ReferenceId::HasSubtype;
00227         VariableTypeAttributes attrs;
00228         attrs.DisplayName = LocalizedText("ConditionVariableType");
00229         attrs.Type = ObjectId::String;
00230         attrs.Rank = -2;
00231         attrs.IsAbstract = false;
00232         node.Attributes = attrs;
00233         registry.AddNodes(std::vector<AddNodesItem>{node});
00234         std::vector<AddReferencesItem> refs;
00235         {
00236         AddReferencesItem ref;
00237         ref.IsForward = true;
00238         ref.ReferenceTypeId = ReferenceId::HasProperty;
00239         ref.SourceNodeId = ToNodeId("i=9002");
00240         ref.TargetNodeClass = NodeClass::DataType;
00241         ref.TargetNodeId = ToNodeId("i=9003");
00242         refs.push_back(ref);
00243         }
00244         registry.AddReferences(refs);
00245         }
00246        
00247         {
00248         AddNodesItem node;
00249         node.RequestedNewNodeId = ToNodeId("i=9003");
00250         node.BrowseName = ToQualifiedName("SourceTimestamp");
00251         node.Class = NodeClass::Variable;
00252         node.ParentNodeId = ToNodeId("i=9002");
00253         node.ReferenceTypeId = ReferenceId::HasProperty;
00254         node.TypeDefinition = ToNodeId("i=68");
00255         VariableAttributes attrs;
00256         attrs.DisplayName = LocalizedText("SourceTimestamp");
00257         attrs.Type = ToNodeId("i=294");
00258         attrs.Rank = -1;
00259         node.Attributes = attrs;
00260         registry.AddNodes(std::vector<AddNodesItem>{node});
00261         std::vector<AddReferencesItem> refs;
00262         {
00263         AddReferencesItem ref;
00264         ref.IsForward = true;
00265         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00266         ref.SourceNodeId = ToNodeId("i=9003");
00267         ref.TargetNodeClass = NodeClass::DataType;
00268         ref.TargetNodeId = ToNodeId("i=78");
00269         refs.push_back(ref);
00270         }
00271         registry.AddReferences(refs);
00272         }
00273        
00274         {
00275         AddNodesItem node;
00276         node.RequestedNewNodeId = ToNodeId("i=9004");
00277         node.BrowseName = ToQualifiedName("HasTrueSubState");
00278         node.Class = NodeClass::ReferenceType;
00279         node.ParentNodeId = ToNodeId("i=32");
00280         node.ReferenceTypeId = ReferenceId::HasSubtype;
00281         ReferenceTypeAttributes attrs;
00282         attrs.DisplayName = LocalizedText("HasTrueSubState");
00283         attrs.InverseName = LocalizedText("IsTrueSubStateOf");
00284         attrs.IsAbstract = false;
00285         attrs.Symmetric = false;
00286         node.Attributes = attrs;
00287         registry.AddNodes(std::vector<AddNodesItem>{node});
00288         }
00289        
00290         {
00291         AddNodesItem node;
00292         node.RequestedNewNodeId = ToNodeId("i=9005");
00293         node.BrowseName = ToQualifiedName("HasFalseSubState");
00294         node.Class = NodeClass::ReferenceType;
00295         node.ParentNodeId = ToNodeId("i=32");
00296         node.ReferenceTypeId = ReferenceId::HasSubtype;
00297         ReferenceTypeAttributes attrs;
00298         attrs.DisplayName = LocalizedText("HasFalseSubState");
00299         attrs.InverseName = LocalizedText("IsFalseSubStateOf");
00300         attrs.IsAbstract = false;
00301         attrs.Symmetric = false;
00302         node.Attributes = attrs;
00303         registry.AddNodes(std::vector<AddNodesItem>{node});
00304         }
00305        
00306         {
00307         AddNodesItem node;
00308         node.RequestedNewNodeId = ToNodeId("i=2782");
00309         node.BrowseName = ToQualifiedName("ConditionType");
00310         node.Class = NodeClass::ObjectType;
00311         node.ParentNodeId = ToNodeId("i=2041");
00312         node.ReferenceTypeId = ReferenceId::HasSubtype;
00313         ObjectTypeAttributes attrs;
00314         attrs.DisplayName = LocalizedText("ConditionType");
00315         attrs.IsAbstract = true;
00316         node.Attributes = attrs;
00317         registry.AddNodes(std::vector<AddNodesItem>{node});
00318         std::vector<AddReferencesItem> refs;
00319         {
00320         AddReferencesItem ref;
00321         ref.IsForward = true;
00322         ref.ReferenceTypeId = ReferenceId::HasProperty;
00323         ref.SourceNodeId = ToNodeId("i=2782");
00324         ref.TargetNodeClass = NodeClass::DataType;
00325         ref.TargetNodeId = ToNodeId("i=11112");
00326         refs.push_back(ref);
00327         }
00328         {
00329         AddReferencesItem ref;
00330         ref.IsForward = true;
00331         ref.ReferenceTypeId = ReferenceId::HasProperty;
00332         ref.SourceNodeId = ToNodeId("i=2782");
00333         ref.TargetNodeClass = NodeClass::DataType;
00334         ref.TargetNodeId = ToNodeId("i=11113");
00335         refs.push_back(ref);
00336         }
00337         {
00338         AddReferencesItem ref;
00339         ref.IsForward = true;
00340         ref.ReferenceTypeId = ReferenceId::HasProperty;
00341         ref.SourceNodeId = ToNodeId("i=2782");
00342         ref.TargetNodeClass = NodeClass::DataType;
00343         ref.TargetNodeId = ToNodeId("i=9009");
00344         refs.push_back(ref);
00345         }
00346         {
00347         AddReferencesItem ref;
00348         ref.IsForward = true;
00349         ref.ReferenceTypeId = ReferenceId::HasProperty;
00350         ref.SourceNodeId = ToNodeId("i=2782");
00351         ref.TargetNodeClass = NodeClass::DataType;
00352         ref.TargetNodeId = ToNodeId("i=9010");
00353         refs.push_back(ref);
00354         }
00355         {
00356         AddReferencesItem ref;
00357         ref.IsForward = true;
00358         ref.ReferenceTypeId = ReferenceId::HasProperty;
00359         ref.SourceNodeId = ToNodeId("i=2782");
00360         ref.TargetNodeClass = NodeClass::DataType;
00361         ref.TargetNodeId = ToNodeId("i=3874");
00362         refs.push_back(ref);
00363         }
00364         {
00365         AddReferencesItem ref;
00366         ref.IsForward = true;
00367         ref.ReferenceTypeId = ReferenceId::HasComponent;
00368         ref.SourceNodeId = ToNodeId("i=2782");
00369         ref.TargetNodeClass = NodeClass::DataType;
00370         ref.TargetNodeId = ToNodeId("i=9011");
00371         refs.push_back(ref);
00372         }
00373         {
00374         AddReferencesItem ref;
00375         ref.IsForward = true;
00376         ref.ReferenceTypeId = ReferenceId::HasComponent;
00377         ref.SourceNodeId = ToNodeId("i=2782");
00378         ref.TargetNodeClass = NodeClass::DataType;
00379         ref.TargetNodeId = ToNodeId("i=9020");
00380         refs.push_back(ref);
00381         }
00382         {
00383         AddReferencesItem ref;
00384         ref.IsForward = true;
00385         ref.ReferenceTypeId = ReferenceId::HasComponent;
00386         ref.SourceNodeId = ToNodeId("i=2782");
00387         ref.TargetNodeClass = NodeClass::DataType;
00388         ref.TargetNodeId = ToNodeId("i=9022");
00389         refs.push_back(ref);
00390         }
00391         {
00392         AddReferencesItem ref;
00393         ref.IsForward = true;
00394         ref.ReferenceTypeId = ReferenceId::HasComponent;
00395         ref.SourceNodeId = ToNodeId("i=2782");
00396         ref.TargetNodeClass = NodeClass::DataType;
00397         ref.TargetNodeId = ToNodeId("i=9024");
00398         refs.push_back(ref);
00399         }
00400         {
00401         AddReferencesItem ref;
00402         ref.IsForward = true;
00403         ref.ReferenceTypeId = ReferenceId::HasProperty;
00404         ref.SourceNodeId = ToNodeId("i=2782");
00405         ref.TargetNodeClass = NodeClass::DataType;
00406         ref.TargetNodeId = ToNodeId("i=9026");
00407         refs.push_back(ref);
00408         }
00409         {
00410         AddReferencesItem ref;
00411         ref.IsForward = true;
00412         ref.ReferenceTypeId = ReferenceId::HasComponent;
00413         ref.SourceNodeId = ToNodeId("i=2782");
00414         ref.TargetNodeClass = NodeClass::DataType;
00415         ref.TargetNodeId = ToNodeId("i=9028");
00416         refs.push_back(ref);
00417         }
00418         {
00419         AddReferencesItem ref;
00420         ref.IsForward = true;
00421         ref.ReferenceTypeId = ReferenceId::HasComponent;
00422         ref.SourceNodeId = ToNodeId("i=2782");
00423         ref.TargetNodeClass = NodeClass::DataType;
00424         ref.TargetNodeId = ToNodeId("i=9027");
00425         refs.push_back(ref);
00426         }
00427         {
00428         AddReferencesItem ref;
00429         ref.IsForward = true;
00430         ref.ReferenceTypeId = ReferenceId::HasComponent;
00431         ref.SourceNodeId = ToNodeId("i=2782");
00432         ref.TargetNodeClass = NodeClass::DataType;
00433         ref.TargetNodeId = ToNodeId("i=9029");
00434         refs.push_back(ref);
00435         }
00436         {
00437         AddReferencesItem ref;
00438         ref.IsForward = true;
00439         ref.ReferenceTypeId = ReferenceId::HasComponent;
00440         ref.SourceNodeId = ToNodeId("i=2782");
00441         ref.TargetNodeClass = NodeClass::DataType;
00442         ref.TargetNodeId = ToNodeId("i=3875");
00443         refs.push_back(ref);
00444         }
00445         registry.AddReferences(refs);
00446         }
00447        
00448         {
00449         AddNodesItem node;
00450         node.RequestedNewNodeId = ToNodeId("i=11112");
00451         node.BrowseName = ToQualifiedName("ConditionClassId");
00452         node.Class = NodeClass::Variable;
00453         node.ParentNodeId = ToNodeId("i=2782");
00454         node.ReferenceTypeId = ReferenceId::HasProperty;
00455         node.TypeDefinition = ToNodeId("i=68");
00456         VariableAttributes attrs;
00457         attrs.DisplayName = LocalizedText("ConditionClassId");
00458         attrs.Type = ObjectId::NodeId;
00459         attrs.Rank = -1;
00460         node.Attributes = attrs;
00461         registry.AddNodes(std::vector<AddNodesItem>{node});
00462         std::vector<AddReferencesItem> refs;
00463         {
00464         AddReferencesItem ref;
00465         ref.IsForward = true;
00466         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00467         ref.SourceNodeId = ToNodeId("i=11112");
00468         ref.TargetNodeClass = NodeClass::DataType;
00469         ref.TargetNodeId = ToNodeId("i=78");
00470         refs.push_back(ref);
00471         }
00472         registry.AddReferences(refs);
00473         }
00474        
00475         {
00476         AddNodesItem node;
00477         node.RequestedNewNodeId = ToNodeId("i=11113");
00478         node.BrowseName = ToQualifiedName("ConditionClassName");
00479         node.Class = NodeClass::Variable;
00480         node.ParentNodeId = ToNodeId("i=2782");
00481         node.ReferenceTypeId = ReferenceId::HasProperty;
00482         node.TypeDefinition = ToNodeId("i=68");
00483         VariableAttributes attrs;
00484         attrs.DisplayName = LocalizedText("ConditionClassName");
00485         attrs.Type = ObjectId::LocalizedText;
00486         attrs.Rank = -1;
00487         node.Attributes = attrs;
00488         registry.AddNodes(std::vector<AddNodesItem>{node});
00489         std::vector<AddReferencesItem> refs;
00490         {
00491         AddReferencesItem ref;
00492         ref.IsForward = true;
00493         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00494         ref.SourceNodeId = ToNodeId("i=11113");
00495         ref.TargetNodeClass = NodeClass::DataType;
00496         ref.TargetNodeId = ToNodeId("i=78");
00497         refs.push_back(ref);
00498         }
00499         registry.AddReferences(refs);
00500         }
00501        
00502         {
00503         AddNodesItem node;
00504         node.RequestedNewNodeId = ToNodeId("i=9009");
00505         node.BrowseName = ToQualifiedName("ConditionName");
00506         node.Class = NodeClass::Variable;
00507         node.ParentNodeId = ToNodeId("i=2782");
00508         node.ReferenceTypeId = ReferenceId::HasProperty;
00509         node.TypeDefinition = ToNodeId("i=68");
00510         VariableAttributes attrs;
00511         attrs.DisplayName = LocalizedText("ConditionName");
00512         attrs.Type = ObjectId::String;
00513         attrs.Rank = -1;
00514         node.Attributes = attrs;
00515         registry.AddNodes(std::vector<AddNodesItem>{node});
00516         std::vector<AddReferencesItem> refs;
00517         {
00518         AddReferencesItem ref;
00519         ref.IsForward = true;
00520         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00521         ref.SourceNodeId = ToNodeId("i=9009");
00522         ref.TargetNodeClass = NodeClass::DataType;
00523         ref.TargetNodeId = ToNodeId("i=78");
00524         refs.push_back(ref);
00525         }
00526         registry.AddReferences(refs);
00527         }
00528        
00529         {
00530         AddNodesItem node;
00531         node.RequestedNewNodeId = ToNodeId("i=9010");
00532         node.BrowseName = ToQualifiedName("BranchId");
00533         node.Class = NodeClass::Variable;
00534         node.ParentNodeId = ToNodeId("i=2782");
00535         node.ReferenceTypeId = ReferenceId::HasProperty;
00536         node.TypeDefinition = ToNodeId("i=68");
00537         VariableAttributes attrs;
00538         attrs.DisplayName = LocalizedText("BranchId");
00539         attrs.Type = ObjectId::NodeId;
00540         attrs.Rank = -1;
00541         node.Attributes = attrs;
00542         registry.AddNodes(std::vector<AddNodesItem>{node});
00543         std::vector<AddReferencesItem> refs;
00544         {
00545         AddReferencesItem ref;
00546         ref.IsForward = true;
00547         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00548         ref.SourceNodeId = ToNodeId("i=9010");
00549         ref.TargetNodeClass = NodeClass::DataType;
00550         ref.TargetNodeId = ToNodeId("i=78");
00551         refs.push_back(ref);
00552         }
00553         registry.AddReferences(refs);
00554         }
00555        
00556         {
00557         AddNodesItem node;
00558         node.RequestedNewNodeId = ToNodeId("i=3874");
00559         node.BrowseName = ToQualifiedName("Retain");
00560         node.Class = NodeClass::Variable;
00561         node.ParentNodeId = ToNodeId("i=2782");
00562         node.ReferenceTypeId = ReferenceId::HasProperty;
00563         node.TypeDefinition = ToNodeId("i=68");
00564         VariableAttributes attrs;
00565         attrs.DisplayName = LocalizedText("Retain");
00566         attrs.Type = ObjectId::Boolean;
00567         attrs.Rank = -1;
00568         node.Attributes = attrs;
00569         registry.AddNodes(std::vector<AddNodesItem>{node});
00570         std::vector<AddReferencesItem> refs;
00571         {
00572         AddReferencesItem ref;
00573         ref.IsForward = true;
00574         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00575         ref.SourceNodeId = ToNodeId("i=3874");
00576         ref.TargetNodeClass = NodeClass::DataType;
00577         ref.TargetNodeId = ToNodeId("i=78");
00578         refs.push_back(ref);
00579         }
00580         registry.AddReferences(refs);
00581         }
00582        
00583         {
00584         AddNodesItem node;
00585         node.RequestedNewNodeId = ToNodeId("i=9011");
00586         node.BrowseName = ToQualifiedName("EnabledState");
00587         node.Class = NodeClass::Variable;
00588         node.ParentNodeId = ToNodeId("i=2782");
00589         node.ReferenceTypeId = ReferenceId::HasComponent;
00590         node.TypeDefinition = ToNodeId("i=8995");
00591         VariableAttributes attrs;
00592         attrs.DisplayName = LocalizedText("EnabledState");
00593         attrs.Type = ObjectId::LocalizedText;
00594         attrs.Rank = -1;
00595         node.Attributes = attrs;
00596         registry.AddNodes(std::vector<AddNodesItem>{node});
00597         std::vector<AddReferencesItem> refs;
00598         {
00599         AddReferencesItem ref;
00600         ref.IsForward = true;
00601         ref.ReferenceTypeId = ReferenceId::HasProperty;
00602         ref.SourceNodeId = ToNodeId("i=9011");
00603         ref.TargetNodeClass = NodeClass::DataType;
00604         ref.TargetNodeId = ToNodeId("i=9012");
00605         refs.push_back(ref);
00606         }
00607         {
00608         AddReferencesItem ref;
00609         ref.IsForward = true;
00610         ref.ReferenceTypeId = ReferenceId::HasProperty;
00611         ref.SourceNodeId = ToNodeId("i=9011");
00612         ref.TargetNodeClass = NodeClass::DataType;
00613         ref.TargetNodeId = ToNodeId("i=9015");
00614         refs.push_back(ref);
00615         }
00616         {
00617         AddReferencesItem ref;
00618         ref.IsForward = true;
00619         ref.ReferenceTypeId = ReferenceId::HasProperty;
00620         ref.SourceNodeId = ToNodeId("i=9011");
00621         ref.TargetNodeClass = NodeClass::DataType;
00622         ref.TargetNodeId = ToNodeId("i=9016");
00623         refs.push_back(ref);
00624         }
00625         {
00626         AddReferencesItem ref;
00627         ref.IsForward = true;
00628         ref.ReferenceTypeId = ReferenceId::HasProperty;
00629         ref.SourceNodeId = ToNodeId("i=9011");
00630         ref.TargetNodeClass = NodeClass::DataType;
00631         ref.TargetNodeId = ToNodeId("i=9017");
00632         refs.push_back(ref);
00633         }
00634         {
00635         AddReferencesItem ref;
00636         ref.IsForward = true;
00637         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00638         ref.SourceNodeId = ToNodeId("i=9011");
00639         ref.TargetNodeClass = NodeClass::DataType;
00640         ref.TargetNodeId = ToNodeId("i=78");
00641         refs.push_back(ref);
00642         }
00643         registry.AddReferences(refs);
00644         }
00645        
00646         {
00647         AddNodesItem node;
00648         node.RequestedNewNodeId = ToNodeId("i=9012");
00649         node.BrowseName = ToQualifiedName("Id");
00650         node.Class = NodeClass::Variable;
00651         node.ParentNodeId = ToNodeId("i=9011");
00652         node.ReferenceTypeId = ReferenceId::HasProperty;
00653         node.TypeDefinition = ToNodeId("i=68");
00654         VariableAttributes attrs;
00655         attrs.DisplayName = LocalizedText("Id");
00656         attrs.Type = ObjectId::Boolean;
00657         attrs.Rank = -1;
00658         node.Attributes = attrs;
00659         registry.AddNodes(std::vector<AddNodesItem>{node});
00660         std::vector<AddReferencesItem> refs;
00661         {
00662         AddReferencesItem ref;
00663         ref.IsForward = true;
00664         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00665         ref.SourceNodeId = ToNodeId("i=9012");
00666         ref.TargetNodeClass = NodeClass::DataType;
00667         ref.TargetNodeId = ToNodeId("i=78");
00668         refs.push_back(ref);
00669         }
00670         registry.AddReferences(refs);
00671         }
00672        
00673         {
00674         AddNodesItem node;
00675         node.RequestedNewNodeId = ToNodeId("i=9015");
00676         node.BrowseName = ToQualifiedName("EffectiveDisplayName");
00677         node.Class = NodeClass::Variable;
00678         node.ParentNodeId = ToNodeId("i=9011");
00679         node.ReferenceTypeId = ReferenceId::HasProperty;
00680         node.TypeDefinition = ToNodeId("i=68");
00681         VariableAttributes attrs;
00682         attrs.DisplayName = LocalizedText("EffectiveDisplayName");
00683         attrs.Type = ObjectId::LocalizedText;
00684         attrs.Rank = -1;
00685         node.Attributes = attrs;
00686         registry.AddNodes(std::vector<AddNodesItem>{node});
00687         std::vector<AddReferencesItem> refs;
00688         {
00689         AddReferencesItem ref;
00690         ref.IsForward = true;
00691         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00692         ref.SourceNodeId = ToNodeId("i=9015");
00693         ref.TargetNodeClass = NodeClass::DataType;
00694         ref.TargetNodeId = ToNodeId("i=80");
00695         refs.push_back(ref);
00696         }
00697         registry.AddReferences(refs);
00698         }
00699        
00700         {
00701         AddNodesItem node;
00702         node.RequestedNewNodeId = ToNodeId("i=9016");
00703         node.BrowseName = ToQualifiedName("TransitionTime");
00704         node.Class = NodeClass::Variable;
00705         node.ParentNodeId = ToNodeId("i=9011");
00706         node.ReferenceTypeId = ReferenceId::HasProperty;
00707         node.TypeDefinition = ToNodeId("i=68");
00708         VariableAttributes attrs;
00709         attrs.DisplayName = LocalizedText("TransitionTime");
00710         attrs.Type = ToNodeId("i=294");
00711         attrs.Rank = -1;
00712         node.Attributes = attrs;
00713         registry.AddNodes(std::vector<AddNodesItem>{node});
00714         std::vector<AddReferencesItem> refs;
00715         {
00716         AddReferencesItem ref;
00717         ref.IsForward = true;
00718         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00719         ref.SourceNodeId = ToNodeId("i=9016");
00720         ref.TargetNodeClass = NodeClass::DataType;
00721         ref.TargetNodeId = ToNodeId("i=80");
00722         refs.push_back(ref);
00723         }
00724         registry.AddReferences(refs);
00725         }
00726        
00727         {
00728         AddNodesItem node;
00729         node.RequestedNewNodeId = ToNodeId("i=9017");
00730         node.BrowseName = ToQualifiedName("EffectiveTransitionTime");
00731         node.Class = NodeClass::Variable;
00732         node.ParentNodeId = ToNodeId("i=9011");
00733         node.ReferenceTypeId = ReferenceId::HasProperty;
00734         node.TypeDefinition = ToNodeId("i=68");
00735         VariableAttributes attrs;
00736         attrs.DisplayName = LocalizedText("EffectiveTransitionTime");
00737         attrs.Type = ToNodeId("i=294");
00738         attrs.Rank = -1;
00739         node.Attributes = attrs;
00740         registry.AddNodes(std::vector<AddNodesItem>{node});
00741         std::vector<AddReferencesItem> refs;
00742         {
00743         AddReferencesItem ref;
00744         ref.IsForward = true;
00745         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00746         ref.SourceNodeId = ToNodeId("i=9017");
00747         ref.TargetNodeClass = NodeClass::DataType;
00748         ref.TargetNodeId = ToNodeId("i=80");
00749         refs.push_back(ref);
00750         }
00751         registry.AddReferences(refs);
00752         }
00753        
00754         {
00755         AddNodesItem node;
00756         node.RequestedNewNodeId = ToNodeId("i=9020");
00757         node.BrowseName = ToQualifiedName("Quality");
00758         node.Class = NodeClass::Variable;
00759         node.ParentNodeId = ToNodeId("i=2782");
00760         node.ReferenceTypeId = ReferenceId::HasComponent;
00761         node.TypeDefinition = ToNodeId("i=9002");
00762         VariableAttributes attrs;
00763         attrs.DisplayName = LocalizedText("Quality");
00764         attrs.Type = ObjectId::StatusCode;
00765         attrs.Rank = -1;
00766         node.Attributes = attrs;
00767         registry.AddNodes(std::vector<AddNodesItem>{node});
00768         std::vector<AddReferencesItem> refs;
00769         {
00770         AddReferencesItem ref;
00771         ref.IsForward = true;
00772         ref.ReferenceTypeId = ReferenceId::HasProperty;
00773         ref.SourceNodeId = ToNodeId("i=9020");
00774         ref.TargetNodeClass = NodeClass::DataType;
00775         ref.TargetNodeId = ToNodeId("i=9021");
00776         refs.push_back(ref);
00777         }
00778         {
00779         AddReferencesItem ref;
00780         ref.IsForward = true;
00781         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00782         ref.SourceNodeId = ToNodeId("i=9020");
00783         ref.TargetNodeClass = NodeClass::DataType;
00784         ref.TargetNodeId = ToNodeId("i=78");
00785         refs.push_back(ref);
00786         }
00787         registry.AddReferences(refs);
00788         }
00789        
00790         {
00791         AddNodesItem node;
00792         node.RequestedNewNodeId = ToNodeId("i=9021");
00793         node.BrowseName = ToQualifiedName("SourceTimestamp");
00794         node.Class = NodeClass::Variable;
00795         node.ParentNodeId = ToNodeId("i=9020");
00796         node.ReferenceTypeId = ReferenceId::HasProperty;
00797         node.TypeDefinition = ToNodeId("i=68");
00798         VariableAttributes attrs;
00799         attrs.DisplayName = LocalizedText("SourceTimestamp");
00800         attrs.Type = ToNodeId("i=294");
00801         attrs.Rank = -1;
00802         node.Attributes = attrs;
00803         registry.AddNodes(std::vector<AddNodesItem>{node});
00804         std::vector<AddReferencesItem> refs;
00805         {
00806         AddReferencesItem ref;
00807         ref.IsForward = true;
00808         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00809         ref.SourceNodeId = ToNodeId("i=9021");
00810         ref.TargetNodeClass = NodeClass::DataType;
00811         ref.TargetNodeId = ToNodeId("i=78");
00812         refs.push_back(ref);
00813         }
00814         registry.AddReferences(refs);
00815         }
00816        
00817         {
00818         AddNodesItem node;
00819         node.RequestedNewNodeId = ToNodeId("i=9022");
00820         node.BrowseName = ToQualifiedName("LastSeverity");
00821         node.Class = NodeClass::Variable;
00822         node.ParentNodeId = ToNodeId("i=2782");
00823         node.ReferenceTypeId = ReferenceId::HasComponent;
00824         node.TypeDefinition = ToNodeId("i=9002");
00825         VariableAttributes attrs;
00826         attrs.DisplayName = LocalizedText("LastSeverity");
00827         attrs.Type = ObjectId::UInt16;
00828         attrs.Rank = -1;
00829         node.Attributes = attrs;
00830         registry.AddNodes(std::vector<AddNodesItem>{node});
00831         std::vector<AddReferencesItem> refs;
00832         {
00833         AddReferencesItem ref;
00834         ref.IsForward = true;
00835         ref.ReferenceTypeId = ReferenceId::HasProperty;
00836         ref.SourceNodeId = ToNodeId("i=9022");
00837         ref.TargetNodeClass = NodeClass::DataType;
00838         ref.TargetNodeId = ToNodeId("i=9023");
00839         refs.push_back(ref);
00840         }
00841         {
00842         AddReferencesItem ref;
00843         ref.IsForward = true;
00844         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00845         ref.SourceNodeId = ToNodeId("i=9022");
00846         ref.TargetNodeClass = NodeClass::DataType;
00847         ref.TargetNodeId = ToNodeId("i=78");
00848         refs.push_back(ref);
00849         }
00850         registry.AddReferences(refs);
00851         }
00852        
00853         {
00854         AddNodesItem node;
00855         node.RequestedNewNodeId = ToNodeId("i=9023");
00856         node.BrowseName = ToQualifiedName("SourceTimestamp");
00857         node.Class = NodeClass::Variable;
00858         node.ParentNodeId = ToNodeId("i=9022");
00859         node.ReferenceTypeId = ReferenceId::HasProperty;
00860         node.TypeDefinition = ToNodeId("i=68");
00861         VariableAttributes attrs;
00862         attrs.DisplayName = LocalizedText("SourceTimestamp");
00863         attrs.Type = ToNodeId("i=294");
00864         attrs.Rank = -1;
00865         node.Attributes = attrs;
00866         registry.AddNodes(std::vector<AddNodesItem>{node});
00867         std::vector<AddReferencesItem> refs;
00868         {
00869         AddReferencesItem ref;
00870         ref.IsForward = true;
00871         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00872         ref.SourceNodeId = ToNodeId("i=9023");
00873         ref.TargetNodeClass = NodeClass::DataType;
00874         ref.TargetNodeId = ToNodeId("i=78");
00875         refs.push_back(ref);
00876         }
00877         registry.AddReferences(refs);
00878         }
00879        
00880         {
00881         AddNodesItem node;
00882         node.RequestedNewNodeId = ToNodeId("i=9024");
00883         node.BrowseName = ToQualifiedName("Comment");
00884         node.Class = NodeClass::Variable;
00885         node.ParentNodeId = ToNodeId("i=2782");
00886         node.ReferenceTypeId = ReferenceId::HasComponent;
00887         node.TypeDefinition = ToNodeId("i=9002");
00888         VariableAttributes attrs;
00889         attrs.DisplayName = LocalizedText("Comment");
00890         attrs.Type = ObjectId::LocalizedText;
00891         attrs.Rank = -1;
00892         node.Attributes = attrs;
00893         registry.AddNodes(std::vector<AddNodesItem>{node});
00894         std::vector<AddReferencesItem> refs;
00895         {
00896         AddReferencesItem ref;
00897         ref.IsForward = true;
00898         ref.ReferenceTypeId = ReferenceId::HasProperty;
00899         ref.SourceNodeId = ToNodeId("i=9024");
00900         ref.TargetNodeClass = NodeClass::DataType;
00901         ref.TargetNodeId = ToNodeId("i=9025");
00902         refs.push_back(ref);
00903         }
00904         {
00905         AddReferencesItem ref;
00906         ref.IsForward = true;
00907         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00908         ref.SourceNodeId = ToNodeId("i=9024");
00909         ref.TargetNodeClass = NodeClass::DataType;
00910         ref.TargetNodeId = ToNodeId("i=78");
00911         refs.push_back(ref);
00912         }
00913         registry.AddReferences(refs);
00914         }
00915        
00916         {
00917         AddNodesItem node;
00918         node.RequestedNewNodeId = ToNodeId("i=9025");
00919         node.BrowseName = ToQualifiedName("SourceTimestamp");
00920         node.Class = NodeClass::Variable;
00921         node.ParentNodeId = ToNodeId("i=9024");
00922         node.ReferenceTypeId = ReferenceId::HasProperty;
00923         node.TypeDefinition = ToNodeId("i=68");
00924         VariableAttributes attrs;
00925         attrs.DisplayName = LocalizedText("SourceTimestamp");
00926         attrs.Type = ToNodeId("i=294");
00927         attrs.Rank = -1;
00928         node.Attributes = attrs;
00929         registry.AddNodes(std::vector<AddNodesItem>{node});
00930         std::vector<AddReferencesItem> refs;
00931         {
00932         AddReferencesItem ref;
00933         ref.IsForward = true;
00934         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00935         ref.SourceNodeId = ToNodeId("i=9025");
00936         ref.TargetNodeClass = NodeClass::DataType;
00937         ref.TargetNodeId = ToNodeId("i=78");
00938         refs.push_back(ref);
00939         }
00940         registry.AddReferences(refs);
00941         }
00942        
00943         {
00944         AddNodesItem node;
00945         node.RequestedNewNodeId = ToNodeId("i=9026");
00946         node.BrowseName = ToQualifiedName("ClientUserId");
00947         node.Class = NodeClass::Variable;
00948         node.ParentNodeId = ToNodeId("i=2782");
00949         node.ReferenceTypeId = ReferenceId::HasProperty;
00950         node.TypeDefinition = ToNodeId("i=68");
00951         VariableAttributes attrs;
00952         attrs.DisplayName = LocalizedText("ClientUserId");
00953         attrs.Type = ObjectId::String;
00954         attrs.Rank = -1;
00955         node.Attributes = attrs;
00956         registry.AddNodes(std::vector<AddNodesItem>{node});
00957         std::vector<AddReferencesItem> refs;
00958         {
00959         AddReferencesItem ref;
00960         ref.IsForward = true;
00961         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00962         ref.SourceNodeId = ToNodeId("i=9026");
00963         ref.TargetNodeClass = NodeClass::DataType;
00964         ref.TargetNodeId = ToNodeId("i=78");
00965         refs.push_back(ref);
00966         }
00967         registry.AddReferences(refs);
00968         }
00969        
00970         {
00971         AddNodesItem node;
00972         node.RequestedNewNodeId = ToNodeId("i=9030");
00973         node.BrowseName = ToQualifiedName("InputArguments");
00974         node.Class = NodeClass::Variable;
00975         node.ParentNodeId = ToNodeId("i=9029");
00976         node.ReferenceTypeId = ReferenceId::HasProperty;
00977         node.TypeDefinition = ToNodeId("i=68");
00978         VariableAttributes attrs;
00979         attrs.DisplayName = LocalizedText("InputArguments");
00980         attrs.Type = ToNodeId("i=296");
00981         attrs.Rank = 1;
00982         node.Attributes = attrs;
00983         registry.AddNodes(std::vector<AddNodesItem>{node});
00984         std::vector<AddReferencesItem> refs;
00985         {
00986         AddReferencesItem ref;
00987         ref.IsForward = true;
00988         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
00989         ref.SourceNodeId = ToNodeId("i=9030");
00990         ref.TargetNodeClass = NodeClass::DataType;
00991         ref.TargetNodeId = ToNodeId("i=78");
00992         refs.push_back(ref);
00993         }
00994         registry.AddReferences(refs);
00995         }
00996        
00997         {
00998         AddNodesItem node;
00999         node.RequestedNewNodeId = ToNodeId("i=3876");
01000         node.BrowseName = ToQualifiedName("InputArguments");
01001         node.Class = NodeClass::Variable;
01002         node.ParentNodeId = ToNodeId("i=3875");
01003         node.ReferenceTypeId = ReferenceId::HasProperty;
01004         node.TypeDefinition = ToNodeId("i=68");
01005         VariableAttributes attrs;
01006         attrs.DisplayName = LocalizedText("InputArguments");
01007         attrs.Type = ToNodeId("i=296");
01008         attrs.Rank = 1;
01009         node.Attributes = attrs;
01010         registry.AddNodes(std::vector<AddNodesItem>{node});
01011         std::vector<AddReferencesItem> refs;
01012         {
01013         AddReferencesItem ref;
01014         ref.IsForward = true;
01015         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01016         ref.SourceNodeId = ToNodeId("i=3876");
01017         ref.TargetNodeClass = NodeClass::DataType;
01018         ref.TargetNodeId = ToNodeId("i=78");
01019         refs.push_back(ref);
01020         }
01021         registry.AddReferences(refs);
01022         }
01023        
01024         {
01025         AddNodesItem node;
01026         node.RequestedNewNodeId = ToNodeId("i=2830");
01027         node.BrowseName = ToQualifiedName("DialogConditionType");
01028         node.Class = NodeClass::ObjectType;
01029         node.ParentNodeId = ToNodeId("i=2782");
01030         node.ReferenceTypeId = ReferenceId::HasSubtype;
01031         ObjectTypeAttributes attrs;
01032         attrs.DisplayName = LocalizedText("DialogConditionType");
01033         attrs.IsAbstract = false;
01034         node.Attributes = attrs;
01035         registry.AddNodes(std::vector<AddNodesItem>{node});
01036         std::vector<AddReferencesItem> refs;
01037         {
01038         AddReferencesItem ref;
01039         ref.IsForward = true;
01040         ref.ReferenceTypeId = ReferenceId::HasComponent;
01041         ref.SourceNodeId = ToNodeId("i=2830");
01042         ref.TargetNodeClass = NodeClass::DataType;
01043         ref.TargetNodeId = ToNodeId("i=9035");
01044         refs.push_back(ref);
01045         }
01046         {
01047         AddReferencesItem ref;
01048         ref.IsForward = true;
01049         ref.ReferenceTypeId = ReferenceId::HasComponent;
01050         ref.SourceNodeId = ToNodeId("i=2830");
01051         ref.TargetNodeClass = NodeClass::DataType;
01052         ref.TargetNodeId = ToNodeId("i=9055");
01053         refs.push_back(ref);
01054         }
01055         {
01056         AddReferencesItem ref;
01057         ref.IsForward = true;
01058         ref.ReferenceTypeId = ReferenceId::HasProperty;
01059         ref.SourceNodeId = ToNodeId("i=2830");
01060         ref.TargetNodeClass = NodeClass::DataType;
01061         ref.TargetNodeId = ToNodeId("i=2831");
01062         refs.push_back(ref);
01063         }
01064         {
01065         AddReferencesItem ref;
01066         ref.IsForward = true;
01067         ref.ReferenceTypeId = ReferenceId::HasProperty;
01068         ref.SourceNodeId = ToNodeId("i=2830");
01069         ref.TargetNodeClass = NodeClass::DataType;
01070         ref.TargetNodeId = ToNodeId("i=9064");
01071         refs.push_back(ref);
01072         }
01073         {
01074         AddReferencesItem ref;
01075         ref.IsForward = true;
01076         ref.ReferenceTypeId = ReferenceId::HasProperty;
01077         ref.SourceNodeId = ToNodeId("i=2830");
01078         ref.TargetNodeClass = NodeClass::DataType;
01079         ref.TargetNodeId = ToNodeId("i=9065");
01080         refs.push_back(ref);
01081         }
01082         {
01083         AddReferencesItem ref;
01084         ref.IsForward = true;
01085         ref.ReferenceTypeId = ReferenceId::HasProperty;
01086         ref.SourceNodeId = ToNodeId("i=2830");
01087         ref.TargetNodeClass = NodeClass::DataType;
01088         ref.TargetNodeId = ToNodeId("i=9066");
01089         refs.push_back(ref);
01090         }
01091         {
01092         AddReferencesItem ref;
01093         ref.IsForward = true;
01094         ref.ReferenceTypeId = ReferenceId::HasProperty;
01095         ref.SourceNodeId = ToNodeId("i=2830");
01096         ref.TargetNodeClass = NodeClass::DataType;
01097         ref.TargetNodeId = ToNodeId("i=9067");
01098         refs.push_back(ref);
01099         }
01100         {
01101         AddReferencesItem ref;
01102         ref.IsForward = true;
01103         ref.ReferenceTypeId = ReferenceId::HasProperty;
01104         ref.SourceNodeId = ToNodeId("i=2830");
01105         ref.TargetNodeClass = NodeClass::DataType;
01106         ref.TargetNodeId = ToNodeId("i=9068");
01107         refs.push_back(ref);
01108         }
01109         {
01110         AddReferencesItem ref;
01111         ref.IsForward = true;
01112         ref.ReferenceTypeId = ReferenceId::HasComponent;
01113         ref.SourceNodeId = ToNodeId("i=2830");
01114         ref.TargetNodeClass = NodeClass::DataType;
01115         ref.TargetNodeId = ToNodeId("i=9069");
01116         refs.push_back(ref);
01117         }
01118         registry.AddReferences(refs);
01119         }
01120        
01121         {
01122         AddNodesItem node;
01123         node.RequestedNewNodeId = ToNodeId("i=9035");
01124         node.BrowseName = ToQualifiedName("EnabledState");
01125         node.Class = NodeClass::Variable;
01126         node.ParentNodeId = ToNodeId("i=2830");
01127         node.ReferenceTypeId = ReferenceId::HasComponent;
01128         node.TypeDefinition = ToNodeId("i=8995");
01129         VariableAttributes attrs;
01130         attrs.DisplayName = LocalizedText("EnabledState");
01131         attrs.Type = ObjectId::LocalizedText;
01132         attrs.Rank = -1;
01133         node.Attributes = attrs;
01134         registry.AddNodes(std::vector<AddNodesItem>{node});
01135         std::vector<AddReferencesItem> refs;
01136         {
01137         AddReferencesItem ref;
01138         ref.IsForward = true;
01139         ref.ReferenceTypeId = ReferenceId::HasProperty;
01140         ref.SourceNodeId = ToNodeId("i=9035");
01141         ref.TargetNodeClass = NodeClass::DataType;
01142         ref.TargetNodeId = ToNodeId("i=9036");
01143         refs.push_back(ref);
01144         }
01145         {
01146         AddReferencesItem ref;
01147         ref.IsForward = true;
01148         ref.ReferenceTypeId = ToNodeId("i=9004");
01149         ref.SourceNodeId = ToNodeId("i=9035");
01150         ref.TargetNodeClass = NodeClass::DataType;
01151         ref.TargetNodeId = ToNodeId("i=9055");
01152         refs.push_back(ref);
01153         }
01154         {
01155         AddReferencesItem ref;
01156         ref.IsForward = true;
01157         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01158         ref.SourceNodeId = ToNodeId("i=9035");
01159         ref.TargetNodeClass = NodeClass::DataType;
01160         ref.TargetNodeId = ToNodeId("i=78");
01161         refs.push_back(ref);
01162         }
01163         registry.AddReferences(refs);
01164         }
01165        
01166         {
01167         AddNodesItem node;
01168         node.RequestedNewNodeId = ToNodeId("i=9036");
01169         node.BrowseName = ToQualifiedName("Id");
01170         node.Class = NodeClass::Variable;
01171         node.ParentNodeId = ToNodeId("i=9035");
01172         node.ReferenceTypeId = ReferenceId::HasProperty;
01173         node.TypeDefinition = ToNodeId("i=68");
01174         VariableAttributes attrs;
01175         attrs.DisplayName = LocalizedText("Id");
01176         attrs.Type = ObjectId::Boolean;
01177         attrs.Rank = -1;
01178         node.Attributes = attrs;
01179         registry.AddNodes(std::vector<AddNodesItem>{node});
01180         std::vector<AddReferencesItem> refs;
01181         {
01182         AddReferencesItem ref;
01183         ref.IsForward = true;
01184         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01185         ref.SourceNodeId = ToNodeId("i=9036");
01186         ref.TargetNodeClass = NodeClass::DataType;
01187         ref.TargetNodeId = ToNodeId("i=78");
01188         refs.push_back(ref);
01189         }
01190         registry.AddReferences(refs);
01191         }
01192        
01193         {
01194         AddNodesItem node;
01195         node.RequestedNewNodeId = ToNodeId("i=9055");
01196         node.BrowseName = ToQualifiedName("DialogState");
01197         node.Class = NodeClass::Variable;
01198         node.ParentNodeId = ToNodeId("i=2830");
01199         node.ReferenceTypeId = ReferenceId::HasComponent;
01200         node.TypeDefinition = ToNodeId("i=8995");
01201         VariableAttributes attrs;
01202         attrs.DisplayName = LocalizedText("DialogState");
01203         attrs.Type = ObjectId::LocalizedText;
01204         attrs.Rank = -1;
01205         node.Attributes = attrs;
01206         registry.AddNodes(std::vector<AddNodesItem>{node});
01207         std::vector<AddReferencesItem> refs;
01208         {
01209         AddReferencesItem ref;
01210         ref.IsForward = true;
01211         ref.ReferenceTypeId = ReferenceId::HasProperty;
01212         ref.SourceNodeId = ToNodeId("i=9055");
01213         ref.TargetNodeClass = NodeClass::DataType;
01214         ref.TargetNodeId = ToNodeId("i=9056");
01215         refs.push_back(ref);
01216         }
01217         {
01218         AddReferencesItem ref;
01219         ref.IsForward = true;
01220         ref.ReferenceTypeId = ReferenceId::HasProperty;
01221         ref.SourceNodeId = ToNodeId("i=9055");
01222         ref.TargetNodeClass = NodeClass::DataType;
01223         ref.TargetNodeId = ToNodeId("i=9060");
01224         refs.push_back(ref);
01225         }
01226         {
01227         AddReferencesItem ref;
01228         ref.IsForward = true;
01229         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01230         ref.SourceNodeId = ToNodeId("i=9055");
01231         ref.TargetNodeClass = NodeClass::DataType;
01232         ref.TargetNodeId = ToNodeId("i=78");
01233         refs.push_back(ref);
01234         }
01235         registry.AddReferences(refs);
01236         }
01237        
01238         {
01239         AddNodesItem node;
01240         node.RequestedNewNodeId = ToNodeId("i=9056");
01241         node.BrowseName = ToQualifiedName("Id");
01242         node.Class = NodeClass::Variable;
01243         node.ParentNodeId = ToNodeId("i=9055");
01244         node.ReferenceTypeId = ReferenceId::HasProperty;
01245         node.TypeDefinition = ToNodeId("i=68");
01246         VariableAttributes attrs;
01247         attrs.DisplayName = LocalizedText("Id");
01248         attrs.Type = ObjectId::Boolean;
01249         attrs.Rank = -1;
01250         node.Attributes = attrs;
01251         registry.AddNodes(std::vector<AddNodesItem>{node});
01252         std::vector<AddReferencesItem> refs;
01253         {
01254         AddReferencesItem ref;
01255         ref.IsForward = true;
01256         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01257         ref.SourceNodeId = ToNodeId("i=9056");
01258         ref.TargetNodeClass = NodeClass::DataType;
01259         ref.TargetNodeId = ToNodeId("i=78");
01260         refs.push_back(ref);
01261         }
01262         registry.AddReferences(refs);
01263         }
01264        
01265         {
01266         AddNodesItem node;
01267         node.RequestedNewNodeId = ToNodeId("i=9060");
01268         node.BrowseName = ToQualifiedName("TransitionTime");
01269         node.Class = NodeClass::Variable;
01270         node.ParentNodeId = ToNodeId("i=9055");
01271         node.ReferenceTypeId = ReferenceId::HasProperty;
01272         node.TypeDefinition = ToNodeId("i=68");
01273         VariableAttributes attrs;
01274         attrs.DisplayName = LocalizedText("TransitionTime");
01275         attrs.Type = ToNodeId("i=294");
01276         attrs.Rank = -1;
01277         node.Attributes = attrs;
01278         registry.AddNodes(std::vector<AddNodesItem>{node});
01279         std::vector<AddReferencesItem> refs;
01280         {
01281         AddReferencesItem ref;
01282         ref.IsForward = true;
01283         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01284         ref.SourceNodeId = ToNodeId("i=9060");
01285         ref.TargetNodeClass = NodeClass::DataType;
01286         ref.TargetNodeId = ToNodeId("i=80");
01287         refs.push_back(ref);
01288         }
01289         registry.AddReferences(refs);
01290         }
01291        
01292         {
01293         AddNodesItem node;
01294         node.RequestedNewNodeId = ToNodeId("i=2831");
01295         node.BrowseName = ToQualifiedName("Prompt");
01296         node.Class = NodeClass::Variable;
01297         node.ParentNodeId = ToNodeId("i=2830");
01298         node.ReferenceTypeId = ReferenceId::HasProperty;
01299         node.TypeDefinition = ToNodeId("i=68");
01300         VariableAttributes attrs;
01301         attrs.DisplayName = LocalizedText("Prompt");
01302         attrs.Type = ObjectId::LocalizedText;
01303         attrs.Rank = -1;
01304         node.Attributes = attrs;
01305         registry.AddNodes(std::vector<AddNodesItem>{node});
01306         std::vector<AddReferencesItem> refs;
01307         {
01308         AddReferencesItem ref;
01309         ref.IsForward = true;
01310         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01311         ref.SourceNodeId = ToNodeId("i=2831");
01312         ref.TargetNodeClass = NodeClass::DataType;
01313         ref.TargetNodeId = ToNodeId("i=78");
01314         refs.push_back(ref);
01315         }
01316         registry.AddReferences(refs);
01317         }
01318        
01319         {
01320         AddNodesItem node;
01321         node.RequestedNewNodeId = ToNodeId("i=9064");
01322         node.BrowseName = ToQualifiedName("ResponseOptionSet");
01323         node.Class = NodeClass::Variable;
01324         node.ParentNodeId = ToNodeId("i=2830");
01325         node.ReferenceTypeId = ReferenceId::HasProperty;
01326         node.TypeDefinition = ToNodeId("i=68");
01327         VariableAttributes attrs;
01328         attrs.DisplayName = LocalizedText("ResponseOptionSet");
01329         attrs.Type = ObjectId::LocalizedText;
01330         attrs.Rank = 1;
01331         node.Attributes = attrs;
01332         registry.AddNodes(std::vector<AddNodesItem>{node});
01333         std::vector<AddReferencesItem> refs;
01334         {
01335         AddReferencesItem ref;
01336         ref.IsForward = true;
01337         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01338         ref.SourceNodeId = ToNodeId("i=9064");
01339         ref.TargetNodeClass = NodeClass::DataType;
01340         ref.TargetNodeId = ToNodeId("i=78");
01341         refs.push_back(ref);
01342         }
01343         registry.AddReferences(refs);
01344         }
01345        
01346         {
01347         AddNodesItem node;
01348         node.RequestedNewNodeId = ToNodeId("i=9065");
01349         node.BrowseName = ToQualifiedName("DefaultResponse");
01350         node.Class = NodeClass::Variable;
01351         node.ParentNodeId = ToNodeId("i=2830");
01352         node.ReferenceTypeId = ReferenceId::HasProperty;
01353         node.TypeDefinition = ToNodeId("i=68");
01354         VariableAttributes attrs;
01355         attrs.DisplayName = LocalizedText("DefaultResponse");
01356         attrs.Type = ObjectId::Int32;
01357         attrs.Rank = -1;
01358         node.Attributes = attrs;
01359         registry.AddNodes(std::vector<AddNodesItem>{node});
01360         std::vector<AddReferencesItem> refs;
01361         {
01362         AddReferencesItem ref;
01363         ref.IsForward = true;
01364         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01365         ref.SourceNodeId = ToNodeId("i=9065");
01366         ref.TargetNodeClass = NodeClass::DataType;
01367         ref.TargetNodeId = ToNodeId("i=78");
01368         refs.push_back(ref);
01369         }
01370         registry.AddReferences(refs);
01371         }
01372        
01373         {
01374         AddNodesItem node;
01375         node.RequestedNewNodeId = ToNodeId("i=9066");
01376         node.BrowseName = ToQualifiedName("OkResponse");
01377         node.Class = NodeClass::Variable;
01378         node.ParentNodeId = ToNodeId("i=2830");
01379         node.ReferenceTypeId = ReferenceId::HasProperty;
01380         node.TypeDefinition = ToNodeId("i=68");
01381         VariableAttributes attrs;
01382         attrs.DisplayName = LocalizedText("OkResponse");
01383         attrs.Type = ObjectId::Int32;
01384         attrs.Rank = -1;
01385         node.Attributes = attrs;
01386         registry.AddNodes(std::vector<AddNodesItem>{node});
01387         std::vector<AddReferencesItem> refs;
01388         {
01389         AddReferencesItem ref;
01390         ref.IsForward = true;
01391         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01392         ref.SourceNodeId = ToNodeId("i=9066");
01393         ref.TargetNodeClass = NodeClass::DataType;
01394         ref.TargetNodeId = ToNodeId("i=78");
01395         refs.push_back(ref);
01396         }
01397         registry.AddReferences(refs);
01398         }
01399        
01400         {
01401         AddNodesItem node;
01402         node.RequestedNewNodeId = ToNodeId("i=9067");
01403         node.BrowseName = ToQualifiedName("CancelResponse");
01404         node.Class = NodeClass::Variable;
01405         node.ParentNodeId = ToNodeId("i=2830");
01406         node.ReferenceTypeId = ReferenceId::HasProperty;
01407         node.TypeDefinition = ToNodeId("i=68");
01408         VariableAttributes attrs;
01409         attrs.DisplayName = LocalizedText("CancelResponse");
01410         attrs.Type = ObjectId::Int32;
01411         attrs.Rank = -1;
01412         node.Attributes = attrs;
01413         registry.AddNodes(std::vector<AddNodesItem>{node});
01414         std::vector<AddReferencesItem> refs;
01415         {
01416         AddReferencesItem ref;
01417         ref.IsForward = true;
01418         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01419         ref.SourceNodeId = ToNodeId("i=9067");
01420         ref.TargetNodeClass = NodeClass::DataType;
01421         ref.TargetNodeId = ToNodeId("i=78");
01422         refs.push_back(ref);
01423         }
01424         registry.AddReferences(refs);
01425         }
01426        
01427         {
01428         AddNodesItem node;
01429         node.RequestedNewNodeId = ToNodeId("i=9068");
01430         node.BrowseName = ToQualifiedName("LastResponse");
01431         node.Class = NodeClass::Variable;
01432         node.ParentNodeId = ToNodeId("i=2830");
01433         node.ReferenceTypeId = ReferenceId::HasProperty;
01434         node.TypeDefinition = ToNodeId("i=68");
01435         VariableAttributes attrs;
01436         attrs.DisplayName = LocalizedText("LastResponse");
01437         attrs.Type = ObjectId::Int32;
01438         attrs.Rank = -1;
01439         node.Attributes = attrs;
01440         registry.AddNodes(std::vector<AddNodesItem>{node});
01441         std::vector<AddReferencesItem> refs;
01442         {
01443         AddReferencesItem ref;
01444         ref.IsForward = true;
01445         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01446         ref.SourceNodeId = ToNodeId("i=9068");
01447         ref.TargetNodeClass = NodeClass::DataType;
01448         ref.TargetNodeId = ToNodeId("i=78");
01449         refs.push_back(ref);
01450         }
01451         registry.AddReferences(refs);
01452         }
01453        
01454         {
01455         AddNodesItem node;
01456         node.RequestedNewNodeId = ToNodeId("i=9070");
01457         node.BrowseName = ToQualifiedName("InputArguments");
01458         node.Class = NodeClass::Variable;
01459         node.ParentNodeId = ToNodeId("i=9069");
01460         node.ReferenceTypeId = ReferenceId::HasProperty;
01461         node.TypeDefinition = ToNodeId("i=68");
01462         VariableAttributes attrs;
01463         attrs.DisplayName = LocalizedText("InputArguments");
01464         attrs.Type = ToNodeId("i=296");
01465         attrs.Rank = 1;
01466         node.Attributes = attrs;
01467         registry.AddNodes(std::vector<AddNodesItem>{node});
01468         std::vector<AddReferencesItem> refs;
01469         {
01470         AddReferencesItem ref;
01471         ref.IsForward = true;
01472         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01473         ref.SourceNodeId = ToNodeId("i=9070");
01474         ref.TargetNodeClass = NodeClass::DataType;
01475         ref.TargetNodeId = ToNodeId("i=78");
01476         refs.push_back(ref);
01477         }
01478         registry.AddReferences(refs);
01479         }
01480        
01481         {
01482         AddNodesItem node;
01483         node.RequestedNewNodeId = ToNodeId("i=2881");
01484         node.BrowseName = ToQualifiedName("AcknowledgeableConditionType");
01485         node.Class = NodeClass::ObjectType;
01486         node.ParentNodeId = ToNodeId("i=2782");
01487         node.ReferenceTypeId = ReferenceId::HasSubtype;
01488         ObjectTypeAttributes attrs;
01489         attrs.DisplayName = LocalizedText("AcknowledgeableConditionType");
01490         attrs.IsAbstract = false;
01491         node.Attributes = attrs;
01492         registry.AddNodes(std::vector<AddNodesItem>{node});
01493         std::vector<AddReferencesItem> refs;
01494         {
01495         AddReferencesItem ref;
01496         ref.IsForward = true;
01497         ref.ReferenceTypeId = ReferenceId::HasComponent;
01498         ref.SourceNodeId = ToNodeId("i=2881");
01499         ref.TargetNodeClass = NodeClass::DataType;
01500         ref.TargetNodeId = ToNodeId("i=9073");
01501         refs.push_back(ref);
01502         }
01503         {
01504         AddReferencesItem ref;
01505         ref.IsForward = true;
01506         ref.ReferenceTypeId = ReferenceId::HasComponent;
01507         ref.SourceNodeId = ToNodeId("i=2881");
01508         ref.TargetNodeClass = NodeClass::DataType;
01509         ref.TargetNodeId = ToNodeId("i=9093");
01510         refs.push_back(ref);
01511         }
01512         {
01513         AddReferencesItem ref;
01514         ref.IsForward = true;
01515         ref.ReferenceTypeId = ReferenceId::HasComponent;
01516         ref.SourceNodeId = ToNodeId("i=2881");
01517         ref.TargetNodeClass = NodeClass::DataType;
01518         ref.TargetNodeId = ToNodeId("i=9102");
01519         refs.push_back(ref);
01520         }
01521         {
01522         AddReferencesItem ref;
01523         ref.IsForward = true;
01524         ref.ReferenceTypeId = ReferenceId::HasComponent;
01525         ref.SourceNodeId = ToNodeId("i=2881");
01526         ref.TargetNodeClass = NodeClass::DataType;
01527         ref.TargetNodeId = ToNodeId("i=9111");
01528         refs.push_back(ref);
01529         }
01530         {
01531         AddReferencesItem ref;
01532         ref.IsForward = true;
01533         ref.ReferenceTypeId = ReferenceId::HasComponent;
01534         ref.SourceNodeId = ToNodeId("i=2881");
01535         ref.TargetNodeClass = NodeClass::DataType;
01536         ref.TargetNodeId = ToNodeId("i=9113");
01537         refs.push_back(ref);
01538         }
01539         registry.AddReferences(refs);
01540         }
01541        
01542         {
01543         AddNodesItem node;
01544         node.RequestedNewNodeId = ToNodeId("i=9073");
01545         node.BrowseName = ToQualifiedName("EnabledState");
01546         node.Class = NodeClass::Variable;
01547         node.ParentNodeId = ToNodeId("i=2881");
01548         node.ReferenceTypeId = ReferenceId::HasComponent;
01549         node.TypeDefinition = ToNodeId("i=8995");
01550         VariableAttributes attrs;
01551         attrs.DisplayName = LocalizedText("EnabledState");
01552         attrs.Type = ObjectId::LocalizedText;
01553         attrs.Rank = -1;
01554         node.Attributes = attrs;
01555         registry.AddNodes(std::vector<AddNodesItem>{node});
01556         std::vector<AddReferencesItem> refs;
01557         {
01558         AddReferencesItem ref;
01559         ref.IsForward = true;
01560         ref.ReferenceTypeId = ReferenceId::HasProperty;
01561         ref.SourceNodeId = ToNodeId("i=9073");
01562         ref.TargetNodeClass = NodeClass::DataType;
01563         ref.TargetNodeId = ToNodeId("i=9074");
01564         refs.push_back(ref);
01565         }
01566         {
01567         AddReferencesItem ref;
01568         ref.IsForward = true;
01569         ref.ReferenceTypeId = ToNodeId("i=9004");
01570         ref.SourceNodeId = ToNodeId("i=9073");
01571         ref.TargetNodeClass = NodeClass::DataType;
01572         ref.TargetNodeId = ToNodeId("i=9093");
01573         refs.push_back(ref);
01574         }
01575         {
01576         AddReferencesItem ref;
01577         ref.IsForward = true;
01578         ref.ReferenceTypeId = ToNodeId("i=9004");
01579         ref.SourceNodeId = ToNodeId("i=9073");
01580         ref.TargetNodeClass = NodeClass::DataType;
01581         ref.TargetNodeId = ToNodeId("i=9102");
01582         refs.push_back(ref);
01583         }
01584         {
01585         AddReferencesItem ref;
01586         ref.IsForward = true;
01587         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01588         ref.SourceNodeId = ToNodeId("i=9073");
01589         ref.TargetNodeClass = NodeClass::DataType;
01590         ref.TargetNodeId = ToNodeId("i=78");
01591         refs.push_back(ref);
01592         }
01593         registry.AddReferences(refs);
01594         }
01595        
01596         {
01597         AddNodesItem node;
01598         node.RequestedNewNodeId = ToNodeId("i=9074");
01599         node.BrowseName = ToQualifiedName("Id");
01600         node.Class = NodeClass::Variable;
01601         node.ParentNodeId = ToNodeId("i=9073");
01602         node.ReferenceTypeId = ReferenceId::HasProperty;
01603         node.TypeDefinition = ToNodeId("i=68");
01604         VariableAttributes attrs;
01605         attrs.DisplayName = LocalizedText("Id");
01606         attrs.Type = ObjectId::Boolean;
01607         attrs.Rank = -1;
01608         node.Attributes = attrs;
01609         registry.AddNodes(std::vector<AddNodesItem>{node});
01610         std::vector<AddReferencesItem> refs;
01611         {
01612         AddReferencesItem ref;
01613         ref.IsForward = true;
01614         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01615         ref.SourceNodeId = ToNodeId("i=9074");
01616         ref.TargetNodeClass = NodeClass::DataType;
01617         ref.TargetNodeId = ToNodeId("i=78");
01618         refs.push_back(ref);
01619         }
01620         registry.AddReferences(refs);
01621         }
01622        
01623         {
01624         AddNodesItem node;
01625         node.RequestedNewNodeId = ToNodeId("i=9093");
01626         node.BrowseName = ToQualifiedName("AckedState");
01627         node.Class = NodeClass::Variable;
01628         node.ParentNodeId = ToNodeId("i=2881");
01629         node.ReferenceTypeId = ReferenceId::HasComponent;
01630         node.TypeDefinition = ToNodeId("i=8995");
01631         VariableAttributes attrs;
01632         attrs.DisplayName = LocalizedText("AckedState");
01633         attrs.Type = ObjectId::LocalizedText;
01634         attrs.Rank = -1;
01635         node.Attributes = attrs;
01636         registry.AddNodes(std::vector<AddNodesItem>{node});
01637         std::vector<AddReferencesItem> refs;
01638         {
01639         AddReferencesItem ref;
01640         ref.IsForward = true;
01641         ref.ReferenceTypeId = ReferenceId::HasProperty;
01642         ref.SourceNodeId = ToNodeId("i=9093");
01643         ref.TargetNodeClass = NodeClass::DataType;
01644         ref.TargetNodeId = ToNodeId("i=9094");
01645         refs.push_back(ref);
01646         }
01647         {
01648         AddReferencesItem ref;
01649         ref.IsForward = true;
01650         ref.ReferenceTypeId = ReferenceId::HasProperty;
01651         ref.SourceNodeId = ToNodeId("i=9093");
01652         ref.TargetNodeClass = NodeClass::DataType;
01653         ref.TargetNodeId = ToNodeId("i=9098");
01654         refs.push_back(ref);
01655         }
01656         {
01657         AddReferencesItem ref;
01658         ref.IsForward = true;
01659         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01660         ref.SourceNodeId = ToNodeId("i=9093");
01661         ref.TargetNodeClass = NodeClass::DataType;
01662         ref.TargetNodeId = ToNodeId("i=78");
01663         refs.push_back(ref);
01664         }
01665         registry.AddReferences(refs);
01666         }
01667        
01668         {
01669         AddNodesItem node;
01670         node.RequestedNewNodeId = ToNodeId("i=9094");
01671         node.BrowseName = ToQualifiedName("Id");
01672         node.Class = NodeClass::Variable;
01673         node.ParentNodeId = ToNodeId("i=9093");
01674         node.ReferenceTypeId = ReferenceId::HasProperty;
01675         node.TypeDefinition = ToNodeId("i=68");
01676         VariableAttributes attrs;
01677         attrs.DisplayName = LocalizedText("Id");
01678         attrs.Type = ObjectId::Boolean;
01679         attrs.Rank = -1;
01680         node.Attributes = attrs;
01681         registry.AddNodes(std::vector<AddNodesItem>{node});
01682         std::vector<AddReferencesItem> refs;
01683         {
01684         AddReferencesItem ref;
01685         ref.IsForward = true;
01686         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01687         ref.SourceNodeId = ToNodeId("i=9094");
01688         ref.TargetNodeClass = NodeClass::DataType;
01689         ref.TargetNodeId = ToNodeId("i=78");
01690         refs.push_back(ref);
01691         }
01692         registry.AddReferences(refs);
01693         }
01694        
01695         {
01696         AddNodesItem node;
01697         node.RequestedNewNodeId = ToNodeId("i=9098");
01698         node.BrowseName = ToQualifiedName("TransitionTime");
01699         node.Class = NodeClass::Variable;
01700         node.ParentNodeId = ToNodeId("i=9093");
01701         node.ReferenceTypeId = ReferenceId::HasProperty;
01702         node.TypeDefinition = ToNodeId("i=68");
01703         VariableAttributes attrs;
01704         attrs.DisplayName = LocalizedText("TransitionTime");
01705         attrs.Type = ToNodeId("i=294");
01706         attrs.Rank = -1;
01707         node.Attributes = attrs;
01708         registry.AddNodes(std::vector<AddNodesItem>{node});
01709         std::vector<AddReferencesItem> refs;
01710         {
01711         AddReferencesItem ref;
01712         ref.IsForward = true;
01713         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01714         ref.SourceNodeId = ToNodeId("i=9098");
01715         ref.TargetNodeClass = NodeClass::DataType;
01716         ref.TargetNodeId = ToNodeId("i=80");
01717         refs.push_back(ref);
01718         }
01719         registry.AddReferences(refs);
01720         }
01721        
01722         {
01723         AddNodesItem node;
01724         node.RequestedNewNodeId = ToNodeId("i=9102");
01725         node.BrowseName = ToQualifiedName("ConfirmedState");
01726         node.Class = NodeClass::Variable;
01727         node.ParentNodeId = ToNodeId("i=2881");
01728         node.ReferenceTypeId = ReferenceId::HasComponent;
01729         node.TypeDefinition = ToNodeId("i=8995");
01730         VariableAttributes attrs;
01731         attrs.DisplayName = LocalizedText("ConfirmedState");
01732         attrs.Type = ObjectId::LocalizedText;
01733         attrs.Rank = -1;
01734         node.Attributes = attrs;
01735         registry.AddNodes(std::vector<AddNodesItem>{node});
01736         std::vector<AddReferencesItem> refs;
01737         {
01738         AddReferencesItem ref;
01739         ref.IsForward = true;
01740         ref.ReferenceTypeId = ReferenceId::HasProperty;
01741         ref.SourceNodeId = ToNodeId("i=9102");
01742         ref.TargetNodeClass = NodeClass::DataType;
01743         ref.TargetNodeId = ToNodeId("i=9103");
01744         refs.push_back(ref);
01745         }
01746         {
01747         AddReferencesItem ref;
01748         ref.IsForward = true;
01749         ref.ReferenceTypeId = ReferenceId::HasProperty;
01750         ref.SourceNodeId = ToNodeId("i=9102");
01751         ref.TargetNodeClass = NodeClass::DataType;
01752         ref.TargetNodeId = ToNodeId("i=9107");
01753         refs.push_back(ref);
01754         }
01755         {
01756         AddReferencesItem ref;
01757         ref.IsForward = true;
01758         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01759         ref.SourceNodeId = ToNodeId("i=9102");
01760         ref.TargetNodeClass = NodeClass::DataType;
01761         ref.TargetNodeId = ToNodeId("i=80");
01762         refs.push_back(ref);
01763         }
01764         registry.AddReferences(refs);
01765         }
01766        
01767         {
01768         AddNodesItem node;
01769         node.RequestedNewNodeId = ToNodeId("i=9103");
01770         node.BrowseName = ToQualifiedName("Id");
01771         node.Class = NodeClass::Variable;
01772         node.ParentNodeId = ToNodeId("i=9102");
01773         node.ReferenceTypeId = ReferenceId::HasProperty;
01774         node.TypeDefinition = ToNodeId("i=68");
01775         VariableAttributes attrs;
01776         attrs.DisplayName = LocalizedText("Id");
01777         attrs.Type = ObjectId::Boolean;
01778         attrs.Rank = -1;
01779         node.Attributes = attrs;
01780         registry.AddNodes(std::vector<AddNodesItem>{node});
01781         std::vector<AddReferencesItem> refs;
01782         {
01783         AddReferencesItem ref;
01784         ref.IsForward = true;
01785         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01786         ref.SourceNodeId = ToNodeId("i=9103");
01787         ref.TargetNodeClass = NodeClass::DataType;
01788         ref.TargetNodeId = ToNodeId("i=78");
01789         refs.push_back(ref);
01790         }
01791         registry.AddReferences(refs);
01792         }
01793        
01794         {
01795         AddNodesItem node;
01796         node.RequestedNewNodeId = ToNodeId("i=9107");
01797         node.BrowseName = ToQualifiedName("TransitionTime");
01798         node.Class = NodeClass::Variable;
01799         node.ParentNodeId = ToNodeId("i=9102");
01800         node.ReferenceTypeId = ReferenceId::HasProperty;
01801         node.TypeDefinition = ToNodeId("i=68");
01802         VariableAttributes attrs;
01803         attrs.DisplayName = LocalizedText("TransitionTime");
01804         attrs.Type = ToNodeId("i=294");
01805         attrs.Rank = -1;
01806         node.Attributes = attrs;
01807         registry.AddNodes(std::vector<AddNodesItem>{node});
01808         std::vector<AddReferencesItem> refs;
01809         {
01810         AddReferencesItem ref;
01811         ref.IsForward = true;
01812         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01813         ref.SourceNodeId = ToNodeId("i=9107");
01814         ref.TargetNodeClass = NodeClass::DataType;
01815         ref.TargetNodeId = ToNodeId("i=80");
01816         refs.push_back(ref);
01817         }
01818         registry.AddReferences(refs);
01819         }
01820        
01821         {
01822         AddNodesItem node;
01823         node.RequestedNewNodeId = ToNodeId("i=9112");
01824         node.BrowseName = ToQualifiedName("InputArguments");
01825         node.Class = NodeClass::Variable;
01826         node.ParentNodeId = ToNodeId("i=9111");
01827         node.ReferenceTypeId = ReferenceId::HasProperty;
01828         node.TypeDefinition = ToNodeId("i=68");
01829         VariableAttributes attrs;
01830         attrs.DisplayName = LocalizedText("InputArguments");
01831         attrs.Type = ToNodeId("i=296");
01832         attrs.Rank = 1;
01833         node.Attributes = attrs;
01834         registry.AddNodes(std::vector<AddNodesItem>{node});
01835         std::vector<AddReferencesItem> refs;
01836         {
01837         AddReferencesItem ref;
01838         ref.IsForward = true;
01839         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01840         ref.SourceNodeId = ToNodeId("i=9112");
01841         ref.TargetNodeClass = NodeClass::DataType;
01842         ref.TargetNodeId = ToNodeId("i=78");
01843         refs.push_back(ref);
01844         }
01845         registry.AddReferences(refs);
01846         }
01847        
01848         {
01849         AddNodesItem node;
01850         node.RequestedNewNodeId = ToNodeId("i=9114");
01851         node.BrowseName = ToQualifiedName("InputArguments");
01852         node.Class = NodeClass::Variable;
01853         node.ParentNodeId = ToNodeId("i=9113");
01854         node.ReferenceTypeId = ReferenceId::HasProperty;
01855         node.TypeDefinition = ToNodeId("i=68");
01856         VariableAttributes attrs;
01857         attrs.DisplayName = LocalizedText("InputArguments");
01858         attrs.Type = ToNodeId("i=296");
01859         attrs.Rank = 1;
01860         node.Attributes = attrs;
01861         registry.AddNodes(std::vector<AddNodesItem>{node});
01862         std::vector<AddReferencesItem> refs;
01863         {
01864         AddReferencesItem ref;
01865         ref.IsForward = true;
01866         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
01867         ref.SourceNodeId = ToNodeId("i=9114");
01868         ref.TargetNodeClass = NodeClass::DataType;
01869         ref.TargetNodeId = ToNodeId("i=78");
01870         refs.push_back(ref);
01871         }
01872         registry.AddReferences(refs);
01873         }
01874        
01875         {
01876         AddNodesItem node;
01877         node.RequestedNewNodeId = ToNodeId("i=2915");
01878         node.BrowseName = ToQualifiedName("AlarmConditionType");
01879         node.Class = NodeClass::ObjectType;
01880         node.ParentNodeId = ToNodeId("i=2881");
01881         node.ReferenceTypeId = ReferenceId::HasSubtype;
01882         ObjectTypeAttributes attrs;
01883         attrs.DisplayName = LocalizedText("AlarmConditionType");
01884         attrs.IsAbstract = false;
01885         node.Attributes = attrs;
01886         registry.AddNodes(std::vector<AddNodesItem>{node});
01887         std::vector<AddReferencesItem> refs;
01888         {
01889         AddReferencesItem ref;
01890         ref.IsForward = true;
01891         ref.ReferenceTypeId = ReferenceId::HasComponent;
01892         ref.SourceNodeId = ToNodeId("i=2915");
01893         ref.TargetNodeClass = NodeClass::DataType;
01894         ref.TargetNodeId = ToNodeId("i=9118");
01895         refs.push_back(ref);
01896         }
01897         {
01898         AddReferencesItem ref;
01899         ref.IsForward = true;
01900         ref.ReferenceTypeId = ReferenceId::HasComponent;
01901         ref.SourceNodeId = ToNodeId("i=2915");
01902         ref.TargetNodeClass = NodeClass::DataType;
01903         ref.TargetNodeId = ToNodeId("i=9160");
01904         refs.push_back(ref);
01905         }
01906         {
01907         AddReferencesItem ref;
01908         ref.IsForward = true;
01909         ref.ReferenceTypeId = ReferenceId::HasProperty;
01910         ref.SourceNodeId = ToNodeId("i=2915");
01911         ref.TargetNodeClass = NodeClass::DataType;
01912         ref.TargetNodeId = ToNodeId("i=11120");
01913         refs.push_back(ref);
01914         }
01915         {
01916         AddReferencesItem ref;
01917         ref.IsForward = true;
01918         ref.ReferenceTypeId = ReferenceId::HasComponent;
01919         ref.SourceNodeId = ToNodeId("i=2915");
01920         ref.TargetNodeClass = NodeClass::DataType;
01921         ref.TargetNodeId = ToNodeId("i=9169");
01922         refs.push_back(ref);
01923         }
01924         {
01925         AddReferencesItem ref;
01926         ref.IsForward = true;
01927         ref.ReferenceTypeId = ReferenceId::HasComponent;
01928         ref.SourceNodeId = ToNodeId("i=2915");
01929         ref.TargetNodeClass = NodeClass::DataType;
01930         ref.TargetNodeId = ToNodeId("i=9178");
01931         refs.push_back(ref);
01932         }
01933         {
01934         AddReferencesItem ref;
01935         ref.IsForward = true;
01936         ref.ReferenceTypeId = ReferenceId::HasProperty;
01937         ref.SourceNodeId = ToNodeId("i=2915");
01938         ref.TargetNodeClass = NodeClass::DataType;
01939         ref.TargetNodeId = ToNodeId("i=9215");
01940         refs.push_back(ref);
01941         }
01942         {
01943         AddReferencesItem ref;
01944         ref.IsForward = true;
01945         ref.ReferenceTypeId = ReferenceId::HasProperty;
01946         ref.SourceNodeId = ToNodeId("i=2915");
01947         ref.TargetNodeClass = NodeClass::DataType;
01948         ref.TargetNodeId = ToNodeId("i=9216");
01949         refs.push_back(ref);
01950         }
01951         registry.AddReferences(refs);
01952         }
01953        
01954         {
01955         AddNodesItem node;
01956         node.RequestedNewNodeId = ToNodeId("i=9118");
01957         node.BrowseName = ToQualifiedName("EnabledState");
01958         node.Class = NodeClass::Variable;
01959         node.ParentNodeId = ToNodeId("i=2915");
01960         node.ReferenceTypeId = ReferenceId::HasComponent;
01961         node.TypeDefinition = ToNodeId("i=8995");
01962         VariableAttributes attrs;
01963         attrs.DisplayName = LocalizedText("EnabledState");
01964         attrs.Type = ObjectId::LocalizedText;
01965         attrs.Rank = -1;
01966         node.Attributes = attrs;
01967         registry.AddNodes(std::vector<AddNodesItem>{node});
01968         std::vector<AddReferencesItem> refs;
01969         {
01970         AddReferencesItem ref;
01971         ref.IsForward = true;
01972         ref.ReferenceTypeId = ReferenceId::HasProperty;
01973         ref.SourceNodeId = ToNodeId("i=9118");
01974         ref.TargetNodeClass = NodeClass::DataType;
01975         ref.TargetNodeId = ToNodeId("i=9119");
01976         refs.push_back(ref);
01977         }
01978         {
01979         AddReferencesItem ref;
01980         ref.IsForward = true;
01981         ref.ReferenceTypeId = ToNodeId("i=9004");
01982         ref.SourceNodeId = ToNodeId("i=9118");
01983         ref.TargetNodeClass = NodeClass::DataType;
01984         ref.TargetNodeId = ToNodeId("i=9160");
01985         refs.push_back(ref);
01986         }
01987         {
01988         AddReferencesItem ref;
01989         ref.IsForward = true;
01990         ref.ReferenceTypeId = ToNodeId("i=9004");
01991         ref.SourceNodeId = ToNodeId("i=9118");
01992         ref.TargetNodeClass = NodeClass::DataType;
01993         ref.TargetNodeId = ToNodeId("i=9169");
01994         refs.push_back(ref);
01995         }
01996         {
01997         AddReferencesItem ref;
01998         ref.IsForward = true;
01999         ref.ReferenceTypeId = ToNodeId("i=9004");
02000         ref.SourceNodeId = ToNodeId("i=9118");
02001         ref.TargetNodeClass = NodeClass::DataType;
02002         ref.TargetNodeId = ToNodeId("i=9178");
02003         refs.push_back(ref);
02004         }
02005         {
02006         AddReferencesItem ref;
02007         ref.IsForward = true;
02008         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02009         ref.SourceNodeId = ToNodeId("i=9118");
02010         ref.TargetNodeClass = NodeClass::DataType;
02011         ref.TargetNodeId = ToNodeId("i=78");
02012         refs.push_back(ref);
02013         }
02014         registry.AddReferences(refs);
02015         }
02016        
02017         {
02018         AddNodesItem node;
02019         node.RequestedNewNodeId = ToNodeId("i=9119");
02020         node.BrowseName = ToQualifiedName("Id");
02021         node.Class = NodeClass::Variable;
02022         node.ParentNodeId = ToNodeId("i=9118");
02023         node.ReferenceTypeId = ReferenceId::HasProperty;
02024         node.TypeDefinition = ToNodeId("i=68");
02025         VariableAttributes attrs;
02026         attrs.DisplayName = LocalizedText("Id");
02027         attrs.Type = ObjectId::Boolean;
02028         attrs.Rank = -1;
02029         node.Attributes = attrs;
02030         registry.AddNodes(std::vector<AddNodesItem>{node});
02031         std::vector<AddReferencesItem> refs;
02032         {
02033         AddReferencesItem ref;
02034         ref.IsForward = true;
02035         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02036         ref.SourceNodeId = ToNodeId("i=9119");
02037         ref.TargetNodeClass = NodeClass::DataType;
02038         ref.TargetNodeId = ToNodeId("i=78");
02039         refs.push_back(ref);
02040         }
02041         registry.AddReferences(refs);
02042         }
02043        
02044         {
02045         AddNodesItem node;
02046         node.RequestedNewNodeId = ToNodeId("i=9160");
02047         node.BrowseName = ToQualifiedName("ActiveState");
02048         node.Class = NodeClass::Variable;
02049         node.ParentNodeId = ToNodeId("i=2915");
02050         node.ReferenceTypeId = ReferenceId::HasComponent;
02051         node.TypeDefinition = ToNodeId("i=8995");
02052         VariableAttributes attrs;
02053         attrs.DisplayName = LocalizedText("ActiveState");
02054         attrs.Type = ObjectId::LocalizedText;
02055         attrs.Rank = -1;
02056         node.Attributes = attrs;
02057         registry.AddNodes(std::vector<AddNodesItem>{node});
02058         std::vector<AddReferencesItem> refs;
02059         {
02060         AddReferencesItem ref;
02061         ref.IsForward = true;
02062         ref.ReferenceTypeId = ReferenceId::HasProperty;
02063         ref.SourceNodeId = ToNodeId("i=9160");
02064         ref.TargetNodeClass = NodeClass::DataType;
02065         ref.TargetNodeId = ToNodeId("i=9161");
02066         refs.push_back(ref);
02067         }
02068         {
02069         AddReferencesItem ref;
02070         ref.IsForward = true;
02071         ref.ReferenceTypeId = ReferenceId::HasProperty;
02072         ref.SourceNodeId = ToNodeId("i=9160");
02073         ref.TargetNodeClass = NodeClass::DataType;
02074         ref.TargetNodeId = ToNodeId("i=9164");
02075         refs.push_back(ref);
02076         }
02077         {
02078         AddReferencesItem ref;
02079         ref.IsForward = true;
02080         ref.ReferenceTypeId = ReferenceId::HasProperty;
02081         ref.SourceNodeId = ToNodeId("i=9160");
02082         ref.TargetNodeClass = NodeClass::DataType;
02083         ref.TargetNodeId = ToNodeId("i=9165");
02084         refs.push_back(ref);
02085         }
02086         {
02087         AddReferencesItem ref;
02088         ref.IsForward = true;
02089         ref.ReferenceTypeId = ReferenceId::HasProperty;
02090         ref.SourceNodeId = ToNodeId("i=9160");
02091         ref.TargetNodeClass = NodeClass::DataType;
02092         ref.TargetNodeId = ToNodeId("i=9166");
02093         refs.push_back(ref);
02094         }
02095         {
02096         AddReferencesItem ref;
02097         ref.IsForward = true;
02098         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02099         ref.SourceNodeId = ToNodeId("i=9160");
02100         ref.TargetNodeClass = NodeClass::DataType;
02101         ref.TargetNodeId = ToNodeId("i=78");
02102         refs.push_back(ref);
02103         }
02104         registry.AddReferences(refs);
02105         }
02106        
02107         {
02108         AddNodesItem node;
02109         node.RequestedNewNodeId = ToNodeId("i=9161");
02110         node.BrowseName = ToQualifiedName("Id");
02111         node.Class = NodeClass::Variable;
02112         node.ParentNodeId = ToNodeId("i=9160");
02113         node.ReferenceTypeId = ReferenceId::HasProperty;
02114         node.TypeDefinition = ToNodeId("i=68");
02115         VariableAttributes attrs;
02116         attrs.DisplayName = LocalizedText("Id");
02117         attrs.Type = ObjectId::Boolean;
02118         attrs.Rank = -1;
02119         node.Attributes = attrs;
02120         registry.AddNodes(std::vector<AddNodesItem>{node});
02121         std::vector<AddReferencesItem> refs;
02122         {
02123         AddReferencesItem ref;
02124         ref.IsForward = true;
02125         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02126         ref.SourceNodeId = ToNodeId("i=9161");
02127         ref.TargetNodeClass = NodeClass::DataType;
02128         ref.TargetNodeId = ToNodeId("i=78");
02129         refs.push_back(ref);
02130         }
02131         registry.AddReferences(refs);
02132         }
02133        
02134         {
02135         AddNodesItem node;
02136         node.RequestedNewNodeId = ToNodeId("i=9164");
02137         node.BrowseName = ToQualifiedName("EffectiveDisplayName");
02138         node.Class = NodeClass::Variable;
02139         node.ParentNodeId = ToNodeId("i=9160");
02140         node.ReferenceTypeId = ReferenceId::HasProperty;
02141         node.TypeDefinition = ToNodeId("i=68");
02142         VariableAttributes attrs;
02143         attrs.DisplayName = LocalizedText("EffectiveDisplayName");
02144         attrs.Type = ObjectId::LocalizedText;
02145         attrs.Rank = -1;
02146         node.Attributes = attrs;
02147         registry.AddNodes(std::vector<AddNodesItem>{node});
02148         std::vector<AddReferencesItem> refs;
02149         {
02150         AddReferencesItem ref;
02151         ref.IsForward = true;
02152         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02153         ref.SourceNodeId = ToNodeId("i=9164");
02154         ref.TargetNodeClass = NodeClass::DataType;
02155         ref.TargetNodeId = ToNodeId("i=80");
02156         refs.push_back(ref);
02157         }
02158         registry.AddReferences(refs);
02159         }
02160        
02161         {
02162         AddNodesItem node;
02163         node.RequestedNewNodeId = ToNodeId("i=9165");
02164         node.BrowseName = ToQualifiedName("TransitionTime");
02165         node.Class = NodeClass::Variable;
02166         node.ParentNodeId = ToNodeId("i=9160");
02167         node.ReferenceTypeId = ReferenceId::HasProperty;
02168         node.TypeDefinition = ToNodeId("i=68");
02169         VariableAttributes attrs;
02170         attrs.DisplayName = LocalizedText("TransitionTime");
02171         attrs.Type = ToNodeId("i=294");
02172         attrs.Rank = -1;
02173         node.Attributes = attrs;
02174         registry.AddNodes(std::vector<AddNodesItem>{node});
02175         std::vector<AddReferencesItem> refs;
02176         {
02177         AddReferencesItem ref;
02178         ref.IsForward = true;
02179         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02180         ref.SourceNodeId = ToNodeId("i=9165");
02181         ref.TargetNodeClass = NodeClass::DataType;
02182         ref.TargetNodeId = ToNodeId("i=80");
02183         refs.push_back(ref);
02184         }
02185         registry.AddReferences(refs);
02186         }
02187        
02188         {
02189         AddNodesItem node;
02190         node.RequestedNewNodeId = ToNodeId("i=9166");
02191         node.BrowseName = ToQualifiedName("EffectiveTransitionTime");
02192         node.Class = NodeClass::Variable;
02193         node.ParentNodeId = ToNodeId("i=9160");
02194         node.ReferenceTypeId = ReferenceId::HasProperty;
02195         node.TypeDefinition = ToNodeId("i=68");
02196         VariableAttributes attrs;
02197         attrs.DisplayName = LocalizedText("EffectiveTransitionTime");
02198         attrs.Type = ToNodeId("i=294");
02199         attrs.Rank = -1;
02200         node.Attributes = attrs;
02201         registry.AddNodes(std::vector<AddNodesItem>{node});
02202         std::vector<AddReferencesItem> refs;
02203         {
02204         AddReferencesItem ref;
02205         ref.IsForward = true;
02206         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02207         ref.SourceNodeId = ToNodeId("i=9166");
02208         ref.TargetNodeClass = NodeClass::DataType;
02209         ref.TargetNodeId = ToNodeId("i=80");
02210         refs.push_back(ref);
02211         }
02212         registry.AddReferences(refs);
02213         }
02214        
02215         {
02216         AddNodesItem node;
02217         node.RequestedNewNodeId = ToNodeId("i=11120");
02218         node.BrowseName = ToQualifiedName("InputNode");
02219         node.Class = NodeClass::Variable;
02220         node.ParentNodeId = ToNodeId("i=2915");
02221         node.ReferenceTypeId = ReferenceId::HasProperty;
02222         node.TypeDefinition = ToNodeId("i=68");
02223         VariableAttributes attrs;
02224         attrs.DisplayName = LocalizedText("InputNode");
02225         attrs.Type = ObjectId::NodeId;
02226         attrs.Rank = -1;
02227         node.Attributes = attrs;
02228         registry.AddNodes(std::vector<AddNodesItem>{node});
02229         std::vector<AddReferencesItem> refs;
02230         {
02231         AddReferencesItem ref;
02232         ref.IsForward = true;
02233         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02234         ref.SourceNodeId = ToNodeId("i=11120");
02235         ref.TargetNodeClass = NodeClass::DataType;
02236         ref.TargetNodeId = ToNodeId("i=78");
02237         refs.push_back(ref);
02238         }
02239         registry.AddReferences(refs);
02240         }
02241        
02242         {
02243         AddNodesItem node;
02244         node.RequestedNewNodeId = ToNodeId("i=9169");
02245         node.BrowseName = ToQualifiedName("SuppressedState");
02246         node.Class = NodeClass::Variable;
02247         node.ParentNodeId = ToNodeId("i=2915");
02248         node.ReferenceTypeId = ReferenceId::HasComponent;
02249         node.TypeDefinition = ToNodeId("i=8995");
02250         VariableAttributes attrs;
02251         attrs.DisplayName = LocalizedText("SuppressedState");
02252         attrs.Type = ObjectId::LocalizedText;
02253         attrs.Rank = -1;
02254         node.Attributes = attrs;
02255         registry.AddNodes(std::vector<AddNodesItem>{node});
02256         std::vector<AddReferencesItem> refs;
02257         {
02258         AddReferencesItem ref;
02259         ref.IsForward = true;
02260         ref.ReferenceTypeId = ReferenceId::HasProperty;
02261         ref.SourceNodeId = ToNodeId("i=9169");
02262         ref.TargetNodeClass = NodeClass::DataType;
02263         ref.TargetNodeId = ToNodeId("i=9170");
02264         refs.push_back(ref);
02265         }
02266         {
02267         AddReferencesItem ref;
02268         ref.IsForward = true;
02269         ref.ReferenceTypeId = ReferenceId::HasProperty;
02270         ref.SourceNodeId = ToNodeId("i=9169");
02271         ref.TargetNodeClass = NodeClass::DataType;
02272         ref.TargetNodeId = ToNodeId("i=9174");
02273         refs.push_back(ref);
02274         }
02275         {
02276         AddReferencesItem ref;
02277         ref.IsForward = true;
02278         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02279         ref.SourceNodeId = ToNodeId("i=9169");
02280         ref.TargetNodeClass = NodeClass::DataType;
02281         ref.TargetNodeId = ToNodeId("i=80");
02282         refs.push_back(ref);
02283         }
02284         registry.AddReferences(refs);
02285         }
02286        
02287         {
02288         AddNodesItem node;
02289         node.RequestedNewNodeId = ToNodeId("i=9170");
02290         node.BrowseName = ToQualifiedName("Id");
02291         node.Class = NodeClass::Variable;
02292         node.ParentNodeId = ToNodeId("i=9169");
02293         node.ReferenceTypeId = ReferenceId::HasProperty;
02294         node.TypeDefinition = ToNodeId("i=68");
02295         VariableAttributes attrs;
02296         attrs.DisplayName = LocalizedText("Id");
02297         attrs.Type = ObjectId::Boolean;
02298         attrs.Rank = -1;
02299         node.Attributes = attrs;
02300         registry.AddNodes(std::vector<AddNodesItem>{node});
02301         std::vector<AddReferencesItem> refs;
02302         {
02303         AddReferencesItem ref;
02304         ref.IsForward = true;
02305         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02306         ref.SourceNodeId = ToNodeId("i=9170");
02307         ref.TargetNodeClass = NodeClass::DataType;
02308         ref.TargetNodeId = ToNodeId("i=78");
02309         refs.push_back(ref);
02310         }
02311         registry.AddReferences(refs);
02312         }
02313        
02314         {
02315         AddNodesItem node;
02316         node.RequestedNewNodeId = ToNodeId("i=9174");
02317         node.BrowseName = ToQualifiedName("TransitionTime");
02318         node.Class = NodeClass::Variable;
02319         node.ParentNodeId = ToNodeId("i=9169");
02320         node.ReferenceTypeId = ReferenceId::HasProperty;
02321         node.TypeDefinition = ToNodeId("i=68");
02322         VariableAttributes attrs;
02323         attrs.DisplayName = LocalizedText("TransitionTime");
02324         attrs.Type = ToNodeId("i=294");
02325         attrs.Rank = -1;
02326         node.Attributes = attrs;
02327         registry.AddNodes(std::vector<AddNodesItem>{node});
02328         std::vector<AddReferencesItem> refs;
02329         {
02330         AddReferencesItem ref;
02331         ref.IsForward = true;
02332         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02333         ref.SourceNodeId = ToNodeId("i=9174");
02334         ref.TargetNodeClass = NodeClass::DataType;
02335         ref.TargetNodeId = ToNodeId("i=80");
02336         refs.push_back(ref);
02337         }
02338         registry.AddReferences(refs);
02339         }
02340        
02341         {
02342         AddNodesItem node;
02343         node.RequestedNewNodeId = ToNodeId("i=9178");
02344         node.BrowseName = ToQualifiedName("ShelvingState");
02345         node.Class = NodeClass::Object;
02346         node.ParentNodeId = ToNodeId("i=2915");
02347         node.ReferenceTypeId = ReferenceId::HasComponent;
02348         node.TypeDefinition = ToNodeId("i=2929");
02349         ObjectAttributes attrs;
02350         attrs.DisplayName = LocalizedText("ShelvingState");
02351         attrs.EventNotifier = 0;
02352         node.Attributes = attrs;
02353         registry.AddNodes(std::vector<AddNodesItem>{node});
02354         std::vector<AddReferencesItem> refs;
02355         {
02356         AddReferencesItem ref;
02357         ref.IsForward = true;
02358         ref.ReferenceTypeId = ReferenceId::HasComponent;
02359         ref.SourceNodeId = ToNodeId("i=9178");
02360         ref.TargetNodeClass = NodeClass::DataType;
02361         ref.TargetNodeId = ToNodeId("i=9179");
02362         refs.push_back(ref);
02363         }
02364         {
02365         AddReferencesItem ref;
02366         ref.IsForward = true;
02367         ref.ReferenceTypeId = ReferenceId::HasComponent;
02368         ref.SourceNodeId = ToNodeId("i=9178");
02369         ref.TargetNodeClass = NodeClass::DataType;
02370         ref.TargetNodeId = ToNodeId("i=9184");
02371         refs.push_back(ref);
02372         }
02373         {
02374         AddReferencesItem ref;
02375         ref.IsForward = true;
02376         ref.ReferenceTypeId = ReferenceId::HasProperty;
02377         ref.SourceNodeId = ToNodeId("i=9178");
02378         ref.TargetNodeClass = NodeClass::DataType;
02379         ref.TargetNodeId = ToNodeId("i=9189");
02380         refs.push_back(ref);
02381         }
02382         {
02383         AddReferencesItem ref;
02384         ref.IsForward = true;
02385         ref.ReferenceTypeId = ReferenceId::HasComponent;
02386         ref.SourceNodeId = ToNodeId("i=9178");
02387         ref.TargetNodeClass = NodeClass::DataType;
02388         ref.TargetNodeId = ToNodeId("i=9211");
02389         refs.push_back(ref);
02390         }
02391         {
02392         AddReferencesItem ref;
02393         ref.IsForward = true;
02394         ref.ReferenceTypeId = ReferenceId::HasComponent;
02395         ref.SourceNodeId = ToNodeId("i=9178");
02396         ref.TargetNodeClass = NodeClass::DataType;
02397         ref.TargetNodeId = ToNodeId("i=9212");
02398         refs.push_back(ref);
02399         }
02400         {
02401         AddReferencesItem ref;
02402         ref.IsForward = true;
02403         ref.ReferenceTypeId = ReferenceId::HasComponent;
02404         ref.SourceNodeId = ToNodeId("i=9178");
02405         ref.TargetNodeClass = NodeClass::DataType;
02406         ref.TargetNodeId = ToNodeId("i=9213");
02407         refs.push_back(ref);
02408         }
02409         {
02410         AddReferencesItem ref;
02411         ref.IsForward = true;
02412         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02413         ref.SourceNodeId = ToNodeId("i=9178");
02414         ref.TargetNodeClass = NodeClass::DataType;
02415         ref.TargetNodeId = ToNodeId("i=80");
02416         refs.push_back(ref);
02417         }
02418         registry.AddReferences(refs);
02419         }
02420        
02421         {
02422         AddNodesItem node;
02423         node.RequestedNewNodeId = ToNodeId("i=9179");
02424         node.BrowseName = ToQualifiedName("CurrentState");
02425         node.Class = NodeClass::Variable;
02426         node.ParentNodeId = ToNodeId("i=9178");
02427         node.ReferenceTypeId = ReferenceId::HasComponent;
02428         node.TypeDefinition = ToNodeId("i=2760");
02429         VariableAttributes attrs;
02430         attrs.DisplayName = LocalizedText("CurrentState");
02431         attrs.Type = ObjectId::LocalizedText;
02432         attrs.Rank = -1;
02433         node.Attributes = attrs;
02434         registry.AddNodes(std::vector<AddNodesItem>{node});
02435         std::vector<AddReferencesItem> refs;
02436         {
02437         AddReferencesItem ref;
02438         ref.IsForward = true;
02439         ref.ReferenceTypeId = ReferenceId::HasProperty;
02440         ref.SourceNodeId = ToNodeId("i=9179");
02441         ref.TargetNodeClass = NodeClass::DataType;
02442         ref.TargetNodeId = ToNodeId("i=9180");
02443         refs.push_back(ref);
02444         }
02445         {
02446         AddReferencesItem ref;
02447         ref.IsForward = true;
02448         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02449         ref.SourceNodeId = ToNodeId("i=9179");
02450         ref.TargetNodeClass = NodeClass::DataType;
02451         ref.TargetNodeId = ToNodeId("i=78");
02452         refs.push_back(ref);
02453         }
02454         registry.AddReferences(refs);
02455         }
02456        
02457         {
02458         AddNodesItem node;
02459         node.RequestedNewNodeId = ToNodeId("i=9180");
02460         node.BrowseName = ToQualifiedName("Id");
02461         node.Class = NodeClass::Variable;
02462         node.ParentNodeId = ToNodeId("i=9179");
02463         node.ReferenceTypeId = ReferenceId::HasProperty;
02464         node.TypeDefinition = ToNodeId("i=68");
02465         VariableAttributes attrs;
02466         attrs.DisplayName = LocalizedText("Id");
02467         attrs.Type = ObjectId::NodeId;
02468         attrs.Rank = -1;
02469         node.Attributes = attrs;
02470         registry.AddNodes(std::vector<AddNodesItem>{node});
02471         std::vector<AddReferencesItem> refs;
02472         {
02473         AddReferencesItem ref;
02474         ref.IsForward = true;
02475         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02476         ref.SourceNodeId = ToNodeId("i=9180");
02477         ref.TargetNodeClass = NodeClass::DataType;
02478         ref.TargetNodeId = ToNodeId("i=78");
02479         refs.push_back(ref);
02480         }
02481         registry.AddReferences(refs);
02482         }
02483        
02484         {
02485         AddNodesItem node;
02486         node.RequestedNewNodeId = ToNodeId("i=9184");
02487         node.BrowseName = ToQualifiedName("LastTransition");
02488         node.Class = NodeClass::Variable;
02489         node.ParentNodeId = ToNodeId("i=9178");
02490         node.ReferenceTypeId = ReferenceId::HasComponent;
02491         node.TypeDefinition = ToNodeId("i=2767");
02492         VariableAttributes attrs;
02493         attrs.DisplayName = LocalizedText("LastTransition");
02494         attrs.Type = ObjectId::LocalizedText;
02495         attrs.Rank = -1;
02496         node.Attributes = attrs;
02497         registry.AddNodes(std::vector<AddNodesItem>{node});
02498         std::vector<AddReferencesItem> refs;
02499         {
02500         AddReferencesItem ref;
02501         ref.IsForward = true;
02502         ref.ReferenceTypeId = ReferenceId::HasProperty;
02503         ref.SourceNodeId = ToNodeId("i=9184");
02504         ref.TargetNodeClass = NodeClass::DataType;
02505         ref.TargetNodeId = ToNodeId("i=9185");
02506         refs.push_back(ref);
02507         }
02508         {
02509         AddReferencesItem ref;
02510         ref.IsForward = true;
02511         ref.ReferenceTypeId = ReferenceId::HasProperty;
02512         ref.SourceNodeId = ToNodeId("i=9184");
02513         ref.TargetNodeClass = NodeClass::DataType;
02514         ref.TargetNodeId = ToNodeId("i=9188");
02515         refs.push_back(ref);
02516         }
02517         {
02518         AddReferencesItem ref;
02519         ref.IsForward = true;
02520         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02521         ref.SourceNodeId = ToNodeId("i=9184");
02522         ref.TargetNodeClass = NodeClass::DataType;
02523         ref.TargetNodeId = ToNodeId("i=80");
02524         refs.push_back(ref);
02525         }
02526         registry.AddReferences(refs);
02527         }
02528        
02529         {
02530         AddNodesItem node;
02531         node.RequestedNewNodeId = ToNodeId("i=9185");
02532         node.BrowseName = ToQualifiedName("Id");
02533         node.Class = NodeClass::Variable;
02534         node.ParentNodeId = ToNodeId("i=9184");
02535         node.ReferenceTypeId = ReferenceId::HasProperty;
02536         node.TypeDefinition = ToNodeId("i=68");
02537         VariableAttributes attrs;
02538         attrs.DisplayName = LocalizedText("Id");
02539         attrs.Type = ObjectId::NodeId;
02540         attrs.Rank = -1;
02541         node.Attributes = attrs;
02542         registry.AddNodes(std::vector<AddNodesItem>{node});
02543         std::vector<AddReferencesItem> refs;
02544         {
02545         AddReferencesItem ref;
02546         ref.IsForward = true;
02547         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02548         ref.SourceNodeId = ToNodeId("i=9185");
02549         ref.TargetNodeClass = NodeClass::DataType;
02550         ref.TargetNodeId = ToNodeId("i=78");
02551         refs.push_back(ref);
02552         }
02553         registry.AddReferences(refs);
02554         }
02555        
02556         {
02557         AddNodesItem node;
02558         node.RequestedNewNodeId = ToNodeId("i=9188");
02559         node.BrowseName = ToQualifiedName("TransitionTime");
02560         node.Class = NodeClass::Variable;
02561         node.ParentNodeId = ToNodeId("i=9184");
02562         node.ReferenceTypeId = ReferenceId::HasProperty;
02563         node.TypeDefinition = ToNodeId("i=68");
02564         VariableAttributes attrs;
02565         attrs.DisplayName = LocalizedText("TransitionTime");
02566         attrs.Type = ToNodeId("i=294");
02567         attrs.Rank = -1;
02568         node.Attributes = attrs;
02569         registry.AddNodes(std::vector<AddNodesItem>{node});
02570         std::vector<AddReferencesItem> refs;
02571         {
02572         AddReferencesItem ref;
02573         ref.IsForward = true;
02574         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02575         ref.SourceNodeId = ToNodeId("i=9188");
02576         ref.TargetNodeClass = NodeClass::DataType;
02577         ref.TargetNodeId = ToNodeId("i=80");
02578         refs.push_back(ref);
02579         }
02580         registry.AddReferences(refs);
02581         }
02582        
02583         {
02584         AddNodesItem node;
02585         node.RequestedNewNodeId = ToNodeId("i=9189");
02586         node.BrowseName = ToQualifiedName("UnshelveTime");
02587         node.Class = NodeClass::Variable;
02588         node.ParentNodeId = ToNodeId("i=9178");
02589         node.ReferenceTypeId = ReferenceId::HasProperty;
02590         node.TypeDefinition = ToNodeId("i=68");
02591         VariableAttributes attrs;
02592         attrs.DisplayName = LocalizedText("UnshelveTime");
02593         attrs.Type = ToNodeId("i=290");
02594         attrs.Rank = -1;
02595         node.Attributes = attrs;
02596         registry.AddNodes(std::vector<AddNodesItem>{node});
02597         std::vector<AddReferencesItem> refs;
02598         {
02599         AddReferencesItem ref;
02600         ref.IsForward = true;
02601         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02602         ref.SourceNodeId = ToNodeId("i=9189");
02603         ref.TargetNodeClass = NodeClass::DataType;
02604         ref.TargetNodeId = ToNodeId("i=78");
02605         refs.push_back(ref);
02606         }
02607         registry.AddReferences(refs);
02608         }
02609        
02610         {
02611         AddNodesItem node;
02612         node.RequestedNewNodeId = ToNodeId("i=9214");
02613         node.BrowseName = ToQualifiedName("InputArguments");
02614         node.Class = NodeClass::Variable;
02615         node.ParentNodeId = ToNodeId("i=9213");
02616         node.ReferenceTypeId = ReferenceId::HasProperty;
02617         node.TypeDefinition = ToNodeId("i=68");
02618         VariableAttributes attrs;
02619         attrs.DisplayName = LocalizedText("InputArguments");
02620         attrs.Type = ToNodeId("i=296");
02621         attrs.Rank = 1;
02622         node.Attributes = attrs;
02623         registry.AddNodes(std::vector<AddNodesItem>{node});
02624         std::vector<AddReferencesItem> refs;
02625         {
02626         AddReferencesItem ref;
02627         ref.IsForward = true;
02628         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02629         ref.SourceNodeId = ToNodeId("i=9214");
02630         ref.TargetNodeClass = NodeClass::DataType;
02631         ref.TargetNodeId = ToNodeId("i=78");
02632         refs.push_back(ref);
02633         }
02634         registry.AddReferences(refs);
02635         }
02636        
02637         {
02638         AddNodesItem node;
02639         node.RequestedNewNodeId = ToNodeId("i=9215");
02640         node.BrowseName = ToQualifiedName("SuppressedOrShelved");
02641         node.Class = NodeClass::Variable;
02642         node.ParentNodeId = ToNodeId("i=2915");
02643         node.ReferenceTypeId = ReferenceId::HasProperty;
02644         node.TypeDefinition = ToNodeId("i=68");
02645         VariableAttributes attrs;
02646         attrs.DisplayName = LocalizedText("SuppressedOrShelved");
02647         attrs.Type = ObjectId::Boolean;
02648         attrs.Rank = -1;
02649         node.Attributes = attrs;
02650         registry.AddNodes(std::vector<AddNodesItem>{node});
02651         std::vector<AddReferencesItem> refs;
02652         {
02653         AddReferencesItem ref;
02654         ref.IsForward = true;
02655         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02656         ref.SourceNodeId = ToNodeId("i=9215");
02657         ref.TargetNodeClass = NodeClass::DataType;
02658         ref.TargetNodeId = ToNodeId("i=78");
02659         refs.push_back(ref);
02660         }
02661         registry.AddReferences(refs);
02662         }
02663        
02664         {
02665         AddNodesItem node;
02666         node.RequestedNewNodeId = ToNodeId("i=9216");
02667         node.BrowseName = ToQualifiedName("MaxTimeShelved");
02668         node.Class = NodeClass::Variable;
02669         node.ParentNodeId = ToNodeId("i=2915");
02670         node.ReferenceTypeId = ReferenceId::HasProperty;
02671         node.TypeDefinition = ToNodeId("i=68");
02672         VariableAttributes attrs;
02673         attrs.DisplayName = LocalizedText("MaxTimeShelved");
02674         attrs.Type = ToNodeId("i=290");
02675         attrs.Rank = -1;
02676         node.Attributes = attrs;
02677         registry.AddNodes(std::vector<AddNodesItem>{node});
02678         std::vector<AddReferencesItem> refs;
02679         {
02680         AddReferencesItem ref;
02681         ref.IsForward = true;
02682         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02683         ref.SourceNodeId = ToNodeId("i=9216");
02684         ref.TargetNodeClass = NodeClass::DataType;
02685         ref.TargetNodeId = ToNodeId("i=80");
02686         refs.push_back(ref);
02687         }
02688         registry.AddReferences(refs);
02689         }
02690        
02691         {
02692         AddNodesItem node;
02693         node.RequestedNewNodeId = ToNodeId("i=2929");
02694         node.BrowseName = ToQualifiedName("ShelvedStateMachineType");
02695         node.Class = NodeClass::ObjectType;
02696         node.ParentNodeId = ToNodeId("i=2771");
02697         node.ReferenceTypeId = ReferenceId::HasSubtype;
02698         ObjectTypeAttributes attrs;
02699         attrs.DisplayName = LocalizedText("ShelvedStateMachineType");
02700         attrs.IsAbstract = false;
02701         node.Attributes = attrs;
02702         registry.AddNodes(std::vector<AddNodesItem>{node});
02703         std::vector<AddReferencesItem> refs;
02704         {
02705         AddReferencesItem ref;
02706         ref.IsForward = true;
02707         ref.ReferenceTypeId = ReferenceId::HasProperty;
02708         ref.SourceNodeId = ToNodeId("i=2929");
02709         ref.TargetNodeClass = NodeClass::DataType;
02710         ref.TargetNodeId = ToNodeId("i=9115");
02711         refs.push_back(ref);
02712         }
02713         {
02714         AddReferencesItem ref;
02715         ref.IsForward = true;
02716         ref.ReferenceTypeId = ReferenceId::HasComponent;
02717         ref.SourceNodeId = ToNodeId("i=2929");
02718         ref.TargetNodeClass = NodeClass::DataType;
02719         ref.TargetNodeId = ToNodeId("i=2930");
02720         refs.push_back(ref);
02721         }
02722         {
02723         AddReferencesItem ref;
02724         ref.IsForward = true;
02725         ref.ReferenceTypeId = ReferenceId::HasComponent;
02726         ref.SourceNodeId = ToNodeId("i=2929");
02727         ref.TargetNodeClass = NodeClass::DataType;
02728         ref.TargetNodeId = ToNodeId("i=2932");
02729         refs.push_back(ref);
02730         }
02731         {
02732         AddReferencesItem ref;
02733         ref.IsForward = true;
02734         ref.ReferenceTypeId = ReferenceId::HasComponent;
02735         ref.SourceNodeId = ToNodeId("i=2929");
02736         ref.TargetNodeClass = NodeClass::DataType;
02737         ref.TargetNodeId = ToNodeId("i=2933");
02738         refs.push_back(ref);
02739         }
02740         {
02741         AddReferencesItem ref;
02742         ref.IsForward = true;
02743         ref.ReferenceTypeId = ReferenceId::HasComponent;
02744         ref.SourceNodeId = ToNodeId("i=2929");
02745         ref.TargetNodeClass = NodeClass::DataType;
02746         ref.TargetNodeId = ToNodeId("i=2935");
02747         refs.push_back(ref);
02748         }
02749         {
02750         AddReferencesItem ref;
02751         ref.IsForward = true;
02752         ref.ReferenceTypeId = ReferenceId::HasComponent;
02753         ref.SourceNodeId = ToNodeId("i=2929");
02754         ref.TargetNodeClass = NodeClass::DataType;
02755         ref.TargetNodeId = ToNodeId("i=2936");
02756         refs.push_back(ref);
02757         }
02758         {
02759         AddReferencesItem ref;
02760         ref.IsForward = true;
02761         ref.ReferenceTypeId = ReferenceId::HasComponent;
02762         ref.SourceNodeId = ToNodeId("i=2929");
02763         ref.TargetNodeClass = NodeClass::DataType;
02764         ref.TargetNodeId = ToNodeId("i=2940");
02765         refs.push_back(ref);
02766         }
02767         {
02768         AddReferencesItem ref;
02769         ref.IsForward = true;
02770         ref.ReferenceTypeId = ReferenceId::HasComponent;
02771         ref.SourceNodeId = ToNodeId("i=2929");
02772         ref.TargetNodeClass = NodeClass::DataType;
02773         ref.TargetNodeId = ToNodeId("i=2942");
02774         refs.push_back(ref);
02775         }
02776         {
02777         AddReferencesItem ref;
02778         ref.IsForward = true;
02779         ref.ReferenceTypeId = ReferenceId::HasComponent;
02780         ref.SourceNodeId = ToNodeId("i=2929");
02781         ref.TargetNodeClass = NodeClass::DataType;
02782         ref.TargetNodeId = ToNodeId("i=2943");
02783         refs.push_back(ref);
02784         }
02785         {
02786         AddReferencesItem ref;
02787         ref.IsForward = true;
02788         ref.ReferenceTypeId = ReferenceId::HasComponent;
02789         ref.SourceNodeId = ToNodeId("i=2929");
02790         ref.TargetNodeClass = NodeClass::DataType;
02791         ref.TargetNodeId = ToNodeId("i=2945");
02792         refs.push_back(ref);
02793         }
02794         {
02795         AddReferencesItem ref;
02796         ref.IsForward = true;
02797         ref.ReferenceTypeId = ReferenceId::HasComponent;
02798         ref.SourceNodeId = ToNodeId("i=2929");
02799         ref.TargetNodeClass = NodeClass::DataType;
02800         ref.TargetNodeId = ToNodeId("i=2947");
02801         refs.push_back(ref);
02802         }
02803         {
02804         AddReferencesItem ref;
02805         ref.IsForward = true;
02806         ref.ReferenceTypeId = ReferenceId::HasComponent;
02807         ref.SourceNodeId = ToNodeId("i=2929");
02808         ref.TargetNodeClass = NodeClass::DataType;
02809         ref.TargetNodeId = ToNodeId("i=2948");
02810         refs.push_back(ref);
02811         }
02812         {
02813         AddReferencesItem ref;
02814         ref.IsForward = true;
02815         ref.ReferenceTypeId = ReferenceId::HasComponent;
02816         ref.SourceNodeId = ToNodeId("i=2929");
02817         ref.TargetNodeClass = NodeClass::DataType;
02818         ref.TargetNodeId = ToNodeId("i=2949");
02819         refs.push_back(ref);
02820         }
02821         registry.AddReferences(refs);
02822         }
02823        
02824         {
02825         AddNodesItem node;
02826         node.RequestedNewNodeId = ToNodeId("i=9115");
02827         node.BrowseName = ToQualifiedName("UnshelveTime");
02828         node.Class = NodeClass::Variable;
02829         node.ParentNodeId = ToNodeId("i=2929");
02830         node.ReferenceTypeId = ReferenceId::HasProperty;
02831         node.TypeDefinition = ToNodeId("i=68");
02832         VariableAttributes attrs;
02833         attrs.DisplayName = LocalizedText("UnshelveTime");
02834         attrs.Type = ToNodeId("i=290");
02835         attrs.Rank = -1;
02836         node.Attributes = attrs;
02837         registry.AddNodes(std::vector<AddNodesItem>{node});
02838         std::vector<AddReferencesItem> refs;
02839         {
02840         AddReferencesItem ref;
02841         ref.IsForward = true;
02842         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02843         ref.SourceNodeId = ToNodeId("i=9115");
02844         ref.TargetNodeClass = NodeClass::DataType;
02845         ref.TargetNodeId = ToNodeId("i=78");
02846         refs.push_back(ref);
02847         }
02848         registry.AddReferences(refs);
02849         }
02850        
02851         {
02852         AddNodesItem node;
02853         node.RequestedNewNodeId = ToNodeId("i=2930");
02854         node.BrowseName = ToQualifiedName("Unshelved");
02855         node.Class = NodeClass::Object;
02856         node.ParentNodeId = ToNodeId("i=2929");
02857         node.ReferenceTypeId = ReferenceId::HasComponent;
02858         node.TypeDefinition = ToNodeId("i=2307");
02859         ObjectAttributes attrs;
02860         attrs.DisplayName = LocalizedText("Unshelved");
02861         attrs.EventNotifier = 0;
02862         node.Attributes = attrs;
02863         registry.AddNodes(std::vector<AddNodesItem>{node});
02864         std::vector<AddReferencesItem> refs;
02865         {
02866         AddReferencesItem ref;
02867         ref.IsForward = true;
02868         ref.ReferenceTypeId = ReferenceId::HasProperty;
02869         ref.SourceNodeId = ToNodeId("i=2930");
02870         ref.TargetNodeClass = NodeClass::DataType;
02871         ref.TargetNodeId = ToNodeId("i=6098");
02872         refs.push_back(ref);
02873         }
02874         registry.AddReferences(refs);
02875         }
02876        
02877         {
02878         AddNodesItem node;
02879         node.RequestedNewNodeId = ToNodeId("i=6098");
02880         node.BrowseName = ToQualifiedName("StateNumber");
02881         node.Class = NodeClass::Variable;
02882         node.ParentNodeId = ToNodeId("i=2930");
02883         node.ReferenceTypeId = ReferenceId::HasProperty;
02884         node.TypeDefinition = ToNodeId("i=68");
02885         VariableAttributes attrs;
02886         attrs.DisplayName = LocalizedText("StateNumber");
02887         attrs.Type = ObjectId::UInt32;
02888         attrs.Rank = -1;
02889         node.Attributes = attrs;
02890         registry.AddNodes(std::vector<AddNodesItem>{node});
02891         std::vector<AddReferencesItem> refs;
02892         {
02893         AddReferencesItem ref;
02894         ref.IsForward = true;
02895         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02896         ref.SourceNodeId = ToNodeId("i=6098");
02897         ref.TargetNodeClass = NodeClass::DataType;
02898         ref.TargetNodeId = ToNodeId("i=78");
02899         refs.push_back(ref);
02900         }
02901         registry.AddReferences(refs);
02902         }
02903        
02904         {
02905         AddNodesItem node;
02906         node.RequestedNewNodeId = ToNodeId("i=2932");
02907         node.BrowseName = ToQualifiedName("TimedShelved");
02908         node.Class = NodeClass::Object;
02909         node.ParentNodeId = ToNodeId("i=2929");
02910         node.ReferenceTypeId = ReferenceId::HasComponent;
02911         node.TypeDefinition = ToNodeId("i=2307");
02912         ObjectAttributes attrs;
02913         attrs.DisplayName = LocalizedText("TimedShelved");
02914         attrs.EventNotifier = 0;
02915         node.Attributes = attrs;
02916         registry.AddNodes(std::vector<AddNodesItem>{node});
02917         std::vector<AddReferencesItem> refs;
02918         {
02919         AddReferencesItem ref;
02920         ref.IsForward = true;
02921         ref.ReferenceTypeId = ReferenceId::HasProperty;
02922         ref.SourceNodeId = ToNodeId("i=2932");
02923         ref.TargetNodeClass = NodeClass::DataType;
02924         ref.TargetNodeId = ToNodeId("i=6100");
02925         refs.push_back(ref);
02926         }
02927         registry.AddReferences(refs);
02928         }
02929        
02930         {
02931         AddNodesItem node;
02932         node.RequestedNewNodeId = ToNodeId("i=6100");
02933         node.BrowseName = ToQualifiedName("StateNumber");
02934         node.Class = NodeClass::Variable;
02935         node.ParentNodeId = ToNodeId("i=2932");
02936         node.ReferenceTypeId = ReferenceId::HasProperty;
02937         node.TypeDefinition = ToNodeId("i=68");
02938         VariableAttributes attrs;
02939         attrs.DisplayName = LocalizedText("StateNumber");
02940         attrs.Type = ObjectId::UInt32;
02941         attrs.Rank = -1;
02942         node.Attributes = attrs;
02943         registry.AddNodes(std::vector<AddNodesItem>{node});
02944         std::vector<AddReferencesItem> refs;
02945         {
02946         AddReferencesItem ref;
02947         ref.IsForward = true;
02948         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
02949         ref.SourceNodeId = ToNodeId("i=6100");
02950         ref.TargetNodeClass = NodeClass::DataType;
02951         ref.TargetNodeId = ToNodeId("i=78");
02952         refs.push_back(ref);
02953         }
02954         registry.AddReferences(refs);
02955         }
02956        
02957         {
02958         AddNodesItem node;
02959         node.RequestedNewNodeId = ToNodeId("i=2933");
02960         node.BrowseName = ToQualifiedName("OneShotShelved");
02961         node.Class = NodeClass::Object;
02962         node.ParentNodeId = ToNodeId("i=2929");
02963         node.ReferenceTypeId = ReferenceId::HasComponent;
02964         node.TypeDefinition = ToNodeId("i=2307");
02965         ObjectAttributes attrs;
02966         attrs.DisplayName = LocalizedText("OneShotShelved");
02967         attrs.EventNotifier = 0;
02968         node.Attributes = attrs;
02969         registry.AddNodes(std::vector<AddNodesItem>{node});
02970         std::vector<AddReferencesItem> refs;
02971         {
02972         AddReferencesItem ref;
02973         ref.IsForward = true;
02974         ref.ReferenceTypeId = ReferenceId::HasProperty;
02975         ref.SourceNodeId = ToNodeId("i=2933");
02976         ref.TargetNodeClass = NodeClass::DataType;
02977         ref.TargetNodeId = ToNodeId("i=6101");
02978         refs.push_back(ref);
02979         }
02980         registry.AddReferences(refs);
02981         }
02982        
02983         {
02984         AddNodesItem node;
02985         node.RequestedNewNodeId = ToNodeId("i=6101");
02986         node.BrowseName = ToQualifiedName("StateNumber");
02987         node.Class = NodeClass::Variable;
02988         node.ParentNodeId = ToNodeId("i=2933");
02989         node.ReferenceTypeId = ReferenceId::HasProperty;
02990         node.TypeDefinition = ToNodeId("i=68");
02991         VariableAttributes attrs;
02992         attrs.DisplayName = LocalizedText("StateNumber");
02993         attrs.Type = ObjectId::UInt32;
02994         attrs.Rank = -1;
02995         node.Attributes = attrs;
02996         registry.AddNodes(std::vector<AddNodesItem>{node});
02997         std::vector<AddReferencesItem> refs;
02998         {
02999         AddReferencesItem ref;
03000         ref.IsForward = true;
03001         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03002         ref.SourceNodeId = ToNodeId("i=6101");
03003         ref.TargetNodeClass = NodeClass::DataType;
03004         ref.TargetNodeId = ToNodeId("i=78");
03005         refs.push_back(ref);
03006         }
03007         registry.AddReferences(refs);
03008         }
03009        
03010         {
03011         AddNodesItem node;
03012         node.RequestedNewNodeId = ToNodeId("i=2935");
03013         node.BrowseName = ToQualifiedName("UnshelvedToTimedShelved");
03014         node.Class = NodeClass::Object;
03015         node.ParentNodeId = ToNodeId("i=2929");
03016         node.ReferenceTypeId = ReferenceId::HasComponent;
03017         node.TypeDefinition = ToNodeId("i=2310");
03018         ObjectAttributes attrs;
03019         attrs.DisplayName = LocalizedText("UnshelvedToTimedShelved");
03020         attrs.EventNotifier = 0;
03021         node.Attributes = attrs;
03022         registry.AddNodes(std::vector<AddNodesItem>{node});
03023         std::vector<AddReferencesItem> refs;
03024         {
03025         AddReferencesItem ref;
03026         ref.IsForward = true;
03027         ref.ReferenceTypeId = ReferenceId::HasProperty;
03028         ref.SourceNodeId = ToNodeId("i=2935");
03029         ref.TargetNodeClass = NodeClass::DataType;
03030         ref.TargetNodeId = ToNodeId("i=11322");
03031         refs.push_back(ref);
03032         }
03033         {
03034         AddReferencesItem ref;
03035         ref.IsForward = true;
03036         ref.ReferenceTypeId = ToNodeId("i=51");
03037         ref.SourceNodeId = ToNodeId("i=2935");
03038         ref.TargetNodeClass = NodeClass::DataType;
03039         ref.TargetNodeId = ToNodeId("i=2930");
03040         refs.push_back(ref);
03041         }
03042         {
03043         AddReferencesItem ref;
03044         ref.IsForward = true;
03045         ref.ReferenceTypeId = ToNodeId("i=52");
03046         ref.SourceNodeId = ToNodeId("i=2935");
03047         ref.TargetNodeClass = NodeClass::DataType;
03048         ref.TargetNodeId = ToNodeId("i=2932");
03049         refs.push_back(ref);
03050         }
03051         {
03052         AddReferencesItem ref;
03053         ref.IsForward = true;
03054         ref.ReferenceTypeId = ToNodeId("i=54");
03055         ref.SourceNodeId = ToNodeId("i=2935");
03056         ref.TargetNodeClass = NodeClass::DataType;
03057         ref.TargetNodeId = ToNodeId("i=2915");
03058         refs.push_back(ref);
03059         }
03060         {
03061         AddReferencesItem ref;
03062         ref.IsForward = true;
03063         ref.ReferenceTypeId = ToNodeId("i=53");
03064         ref.SourceNodeId = ToNodeId("i=2935");
03065         ref.TargetNodeClass = NodeClass::DataType;
03066         ref.TargetNodeId = ToNodeId("i=2949");
03067         refs.push_back(ref);
03068         }
03069         registry.AddReferences(refs);
03070         }
03071        
03072         {
03073         AddNodesItem node;
03074         node.RequestedNewNodeId = ToNodeId("i=11322");
03075         node.BrowseName = ToQualifiedName("TransitionNumber");
03076         node.Class = NodeClass::Variable;
03077         node.ParentNodeId = ToNodeId("i=2935");
03078         node.ReferenceTypeId = ReferenceId::HasProperty;
03079         node.TypeDefinition = ToNodeId("i=68");
03080         VariableAttributes attrs;
03081         attrs.DisplayName = LocalizedText("TransitionNumber");
03082         attrs.Type = ObjectId::UInt32;
03083         attrs.Rank = -1;
03084         node.Attributes = attrs;
03085         registry.AddNodes(std::vector<AddNodesItem>{node});
03086         std::vector<AddReferencesItem> refs;
03087         {
03088         AddReferencesItem ref;
03089         ref.IsForward = true;
03090         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03091         ref.SourceNodeId = ToNodeId("i=11322");
03092         ref.TargetNodeClass = NodeClass::DataType;
03093         ref.TargetNodeId = ToNodeId("i=78");
03094         refs.push_back(ref);
03095         }
03096         registry.AddReferences(refs);
03097         }
03098        
03099         {
03100         AddNodesItem node;
03101         node.RequestedNewNodeId = ToNodeId("i=2936");
03102         node.BrowseName = ToQualifiedName("UnshelvedToOneShotShelved");
03103         node.Class = NodeClass::Object;
03104         node.ParentNodeId = ToNodeId("i=2929");
03105         node.ReferenceTypeId = ReferenceId::HasComponent;
03106         node.TypeDefinition = ToNodeId("i=2310");
03107         ObjectAttributes attrs;
03108         attrs.DisplayName = LocalizedText("UnshelvedToOneShotShelved");
03109         attrs.EventNotifier = 0;
03110         node.Attributes = attrs;
03111         registry.AddNodes(std::vector<AddNodesItem>{node});
03112         std::vector<AddReferencesItem> refs;
03113         {
03114         AddReferencesItem ref;
03115         ref.IsForward = true;
03116         ref.ReferenceTypeId = ReferenceId::HasProperty;
03117         ref.SourceNodeId = ToNodeId("i=2936");
03118         ref.TargetNodeClass = NodeClass::DataType;
03119         ref.TargetNodeId = ToNodeId("i=11323");
03120         refs.push_back(ref);
03121         }
03122         {
03123         AddReferencesItem ref;
03124         ref.IsForward = true;
03125         ref.ReferenceTypeId = ToNodeId("i=51");
03126         ref.SourceNodeId = ToNodeId("i=2936");
03127         ref.TargetNodeClass = NodeClass::DataType;
03128         ref.TargetNodeId = ToNodeId("i=2930");
03129         refs.push_back(ref);
03130         }
03131         {
03132         AddReferencesItem ref;
03133         ref.IsForward = true;
03134         ref.ReferenceTypeId = ToNodeId("i=52");
03135         ref.SourceNodeId = ToNodeId("i=2936");
03136         ref.TargetNodeClass = NodeClass::DataType;
03137         ref.TargetNodeId = ToNodeId("i=2933");
03138         refs.push_back(ref);
03139         }
03140         {
03141         AddReferencesItem ref;
03142         ref.IsForward = true;
03143         ref.ReferenceTypeId = ToNodeId("i=54");
03144         ref.SourceNodeId = ToNodeId("i=2936");
03145         ref.TargetNodeClass = NodeClass::DataType;
03146         ref.TargetNodeId = ToNodeId("i=2915");
03147         refs.push_back(ref);
03148         }
03149         {
03150         AddReferencesItem ref;
03151         ref.IsForward = true;
03152         ref.ReferenceTypeId = ToNodeId("i=53");
03153         ref.SourceNodeId = ToNodeId("i=2936");
03154         ref.TargetNodeClass = NodeClass::DataType;
03155         ref.TargetNodeId = ToNodeId("i=2948");
03156         refs.push_back(ref);
03157         }
03158         registry.AddReferences(refs);
03159         }
03160        
03161         {
03162         AddNodesItem node;
03163         node.RequestedNewNodeId = ToNodeId("i=11323");
03164         node.BrowseName = ToQualifiedName("TransitionNumber");
03165         node.Class = NodeClass::Variable;
03166         node.ParentNodeId = ToNodeId("i=2936");
03167         node.ReferenceTypeId = ReferenceId::HasProperty;
03168         node.TypeDefinition = ToNodeId("i=68");
03169         VariableAttributes attrs;
03170         attrs.DisplayName = LocalizedText("TransitionNumber");
03171         attrs.Type = ObjectId::UInt32;
03172         attrs.Rank = -1;
03173         node.Attributes = attrs;
03174         registry.AddNodes(std::vector<AddNodesItem>{node});
03175         std::vector<AddReferencesItem> refs;
03176         {
03177         AddReferencesItem ref;
03178         ref.IsForward = true;
03179         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03180         ref.SourceNodeId = ToNodeId("i=11323");
03181         ref.TargetNodeClass = NodeClass::DataType;
03182         ref.TargetNodeId = ToNodeId("i=78");
03183         refs.push_back(ref);
03184         }
03185         registry.AddReferences(refs);
03186         }
03187        
03188         {
03189         AddNodesItem node;
03190         node.RequestedNewNodeId = ToNodeId("i=2940");
03191         node.BrowseName = ToQualifiedName("TimedShelvedToUnshelved");
03192         node.Class = NodeClass::Object;
03193         node.ParentNodeId = ToNodeId("i=2929");
03194         node.ReferenceTypeId = ReferenceId::HasComponent;
03195         node.TypeDefinition = ToNodeId("i=2310");
03196         ObjectAttributes attrs;
03197         attrs.DisplayName = LocalizedText("TimedShelvedToUnshelved");
03198         attrs.EventNotifier = 0;
03199         node.Attributes = attrs;
03200         registry.AddNodes(std::vector<AddNodesItem>{node});
03201         std::vector<AddReferencesItem> refs;
03202         {
03203         AddReferencesItem ref;
03204         ref.IsForward = true;
03205         ref.ReferenceTypeId = ReferenceId::HasProperty;
03206         ref.SourceNodeId = ToNodeId("i=2940");
03207         ref.TargetNodeClass = NodeClass::DataType;
03208         ref.TargetNodeId = ToNodeId("i=11324");
03209         refs.push_back(ref);
03210         }
03211         {
03212         AddReferencesItem ref;
03213         ref.IsForward = true;
03214         ref.ReferenceTypeId = ToNodeId("i=51");
03215         ref.SourceNodeId = ToNodeId("i=2940");
03216         ref.TargetNodeClass = NodeClass::DataType;
03217         ref.TargetNodeId = ToNodeId("i=2932");
03218         refs.push_back(ref);
03219         }
03220         {
03221         AddReferencesItem ref;
03222         ref.IsForward = true;
03223         ref.ReferenceTypeId = ToNodeId("i=52");
03224         ref.SourceNodeId = ToNodeId("i=2940");
03225         ref.TargetNodeClass = NodeClass::DataType;
03226         ref.TargetNodeId = ToNodeId("i=2930");
03227         refs.push_back(ref);
03228         }
03229         {
03230         AddReferencesItem ref;
03231         ref.IsForward = true;
03232         ref.ReferenceTypeId = ToNodeId("i=54");
03233         ref.SourceNodeId = ToNodeId("i=2940");
03234         ref.TargetNodeClass = NodeClass::DataType;
03235         ref.TargetNodeId = ToNodeId("i=2915");
03236         refs.push_back(ref);
03237         }
03238         {
03239         AddReferencesItem ref;
03240         ref.IsForward = true;
03241         ref.ReferenceTypeId = ToNodeId("i=53");
03242         ref.SourceNodeId = ToNodeId("i=2940");
03243         ref.TargetNodeClass = NodeClass::DataType;
03244         ref.TargetNodeId = ToNodeId("i=2947");
03245         refs.push_back(ref);
03246         }
03247         registry.AddReferences(refs);
03248         }
03249        
03250         {
03251         AddNodesItem node;
03252         node.RequestedNewNodeId = ToNodeId("i=11324");
03253         node.BrowseName = ToQualifiedName("TransitionNumber");
03254         node.Class = NodeClass::Variable;
03255         node.ParentNodeId = ToNodeId("i=2940");
03256         node.ReferenceTypeId = ReferenceId::HasProperty;
03257         node.TypeDefinition = ToNodeId("i=68");
03258         VariableAttributes attrs;
03259         attrs.DisplayName = LocalizedText("TransitionNumber");
03260         attrs.Type = ObjectId::UInt32;
03261         attrs.Rank = -1;
03262         node.Attributes = attrs;
03263         registry.AddNodes(std::vector<AddNodesItem>{node});
03264         std::vector<AddReferencesItem> refs;
03265         {
03266         AddReferencesItem ref;
03267         ref.IsForward = true;
03268         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03269         ref.SourceNodeId = ToNodeId("i=11324");
03270         ref.TargetNodeClass = NodeClass::DataType;
03271         ref.TargetNodeId = ToNodeId("i=78");
03272         refs.push_back(ref);
03273         }
03274         registry.AddReferences(refs);
03275         }
03276        
03277         {
03278         AddNodesItem node;
03279         node.RequestedNewNodeId = ToNodeId("i=2942");
03280         node.BrowseName = ToQualifiedName("TimedShelvedToOneShotShelved");
03281         node.Class = NodeClass::Object;
03282         node.ParentNodeId = ToNodeId("i=2929");
03283         node.ReferenceTypeId = ReferenceId::HasComponent;
03284         node.TypeDefinition = ToNodeId("i=2310");
03285         ObjectAttributes attrs;
03286         attrs.DisplayName = LocalizedText("TimedShelvedToOneShotShelved");
03287         attrs.EventNotifier = 0;
03288         node.Attributes = attrs;
03289         registry.AddNodes(std::vector<AddNodesItem>{node});
03290         std::vector<AddReferencesItem> refs;
03291         {
03292         AddReferencesItem ref;
03293         ref.IsForward = true;
03294         ref.ReferenceTypeId = ReferenceId::HasProperty;
03295         ref.SourceNodeId = ToNodeId("i=2942");
03296         ref.TargetNodeClass = NodeClass::DataType;
03297         ref.TargetNodeId = ToNodeId("i=11325");
03298         refs.push_back(ref);
03299         }
03300         {
03301         AddReferencesItem ref;
03302         ref.IsForward = true;
03303         ref.ReferenceTypeId = ToNodeId("i=51");
03304         ref.SourceNodeId = ToNodeId("i=2942");
03305         ref.TargetNodeClass = NodeClass::DataType;
03306         ref.TargetNodeId = ToNodeId("i=2932");
03307         refs.push_back(ref);
03308         }
03309         {
03310         AddReferencesItem ref;
03311         ref.IsForward = true;
03312         ref.ReferenceTypeId = ToNodeId("i=52");
03313         ref.SourceNodeId = ToNodeId("i=2942");
03314         ref.TargetNodeClass = NodeClass::DataType;
03315         ref.TargetNodeId = ToNodeId("i=2933");
03316         refs.push_back(ref);
03317         }
03318         {
03319         AddReferencesItem ref;
03320         ref.IsForward = true;
03321         ref.ReferenceTypeId = ToNodeId("i=54");
03322         ref.SourceNodeId = ToNodeId("i=2942");
03323         ref.TargetNodeClass = NodeClass::DataType;
03324         ref.TargetNodeId = ToNodeId("i=2915");
03325         refs.push_back(ref);
03326         }
03327         {
03328         AddReferencesItem ref;
03329         ref.IsForward = true;
03330         ref.ReferenceTypeId = ToNodeId("i=53");
03331         ref.SourceNodeId = ToNodeId("i=2942");
03332         ref.TargetNodeClass = NodeClass::DataType;
03333         ref.TargetNodeId = ToNodeId("i=2948");
03334         refs.push_back(ref);
03335         }
03336         registry.AddReferences(refs);
03337         }
03338        
03339         {
03340         AddNodesItem node;
03341         node.RequestedNewNodeId = ToNodeId("i=11325");
03342         node.BrowseName = ToQualifiedName("TransitionNumber");
03343         node.Class = NodeClass::Variable;
03344         node.ParentNodeId = ToNodeId("i=2942");
03345         node.ReferenceTypeId = ReferenceId::HasProperty;
03346         node.TypeDefinition = ToNodeId("i=68");
03347         VariableAttributes attrs;
03348         attrs.DisplayName = LocalizedText("TransitionNumber");
03349         attrs.Type = ObjectId::UInt32;
03350         attrs.Rank = -1;
03351         node.Attributes = attrs;
03352         registry.AddNodes(std::vector<AddNodesItem>{node});
03353         std::vector<AddReferencesItem> refs;
03354         {
03355         AddReferencesItem ref;
03356         ref.IsForward = true;
03357         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03358         ref.SourceNodeId = ToNodeId("i=11325");
03359         ref.TargetNodeClass = NodeClass::DataType;
03360         ref.TargetNodeId = ToNodeId("i=78");
03361         refs.push_back(ref);
03362         }
03363         registry.AddReferences(refs);
03364         }
03365        
03366         {
03367         AddNodesItem node;
03368         node.RequestedNewNodeId = ToNodeId("i=2943");
03369         node.BrowseName = ToQualifiedName("OneShotShelvedToUnshelved");
03370         node.Class = NodeClass::Object;
03371         node.ParentNodeId = ToNodeId("i=2929");
03372         node.ReferenceTypeId = ReferenceId::HasComponent;
03373         node.TypeDefinition = ToNodeId("i=2310");
03374         ObjectAttributes attrs;
03375         attrs.DisplayName = LocalizedText("OneShotShelvedToUnshelved");
03376         attrs.EventNotifier = 0;
03377         node.Attributes = attrs;
03378         registry.AddNodes(std::vector<AddNodesItem>{node});
03379         std::vector<AddReferencesItem> refs;
03380         {
03381         AddReferencesItem ref;
03382         ref.IsForward = true;
03383         ref.ReferenceTypeId = ReferenceId::HasProperty;
03384         ref.SourceNodeId = ToNodeId("i=2943");
03385         ref.TargetNodeClass = NodeClass::DataType;
03386         ref.TargetNodeId = ToNodeId("i=11326");
03387         refs.push_back(ref);
03388         }
03389         {
03390         AddReferencesItem ref;
03391         ref.IsForward = true;
03392         ref.ReferenceTypeId = ToNodeId("i=51");
03393         ref.SourceNodeId = ToNodeId("i=2943");
03394         ref.TargetNodeClass = NodeClass::DataType;
03395         ref.TargetNodeId = ToNodeId("i=2933");
03396         refs.push_back(ref);
03397         }
03398         {
03399         AddReferencesItem ref;
03400         ref.IsForward = true;
03401         ref.ReferenceTypeId = ToNodeId("i=52");
03402         ref.SourceNodeId = ToNodeId("i=2943");
03403         ref.TargetNodeClass = NodeClass::DataType;
03404         ref.TargetNodeId = ToNodeId("i=2930");
03405         refs.push_back(ref);
03406         }
03407         {
03408         AddReferencesItem ref;
03409         ref.IsForward = true;
03410         ref.ReferenceTypeId = ToNodeId("i=54");
03411         ref.SourceNodeId = ToNodeId("i=2943");
03412         ref.TargetNodeClass = NodeClass::DataType;
03413         ref.TargetNodeId = ToNodeId("i=2915");
03414         refs.push_back(ref);
03415         }
03416         {
03417         AddReferencesItem ref;
03418         ref.IsForward = true;
03419         ref.ReferenceTypeId = ToNodeId("i=53");
03420         ref.SourceNodeId = ToNodeId("i=2943");
03421         ref.TargetNodeClass = NodeClass::DataType;
03422         ref.TargetNodeId = ToNodeId("i=2947");
03423         refs.push_back(ref);
03424         }
03425         registry.AddReferences(refs);
03426         }
03427        
03428         {
03429         AddNodesItem node;
03430         node.RequestedNewNodeId = ToNodeId("i=11326");
03431         node.BrowseName = ToQualifiedName("TransitionNumber");
03432         node.Class = NodeClass::Variable;
03433         node.ParentNodeId = ToNodeId("i=2943");
03434         node.ReferenceTypeId = ReferenceId::HasProperty;
03435         node.TypeDefinition = ToNodeId("i=68");
03436         VariableAttributes attrs;
03437         attrs.DisplayName = LocalizedText("TransitionNumber");
03438         attrs.Type = ObjectId::UInt32;
03439         attrs.Rank = -1;
03440         node.Attributes = attrs;
03441         registry.AddNodes(std::vector<AddNodesItem>{node});
03442         std::vector<AddReferencesItem> refs;
03443         {
03444         AddReferencesItem ref;
03445         ref.IsForward = true;
03446         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03447         ref.SourceNodeId = ToNodeId("i=11326");
03448         ref.TargetNodeClass = NodeClass::DataType;
03449         ref.TargetNodeId = ToNodeId("i=78");
03450         refs.push_back(ref);
03451         }
03452         registry.AddReferences(refs);
03453         }
03454        
03455         {
03456         AddNodesItem node;
03457         node.RequestedNewNodeId = ToNodeId("i=2945");
03458         node.BrowseName = ToQualifiedName("OneShotShelvedToTimedShelved");
03459         node.Class = NodeClass::Object;
03460         node.ParentNodeId = ToNodeId("i=2929");
03461         node.ReferenceTypeId = ReferenceId::HasComponent;
03462         node.TypeDefinition = ToNodeId("i=2310");
03463         ObjectAttributes attrs;
03464         attrs.DisplayName = LocalizedText("OneShotShelvedToTimedShelved");
03465         attrs.EventNotifier = 0;
03466         node.Attributes = attrs;
03467         registry.AddNodes(std::vector<AddNodesItem>{node});
03468         std::vector<AddReferencesItem> refs;
03469         {
03470         AddReferencesItem ref;
03471         ref.IsForward = true;
03472         ref.ReferenceTypeId = ReferenceId::HasProperty;
03473         ref.SourceNodeId = ToNodeId("i=2945");
03474         ref.TargetNodeClass = NodeClass::DataType;
03475         ref.TargetNodeId = ToNodeId("i=11327");
03476         refs.push_back(ref);
03477         }
03478         {
03479         AddReferencesItem ref;
03480         ref.IsForward = true;
03481         ref.ReferenceTypeId = ToNodeId("i=51");
03482         ref.SourceNodeId = ToNodeId("i=2945");
03483         ref.TargetNodeClass = NodeClass::DataType;
03484         ref.TargetNodeId = ToNodeId("i=2933");
03485         refs.push_back(ref);
03486         }
03487         {
03488         AddReferencesItem ref;
03489         ref.IsForward = true;
03490         ref.ReferenceTypeId = ToNodeId("i=52");
03491         ref.SourceNodeId = ToNodeId("i=2945");
03492         ref.TargetNodeClass = NodeClass::DataType;
03493         ref.TargetNodeId = ToNodeId("i=2932");
03494         refs.push_back(ref);
03495         }
03496         {
03497         AddReferencesItem ref;
03498         ref.IsForward = true;
03499         ref.ReferenceTypeId = ToNodeId("i=54");
03500         ref.SourceNodeId = ToNodeId("i=2945");
03501         ref.TargetNodeClass = NodeClass::DataType;
03502         ref.TargetNodeId = ToNodeId("i=2915");
03503         refs.push_back(ref);
03504         }
03505         {
03506         AddReferencesItem ref;
03507         ref.IsForward = true;
03508         ref.ReferenceTypeId = ToNodeId("i=53");
03509         ref.SourceNodeId = ToNodeId("i=2945");
03510         ref.TargetNodeClass = NodeClass::DataType;
03511         ref.TargetNodeId = ToNodeId("i=2949");
03512         refs.push_back(ref);
03513         }
03514         registry.AddReferences(refs);
03515         }
03516        
03517         {
03518         AddNodesItem node;
03519         node.RequestedNewNodeId = ToNodeId("i=11327");
03520         node.BrowseName = ToQualifiedName("TransitionNumber");
03521         node.Class = NodeClass::Variable;
03522         node.ParentNodeId = ToNodeId("i=2945");
03523         node.ReferenceTypeId = ReferenceId::HasProperty;
03524         node.TypeDefinition = ToNodeId("i=68");
03525         VariableAttributes attrs;
03526         attrs.DisplayName = LocalizedText("TransitionNumber");
03527         attrs.Type = ObjectId::UInt32;
03528         attrs.Rank = -1;
03529         node.Attributes = attrs;
03530         registry.AddNodes(std::vector<AddNodesItem>{node});
03531         std::vector<AddReferencesItem> refs;
03532         {
03533         AddReferencesItem ref;
03534         ref.IsForward = true;
03535         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03536         ref.SourceNodeId = ToNodeId("i=11327");
03537         ref.TargetNodeClass = NodeClass::DataType;
03538         ref.TargetNodeId = ToNodeId("i=78");
03539         refs.push_back(ref);
03540         }
03541         registry.AddReferences(refs);
03542         }
03543        
03544         {
03545         AddNodesItem node;
03546         node.RequestedNewNodeId = ToNodeId("i=2991");
03547         node.BrowseName = ToQualifiedName("InputArguments");
03548         node.Class = NodeClass::Variable;
03549         node.ParentNodeId = ToNodeId("i=2949");
03550         node.ReferenceTypeId = ReferenceId::HasProperty;
03551         node.TypeDefinition = ToNodeId("i=68");
03552         VariableAttributes attrs;
03553         attrs.DisplayName = LocalizedText("InputArguments");
03554         attrs.Type = ToNodeId("i=296");
03555         attrs.Rank = 1;
03556         node.Attributes = attrs;
03557         registry.AddNodes(std::vector<AddNodesItem>{node});
03558         std::vector<AddReferencesItem> refs;
03559         {
03560         AddReferencesItem ref;
03561         ref.IsForward = true;
03562         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03563         ref.SourceNodeId = ToNodeId("i=2991");
03564         ref.TargetNodeClass = NodeClass::DataType;
03565         ref.TargetNodeId = ToNodeId("i=78");
03566         refs.push_back(ref);
03567         }
03568         registry.AddReferences(refs);
03569         }
03570        
03571         {
03572         AddNodesItem node;
03573         node.RequestedNewNodeId = ToNodeId("i=2955");
03574         node.BrowseName = ToQualifiedName("LimitAlarmType");
03575         node.Class = NodeClass::ObjectType;
03576         node.ParentNodeId = ToNodeId("i=2915");
03577         node.ReferenceTypeId = ReferenceId::HasSubtype;
03578         ObjectTypeAttributes attrs;
03579         attrs.DisplayName = LocalizedText("LimitAlarmType");
03580         attrs.IsAbstract = false;
03581         node.Attributes = attrs;
03582         registry.AddNodes(std::vector<AddNodesItem>{node});
03583         std::vector<AddReferencesItem> refs;
03584         {
03585         AddReferencesItem ref;
03586         ref.IsForward = true;
03587         ref.ReferenceTypeId = ReferenceId::HasProperty;
03588         ref.SourceNodeId = ToNodeId("i=2955");
03589         ref.TargetNodeClass = NodeClass::DataType;
03590         ref.TargetNodeId = ToNodeId("i=11124");
03591         refs.push_back(ref);
03592         }
03593         {
03594         AddReferencesItem ref;
03595         ref.IsForward = true;
03596         ref.ReferenceTypeId = ReferenceId::HasProperty;
03597         ref.SourceNodeId = ToNodeId("i=2955");
03598         ref.TargetNodeClass = NodeClass::DataType;
03599         ref.TargetNodeId = ToNodeId("i=11125");
03600         refs.push_back(ref);
03601         }
03602         {
03603         AddReferencesItem ref;
03604         ref.IsForward = true;
03605         ref.ReferenceTypeId = ReferenceId::HasProperty;
03606         ref.SourceNodeId = ToNodeId("i=2955");
03607         ref.TargetNodeClass = NodeClass::DataType;
03608         ref.TargetNodeId = ToNodeId("i=11126");
03609         refs.push_back(ref);
03610         }
03611         {
03612         AddReferencesItem ref;
03613         ref.IsForward = true;
03614         ref.ReferenceTypeId = ReferenceId::HasProperty;
03615         ref.SourceNodeId = ToNodeId("i=2955");
03616         ref.TargetNodeClass = NodeClass::DataType;
03617         ref.TargetNodeId = ToNodeId("i=11127");
03618         refs.push_back(ref);
03619         }
03620         registry.AddReferences(refs);
03621         }
03622        
03623         {
03624         AddNodesItem node;
03625         node.RequestedNewNodeId = ToNodeId("i=11124");
03626         node.BrowseName = ToQualifiedName("HighHighLimit");
03627         node.Class = NodeClass::Variable;
03628         node.ParentNodeId = ToNodeId("i=2955");
03629         node.ReferenceTypeId = ReferenceId::HasProperty;
03630         node.TypeDefinition = ToNodeId("i=68");
03631         VariableAttributes attrs;
03632         attrs.DisplayName = LocalizedText("HighHighLimit");
03633         attrs.Type = ObjectId::Double;
03634         attrs.Rank = -1;
03635         node.Attributes = attrs;
03636         registry.AddNodes(std::vector<AddNodesItem>{node});
03637         std::vector<AddReferencesItem> refs;
03638         {
03639         AddReferencesItem ref;
03640         ref.IsForward = true;
03641         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03642         ref.SourceNodeId = ToNodeId("i=11124");
03643         ref.TargetNodeClass = NodeClass::DataType;
03644         ref.TargetNodeId = ToNodeId("i=80");
03645         refs.push_back(ref);
03646         }
03647         registry.AddReferences(refs);
03648         }
03649        
03650         {
03651         AddNodesItem node;
03652         node.RequestedNewNodeId = ToNodeId("i=11125");
03653         node.BrowseName = ToQualifiedName("HighLimit");
03654         node.Class = NodeClass::Variable;
03655         node.ParentNodeId = ToNodeId("i=2955");
03656         node.ReferenceTypeId = ReferenceId::HasProperty;
03657         node.TypeDefinition = ToNodeId("i=68");
03658         VariableAttributes attrs;
03659         attrs.DisplayName = LocalizedText("HighLimit");
03660         attrs.Type = ObjectId::Double;
03661         attrs.Rank = -1;
03662         node.Attributes = attrs;
03663         registry.AddNodes(std::vector<AddNodesItem>{node});
03664         std::vector<AddReferencesItem> refs;
03665         {
03666         AddReferencesItem ref;
03667         ref.IsForward = true;
03668         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03669         ref.SourceNodeId = ToNodeId("i=11125");
03670         ref.TargetNodeClass = NodeClass::DataType;
03671         ref.TargetNodeId = ToNodeId("i=80");
03672         refs.push_back(ref);
03673         }
03674         registry.AddReferences(refs);
03675         }
03676        
03677         {
03678         AddNodesItem node;
03679         node.RequestedNewNodeId = ToNodeId("i=11126");
03680         node.BrowseName = ToQualifiedName("LowLimit");
03681         node.Class = NodeClass::Variable;
03682         node.ParentNodeId = ToNodeId("i=2955");
03683         node.ReferenceTypeId = ReferenceId::HasProperty;
03684         node.TypeDefinition = ToNodeId("i=68");
03685         VariableAttributes attrs;
03686         attrs.DisplayName = LocalizedText("LowLimit");
03687         attrs.Type = ObjectId::Double;
03688         attrs.Rank = -1;
03689         node.Attributes = attrs;
03690         registry.AddNodes(std::vector<AddNodesItem>{node});
03691         std::vector<AddReferencesItem> refs;
03692         {
03693         AddReferencesItem ref;
03694         ref.IsForward = true;
03695         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03696         ref.SourceNodeId = ToNodeId("i=11126");
03697         ref.TargetNodeClass = NodeClass::DataType;
03698         ref.TargetNodeId = ToNodeId("i=80");
03699         refs.push_back(ref);
03700         }
03701         registry.AddReferences(refs);
03702         }
03703        
03704         {
03705         AddNodesItem node;
03706         node.RequestedNewNodeId = ToNodeId("i=11127");
03707         node.BrowseName = ToQualifiedName("LowLowLimit");
03708         node.Class = NodeClass::Variable;
03709         node.ParentNodeId = ToNodeId("i=2955");
03710         node.ReferenceTypeId = ReferenceId::HasProperty;
03711         node.TypeDefinition = ToNodeId("i=68");
03712         VariableAttributes attrs;
03713         attrs.DisplayName = LocalizedText("LowLowLimit");
03714         attrs.Type = ObjectId::Double;
03715         attrs.Rank = -1;
03716         node.Attributes = attrs;
03717         registry.AddNodes(std::vector<AddNodesItem>{node});
03718         std::vector<AddReferencesItem> refs;
03719         {
03720         AddReferencesItem ref;
03721         ref.IsForward = true;
03722         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03723         ref.SourceNodeId = ToNodeId("i=11127");
03724         ref.TargetNodeClass = NodeClass::DataType;
03725         ref.TargetNodeId = ToNodeId("i=80");
03726         refs.push_back(ref);
03727         }
03728         registry.AddReferences(refs);
03729         }
03730        
03731         {
03732         AddNodesItem node;
03733         node.RequestedNewNodeId = ToNodeId("i=9318");
03734         node.BrowseName = ToQualifiedName("ExclusiveLimitStateMachineType");
03735         node.Class = NodeClass::ObjectType;
03736         node.ParentNodeId = ToNodeId("i=2771");
03737         node.ReferenceTypeId = ReferenceId::HasSubtype;
03738         ObjectTypeAttributes attrs;
03739         attrs.DisplayName = LocalizedText("ExclusiveLimitStateMachineType");
03740         attrs.IsAbstract = false;
03741         node.Attributes = attrs;
03742         registry.AddNodes(std::vector<AddNodesItem>{node});
03743         std::vector<AddReferencesItem> refs;
03744         {
03745         AddReferencesItem ref;
03746         ref.IsForward = true;
03747         ref.ReferenceTypeId = ReferenceId::HasComponent;
03748         ref.SourceNodeId = ToNodeId("i=9318");
03749         ref.TargetNodeClass = NodeClass::DataType;
03750         ref.TargetNodeId = ToNodeId("i=9329");
03751         refs.push_back(ref);
03752         }
03753         {
03754         AddReferencesItem ref;
03755         ref.IsForward = true;
03756         ref.ReferenceTypeId = ReferenceId::HasComponent;
03757         ref.SourceNodeId = ToNodeId("i=9318");
03758         ref.TargetNodeClass = NodeClass::DataType;
03759         ref.TargetNodeId = ToNodeId("i=9331");
03760         refs.push_back(ref);
03761         }
03762         {
03763         AddReferencesItem ref;
03764         ref.IsForward = true;
03765         ref.ReferenceTypeId = ReferenceId::HasComponent;
03766         ref.SourceNodeId = ToNodeId("i=9318");
03767         ref.TargetNodeClass = NodeClass::DataType;
03768         ref.TargetNodeId = ToNodeId("i=9333");
03769         refs.push_back(ref);
03770         }
03771         {
03772         AddReferencesItem ref;
03773         ref.IsForward = true;
03774         ref.ReferenceTypeId = ReferenceId::HasComponent;
03775         ref.SourceNodeId = ToNodeId("i=9318");
03776         ref.TargetNodeClass = NodeClass::DataType;
03777         ref.TargetNodeId = ToNodeId("i=9335");
03778         refs.push_back(ref);
03779         }
03780         {
03781         AddReferencesItem ref;
03782         ref.IsForward = true;
03783         ref.ReferenceTypeId = ReferenceId::HasComponent;
03784         ref.SourceNodeId = ToNodeId("i=9318");
03785         ref.TargetNodeClass = NodeClass::DataType;
03786         ref.TargetNodeId = ToNodeId("i=9337");
03787         refs.push_back(ref);
03788         }
03789         {
03790         AddReferencesItem ref;
03791         ref.IsForward = true;
03792         ref.ReferenceTypeId = ReferenceId::HasComponent;
03793         ref.SourceNodeId = ToNodeId("i=9318");
03794         ref.TargetNodeClass = NodeClass::DataType;
03795         ref.TargetNodeId = ToNodeId("i=9338");
03796         refs.push_back(ref);
03797         }
03798         {
03799         AddReferencesItem ref;
03800         ref.IsForward = true;
03801         ref.ReferenceTypeId = ReferenceId::HasComponent;
03802         ref.SourceNodeId = ToNodeId("i=9318");
03803         ref.TargetNodeClass = NodeClass::DataType;
03804         ref.TargetNodeId = ToNodeId("i=9339");
03805         refs.push_back(ref);
03806         }
03807         {
03808         AddReferencesItem ref;
03809         ref.IsForward = true;
03810         ref.ReferenceTypeId = ReferenceId::HasComponent;
03811         ref.SourceNodeId = ToNodeId("i=9318");
03812         ref.TargetNodeClass = NodeClass::DataType;
03813         ref.TargetNodeId = ToNodeId("i=9340");
03814         refs.push_back(ref);
03815         }
03816         registry.AddReferences(refs);
03817         }
03818        
03819         {
03820         AddNodesItem node;
03821         node.RequestedNewNodeId = ToNodeId("i=9329");
03822         node.BrowseName = ToQualifiedName("HighHigh");
03823         node.Class = NodeClass::Object;
03824         node.ParentNodeId = ToNodeId("i=9318");
03825         node.ReferenceTypeId = ReferenceId::HasComponent;
03826         node.TypeDefinition = ToNodeId("i=2307");
03827         ObjectAttributes attrs;
03828         attrs.DisplayName = LocalizedText("HighHigh");
03829         attrs.EventNotifier = 0;
03830         node.Attributes = attrs;
03831         registry.AddNodes(std::vector<AddNodesItem>{node});
03832         std::vector<AddReferencesItem> refs;
03833         {
03834         AddReferencesItem ref;
03835         ref.IsForward = true;
03836         ref.ReferenceTypeId = ReferenceId::HasProperty;
03837         ref.SourceNodeId = ToNodeId("i=9329");
03838         ref.TargetNodeClass = NodeClass::DataType;
03839         ref.TargetNodeId = ToNodeId("i=9330");
03840         refs.push_back(ref);
03841         }
03842         registry.AddReferences(refs);
03843         }
03844        
03845         {
03846         AddNodesItem node;
03847         node.RequestedNewNodeId = ToNodeId("i=9330");
03848         node.BrowseName = ToQualifiedName("StateNumber");
03849         node.Class = NodeClass::Variable;
03850         node.ParentNodeId = ToNodeId("i=9329");
03851         node.ReferenceTypeId = ReferenceId::HasProperty;
03852         node.TypeDefinition = ToNodeId("i=68");
03853         VariableAttributes attrs;
03854         attrs.DisplayName = LocalizedText("StateNumber");
03855         attrs.Type = ObjectId::UInt32;
03856         attrs.Rank = -1;
03857         node.Attributes = attrs;
03858         registry.AddNodes(std::vector<AddNodesItem>{node});
03859         std::vector<AddReferencesItem> refs;
03860         {
03861         AddReferencesItem ref;
03862         ref.IsForward = true;
03863         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03864         ref.SourceNodeId = ToNodeId("i=9330");
03865         ref.TargetNodeClass = NodeClass::DataType;
03866         ref.TargetNodeId = ToNodeId("i=78");
03867         refs.push_back(ref);
03868         }
03869         registry.AddReferences(refs);
03870         }
03871        
03872         {
03873         AddNodesItem node;
03874         node.RequestedNewNodeId = ToNodeId("i=9331");
03875         node.BrowseName = ToQualifiedName("High");
03876         node.Class = NodeClass::Object;
03877         node.ParentNodeId = ToNodeId("i=9318");
03878         node.ReferenceTypeId = ReferenceId::HasComponent;
03879         node.TypeDefinition = ToNodeId("i=2307");
03880         ObjectAttributes attrs;
03881         attrs.DisplayName = LocalizedText("High");
03882         attrs.EventNotifier = 0;
03883         node.Attributes = attrs;
03884         registry.AddNodes(std::vector<AddNodesItem>{node});
03885         std::vector<AddReferencesItem> refs;
03886         {
03887         AddReferencesItem ref;
03888         ref.IsForward = true;
03889         ref.ReferenceTypeId = ReferenceId::HasProperty;
03890         ref.SourceNodeId = ToNodeId("i=9331");
03891         ref.TargetNodeClass = NodeClass::DataType;
03892         ref.TargetNodeId = ToNodeId("i=9332");
03893         refs.push_back(ref);
03894         }
03895         registry.AddReferences(refs);
03896         }
03897        
03898         {
03899         AddNodesItem node;
03900         node.RequestedNewNodeId = ToNodeId("i=9332");
03901         node.BrowseName = ToQualifiedName("StateNumber");
03902         node.Class = NodeClass::Variable;
03903         node.ParentNodeId = ToNodeId("i=9331");
03904         node.ReferenceTypeId = ReferenceId::HasProperty;
03905         node.TypeDefinition = ToNodeId("i=68");
03906         VariableAttributes attrs;
03907         attrs.DisplayName = LocalizedText("StateNumber");
03908         attrs.Type = ObjectId::UInt32;
03909         attrs.Rank = -1;
03910         node.Attributes = attrs;
03911         registry.AddNodes(std::vector<AddNodesItem>{node});
03912         std::vector<AddReferencesItem> refs;
03913         {
03914         AddReferencesItem ref;
03915         ref.IsForward = true;
03916         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03917         ref.SourceNodeId = ToNodeId("i=9332");
03918         ref.TargetNodeClass = NodeClass::DataType;
03919         ref.TargetNodeId = ToNodeId("i=78");
03920         refs.push_back(ref);
03921         }
03922         registry.AddReferences(refs);
03923         }
03924        
03925         {
03926         AddNodesItem node;
03927         node.RequestedNewNodeId = ToNodeId("i=9333");
03928         node.BrowseName = ToQualifiedName("Low");
03929         node.Class = NodeClass::Object;
03930         node.ParentNodeId = ToNodeId("i=9318");
03931         node.ReferenceTypeId = ReferenceId::HasComponent;
03932         node.TypeDefinition = ToNodeId("i=2307");
03933         ObjectAttributes attrs;
03934         attrs.DisplayName = LocalizedText("Low");
03935         attrs.EventNotifier = 0;
03936         node.Attributes = attrs;
03937         registry.AddNodes(std::vector<AddNodesItem>{node});
03938         std::vector<AddReferencesItem> refs;
03939         {
03940         AddReferencesItem ref;
03941         ref.IsForward = true;
03942         ref.ReferenceTypeId = ReferenceId::HasProperty;
03943         ref.SourceNodeId = ToNodeId("i=9333");
03944         ref.TargetNodeClass = NodeClass::DataType;
03945         ref.TargetNodeId = ToNodeId("i=9334");
03946         refs.push_back(ref);
03947         }
03948         registry.AddReferences(refs);
03949         }
03950        
03951         {
03952         AddNodesItem node;
03953         node.RequestedNewNodeId = ToNodeId("i=9334");
03954         node.BrowseName = ToQualifiedName("StateNumber");
03955         node.Class = NodeClass::Variable;
03956         node.ParentNodeId = ToNodeId("i=9333");
03957         node.ReferenceTypeId = ReferenceId::HasProperty;
03958         node.TypeDefinition = ToNodeId("i=68");
03959         VariableAttributes attrs;
03960         attrs.DisplayName = LocalizedText("StateNumber");
03961         attrs.Type = ObjectId::UInt32;
03962         attrs.Rank = -1;
03963         node.Attributes = attrs;
03964         registry.AddNodes(std::vector<AddNodesItem>{node});
03965         std::vector<AddReferencesItem> refs;
03966         {
03967         AddReferencesItem ref;
03968         ref.IsForward = true;
03969         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
03970         ref.SourceNodeId = ToNodeId("i=9334");
03971         ref.TargetNodeClass = NodeClass::DataType;
03972         ref.TargetNodeId = ToNodeId("i=78");
03973         refs.push_back(ref);
03974         }
03975         registry.AddReferences(refs);
03976         }
03977        
03978         {
03979         AddNodesItem node;
03980         node.RequestedNewNodeId = ToNodeId("i=9335");
03981         node.BrowseName = ToQualifiedName("LowLow");
03982         node.Class = NodeClass::Object;
03983         node.ParentNodeId = ToNodeId("i=9318");
03984         node.ReferenceTypeId = ReferenceId::HasComponent;
03985         node.TypeDefinition = ToNodeId("i=2307");
03986         ObjectAttributes attrs;
03987         attrs.DisplayName = LocalizedText("LowLow");
03988         attrs.EventNotifier = 0;
03989         node.Attributes = attrs;
03990         registry.AddNodes(std::vector<AddNodesItem>{node});
03991         std::vector<AddReferencesItem> refs;
03992         {
03993         AddReferencesItem ref;
03994         ref.IsForward = true;
03995         ref.ReferenceTypeId = ReferenceId::HasProperty;
03996         ref.SourceNodeId = ToNodeId("i=9335");
03997         ref.TargetNodeClass = NodeClass::DataType;
03998         ref.TargetNodeId = ToNodeId("i=9336");
03999         refs.push_back(ref);
04000         }
04001         registry.AddReferences(refs);
04002         }
04003        
04004         {
04005         AddNodesItem node;
04006         node.RequestedNewNodeId = ToNodeId("i=9336");
04007         node.BrowseName = ToQualifiedName("StateNumber");
04008         node.Class = NodeClass::Variable;
04009         node.ParentNodeId = ToNodeId("i=9335");
04010         node.ReferenceTypeId = ReferenceId::HasProperty;
04011         node.TypeDefinition = ToNodeId("i=68");
04012         VariableAttributes attrs;
04013         attrs.DisplayName = LocalizedText("StateNumber");
04014         attrs.Type = ObjectId::UInt32;
04015         attrs.Rank = -1;
04016         node.Attributes = attrs;
04017         registry.AddNodes(std::vector<AddNodesItem>{node});
04018         std::vector<AddReferencesItem> refs;
04019         {
04020         AddReferencesItem ref;
04021         ref.IsForward = true;
04022         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04023         ref.SourceNodeId = ToNodeId("i=9336");
04024         ref.TargetNodeClass = NodeClass::DataType;
04025         ref.TargetNodeId = ToNodeId("i=78");
04026         refs.push_back(ref);
04027         }
04028         registry.AddReferences(refs);
04029         }
04030        
04031         {
04032         AddNodesItem node;
04033         node.RequestedNewNodeId = ToNodeId("i=9337");
04034         node.BrowseName = ToQualifiedName("LowLowToLow");
04035         node.Class = NodeClass::Object;
04036         node.ParentNodeId = ToNodeId("i=9318");
04037         node.ReferenceTypeId = ReferenceId::HasComponent;
04038         node.TypeDefinition = ToNodeId("i=2310");
04039         ObjectAttributes attrs;
04040         attrs.DisplayName = LocalizedText("LowLowToLow");
04041         attrs.EventNotifier = 0;
04042         node.Attributes = attrs;
04043         registry.AddNodes(std::vector<AddNodesItem>{node});
04044         std::vector<AddReferencesItem> refs;
04045         {
04046         AddReferencesItem ref;
04047         ref.IsForward = true;
04048         ref.ReferenceTypeId = ReferenceId::HasProperty;
04049         ref.SourceNodeId = ToNodeId("i=9337");
04050         ref.TargetNodeClass = NodeClass::DataType;
04051         ref.TargetNodeId = ToNodeId("i=11340");
04052         refs.push_back(ref);
04053         }
04054         {
04055         AddReferencesItem ref;
04056         ref.IsForward = true;
04057         ref.ReferenceTypeId = ToNodeId("i=51");
04058         ref.SourceNodeId = ToNodeId("i=9337");
04059         ref.TargetNodeClass = NodeClass::DataType;
04060         ref.TargetNodeId = ToNodeId("i=9335");
04061         refs.push_back(ref);
04062         }
04063         {
04064         AddReferencesItem ref;
04065         ref.IsForward = true;
04066         ref.ReferenceTypeId = ToNodeId("i=52");
04067         ref.SourceNodeId = ToNodeId("i=9337");
04068         ref.TargetNodeClass = NodeClass::DataType;
04069         ref.TargetNodeId = ToNodeId("i=9333");
04070         refs.push_back(ref);
04071         }
04072         registry.AddReferences(refs);
04073         }
04074        
04075         {
04076         AddNodesItem node;
04077         node.RequestedNewNodeId = ToNodeId("i=11340");
04078         node.BrowseName = ToQualifiedName("TransitionNumber");
04079         node.Class = NodeClass::Variable;
04080         node.ParentNodeId = ToNodeId("i=9337");
04081         node.ReferenceTypeId = ReferenceId::HasProperty;
04082         node.TypeDefinition = ToNodeId("i=68");
04083         VariableAttributes attrs;
04084         attrs.DisplayName = LocalizedText("TransitionNumber");
04085         attrs.Type = ObjectId::UInt32;
04086         attrs.Rank = -1;
04087         node.Attributes = attrs;
04088         registry.AddNodes(std::vector<AddNodesItem>{node});
04089         std::vector<AddReferencesItem> refs;
04090         {
04091         AddReferencesItem ref;
04092         ref.IsForward = true;
04093         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04094         ref.SourceNodeId = ToNodeId("i=11340");
04095         ref.TargetNodeClass = NodeClass::DataType;
04096         ref.TargetNodeId = ToNodeId("i=78");
04097         refs.push_back(ref);
04098         }
04099         registry.AddReferences(refs);
04100         }
04101        
04102         {
04103         AddNodesItem node;
04104         node.RequestedNewNodeId = ToNodeId("i=9338");
04105         node.BrowseName = ToQualifiedName("LowToLowLow");
04106         node.Class = NodeClass::Object;
04107         node.ParentNodeId = ToNodeId("i=9318");
04108         node.ReferenceTypeId = ReferenceId::HasComponent;
04109         node.TypeDefinition = ToNodeId("i=2310");
04110         ObjectAttributes attrs;
04111         attrs.DisplayName = LocalizedText("LowToLowLow");
04112         attrs.EventNotifier = 0;
04113         node.Attributes = attrs;
04114         registry.AddNodes(std::vector<AddNodesItem>{node});
04115         std::vector<AddReferencesItem> refs;
04116         {
04117         AddReferencesItem ref;
04118         ref.IsForward = true;
04119         ref.ReferenceTypeId = ReferenceId::HasProperty;
04120         ref.SourceNodeId = ToNodeId("i=9338");
04121         ref.TargetNodeClass = NodeClass::DataType;
04122         ref.TargetNodeId = ToNodeId("i=11341");
04123         refs.push_back(ref);
04124         }
04125         {
04126         AddReferencesItem ref;
04127         ref.IsForward = true;
04128         ref.ReferenceTypeId = ToNodeId("i=51");
04129         ref.SourceNodeId = ToNodeId("i=9338");
04130         ref.TargetNodeClass = NodeClass::DataType;
04131         ref.TargetNodeId = ToNodeId("i=9333");
04132         refs.push_back(ref);
04133         }
04134         {
04135         AddReferencesItem ref;
04136         ref.IsForward = true;
04137         ref.ReferenceTypeId = ToNodeId("i=52");
04138         ref.SourceNodeId = ToNodeId("i=9338");
04139         ref.TargetNodeClass = NodeClass::DataType;
04140         ref.TargetNodeId = ToNodeId("i=9335");
04141         refs.push_back(ref);
04142         }
04143         registry.AddReferences(refs);
04144         }
04145        
04146         {
04147         AddNodesItem node;
04148         node.RequestedNewNodeId = ToNodeId("i=11341");
04149         node.BrowseName = ToQualifiedName("TransitionNumber");
04150         node.Class = NodeClass::Variable;
04151         node.ParentNodeId = ToNodeId("i=9338");
04152         node.ReferenceTypeId = ReferenceId::HasProperty;
04153         node.TypeDefinition = ToNodeId("i=68");
04154         VariableAttributes attrs;
04155         attrs.DisplayName = LocalizedText("TransitionNumber");
04156         attrs.Type = ObjectId::UInt32;
04157         attrs.Rank = -1;
04158         node.Attributes = attrs;
04159         registry.AddNodes(std::vector<AddNodesItem>{node});
04160         std::vector<AddReferencesItem> refs;
04161         {
04162         AddReferencesItem ref;
04163         ref.IsForward = true;
04164         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04165         ref.SourceNodeId = ToNodeId("i=11341");
04166         ref.TargetNodeClass = NodeClass::DataType;
04167         ref.TargetNodeId = ToNodeId("i=78");
04168         refs.push_back(ref);
04169         }
04170         registry.AddReferences(refs);
04171         }
04172        
04173         {
04174         AddNodesItem node;
04175         node.RequestedNewNodeId = ToNodeId("i=9339");
04176         node.BrowseName = ToQualifiedName("HighHighToHigh");
04177         node.Class = NodeClass::Object;
04178         node.ParentNodeId = ToNodeId("i=9318");
04179         node.ReferenceTypeId = ReferenceId::HasComponent;
04180         node.TypeDefinition = ToNodeId("i=2310");
04181         ObjectAttributes attrs;
04182         attrs.DisplayName = LocalizedText("HighHighToHigh");
04183         attrs.EventNotifier = 0;
04184         node.Attributes = attrs;
04185         registry.AddNodes(std::vector<AddNodesItem>{node});
04186         std::vector<AddReferencesItem> refs;
04187         {
04188         AddReferencesItem ref;
04189         ref.IsForward = true;
04190         ref.ReferenceTypeId = ReferenceId::HasProperty;
04191         ref.SourceNodeId = ToNodeId("i=9339");
04192         ref.TargetNodeClass = NodeClass::DataType;
04193         ref.TargetNodeId = ToNodeId("i=11342");
04194         refs.push_back(ref);
04195         }
04196         {
04197         AddReferencesItem ref;
04198         ref.IsForward = true;
04199         ref.ReferenceTypeId = ToNodeId("i=51");
04200         ref.SourceNodeId = ToNodeId("i=9339");
04201         ref.TargetNodeClass = NodeClass::DataType;
04202         ref.TargetNodeId = ToNodeId("i=9329");
04203         refs.push_back(ref);
04204         }
04205         {
04206         AddReferencesItem ref;
04207         ref.IsForward = true;
04208         ref.ReferenceTypeId = ToNodeId("i=52");
04209         ref.SourceNodeId = ToNodeId("i=9339");
04210         ref.TargetNodeClass = NodeClass::DataType;
04211         ref.TargetNodeId = ToNodeId("i=9331");
04212         refs.push_back(ref);
04213         }
04214         registry.AddReferences(refs);
04215         }
04216        
04217         {
04218         AddNodesItem node;
04219         node.RequestedNewNodeId = ToNodeId("i=11342");
04220         node.BrowseName = ToQualifiedName("TransitionNumber");
04221         node.Class = NodeClass::Variable;
04222         node.ParentNodeId = ToNodeId("i=9339");
04223         node.ReferenceTypeId = ReferenceId::HasProperty;
04224         node.TypeDefinition = ToNodeId("i=68");
04225         VariableAttributes attrs;
04226         attrs.DisplayName = LocalizedText("TransitionNumber");
04227         attrs.Type = ObjectId::UInt32;
04228         attrs.Rank = -1;
04229         node.Attributes = attrs;
04230         registry.AddNodes(std::vector<AddNodesItem>{node});
04231         std::vector<AddReferencesItem> refs;
04232         {
04233         AddReferencesItem ref;
04234         ref.IsForward = true;
04235         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04236         ref.SourceNodeId = ToNodeId("i=11342");
04237         ref.TargetNodeClass = NodeClass::DataType;
04238         ref.TargetNodeId = ToNodeId("i=78");
04239         refs.push_back(ref);
04240         }
04241         registry.AddReferences(refs);
04242         }
04243        
04244         {
04245         AddNodesItem node;
04246         node.RequestedNewNodeId = ToNodeId("i=9340");
04247         node.BrowseName = ToQualifiedName("HighToHighHigh");
04248         node.Class = NodeClass::Object;
04249         node.ParentNodeId = ToNodeId("i=9318");
04250         node.ReferenceTypeId = ReferenceId::HasComponent;
04251         node.TypeDefinition = ToNodeId("i=2310");
04252         ObjectAttributes attrs;
04253         attrs.DisplayName = LocalizedText("HighToHighHigh");
04254         attrs.EventNotifier = 0;
04255         node.Attributes = attrs;
04256         registry.AddNodes(std::vector<AddNodesItem>{node});
04257         std::vector<AddReferencesItem> refs;
04258         {
04259         AddReferencesItem ref;
04260         ref.IsForward = true;
04261         ref.ReferenceTypeId = ReferenceId::HasProperty;
04262         ref.SourceNodeId = ToNodeId("i=9340");
04263         ref.TargetNodeClass = NodeClass::DataType;
04264         ref.TargetNodeId = ToNodeId("i=11343");
04265         refs.push_back(ref);
04266         }
04267         {
04268         AddReferencesItem ref;
04269         ref.IsForward = true;
04270         ref.ReferenceTypeId = ToNodeId("i=51");
04271         ref.SourceNodeId = ToNodeId("i=9340");
04272         ref.TargetNodeClass = NodeClass::DataType;
04273         ref.TargetNodeId = ToNodeId("i=9331");
04274         refs.push_back(ref);
04275         }
04276         {
04277         AddReferencesItem ref;
04278         ref.IsForward = true;
04279         ref.ReferenceTypeId = ToNodeId("i=52");
04280         ref.SourceNodeId = ToNodeId("i=9340");
04281         ref.TargetNodeClass = NodeClass::DataType;
04282         ref.TargetNodeId = ToNodeId("i=9329");
04283         refs.push_back(ref);
04284         }
04285         registry.AddReferences(refs);
04286         }
04287        
04288         {
04289         AddNodesItem node;
04290         node.RequestedNewNodeId = ToNodeId("i=11343");
04291         node.BrowseName = ToQualifiedName("TransitionNumber");
04292         node.Class = NodeClass::Variable;
04293         node.ParentNodeId = ToNodeId("i=9340");
04294         node.ReferenceTypeId = ReferenceId::HasProperty;
04295         node.TypeDefinition = ToNodeId("i=68");
04296         VariableAttributes attrs;
04297         attrs.DisplayName = LocalizedText("TransitionNumber");
04298         attrs.Type = ObjectId::UInt32;
04299         attrs.Rank = -1;
04300         node.Attributes = attrs;
04301         registry.AddNodes(std::vector<AddNodesItem>{node});
04302         std::vector<AddReferencesItem> refs;
04303         {
04304         AddReferencesItem ref;
04305         ref.IsForward = true;
04306         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04307         ref.SourceNodeId = ToNodeId("i=11343");
04308         ref.TargetNodeClass = NodeClass::DataType;
04309         ref.TargetNodeId = ToNodeId("i=78");
04310         refs.push_back(ref);
04311         }
04312         registry.AddReferences(refs);
04313         }
04314        
04315         {
04316         AddNodesItem node;
04317         node.RequestedNewNodeId = ToNodeId("i=9341");
04318         node.BrowseName = ToQualifiedName("ExclusiveLimitAlarmType");
04319         node.Class = NodeClass::ObjectType;
04320         node.ParentNodeId = ToNodeId("i=2955");
04321         node.ReferenceTypeId = ReferenceId::HasSubtype;
04322         ObjectTypeAttributes attrs;
04323         attrs.DisplayName = LocalizedText("ExclusiveLimitAlarmType");
04324         attrs.IsAbstract = false;
04325         node.Attributes = attrs;
04326         registry.AddNodes(std::vector<AddNodesItem>{node});
04327         std::vector<AddReferencesItem> refs;
04328         {
04329         AddReferencesItem ref;
04330         ref.IsForward = true;
04331         ref.ReferenceTypeId = ReferenceId::HasComponent;
04332         ref.SourceNodeId = ToNodeId("i=9341");
04333         ref.TargetNodeClass = NodeClass::DataType;
04334         ref.TargetNodeId = ToNodeId("i=9398");
04335         refs.push_back(ref);
04336         }
04337         {
04338         AddReferencesItem ref;
04339         ref.IsForward = true;
04340         ref.ReferenceTypeId = ReferenceId::HasComponent;
04341         ref.SourceNodeId = ToNodeId("i=9341");
04342         ref.TargetNodeClass = NodeClass::DataType;
04343         ref.TargetNodeId = ToNodeId("i=9455");
04344         refs.push_back(ref);
04345         }
04346         registry.AddReferences(refs);
04347         }
04348        
04349         {
04350         AddNodesItem node;
04351         node.RequestedNewNodeId = ToNodeId("i=9398");
04352         node.BrowseName = ToQualifiedName("ActiveState");
04353         node.Class = NodeClass::Variable;
04354         node.ParentNodeId = ToNodeId("i=9341");
04355         node.ReferenceTypeId = ReferenceId::HasComponent;
04356         node.TypeDefinition = ToNodeId("i=8995");
04357         VariableAttributes attrs;
04358         attrs.DisplayName = LocalizedText("ActiveState");
04359         attrs.Type = ObjectId::LocalizedText;
04360         attrs.Rank = -1;
04361         node.Attributes = attrs;
04362         registry.AddNodes(std::vector<AddNodesItem>{node});
04363         std::vector<AddReferencesItem> refs;
04364         {
04365         AddReferencesItem ref;
04366         ref.IsForward = true;
04367         ref.ReferenceTypeId = ReferenceId::HasProperty;
04368         ref.SourceNodeId = ToNodeId("i=9398");
04369         ref.TargetNodeClass = NodeClass::DataType;
04370         ref.TargetNodeId = ToNodeId("i=9399");
04371         refs.push_back(ref);
04372         }
04373         {
04374         AddReferencesItem ref;
04375         ref.IsForward = true;
04376         ref.ReferenceTypeId = ToNodeId("i=9004");
04377         ref.SourceNodeId = ToNodeId("i=9398");
04378         ref.TargetNodeClass = NodeClass::DataType;
04379         ref.TargetNodeId = ToNodeId("i=9455");
04380         refs.push_back(ref);
04381         }
04382         {
04383         AddReferencesItem ref;
04384         ref.IsForward = true;
04385         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04386         ref.SourceNodeId = ToNodeId("i=9398");
04387         ref.TargetNodeClass = NodeClass::DataType;
04388         ref.TargetNodeId = ToNodeId("i=78");
04389         refs.push_back(ref);
04390         }
04391         registry.AddReferences(refs);
04392         }
04393        
04394         {
04395         AddNodesItem node;
04396         node.RequestedNewNodeId = ToNodeId("i=9399");
04397         node.BrowseName = ToQualifiedName("Id");
04398         node.Class = NodeClass::Variable;
04399         node.ParentNodeId = ToNodeId("i=9398");
04400         node.ReferenceTypeId = ReferenceId::HasProperty;
04401         node.TypeDefinition = ToNodeId("i=68");
04402         VariableAttributes attrs;
04403         attrs.DisplayName = LocalizedText("Id");
04404         attrs.Type = ObjectId::Boolean;
04405         attrs.Rank = -1;
04406         node.Attributes = attrs;
04407         registry.AddNodes(std::vector<AddNodesItem>{node});
04408         std::vector<AddReferencesItem> refs;
04409         {
04410         AddReferencesItem ref;
04411         ref.IsForward = true;
04412         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04413         ref.SourceNodeId = ToNodeId("i=9399");
04414         ref.TargetNodeClass = NodeClass::DataType;
04415         ref.TargetNodeId = ToNodeId("i=78");
04416         refs.push_back(ref);
04417         }
04418         registry.AddReferences(refs);
04419         }
04420        
04421         {
04422         AddNodesItem node;
04423         node.RequestedNewNodeId = ToNodeId("i=9455");
04424         node.BrowseName = ToQualifiedName("LimitState");
04425         node.Class = NodeClass::Object;
04426         node.ParentNodeId = ToNodeId("i=9341");
04427         node.ReferenceTypeId = ReferenceId::HasComponent;
04428         node.TypeDefinition = ToNodeId("i=9318");
04429         ObjectAttributes attrs;
04430         attrs.DisplayName = LocalizedText("LimitState");
04431         attrs.EventNotifier = 0;
04432         node.Attributes = attrs;
04433         registry.AddNodes(std::vector<AddNodesItem>{node});
04434         std::vector<AddReferencesItem> refs;
04435         {
04436         AddReferencesItem ref;
04437         ref.IsForward = true;
04438         ref.ReferenceTypeId = ReferenceId::HasComponent;
04439         ref.SourceNodeId = ToNodeId("i=9455");
04440         ref.TargetNodeClass = NodeClass::DataType;
04441         ref.TargetNodeId = ToNodeId("i=9456");
04442         refs.push_back(ref);
04443         }
04444         {
04445         AddReferencesItem ref;
04446         ref.IsForward = true;
04447         ref.ReferenceTypeId = ReferenceId::HasComponent;
04448         ref.SourceNodeId = ToNodeId("i=9455");
04449         ref.TargetNodeClass = NodeClass::DataType;
04450         ref.TargetNodeId = ToNodeId("i=9461");
04451         refs.push_back(ref);
04452         }
04453         {
04454         AddReferencesItem ref;
04455         ref.IsForward = true;
04456         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04457         ref.SourceNodeId = ToNodeId("i=9455");
04458         ref.TargetNodeClass = NodeClass::DataType;
04459         ref.TargetNodeId = ToNodeId("i=78");
04460         refs.push_back(ref);
04461         }
04462         registry.AddReferences(refs);
04463         }
04464        
04465         {
04466         AddNodesItem node;
04467         node.RequestedNewNodeId = ToNodeId("i=9456");
04468         node.BrowseName = ToQualifiedName("CurrentState");
04469         node.Class = NodeClass::Variable;
04470         node.ParentNodeId = ToNodeId("i=9455");
04471         node.ReferenceTypeId = ReferenceId::HasComponent;
04472         node.TypeDefinition = ToNodeId("i=2760");
04473         VariableAttributes attrs;
04474         attrs.DisplayName = LocalizedText("CurrentState");
04475         attrs.Type = ObjectId::LocalizedText;
04476         attrs.Rank = -1;
04477         node.Attributes = attrs;
04478         registry.AddNodes(std::vector<AddNodesItem>{node});
04479         std::vector<AddReferencesItem> refs;
04480         {
04481         AddReferencesItem ref;
04482         ref.IsForward = true;
04483         ref.ReferenceTypeId = ReferenceId::HasProperty;
04484         ref.SourceNodeId = ToNodeId("i=9456");
04485         ref.TargetNodeClass = NodeClass::DataType;
04486         ref.TargetNodeId = ToNodeId("i=9457");
04487         refs.push_back(ref);
04488         }
04489         {
04490         AddReferencesItem ref;
04491         ref.IsForward = true;
04492         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04493         ref.SourceNodeId = ToNodeId("i=9456");
04494         ref.TargetNodeClass = NodeClass::DataType;
04495         ref.TargetNodeId = ToNodeId("i=78");
04496         refs.push_back(ref);
04497         }
04498         registry.AddReferences(refs);
04499         }
04500        
04501         {
04502         AddNodesItem node;
04503         node.RequestedNewNodeId = ToNodeId("i=9457");
04504         node.BrowseName = ToQualifiedName("Id");
04505         node.Class = NodeClass::Variable;
04506         node.ParentNodeId = ToNodeId("i=9456");
04507         node.ReferenceTypeId = ReferenceId::HasProperty;
04508         node.TypeDefinition = ToNodeId("i=68");
04509         VariableAttributes attrs;
04510         attrs.DisplayName = LocalizedText("Id");
04511         attrs.Type = ObjectId::NodeId;
04512         attrs.Rank = -1;
04513         node.Attributes = attrs;
04514         registry.AddNodes(std::vector<AddNodesItem>{node});
04515         std::vector<AddReferencesItem> refs;
04516         {
04517         AddReferencesItem ref;
04518         ref.IsForward = true;
04519         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04520         ref.SourceNodeId = ToNodeId("i=9457");
04521         ref.TargetNodeClass = NodeClass::DataType;
04522         ref.TargetNodeId = ToNodeId("i=78");
04523         refs.push_back(ref);
04524         }
04525         registry.AddReferences(refs);
04526         }
04527        
04528         {
04529         AddNodesItem node;
04530         node.RequestedNewNodeId = ToNodeId("i=9461");
04531         node.BrowseName = ToQualifiedName("LastTransition");
04532         node.Class = NodeClass::Variable;
04533         node.ParentNodeId = ToNodeId("i=9455");
04534         node.ReferenceTypeId = ReferenceId::HasComponent;
04535         node.TypeDefinition = ToNodeId("i=2767");
04536         VariableAttributes attrs;
04537         attrs.DisplayName = LocalizedText("LastTransition");
04538         attrs.Type = ObjectId::LocalizedText;
04539         attrs.Rank = -1;
04540         node.Attributes = attrs;
04541         registry.AddNodes(std::vector<AddNodesItem>{node});
04542         std::vector<AddReferencesItem> refs;
04543         {
04544         AddReferencesItem ref;
04545         ref.IsForward = true;
04546         ref.ReferenceTypeId = ReferenceId::HasProperty;
04547         ref.SourceNodeId = ToNodeId("i=9461");
04548         ref.TargetNodeClass = NodeClass::DataType;
04549         ref.TargetNodeId = ToNodeId("i=9462");
04550         refs.push_back(ref);
04551         }
04552         {
04553         AddReferencesItem ref;
04554         ref.IsForward = true;
04555         ref.ReferenceTypeId = ReferenceId::HasProperty;
04556         ref.SourceNodeId = ToNodeId("i=9461");
04557         ref.TargetNodeClass = NodeClass::DataType;
04558         ref.TargetNodeId = ToNodeId("i=9465");
04559         refs.push_back(ref);
04560         }
04561         {
04562         AddReferencesItem ref;
04563         ref.IsForward = true;
04564         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04565         ref.SourceNodeId = ToNodeId("i=9461");
04566         ref.TargetNodeClass = NodeClass::DataType;
04567         ref.TargetNodeId = ToNodeId("i=80");
04568         refs.push_back(ref);
04569         }
04570         registry.AddReferences(refs);
04571         }
04572        
04573         {
04574         AddNodesItem node;
04575         node.RequestedNewNodeId = ToNodeId("i=9462");
04576         node.BrowseName = ToQualifiedName("Id");
04577         node.Class = NodeClass::Variable;
04578         node.ParentNodeId = ToNodeId("i=9461");
04579         node.ReferenceTypeId = ReferenceId::HasProperty;
04580         node.TypeDefinition = ToNodeId("i=68");
04581         VariableAttributes attrs;
04582         attrs.DisplayName = LocalizedText("Id");
04583         attrs.Type = ObjectId::NodeId;
04584         attrs.Rank = -1;
04585         node.Attributes = attrs;
04586         registry.AddNodes(std::vector<AddNodesItem>{node});
04587         std::vector<AddReferencesItem> refs;
04588         {
04589         AddReferencesItem ref;
04590         ref.IsForward = true;
04591         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04592         ref.SourceNodeId = ToNodeId("i=9462");
04593         ref.TargetNodeClass = NodeClass::DataType;
04594         ref.TargetNodeId = ToNodeId("i=78");
04595         refs.push_back(ref);
04596         }
04597         registry.AddReferences(refs);
04598         }
04599        
04600         {
04601         AddNodesItem node;
04602         node.RequestedNewNodeId = ToNodeId("i=9465");
04603         node.BrowseName = ToQualifiedName("TransitionTime");
04604         node.Class = NodeClass::Variable;
04605         node.ParentNodeId = ToNodeId("i=9461");
04606         node.ReferenceTypeId = ReferenceId::HasProperty;
04607         node.TypeDefinition = ToNodeId("i=68");
04608         VariableAttributes attrs;
04609         attrs.DisplayName = LocalizedText("TransitionTime");
04610         attrs.Type = ToNodeId("i=294");
04611         attrs.Rank = -1;
04612         node.Attributes = attrs;
04613         registry.AddNodes(std::vector<AddNodesItem>{node});
04614         std::vector<AddReferencesItem> refs;
04615         {
04616         AddReferencesItem ref;
04617         ref.IsForward = true;
04618         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04619         ref.SourceNodeId = ToNodeId("i=9465");
04620         ref.TargetNodeClass = NodeClass::DataType;
04621         ref.TargetNodeId = ToNodeId("i=80");
04622         refs.push_back(ref);
04623         }
04624         registry.AddReferences(refs);
04625         }
04626        
04627         {
04628         AddNodesItem node;
04629         node.RequestedNewNodeId = ToNodeId("i=9906");
04630         node.BrowseName = ToQualifiedName("NonExclusiveLimitAlarmType");
04631         node.Class = NodeClass::ObjectType;
04632         node.ParentNodeId = ToNodeId("i=2955");
04633         node.ReferenceTypeId = ReferenceId::HasSubtype;
04634         ObjectTypeAttributes attrs;
04635         attrs.DisplayName = LocalizedText("NonExclusiveLimitAlarmType");
04636         attrs.IsAbstract = false;
04637         node.Attributes = attrs;
04638         registry.AddNodes(std::vector<AddNodesItem>{node});
04639         std::vector<AddReferencesItem> refs;
04640         {
04641         AddReferencesItem ref;
04642         ref.IsForward = true;
04643         ref.ReferenceTypeId = ReferenceId::HasComponent;
04644         ref.SourceNodeId = ToNodeId("i=9906");
04645         ref.TargetNodeClass = NodeClass::DataType;
04646         ref.TargetNodeId = ToNodeId("i=9963");
04647         refs.push_back(ref);
04648         }
04649         {
04650         AddReferencesItem ref;
04651         ref.IsForward = true;
04652         ref.ReferenceTypeId = ReferenceId::HasComponent;
04653         ref.SourceNodeId = ToNodeId("i=9906");
04654         ref.TargetNodeClass = NodeClass::DataType;
04655         ref.TargetNodeId = ToNodeId("i=10020");
04656         refs.push_back(ref);
04657         }
04658         {
04659         AddReferencesItem ref;
04660         ref.IsForward = true;
04661         ref.ReferenceTypeId = ReferenceId::HasComponent;
04662         ref.SourceNodeId = ToNodeId("i=9906");
04663         ref.TargetNodeClass = NodeClass::DataType;
04664         ref.TargetNodeId = ToNodeId("i=10029");
04665         refs.push_back(ref);
04666         }
04667         {
04668         AddReferencesItem ref;
04669         ref.IsForward = true;
04670         ref.ReferenceTypeId = ReferenceId::HasComponent;
04671         ref.SourceNodeId = ToNodeId("i=9906");
04672         ref.TargetNodeClass = NodeClass::DataType;
04673         ref.TargetNodeId = ToNodeId("i=10038");
04674         refs.push_back(ref);
04675         }
04676         {
04677         AddReferencesItem ref;
04678         ref.IsForward = true;
04679         ref.ReferenceTypeId = ReferenceId::HasComponent;
04680         ref.SourceNodeId = ToNodeId("i=9906");
04681         ref.TargetNodeClass = NodeClass::DataType;
04682         ref.TargetNodeId = ToNodeId("i=10047");
04683         refs.push_back(ref);
04684         }
04685         registry.AddReferences(refs);
04686         }
04687        
04688         {
04689         AddNodesItem node;
04690         node.RequestedNewNodeId = ToNodeId("i=9963");
04691         node.BrowseName = ToQualifiedName("ActiveState");
04692         node.Class = NodeClass::Variable;
04693         node.ParentNodeId = ToNodeId("i=9906");
04694         node.ReferenceTypeId = ReferenceId::HasComponent;
04695         node.TypeDefinition = ToNodeId("i=8995");
04696         VariableAttributes attrs;
04697         attrs.DisplayName = LocalizedText("ActiveState");
04698         attrs.Type = ObjectId::LocalizedText;
04699         attrs.Rank = -1;
04700         node.Attributes = attrs;
04701         registry.AddNodes(std::vector<AddNodesItem>{node});
04702         std::vector<AddReferencesItem> refs;
04703         {
04704         AddReferencesItem ref;
04705         ref.IsForward = true;
04706         ref.ReferenceTypeId = ReferenceId::HasProperty;
04707         ref.SourceNodeId = ToNodeId("i=9963");
04708         ref.TargetNodeClass = NodeClass::DataType;
04709         ref.TargetNodeId = ToNodeId("i=9964");
04710         refs.push_back(ref);
04711         }
04712         {
04713         AddReferencesItem ref;
04714         ref.IsForward = true;
04715         ref.ReferenceTypeId = ToNodeId("i=9004");
04716         ref.SourceNodeId = ToNodeId("i=9963");
04717         ref.TargetNodeClass = NodeClass::DataType;
04718         ref.TargetNodeId = ToNodeId("i=10020");
04719         refs.push_back(ref);
04720         }
04721         {
04722         AddReferencesItem ref;
04723         ref.IsForward = true;
04724         ref.ReferenceTypeId = ToNodeId("i=9004");
04725         ref.SourceNodeId = ToNodeId("i=9963");
04726         ref.TargetNodeClass = NodeClass::DataType;
04727         ref.TargetNodeId = ToNodeId("i=10029");
04728         refs.push_back(ref);
04729         }
04730         {
04731         AddReferencesItem ref;
04732         ref.IsForward = true;
04733         ref.ReferenceTypeId = ToNodeId("i=9004");
04734         ref.SourceNodeId = ToNodeId("i=9963");
04735         ref.TargetNodeClass = NodeClass::DataType;
04736         ref.TargetNodeId = ToNodeId("i=10038");
04737         refs.push_back(ref);
04738         }
04739         {
04740         AddReferencesItem ref;
04741         ref.IsForward = true;
04742         ref.ReferenceTypeId = ToNodeId("i=9004");
04743         ref.SourceNodeId = ToNodeId("i=9963");
04744         ref.TargetNodeClass = NodeClass::DataType;
04745         ref.TargetNodeId = ToNodeId("i=10047");
04746         refs.push_back(ref);
04747         }
04748         {
04749         AddReferencesItem ref;
04750         ref.IsForward = true;
04751         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04752         ref.SourceNodeId = ToNodeId("i=9963");
04753         ref.TargetNodeClass = NodeClass::DataType;
04754         ref.TargetNodeId = ToNodeId("i=78");
04755         refs.push_back(ref);
04756         }
04757         registry.AddReferences(refs);
04758         }
04759        
04760         {
04761         AddNodesItem node;
04762         node.RequestedNewNodeId = ToNodeId("i=9964");
04763         node.BrowseName = ToQualifiedName("Id");
04764         node.Class = NodeClass::Variable;
04765         node.ParentNodeId = ToNodeId("i=9963");
04766         node.ReferenceTypeId = ReferenceId::HasProperty;
04767         node.TypeDefinition = ToNodeId("i=68");
04768         VariableAttributes attrs;
04769         attrs.DisplayName = LocalizedText("Id");
04770         attrs.Type = ObjectId::Boolean;
04771         attrs.Rank = -1;
04772         node.Attributes = attrs;
04773         registry.AddNodes(std::vector<AddNodesItem>{node});
04774         std::vector<AddReferencesItem> refs;
04775         {
04776         AddReferencesItem ref;
04777         ref.IsForward = true;
04778         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04779         ref.SourceNodeId = ToNodeId("i=9964");
04780         ref.TargetNodeClass = NodeClass::DataType;
04781         ref.TargetNodeId = ToNodeId("i=78");
04782         refs.push_back(ref);
04783         }
04784         registry.AddReferences(refs);
04785         }
04786        
04787         {
04788         AddNodesItem node;
04789         node.RequestedNewNodeId = ToNodeId("i=10020");
04790         node.BrowseName = ToQualifiedName("HighHighState");
04791         node.Class = NodeClass::Variable;
04792         node.ParentNodeId = ToNodeId("i=9906");
04793         node.ReferenceTypeId = ReferenceId::HasComponent;
04794         node.TypeDefinition = ToNodeId("i=8995");
04795         VariableAttributes attrs;
04796         attrs.DisplayName = LocalizedText("HighHighState");
04797         attrs.Type = ObjectId::LocalizedText;
04798         attrs.Rank = -1;
04799         node.Attributes = attrs;
04800         registry.AddNodes(std::vector<AddNodesItem>{node});
04801         std::vector<AddReferencesItem> refs;
04802         {
04803         AddReferencesItem ref;
04804         ref.IsForward = true;
04805         ref.ReferenceTypeId = ReferenceId::HasProperty;
04806         ref.SourceNodeId = ToNodeId("i=10020");
04807         ref.TargetNodeClass = NodeClass::DataType;
04808         ref.TargetNodeId = ToNodeId("i=10021");
04809         refs.push_back(ref);
04810         }
04811         {
04812         AddReferencesItem ref;
04813         ref.IsForward = true;
04814         ref.ReferenceTypeId = ReferenceId::HasProperty;
04815         ref.SourceNodeId = ToNodeId("i=10020");
04816         ref.TargetNodeClass = NodeClass::DataType;
04817         ref.TargetNodeId = ToNodeId("i=10025");
04818         refs.push_back(ref);
04819         }
04820         {
04821         AddReferencesItem ref;
04822         ref.IsForward = true;
04823         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04824         ref.SourceNodeId = ToNodeId("i=10020");
04825         ref.TargetNodeClass = NodeClass::DataType;
04826         ref.TargetNodeId = ToNodeId("i=80");
04827         refs.push_back(ref);
04828         }
04829         registry.AddReferences(refs);
04830         }
04831        
04832         {
04833         AddNodesItem node;
04834         node.RequestedNewNodeId = ToNodeId("i=10021");
04835         node.BrowseName = ToQualifiedName("Id");
04836         node.Class = NodeClass::Variable;
04837         node.ParentNodeId = ToNodeId("i=10020");
04838         node.ReferenceTypeId = ReferenceId::HasProperty;
04839         node.TypeDefinition = ToNodeId("i=68");
04840         VariableAttributes attrs;
04841         attrs.DisplayName = LocalizedText("Id");
04842         attrs.Type = ObjectId::Boolean;
04843         attrs.Rank = -1;
04844         node.Attributes = attrs;
04845         registry.AddNodes(std::vector<AddNodesItem>{node});
04846         std::vector<AddReferencesItem> refs;
04847         {
04848         AddReferencesItem ref;
04849         ref.IsForward = true;
04850         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04851         ref.SourceNodeId = ToNodeId("i=10021");
04852         ref.TargetNodeClass = NodeClass::DataType;
04853         ref.TargetNodeId = ToNodeId("i=78");
04854         refs.push_back(ref);
04855         }
04856         registry.AddReferences(refs);
04857         }
04858        
04859         {
04860         AddNodesItem node;
04861         node.RequestedNewNodeId = ToNodeId("i=10025");
04862         node.BrowseName = ToQualifiedName("TransitionTime");
04863         node.Class = NodeClass::Variable;
04864         node.ParentNodeId = ToNodeId("i=10020");
04865         node.ReferenceTypeId = ReferenceId::HasProperty;
04866         node.TypeDefinition = ToNodeId("i=68");
04867         VariableAttributes attrs;
04868         attrs.DisplayName = LocalizedText("TransitionTime");
04869         attrs.Type = ToNodeId("i=294");
04870         attrs.Rank = -1;
04871         node.Attributes = attrs;
04872         registry.AddNodes(std::vector<AddNodesItem>{node});
04873         std::vector<AddReferencesItem> refs;
04874         {
04875         AddReferencesItem ref;
04876         ref.IsForward = true;
04877         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04878         ref.SourceNodeId = ToNodeId("i=10025");
04879         ref.TargetNodeClass = NodeClass::DataType;
04880         ref.TargetNodeId = ToNodeId("i=80");
04881         refs.push_back(ref);
04882         }
04883         registry.AddReferences(refs);
04884         }
04885        
04886         {
04887         AddNodesItem node;
04888         node.RequestedNewNodeId = ToNodeId("i=10029");
04889         node.BrowseName = ToQualifiedName("HighState");
04890         node.Class = NodeClass::Variable;
04891         node.ParentNodeId = ToNodeId("i=9906");
04892         node.ReferenceTypeId = ReferenceId::HasComponent;
04893         node.TypeDefinition = ToNodeId("i=8995");
04894         VariableAttributes attrs;
04895         attrs.DisplayName = LocalizedText("HighState");
04896         attrs.Type = ObjectId::LocalizedText;
04897         attrs.Rank = -1;
04898         node.Attributes = attrs;
04899         registry.AddNodes(std::vector<AddNodesItem>{node});
04900         std::vector<AddReferencesItem> refs;
04901         {
04902         AddReferencesItem ref;
04903         ref.IsForward = true;
04904         ref.ReferenceTypeId = ReferenceId::HasProperty;
04905         ref.SourceNodeId = ToNodeId("i=10029");
04906         ref.TargetNodeClass = NodeClass::DataType;
04907         ref.TargetNodeId = ToNodeId("i=10030");
04908         refs.push_back(ref);
04909         }
04910         {
04911         AddReferencesItem ref;
04912         ref.IsForward = true;
04913         ref.ReferenceTypeId = ReferenceId::HasProperty;
04914         ref.SourceNodeId = ToNodeId("i=10029");
04915         ref.TargetNodeClass = NodeClass::DataType;
04916         ref.TargetNodeId = ToNodeId("i=10034");
04917         refs.push_back(ref);
04918         }
04919         {
04920         AddReferencesItem ref;
04921         ref.IsForward = true;
04922         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04923         ref.SourceNodeId = ToNodeId("i=10029");
04924         ref.TargetNodeClass = NodeClass::DataType;
04925         ref.TargetNodeId = ToNodeId("i=80");
04926         refs.push_back(ref);
04927         }
04928         registry.AddReferences(refs);
04929         }
04930        
04931         {
04932         AddNodesItem node;
04933         node.RequestedNewNodeId = ToNodeId("i=10030");
04934         node.BrowseName = ToQualifiedName("Id");
04935         node.Class = NodeClass::Variable;
04936         node.ParentNodeId = ToNodeId("i=10029");
04937         node.ReferenceTypeId = ReferenceId::HasProperty;
04938         node.TypeDefinition = ToNodeId("i=68");
04939         VariableAttributes attrs;
04940         attrs.DisplayName = LocalizedText("Id");
04941         attrs.Type = ObjectId::Boolean;
04942         attrs.Rank = -1;
04943         node.Attributes = attrs;
04944         registry.AddNodes(std::vector<AddNodesItem>{node});
04945         std::vector<AddReferencesItem> refs;
04946         {
04947         AddReferencesItem ref;
04948         ref.IsForward = true;
04949         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04950         ref.SourceNodeId = ToNodeId("i=10030");
04951         ref.TargetNodeClass = NodeClass::DataType;
04952         ref.TargetNodeId = ToNodeId("i=78");
04953         refs.push_back(ref);
04954         }
04955         registry.AddReferences(refs);
04956         }
04957        
04958         {
04959         AddNodesItem node;
04960         node.RequestedNewNodeId = ToNodeId("i=10034");
04961         node.BrowseName = ToQualifiedName("TransitionTime");
04962         node.Class = NodeClass::Variable;
04963         node.ParentNodeId = ToNodeId("i=10029");
04964         node.ReferenceTypeId = ReferenceId::HasProperty;
04965         node.TypeDefinition = ToNodeId("i=68");
04966         VariableAttributes attrs;
04967         attrs.DisplayName = LocalizedText("TransitionTime");
04968         attrs.Type = ToNodeId("i=294");
04969         attrs.Rank = -1;
04970         node.Attributes = attrs;
04971         registry.AddNodes(std::vector<AddNodesItem>{node});
04972         std::vector<AddReferencesItem> refs;
04973         {
04974         AddReferencesItem ref;
04975         ref.IsForward = true;
04976         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
04977         ref.SourceNodeId = ToNodeId("i=10034");
04978         ref.TargetNodeClass = NodeClass::DataType;
04979         ref.TargetNodeId = ToNodeId("i=80");
04980         refs.push_back(ref);
04981         }
04982         registry.AddReferences(refs);
04983         }
04984        
04985         {
04986         AddNodesItem node;
04987         node.RequestedNewNodeId = ToNodeId("i=10038");
04988         node.BrowseName = ToQualifiedName("LowState");
04989         node.Class = NodeClass::Variable;
04990         node.ParentNodeId = ToNodeId("i=9906");
04991         node.ReferenceTypeId = ReferenceId::HasComponent;
04992         node.TypeDefinition = ToNodeId("i=8995");
04993         VariableAttributes attrs;
04994         attrs.DisplayName = LocalizedText("LowState");
04995         attrs.Type = ObjectId::LocalizedText;
04996         attrs.Rank = -1;
04997         node.Attributes = attrs;
04998         registry.AddNodes(std::vector<AddNodesItem>{node});
04999         std::vector<AddReferencesItem> refs;
05000         {
05001         AddReferencesItem ref;
05002         ref.IsForward = true;
05003         ref.ReferenceTypeId = ReferenceId::HasProperty;
05004         ref.SourceNodeId = ToNodeId("i=10038");
05005         ref.TargetNodeClass = NodeClass::DataType;
05006         ref.TargetNodeId = ToNodeId("i=10039");
05007         refs.push_back(ref);
05008         }
05009         {
05010         AddReferencesItem ref;
05011         ref.IsForward = true;
05012         ref.ReferenceTypeId = ReferenceId::HasProperty;
05013         ref.SourceNodeId = ToNodeId("i=10038");
05014         ref.TargetNodeClass = NodeClass::DataType;
05015         ref.TargetNodeId = ToNodeId("i=10043");
05016         refs.push_back(ref);
05017         }
05018         {
05019         AddReferencesItem ref;
05020         ref.IsForward = true;
05021         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05022         ref.SourceNodeId = ToNodeId("i=10038");
05023         ref.TargetNodeClass = NodeClass::DataType;
05024         ref.TargetNodeId = ToNodeId("i=80");
05025         refs.push_back(ref);
05026         }
05027         registry.AddReferences(refs);
05028         }
05029        
05030         {
05031         AddNodesItem node;
05032         node.RequestedNewNodeId = ToNodeId("i=10039");
05033         node.BrowseName = ToQualifiedName("Id");
05034         node.Class = NodeClass::Variable;
05035         node.ParentNodeId = ToNodeId("i=10038");
05036         node.ReferenceTypeId = ReferenceId::HasProperty;
05037         node.TypeDefinition = ToNodeId("i=68");
05038         VariableAttributes attrs;
05039         attrs.DisplayName = LocalizedText("Id");
05040         attrs.Type = ObjectId::Boolean;
05041         attrs.Rank = -1;
05042         node.Attributes = attrs;
05043         registry.AddNodes(std::vector<AddNodesItem>{node});
05044         std::vector<AddReferencesItem> refs;
05045         {
05046         AddReferencesItem ref;
05047         ref.IsForward = true;
05048         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05049         ref.SourceNodeId = ToNodeId("i=10039");
05050         ref.TargetNodeClass = NodeClass::DataType;
05051         ref.TargetNodeId = ToNodeId("i=78");
05052         refs.push_back(ref);
05053         }
05054         registry.AddReferences(refs);
05055         }
05056        
05057         {
05058         AddNodesItem node;
05059         node.RequestedNewNodeId = ToNodeId("i=10043");
05060         node.BrowseName = ToQualifiedName("TransitionTime");
05061         node.Class = NodeClass::Variable;
05062         node.ParentNodeId = ToNodeId("i=10038");
05063         node.ReferenceTypeId = ReferenceId::HasProperty;
05064         node.TypeDefinition = ToNodeId("i=68");
05065         VariableAttributes attrs;
05066         attrs.DisplayName = LocalizedText("TransitionTime");
05067         attrs.Type = ToNodeId("i=294");
05068         attrs.Rank = -1;
05069         node.Attributes = attrs;
05070         registry.AddNodes(std::vector<AddNodesItem>{node});
05071         std::vector<AddReferencesItem> refs;
05072         {
05073         AddReferencesItem ref;
05074         ref.IsForward = true;
05075         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05076         ref.SourceNodeId = ToNodeId("i=10043");
05077         ref.TargetNodeClass = NodeClass::DataType;
05078         ref.TargetNodeId = ToNodeId("i=80");
05079         refs.push_back(ref);
05080         }
05081         registry.AddReferences(refs);
05082         }
05083        
05084         {
05085         AddNodesItem node;
05086         node.RequestedNewNodeId = ToNodeId("i=10047");
05087         node.BrowseName = ToQualifiedName("LowLowState");
05088         node.Class = NodeClass::Variable;
05089         node.ParentNodeId = ToNodeId("i=9906");
05090         node.ReferenceTypeId = ReferenceId::HasComponent;
05091         node.TypeDefinition = ToNodeId("i=8995");
05092         VariableAttributes attrs;
05093         attrs.DisplayName = LocalizedText("LowLowState");
05094         attrs.Type = ObjectId::LocalizedText;
05095         attrs.Rank = -1;
05096         node.Attributes = attrs;
05097         registry.AddNodes(std::vector<AddNodesItem>{node});
05098         std::vector<AddReferencesItem> refs;
05099         {
05100         AddReferencesItem ref;
05101         ref.IsForward = true;
05102         ref.ReferenceTypeId = ReferenceId::HasProperty;
05103         ref.SourceNodeId = ToNodeId("i=10047");
05104         ref.TargetNodeClass = NodeClass::DataType;
05105         ref.TargetNodeId = ToNodeId("i=10048");
05106         refs.push_back(ref);
05107         }
05108         {
05109         AddReferencesItem ref;
05110         ref.IsForward = true;
05111         ref.ReferenceTypeId = ReferenceId::HasProperty;
05112         ref.SourceNodeId = ToNodeId("i=10047");
05113         ref.TargetNodeClass = NodeClass::DataType;
05114         ref.TargetNodeId = ToNodeId("i=10052");
05115         refs.push_back(ref);
05116         }
05117         {
05118         AddReferencesItem ref;
05119         ref.IsForward = true;
05120         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05121         ref.SourceNodeId = ToNodeId("i=10047");
05122         ref.TargetNodeClass = NodeClass::DataType;
05123         ref.TargetNodeId = ToNodeId("i=80");
05124         refs.push_back(ref);
05125         }
05126         registry.AddReferences(refs);
05127         }
05128        
05129         {
05130         AddNodesItem node;
05131         node.RequestedNewNodeId = ToNodeId("i=10048");
05132         node.BrowseName = ToQualifiedName("Id");
05133         node.Class = NodeClass::Variable;
05134         node.ParentNodeId = ToNodeId("i=10047");
05135         node.ReferenceTypeId = ReferenceId::HasProperty;
05136         node.TypeDefinition = ToNodeId("i=68");
05137         VariableAttributes attrs;
05138         attrs.DisplayName = LocalizedText("Id");
05139         attrs.Type = ObjectId::Boolean;
05140         attrs.Rank = -1;
05141         node.Attributes = attrs;
05142         registry.AddNodes(std::vector<AddNodesItem>{node});
05143         std::vector<AddReferencesItem> refs;
05144         {
05145         AddReferencesItem ref;
05146         ref.IsForward = true;
05147         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05148         ref.SourceNodeId = ToNodeId("i=10048");
05149         ref.TargetNodeClass = NodeClass::DataType;
05150         ref.TargetNodeId = ToNodeId("i=78");
05151         refs.push_back(ref);
05152         }
05153         registry.AddReferences(refs);
05154         }
05155        
05156         {
05157         AddNodesItem node;
05158         node.RequestedNewNodeId = ToNodeId("i=10052");
05159         node.BrowseName = ToQualifiedName("TransitionTime");
05160         node.Class = NodeClass::Variable;
05161         node.ParentNodeId = ToNodeId("i=10047");
05162         node.ReferenceTypeId = ReferenceId::HasProperty;
05163         node.TypeDefinition = ToNodeId("i=68");
05164         VariableAttributes attrs;
05165         attrs.DisplayName = LocalizedText("TransitionTime");
05166         attrs.Type = ToNodeId("i=294");
05167         attrs.Rank = -1;
05168         node.Attributes = attrs;
05169         registry.AddNodes(std::vector<AddNodesItem>{node});
05170         std::vector<AddReferencesItem> refs;
05171         {
05172         AddReferencesItem ref;
05173         ref.IsForward = true;
05174         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05175         ref.SourceNodeId = ToNodeId("i=10052");
05176         ref.TargetNodeClass = NodeClass::DataType;
05177         ref.TargetNodeId = ToNodeId("i=80");
05178         refs.push_back(ref);
05179         }
05180         registry.AddReferences(refs);
05181         }
05182        
05183         {
05184         AddNodesItem node;
05185         node.RequestedNewNodeId = ToNodeId("i=10060");
05186         node.BrowseName = ToQualifiedName("NonExclusiveLevelAlarmType");
05187         node.Class = NodeClass::ObjectType;
05188         node.ParentNodeId = ToNodeId("i=9906");
05189         node.ReferenceTypeId = ReferenceId::HasSubtype;
05190         ObjectTypeAttributes attrs;
05191         attrs.DisplayName = LocalizedText("NonExclusiveLevelAlarmType");
05192         attrs.IsAbstract = false;
05193         node.Attributes = attrs;
05194         registry.AddNodes(std::vector<AddNodesItem>{node});
05195         }
05196        
05197         {
05198         AddNodesItem node;
05199         node.RequestedNewNodeId = ToNodeId("i=9482");
05200         node.BrowseName = ToQualifiedName("ExclusiveLevelAlarmType");
05201         node.Class = NodeClass::ObjectType;
05202         node.ParentNodeId = ToNodeId("i=9341");
05203         node.ReferenceTypeId = ReferenceId::HasSubtype;
05204         ObjectTypeAttributes attrs;
05205         attrs.DisplayName = LocalizedText("ExclusiveLevelAlarmType");
05206         attrs.IsAbstract = false;
05207         node.Attributes = attrs;
05208         registry.AddNodes(std::vector<AddNodesItem>{node});
05209         }
05210        
05211         {
05212         AddNodesItem node;
05213         node.RequestedNewNodeId = ToNodeId("i=10368");
05214         node.BrowseName = ToQualifiedName("NonExclusiveDeviationAlarmType");
05215         node.Class = NodeClass::ObjectType;
05216         node.ParentNodeId = ToNodeId("i=9906");
05217         node.ReferenceTypeId = ReferenceId::HasSubtype;
05218         ObjectTypeAttributes attrs;
05219         attrs.DisplayName = LocalizedText("NonExclusiveDeviationAlarmType");
05220         attrs.IsAbstract = false;
05221         node.Attributes = attrs;
05222         registry.AddNodes(std::vector<AddNodesItem>{node});
05223         std::vector<AddReferencesItem> refs;
05224         {
05225         AddReferencesItem ref;
05226         ref.IsForward = true;
05227         ref.ReferenceTypeId = ReferenceId::HasProperty;
05228         ref.SourceNodeId = ToNodeId("i=10368");
05229         ref.TargetNodeClass = NodeClass::DataType;
05230         ref.TargetNodeId = ToNodeId("i=10522");
05231         refs.push_back(ref);
05232         }
05233         registry.AddReferences(refs);
05234         }
05235        
05236         {
05237         AddNodesItem node;
05238         node.RequestedNewNodeId = ToNodeId("i=10522");
05239         node.BrowseName = ToQualifiedName("SetpointNode");
05240         node.Class = NodeClass::Variable;
05241         node.ParentNodeId = ToNodeId("i=10368");
05242         node.ReferenceTypeId = ReferenceId::HasProperty;
05243         node.TypeDefinition = ToNodeId("i=68");
05244         VariableAttributes attrs;
05245         attrs.DisplayName = LocalizedText("SetpointNode");
05246         attrs.Type = ObjectId::NodeId;
05247         attrs.Rank = -1;
05248         node.Attributes = attrs;
05249         registry.AddNodes(std::vector<AddNodesItem>{node});
05250         std::vector<AddReferencesItem> refs;
05251         {
05252         AddReferencesItem ref;
05253         ref.IsForward = true;
05254         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05255         ref.SourceNodeId = ToNodeId("i=10522");
05256         ref.TargetNodeClass = NodeClass::DataType;
05257         ref.TargetNodeId = ToNodeId("i=78");
05258         refs.push_back(ref);
05259         }
05260         registry.AddReferences(refs);
05261         }
05262        
05263         {
05264         AddNodesItem node;
05265         node.RequestedNewNodeId = ToNodeId("i=9764");
05266         node.BrowseName = ToQualifiedName("ExclusiveDeviationAlarmType");
05267         node.Class = NodeClass::ObjectType;
05268         node.ParentNodeId = ToNodeId("i=9341");
05269         node.ReferenceTypeId = ReferenceId::HasSubtype;
05270         ObjectTypeAttributes attrs;
05271         attrs.DisplayName = LocalizedText("ExclusiveDeviationAlarmType");
05272         attrs.IsAbstract = false;
05273         node.Attributes = attrs;
05274         registry.AddNodes(std::vector<AddNodesItem>{node});
05275         std::vector<AddReferencesItem> refs;
05276         {
05277         AddReferencesItem ref;
05278         ref.IsForward = true;
05279         ref.ReferenceTypeId = ReferenceId::HasProperty;
05280         ref.SourceNodeId = ToNodeId("i=9764");
05281         ref.TargetNodeClass = NodeClass::DataType;
05282         ref.TargetNodeId = ToNodeId("i=9905");
05283         refs.push_back(ref);
05284         }
05285         registry.AddReferences(refs);
05286         }
05287        
05288         {
05289         AddNodesItem node;
05290         node.RequestedNewNodeId = ToNodeId("i=9905");
05291         node.BrowseName = ToQualifiedName("SetpointNode");
05292         node.Class = NodeClass::Variable;
05293         node.ParentNodeId = ToNodeId("i=9764");
05294         node.ReferenceTypeId = ReferenceId::HasProperty;
05295         node.TypeDefinition = ToNodeId("i=68");
05296         VariableAttributes attrs;
05297         attrs.DisplayName = LocalizedText("SetpointNode");
05298         attrs.Type = ObjectId::NodeId;
05299         attrs.Rank = -1;
05300         node.Attributes = attrs;
05301         registry.AddNodes(std::vector<AddNodesItem>{node});
05302         std::vector<AddReferencesItem> refs;
05303         {
05304         AddReferencesItem ref;
05305         ref.IsForward = true;
05306         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05307         ref.SourceNodeId = ToNodeId("i=9905");
05308         ref.TargetNodeClass = NodeClass::DataType;
05309         ref.TargetNodeId = ToNodeId("i=78");
05310         refs.push_back(ref);
05311         }
05312         registry.AddReferences(refs);
05313         }
05314        
05315         {
05316         AddNodesItem node;
05317         node.RequestedNewNodeId = ToNodeId("i=10214");
05318         node.BrowseName = ToQualifiedName("NonExclusiveRateOfChangeAlarmType");
05319         node.Class = NodeClass::ObjectType;
05320         node.ParentNodeId = ToNodeId("i=9906");
05321         node.ReferenceTypeId = ReferenceId::HasSubtype;
05322         ObjectTypeAttributes attrs;
05323         attrs.DisplayName = LocalizedText("NonExclusiveRateOfChangeAlarmType");
05324         attrs.IsAbstract = false;
05325         node.Attributes = attrs;
05326         registry.AddNodes(std::vector<AddNodesItem>{node});
05327         }
05328        
05329         {
05330         AddNodesItem node;
05331         node.RequestedNewNodeId = ToNodeId("i=9623");
05332         node.BrowseName = ToQualifiedName("ExclusiveRateOfChangeAlarmType");
05333         node.Class = NodeClass::ObjectType;
05334         node.ParentNodeId = ToNodeId("i=9341");
05335         node.ReferenceTypeId = ReferenceId::HasSubtype;
05336         ObjectTypeAttributes attrs;
05337         attrs.DisplayName = LocalizedText("ExclusiveRateOfChangeAlarmType");
05338         attrs.IsAbstract = false;
05339         node.Attributes = attrs;
05340         registry.AddNodes(std::vector<AddNodesItem>{node});
05341         }
05342        
05343         {
05344         AddNodesItem node;
05345         node.RequestedNewNodeId = ToNodeId("i=10523");
05346         node.BrowseName = ToQualifiedName("DiscreteAlarmType");
05347         node.Class = NodeClass::ObjectType;
05348         node.ParentNodeId = ToNodeId("i=2915");
05349         node.ReferenceTypeId = ReferenceId::HasSubtype;
05350         ObjectTypeAttributes attrs;
05351         attrs.DisplayName = LocalizedText("DiscreteAlarmType");
05352         attrs.IsAbstract = false;
05353         node.Attributes = attrs;
05354         registry.AddNodes(std::vector<AddNodesItem>{node});
05355         }
05356        
05357         {
05358         AddNodesItem node;
05359         node.RequestedNewNodeId = ToNodeId("i=10637");
05360         node.BrowseName = ToQualifiedName("OffNormalAlarmType");
05361         node.Class = NodeClass::ObjectType;
05362         node.ParentNodeId = ToNodeId("i=10523");
05363         node.ReferenceTypeId = ReferenceId::HasSubtype;
05364         ObjectTypeAttributes attrs;
05365         attrs.DisplayName = LocalizedText("OffNormalAlarmType");
05366         attrs.IsAbstract = false;
05367         node.Attributes = attrs;
05368         registry.AddNodes(std::vector<AddNodesItem>{node});
05369         std::vector<AddReferencesItem> refs;
05370         {
05371         AddReferencesItem ref;
05372         ref.IsForward = true;
05373         ref.ReferenceTypeId = ReferenceId::HasProperty;
05374         ref.SourceNodeId = ToNodeId("i=10637");
05375         ref.TargetNodeClass = NodeClass::DataType;
05376         ref.TargetNodeId = ToNodeId("i=11158");
05377         refs.push_back(ref);
05378         }
05379         registry.AddReferences(refs);
05380         }
05381        
05382         {
05383         AddNodesItem node;
05384         node.RequestedNewNodeId = ToNodeId("i=11158");
05385         node.BrowseName = ToQualifiedName("NormalState");
05386         node.Class = NodeClass::Variable;
05387         node.ParentNodeId = ToNodeId("i=10637");
05388         node.ReferenceTypeId = ReferenceId::HasProperty;
05389         node.TypeDefinition = ToNodeId("i=68");
05390         VariableAttributes attrs;
05391         attrs.DisplayName = LocalizedText("NormalState");
05392         attrs.Type = ObjectId::NodeId;
05393         attrs.Rank = -1;
05394         node.Attributes = attrs;
05395         registry.AddNodes(std::vector<AddNodesItem>{node});
05396         std::vector<AddReferencesItem> refs;
05397         {
05398         AddReferencesItem ref;
05399         ref.IsForward = true;
05400         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05401         ref.SourceNodeId = ToNodeId("i=11158");
05402         ref.TargetNodeClass = NodeClass::DataType;
05403         ref.TargetNodeId = ToNodeId("i=78");
05404         refs.push_back(ref);
05405         }
05406         registry.AddReferences(refs);
05407         }
05408        
05409         {
05410         AddNodesItem node;
05411         node.RequestedNewNodeId = ToNodeId("i=11753");
05412         node.BrowseName = ToQualifiedName("SystemOffNormalAlarmType");
05413         node.Class = NodeClass::ObjectType;
05414         node.ParentNodeId = ToNodeId("i=10637");
05415         node.ReferenceTypeId = ReferenceId::HasSubtype;
05416         ObjectTypeAttributes attrs;
05417         attrs.DisplayName = LocalizedText("SystemOffNormalAlarmType");
05418         attrs.IsAbstract = false;
05419         node.Attributes = attrs;
05420         registry.AddNodes(std::vector<AddNodesItem>{node});
05421         }
05422        
05423         {
05424         AddNodesItem node;
05425         node.RequestedNewNodeId = ToNodeId("i=10751");
05426         node.BrowseName = ToQualifiedName("TripAlarmType");
05427         node.Class = NodeClass::ObjectType;
05428         node.ParentNodeId = ToNodeId("i=10637");
05429         node.ReferenceTypeId = ReferenceId::HasSubtype;
05430         ObjectTypeAttributes attrs;
05431         attrs.DisplayName = LocalizedText("TripAlarmType");
05432         attrs.IsAbstract = false;
05433         node.Attributes = attrs;
05434         registry.AddNodes(std::vector<AddNodesItem>{node});
05435         }
05436        
05437         {
05438         AddNodesItem node;
05439         node.RequestedNewNodeId = ToNodeId("i=11163");
05440         node.BrowseName = ToQualifiedName("BaseConditionClassType");
05441         node.Class = NodeClass::ObjectType;
05442         node.ParentNodeId = ToNodeId("i=58");
05443         node.ReferenceTypeId = ReferenceId::HasSubtype;
05444         ObjectTypeAttributes attrs;
05445         attrs.DisplayName = LocalizedText("BaseConditionClassType");
05446         attrs.IsAbstract = false;
05447         node.Attributes = attrs;
05448         registry.AddNodes(std::vector<AddNodesItem>{node});
05449         }
05450        
05451         {
05452         AddNodesItem node;
05453         node.RequestedNewNodeId = ToNodeId("i=11164");
05454         node.BrowseName = ToQualifiedName("ProcessConditionClassType");
05455         node.Class = NodeClass::ObjectType;
05456         node.ParentNodeId = ToNodeId("i=11163");
05457         node.ReferenceTypeId = ReferenceId::HasSubtype;
05458         ObjectTypeAttributes attrs;
05459         attrs.DisplayName = LocalizedText("ProcessConditionClassType");
05460         attrs.IsAbstract = false;
05461         node.Attributes = attrs;
05462         registry.AddNodes(std::vector<AddNodesItem>{node});
05463         }
05464        
05465         {
05466         AddNodesItem node;
05467         node.RequestedNewNodeId = ToNodeId("i=11165");
05468         node.BrowseName = ToQualifiedName("MaintenanceConditionClassType");
05469         node.Class = NodeClass::ObjectType;
05470         node.ParentNodeId = ToNodeId("i=11163");
05471         node.ReferenceTypeId = ReferenceId::HasSubtype;
05472         ObjectTypeAttributes attrs;
05473         attrs.DisplayName = LocalizedText("MaintenanceConditionClassType");
05474         attrs.IsAbstract = false;
05475         node.Attributes = attrs;
05476         registry.AddNodes(std::vector<AddNodesItem>{node});
05477         }
05478        
05479         {
05480         AddNodesItem node;
05481         node.RequestedNewNodeId = ToNodeId("i=11166");
05482         node.BrowseName = ToQualifiedName("SystemConditionClassType");
05483         node.Class = NodeClass::ObjectType;
05484         node.ParentNodeId = ToNodeId("i=11163");
05485         node.ReferenceTypeId = ReferenceId::HasSubtype;
05486         ObjectTypeAttributes attrs;
05487         attrs.DisplayName = LocalizedText("SystemConditionClassType");
05488         attrs.IsAbstract = false;
05489         node.Attributes = attrs;
05490         registry.AddNodes(std::vector<AddNodesItem>{node});
05491         }
05492        
05493         {
05494         AddNodesItem node;
05495         node.RequestedNewNodeId = ToNodeId("i=2790");
05496         node.BrowseName = ToQualifiedName("AuditConditionEventType");
05497         node.Class = NodeClass::ObjectType;
05498         node.ParentNodeId = ToNodeId("i=2127");
05499         node.ReferenceTypeId = ReferenceId::HasSubtype;
05500         ObjectTypeAttributes attrs;
05501         attrs.DisplayName = LocalizedText("AuditConditionEventType");
05502         attrs.IsAbstract = false;
05503         node.Attributes = attrs;
05504         registry.AddNodes(std::vector<AddNodesItem>{node});
05505         }
05506        
05507         {
05508         AddNodesItem node;
05509         node.RequestedNewNodeId = ToNodeId("i=2803");
05510         node.BrowseName = ToQualifiedName("AuditConditionEnableEventType");
05511         node.Class = NodeClass::ObjectType;
05512         node.ParentNodeId = ToNodeId("i=2790");
05513         node.ReferenceTypeId = ReferenceId::HasSubtype;
05514         ObjectTypeAttributes attrs;
05515         attrs.DisplayName = LocalizedText("AuditConditionEnableEventType");
05516         attrs.IsAbstract = false;
05517         node.Attributes = attrs;
05518         registry.AddNodes(std::vector<AddNodesItem>{node});
05519         }
05520        
05521         {
05522         AddNodesItem node;
05523         node.RequestedNewNodeId = ToNodeId("i=2829");
05524         node.BrowseName = ToQualifiedName("AuditConditionCommentEventType");
05525         node.Class = NodeClass::ObjectType;
05526         node.ParentNodeId = ToNodeId("i=2790");
05527         node.ReferenceTypeId = ReferenceId::HasSubtype;
05528         ObjectTypeAttributes attrs;
05529         attrs.DisplayName = LocalizedText("AuditConditionCommentEventType");
05530         attrs.IsAbstract = false;
05531         node.Attributes = attrs;
05532         registry.AddNodes(std::vector<AddNodesItem>{node});
05533         std::vector<AddReferencesItem> refs;
05534         {
05535         AddReferencesItem ref;
05536         ref.IsForward = true;
05537         ref.ReferenceTypeId = ReferenceId::HasProperty;
05538         ref.SourceNodeId = ToNodeId("i=2829");
05539         ref.TargetNodeClass = NodeClass::DataType;
05540         ref.TargetNodeId = ToNodeId("i=4170");
05541         refs.push_back(ref);
05542         }
05543         {
05544         AddReferencesItem ref;
05545         ref.IsForward = true;
05546         ref.ReferenceTypeId = ReferenceId::HasProperty;
05547         ref.SourceNodeId = ToNodeId("i=2829");
05548         ref.TargetNodeClass = NodeClass::DataType;
05549         ref.TargetNodeId = ToNodeId("i=11851");
05550         refs.push_back(ref);
05551         }
05552         registry.AddReferences(refs);
05553         }
05554        
05555         {
05556         AddNodesItem node;
05557         node.RequestedNewNodeId = ToNodeId("i=4170");
05558         node.BrowseName = ToQualifiedName("EventId");
05559         node.Class = NodeClass::Variable;
05560         node.ParentNodeId = ToNodeId("i=2829");
05561         node.ReferenceTypeId = ReferenceId::HasProperty;
05562         node.TypeDefinition = ToNodeId("i=68");
05563         VariableAttributes attrs;
05564         attrs.Description = LocalizedText("A globally unique identifier for the event.");
05565         attrs.DisplayName = LocalizedText("EventId");
05566         attrs.Type = ObjectId::ByteString;
05567         attrs.Rank = -1;
05568         node.Attributes = attrs;
05569         registry.AddNodes(std::vector<AddNodesItem>{node});
05570         std::vector<AddReferencesItem> refs;
05571         {
05572         AddReferencesItem ref;
05573         ref.IsForward = true;
05574         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05575         ref.SourceNodeId = ToNodeId("i=4170");
05576         ref.TargetNodeClass = NodeClass::DataType;
05577         ref.TargetNodeId = ToNodeId("i=78");
05578         refs.push_back(ref);
05579         }
05580         registry.AddReferences(refs);
05581         }
05582        
05583         {
05584         AddNodesItem node;
05585         node.RequestedNewNodeId = ToNodeId("i=11851");
05586         node.BrowseName = ToQualifiedName("Comment");
05587         node.Class = NodeClass::Variable;
05588         node.ParentNodeId = ToNodeId("i=2829");
05589         node.ReferenceTypeId = ReferenceId::HasProperty;
05590         node.TypeDefinition = ToNodeId("i=68");
05591         VariableAttributes attrs;
05592         attrs.DisplayName = LocalizedText("Comment");
05593         attrs.Type = ObjectId::LocalizedText;
05594         attrs.Rank = -1;
05595         node.Attributes = attrs;
05596         registry.AddNodes(std::vector<AddNodesItem>{node});
05597         std::vector<AddReferencesItem> refs;
05598         {
05599         AddReferencesItem ref;
05600         ref.IsForward = true;
05601         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05602         ref.SourceNodeId = ToNodeId("i=11851");
05603         ref.TargetNodeClass = NodeClass::DataType;
05604         ref.TargetNodeId = ToNodeId("i=78");
05605         refs.push_back(ref);
05606         }
05607         registry.AddReferences(refs);
05608         }
05609        
05610         {
05611         AddNodesItem node;
05612         node.RequestedNewNodeId = ToNodeId("i=8927");
05613         node.BrowseName = ToQualifiedName("AuditConditionRespondEventType");
05614         node.Class = NodeClass::ObjectType;
05615         node.ParentNodeId = ToNodeId("i=2790");
05616         node.ReferenceTypeId = ReferenceId::HasSubtype;
05617         ObjectTypeAttributes attrs;
05618         attrs.DisplayName = LocalizedText("AuditConditionRespondEventType");
05619         attrs.IsAbstract = false;
05620         node.Attributes = attrs;
05621         registry.AddNodes(std::vector<AddNodesItem>{node});
05622         std::vector<AddReferencesItem> refs;
05623         {
05624         AddReferencesItem ref;
05625         ref.IsForward = true;
05626         ref.ReferenceTypeId = ReferenceId::HasProperty;
05627         ref.SourceNodeId = ToNodeId("i=8927");
05628         ref.TargetNodeClass = NodeClass::DataType;
05629         ref.TargetNodeId = ToNodeId("i=11852");
05630         refs.push_back(ref);
05631         }
05632         registry.AddReferences(refs);
05633         }
05634        
05635         {
05636         AddNodesItem node;
05637         node.RequestedNewNodeId = ToNodeId("i=11852");
05638         node.BrowseName = ToQualifiedName("SelectedResponse");
05639         node.Class = NodeClass::Variable;
05640         node.ParentNodeId = ToNodeId("i=8927");
05641         node.ReferenceTypeId = ReferenceId::HasProperty;
05642         node.TypeDefinition = ToNodeId("i=68");
05643         VariableAttributes attrs;
05644         attrs.DisplayName = LocalizedText("SelectedResponse");
05645         attrs.Type = ObjectId::Int32;
05646         attrs.Rank = -1;
05647         node.Attributes = attrs;
05648         registry.AddNodes(std::vector<AddNodesItem>{node});
05649         std::vector<AddReferencesItem> refs;
05650         {
05651         AddReferencesItem ref;
05652         ref.IsForward = true;
05653         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05654         ref.SourceNodeId = ToNodeId("i=11852");
05655         ref.TargetNodeClass = NodeClass::DataType;
05656         ref.TargetNodeId = ToNodeId("i=78");
05657         refs.push_back(ref);
05658         }
05659         registry.AddReferences(refs);
05660         }
05661        
05662         {
05663         AddNodesItem node;
05664         node.RequestedNewNodeId = ToNodeId("i=8944");
05665         node.BrowseName = ToQualifiedName("AuditConditionAcknowledgeEventType");
05666         node.Class = NodeClass::ObjectType;
05667         node.ParentNodeId = ToNodeId("i=2790");
05668         node.ReferenceTypeId = ReferenceId::HasSubtype;
05669         ObjectTypeAttributes attrs;
05670         attrs.DisplayName = LocalizedText("AuditConditionAcknowledgeEventType");
05671         attrs.IsAbstract = false;
05672         node.Attributes = attrs;
05673         registry.AddNodes(std::vector<AddNodesItem>{node});
05674         std::vector<AddReferencesItem> refs;
05675         {
05676         AddReferencesItem ref;
05677         ref.IsForward = true;
05678         ref.ReferenceTypeId = ReferenceId::HasProperty;
05679         ref.SourceNodeId = ToNodeId("i=8944");
05680         ref.TargetNodeClass = NodeClass::DataType;
05681         ref.TargetNodeId = ToNodeId("i=8945");
05682         refs.push_back(ref);
05683         }
05684         {
05685         AddReferencesItem ref;
05686         ref.IsForward = true;
05687         ref.ReferenceTypeId = ReferenceId::HasProperty;
05688         ref.SourceNodeId = ToNodeId("i=8944");
05689         ref.TargetNodeClass = NodeClass::DataType;
05690         ref.TargetNodeId = ToNodeId("i=11853");
05691         refs.push_back(ref);
05692         }
05693         registry.AddReferences(refs);
05694         }
05695        
05696         {
05697         AddNodesItem node;
05698         node.RequestedNewNodeId = ToNodeId("i=8945");
05699         node.BrowseName = ToQualifiedName("EventId");
05700         node.Class = NodeClass::Variable;
05701         node.ParentNodeId = ToNodeId("i=8944");
05702         node.ReferenceTypeId = ReferenceId::HasProperty;
05703         node.TypeDefinition = ToNodeId("i=68");
05704         VariableAttributes attrs;
05705         attrs.Description = LocalizedText("A globally unique identifier for the event.");
05706         attrs.DisplayName = LocalizedText("EventId");
05707         attrs.Type = ObjectId::ByteString;
05708         attrs.Rank = -1;
05709         node.Attributes = attrs;
05710         registry.AddNodes(std::vector<AddNodesItem>{node});
05711         std::vector<AddReferencesItem> refs;
05712         {
05713         AddReferencesItem ref;
05714         ref.IsForward = true;
05715         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05716         ref.SourceNodeId = ToNodeId("i=8945");
05717         ref.TargetNodeClass = NodeClass::DataType;
05718         ref.TargetNodeId = ToNodeId("i=78");
05719         refs.push_back(ref);
05720         }
05721         registry.AddReferences(refs);
05722         }
05723        
05724         {
05725         AddNodesItem node;
05726         node.RequestedNewNodeId = ToNodeId("i=11853");
05727         node.BrowseName = ToQualifiedName("Comment");
05728         node.Class = NodeClass::Variable;
05729         node.ParentNodeId = ToNodeId("i=8944");
05730         node.ReferenceTypeId = ReferenceId::HasProperty;
05731         node.TypeDefinition = ToNodeId("i=68");
05732         VariableAttributes attrs;
05733         attrs.DisplayName = LocalizedText("Comment");
05734         attrs.Type = ObjectId::LocalizedText;
05735         attrs.Rank = -1;
05736         node.Attributes = attrs;
05737         registry.AddNodes(std::vector<AddNodesItem>{node});
05738         std::vector<AddReferencesItem> refs;
05739         {
05740         AddReferencesItem ref;
05741         ref.IsForward = true;
05742         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05743         ref.SourceNodeId = ToNodeId("i=11853");
05744         ref.TargetNodeClass = NodeClass::DataType;
05745         ref.TargetNodeId = ToNodeId("i=78");
05746         refs.push_back(ref);
05747         }
05748         registry.AddReferences(refs);
05749         }
05750        
05751         {
05752         AddNodesItem node;
05753         node.RequestedNewNodeId = ToNodeId("i=8961");
05754         node.BrowseName = ToQualifiedName("AuditConditionConfirmEventType");
05755         node.Class = NodeClass::ObjectType;
05756         node.ParentNodeId = ToNodeId("i=2790");
05757         node.ReferenceTypeId = ReferenceId::HasSubtype;
05758         ObjectTypeAttributes attrs;
05759         attrs.DisplayName = LocalizedText("AuditConditionConfirmEventType");
05760         attrs.IsAbstract = false;
05761         node.Attributes = attrs;
05762         registry.AddNodes(std::vector<AddNodesItem>{node});
05763         std::vector<AddReferencesItem> refs;
05764         {
05765         AddReferencesItem ref;
05766         ref.IsForward = true;
05767         ref.ReferenceTypeId = ReferenceId::HasProperty;
05768         ref.SourceNodeId = ToNodeId("i=8961");
05769         ref.TargetNodeClass = NodeClass::DataType;
05770         ref.TargetNodeId = ToNodeId("i=8962");
05771         refs.push_back(ref);
05772         }
05773         {
05774         AddReferencesItem ref;
05775         ref.IsForward = true;
05776         ref.ReferenceTypeId = ReferenceId::HasProperty;
05777         ref.SourceNodeId = ToNodeId("i=8961");
05778         ref.TargetNodeClass = NodeClass::DataType;
05779         ref.TargetNodeId = ToNodeId("i=11854");
05780         refs.push_back(ref);
05781         }
05782         registry.AddReferences(refs);
05783         }
05784        
05785         {
05786         AddNodesItem node;
05787         node.RequestedNewNodeId = ToNodeId("i=8962");
05788         node.BrowseName = ToQualifiedName("EventId");
05789         node.Class = NodeClass::Variable;
05790         node.ParentNodeId = ToNodeId("i=8961");
05791         node.ReferenceTypeId = ReferenceId::HasProperty;
05792         node.TypeDefinition = ToNodeId("i=68");
05793         VariableAttributes attrs;
05794         attrs.Description = LocalizedText("A globally unique identifier for the event.");
05795         attrs.DisplayName = LocalizedText("EventId");
05796         attrs.Type = ObjectId::ByteString;
05797         attrs.Rank = -1;
05798         node.Attributes = attrs;
05799         registry.AddNodes(std::vector<AddNodesItem>{node});
05800         std::vector<AddReferencesItem> refs;
05801         {
05802         AddReferencesItem ref;
05803         ref.IsForward = true;
05804         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05805         ref.SourceNodeId = ToNodeId("i=8962");
05806         ref.TargetNodeClass = NodeClass::DataType;
05807         ref.TargetNodeId = ToNodeId("i=78");
05808         refs.push_back(ref);
05809         }
05810         registry.AddReferences(refs);
05811         }
05812        
05813         {
05814         AddNodesItem node;
05815         node.RequestedNewNodeId = ToNodeId("i=11854");
05816         node.BrowseName = ToQualifiedName("Comment");
05817         node.Class = NodeClass::Variable;
05818         node.ParentNodeId = ToNodeId("i=8961");
05819         node.ReferenceTypeId = ReferenceId::HasProperty;
05820         node.TypeDefinition = ToNodeId("i=68");
05821         VariableAttributes attrs;
05822         attrs.DisplayName = LocalizedText("Comment");
05823         attrs.Type = ObjectId::LocalizedText;
05824         attrs.Rank = -1;
05825         node.Attributes = attrs;
05826         registry.AddNodes(std::vector<AddNodesItem>{node});
05827         std::vector<AddReferencesItem> refs;
05828         {
05829         AddReferencesItem ref;
05830         ref.IsForward = true;
05831         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05832         ref.SourceNodeId = ToNodeId("i=11854");
05833         ref.TargetNodeClass = NodeClass::DataType;
05834         ref.TargetNodeId = ToNodeId("i=78");
05835         refs.push_back(ref);
05836         }
05837         registry.AddReferences(refs);
05838         }
05839        
05840         {
05841         AddNodesItem node;
05842         node.RequestedNewNodeId = ToNodeId("i=11093");
05843         node.BrowseName = ToQualifiedName("AuditConditionShelvingEventType");
05844         node.Class = NodeClass::ObjectType;
05845         node.ParentNodeId = ToNodeId("i=2790");
05846         node.ReferenceTypeId = ReferenceId::HasSubtype;
05847         ObjectTypeAttributes attrs;
05848         attrs.DisplayName = LocalizedText("AuditConditionShelvingEventType");
05849         attrs.IsAbstract = false;
05850         node.Attributes = attrs;
05851         registry.AddNodes(std::vector<AddNodesItem>{node});
05852         std::vector<AddReferencesItem> refs;
05853         {
05854         AddReferencesItem ref;
05855         ref.IsForward = true;
05856         ref.ReferenceTypeId = ReferenceId::HasProperty;
05857         ref.SourceNodeId = ToNodeId("i=11093");
05858         ref.TargetNodeClass = NodeClass::DataType;
05859         ref.TargetNodeId = ToNodeId("i=11855");
05860         refs.push_back(ref);
05861         }
05862         registry.AddReferences(refs);
05863         }
05864        
05865         {
05866         AddNodesItem node;
05867         node.RequestedNewNodeId = ToNodeId("i=11855");
05868         node.BrowseName = ToQualifiedName("ShelvingTime");
05869         node.Class = NodeClass::Variable;
05870         node.ParentNodeId = ToNodeId("i=11093");
05871         node.ReferenceTypeId = ReferenceId::HasProperty;
05872         node.TypeDefinition = ToNodeId("i=68");
05873         VariableAttributes attrs;
05874         attrs.DisplayName = LocalizedText("ShelvingTime");
05875         attrs.Type = ToNodeId("i=290");
05876         attrs.Rank = -1;
05877         node.Attributes = attrs;
05878         registry.AddNodes(std::vector<AddNodesItem>{node});
05879         std::vector<AddReferencesItem> refs;
05880         {
05881         AddReferencesItem ref;
05882         ref.IsForward = true;
05883         ref.ReferenceTypeId = ReferenceId::HasModellingRule;
05884         ref.SourceNodeId = ToNodeId("i=11855");
05885         ref.TargetNodeClass = NodeClass::DataType;
05886         ref.TargetNodeId = ToNodeId("i=78");
05887         refs.push_back(ref);
05888         }
05889         registry.AddReferences(refs);
05890         }
05891        
05892         {
05893         AddNodesItem node;
05894         node.RequestedNewNodeId = ToNodeId("i=2787");
05895         node.BrowseName = ToQualifiedName("RefreshStartEventType");
05896         node.Class = NodeClass::ObjectType;
05897         node.ParentNodeId = ToNodeId("i=2130");
05898         node.ReferenceTypeId = ReferenceId::HasSubtype;
05899         ObjectTypeAttributes attrs;
05900         attrs.DisplayName = LocalizedText("RefreshStartEventType");
05901         attrs.IsAbstract = false;
05902         node.Attributes = attrs;
05903         registry.AddNodes(std::vector<AddNodesItem>{node});
05904         }
05905        
05906         {
05907         AddNodesItem node;
05908         node.RequestedNewNodeId = ToNodeId("i=2788");
05909         node.BrowseName = ToQualifiedName("RefreshEndEventType");
05910         node.Class = NodeClass::ObjectType;
05911         node.ParentNodeId = ToNodeId("i=2130");
05912         node.ReferenceTypeId = ReferenceId::HasSubtype;
05913         ObjectTypeAttributes attrs;
05914         attrs.DisplayName = LocalizedText("RefreshEndEventType");
05915         attrs.IsAbstract = false;
05916         node.Attributes = attrs;
05917         registry.AddNodes(std::vector<AddNodesItem>{node});
05918         }
05919        
05920         {
05921         AddNodesItem node;
05922         node.RequestedNewNodeId = ToNodeId("i=2789");
05923         node.BrowseName = ToQualifiedName("RefreshRequiredEventType");
05924         node.Class = NodeClass::ObjectType;
05925         node.ParentNodeId = ToNodeId("i=2130");
05926         node.ReferenceTypeId = ReferenceId::HasSubtype;
05927         ObjectTypeAttributes attrs;
05928         attrs.DisplayName = LocalizedText("RefreshRequiredEventType");
05929         attrs.IsAbstract = false;
05930         node.Attributes = attrs;
05931         registry.AddNodes(std::vector<AddNodesItem>{node});
05932         }
05933        
05934         {
05935         AddNodesItem node;
05936         node.RequestedNewNodeId = ToNodeId("i=9006");
05937         node.BrowseName = ToQualifiedName("HasCondition");
05938         node.Class = NodeClass::ReferenceType;
05939         node.ParentNodeId = ToNodeId("i=32");
05940         node.ReferenceTypeId = ReferenceId::HasSubtype;
05941         ReferenceTypeAttributes attrs;
05942         attrs.DisplayName = LocalizedText("HasCondition");
05943         attrs.InverseName = LocalizedText("IsConditionOf");
05944         attrs.IsAbstract = false;
05945         attrs.Symmetric = false;
05946         node.Attributes = attrs;
05947         registry.AddNodes(std::vector<AddNodesItem>{node});
05948         }
05949 
05950    }
05951 
05952 } // namespace
05953