rplc_opcua 0.12.4

// OPCUA for Rust
// SPDX-License-Identifier: MPL-2.0
// Copyright (C) 2017-2022 Adam Lock
// This file was autogenerated from Opc.Ua.NodeSet2.Part5.xml by tools/schema/gen_address_space.js
// DO NOT EDIT THIS FILE

#[allow(unused_imports)]
use std::{convert::TryFrom, str::FromStr};

#[allow(unused_imports)]
use crate::{
    server::address_space::{types::*, EventNotifier},
    types::{
        service_types::Argument, DataTypeId, ExtensionObject, LocalizedText, NodeId,
        ReferenceTypeId, UAString, Variant, VariantTypeId,
    },
};

#[allow(unused_variables)]
pub fn populate_address_space(address_space: &mut AddressSpace) {
    add_objecttype_1(address_space);
    add_objecttype_2(address_space);
    add_objecttype_3(address_space);
    add_objecttype_4(address_space);
    add_objecttype_5(address_space);
    add_objecttype_6(address_space);
    add_objecttype_7(address_space);
    add_objecttype_8(address_space);
    add_objecttype_9(address_space);
    add_objecttype_10(address_space);
    add_objecttype_11(address_space);
    add_objecttype_12(address_space);
    add_objecttype_13(address_space);
    add_objecttype_14(address_space);
    add_objecttype_15(address_space);
    add_objecttype_16(address_space);
    add_objecttype_17(address_space);
    add_objecttype_18(address_space);
    add_objecttype_19(address_space);
    add_objecttype_20(address_space);
    add_objecttype_21(address_space);
    add_objecttype_22(address_space);
    add_objecttype_23(address_space);
    add_objecttype_24(address_space);
    add_objecttype_25(address_space);
    add_objecttype_26(address_space);
    add_objecttype_27(address_space);
    add_objecttype_28(address_space);
    add_objecttype_29(address_space);
    add_objecttype_30(address_space);
    add_objecttype_31(address_space);
    add_objecttype_32(address_space);
    add_objecttype_33(address_space);
    add_objecttype_34(address_space);
    add_objecttype_35(address_space);
    add_objecttype_36(address_space);
    add_objecttype_37(address_space);
    add_objecttype_38(address_space);
    add_objecttype_39(address_space);
    add_objecttype_40(address_space);
    add_datatype_41(address_space);
    add_datatype_42(address_space);
    add_datatype_43(address_space);
    add_datatype_44(address_space);
    add_datatype_45(address_space);
    add_datatype_46(address_space);
    add_datatype_47(address_space);
    add_datatype_48(address_space);
    add_datatype_49(address_space);
    add_datatype_50(address_space);
    add_datatype_51(address_space);
    add_datatype_52(address_space);
    add_datatype_53(address_space);
    add_datatype_54(address_space);
    add_datatype_55(address_space);
    add_datatype_56(address_space);
    add_datatype_57(address_space);
    add_datatype_58(address_space);
    add_datatype_59(address_space);
    add_datatype_60(address_space);
    add_datatype_61(address_space);
    add_datatype_62(address_space);
    add_datatype_63(address_space);
    add_datatype_64(address_space);
    add_datatype_65(address_space);
    add_datatype_66(address_space);
    add_datatype_67(address_space);
    add_datatype_68(address_space);
    add_datatype_69(address_space);
    add_datatype_70(address_space);
    add_datatype_71(address_space);
    add_datatype_72(address_space);
    add_datatype_73(address_space);
    add_datatype_74(address_space);
    add_datatype_75(address_space);
    add_referencetype_76(address_space);
    add_referencetype_77(address_space);
    add_referencetype_78(address_space);
    add_referencetype_79(address_space);
    add_referencetype_80(address_space);
    add_referencetype_81(address_space);
    add_referencetype_82(address_space);
    add_referencetype_83(address_space);
    add_referencetype_84(address_space);
    add_variable_85(address_space);
    add_variable_86(address_space);
    add_variable_87(address_space);
    add_variable_88(address_space);
    add_variable_89(address_space);
    add_variable_90(address_space);
    add_variable_91(address_space);
    add_variable_92(address_space);
    add_variable_93(address_space);
    add_variable_94(address_space);
    add_variable_95(address_space);
    add_variable_96(address_space);
    add_variable_97(address_space);
    add_variable_98(address_space);
    add_variable_99(address_space);
    add_variable_100(address_space);
}

fn add_objecttype_1(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCertificateMismatchEventType";
    let node_id = NodeId::new(0, 2089);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2080), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_2(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditNodeManagementEventType";
    let node_id = NodeId::new(0, 2090);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2052), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_3(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditAddNodesEventType";
    let node_id = NodeId::new(0, 2091);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2092), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2090), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_4(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditDeleteNodesEventType";
    let node_id = NodeId::new(0, 2093);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2094), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2090), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_5(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditAddReferencesEventType";
    let node_id = NodeId::new(0, 2095);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2096), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2090), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_6(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditDeleteReferencesEventType";
    let node_id = NodeId::new(0, 2097);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2098), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2090), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_7(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditUpdateEventType";
    let node_id = NodeId::new(0, 2099);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2052), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_8(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditWriteUpdateEventType";
    let node_id = NodeId::new(0, 2100);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2750), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2101), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2102), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2103), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2099), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_9(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditHistoryUpdateEventType";
    let node_id = NodeId::new(0, 2104);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2751), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2099), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_10(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditUpdateMethodEventType";
    let node_id = NodeId::new(0, 2127);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2128), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2129), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2052), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_11(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "SystemEventType";
    let node_id = NodeId::new(0, 2130);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2041), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_12(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "DeviceFailureEventType";
    let node_id = NodeId::new(0, 2131);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2130), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_13(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "SystemStatusChangeEventType";
    let node_id = NodeId::new(0, 11446);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11696), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2130), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_14(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "BaseModelChangeEventType";
    let node_id = NodeId::new(0, 2132);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2041), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_15(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "GeneralModelChangeEventType";
    let node_id = NodeId::new(0, 2133);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2134), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2132), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_16(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "SemanticChangeEventType";
    let node_id = NodeId::new(0, 2738);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2739), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2041), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_17(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "EventQueueOverflowEventType";
    let node_id = NodeId::new(0, 3035);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2041), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_18(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ProgressEventType";
    let node_id = NodeId::new(0, 11436);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 12502), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12503), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2041), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_19(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AggregateFunctionType";
    let node_id = NodeId::new(0, 2340);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_20(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "StateMachineType";
    let node_id = NodeId::new(0, 2299);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2769), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2770), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_21(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "FiniteStateMachineType";
    let node_id = NodeId::new(0, 2771);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2772), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2773), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 17635), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 17636), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2299), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_22(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "StateType";
    let node_id = NodeId::new(0, 2307);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2308), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_23(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "InitialStateType";
    let node_id = NodeId::new(0, 2309);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2307), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_24(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "TransitionType";
    let node_id = NodeId::new(0, 2310);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2312), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_25(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ChoiceStateType";
    let node_id = NodeId::new(0, 15109);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2307), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_26(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "TransitionEventType";
    let node_id = NodeId::new(0, 2311);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2774), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2775), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2776), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2041), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_27(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditUpdateStateEventType";
    let node_id = NodeId::new(0, 2315);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2777), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2778), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2127), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_28(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "FileDirectoryType";
    let node_id = NodeId::new(0, 13353);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 13354), &ReferenceTypeId::Organizes, ReferenceDirection::Forward),
        (&NodeId::new(0, 13366), &ReferenceTypeId::Organizes, ReferenceDirection::Forward),
        (&NodeId::new(0, 13387), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 13390), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 13393), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 13395), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 61), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_29(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "TemporaryFileTransferType";
    let node_id = NodeId::new(0, 15744);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 15745), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 15746), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15749), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15751), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15754), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_30(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "FileTransferStateMachineType";
    let node_id = NodeId::new(0, 15803);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 15815), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15817), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15819), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15821), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15823), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15825), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15827), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15829), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15831), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15833), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15835), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15837), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15839), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15841), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15843), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2771), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_31(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "RoleSetType";
    let node_id = NodeId::new(0, 15607);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 15608), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15997), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 16000), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_32(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "RoleType";
    let node_id = NodeId::new(0, 15620);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 16173), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 16174), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 15410), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 16175), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 15411), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 15624), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15626), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 16176), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 16178), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 16180), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 16182), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_33(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "RoleMappingRuleChangedAuditEventType";
    let node_id = NodeId::new(0, 17641);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2127), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_34(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "DictionaryEntryType";
    let node_id = NodeId::new(0, 17589);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 17590), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_35(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "DictionaryFolderType";
    let node_id = NodeId::new(0, 17591);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 17592), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 17593), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 61), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_36(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "IrdiDictionaryEntryType";
    let node_id = NodeId::new(0, 17598);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 17589), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_37(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "UriDictionaryEntryType";
    let node_id = NodeId::new(0, 17600);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 17589), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_38(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "BaseInterfaceType";
    let node_id = NodeId::new(0, 17602);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_39(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "IOrderedObjectType";
    let node_id = NodeId::new(0, 23513);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 23517), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17602), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_40(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "OrderedListType";
    let node_id = NodeId::new(0, 23518);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 23525), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_41(address_space: &mut AddressSpace) {
    // DataType
    let name = "BitFieldMaskDataType";
    let node_id = NodeId::new(0, 11737);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 9), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_42(address_space: &mut AddressSpace) {
    // DataType
    let name = "KeyValuePair";
    let node_id = NodeId::new(0, 14533);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_43(address_space: &mut AddressSpace) {
    // DataType
    let name = "AdditionalParametersType";
    let node_id = NodeId::new(0, 16313);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_44(address_space: &mut AddressSpace) {
    // DataType
    let name = "EphemeralKeyType";
    let node_id = NodeId::new(0, 17548);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_45(address_space: &mut AddressSpace) {
    // DataType
    let name = "EndpointType";
    let node_id = NodeId::new(0, 15528);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_46(address_space: &mut AddressSpace) {
    // DataType
    let name = "RationalNumber";
    let node_id = NodeId::new(0, 18806);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_47(address_space: &mut AddressSpace) {
    // DataType
    let name = "Vector";
    let node_id = NodeId::new(0, 18807);
    let node = DataType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_48(address_space: &mut AddressSpace) {
    // DataType
    let name = "3DVector";
    let node_id = NodeId::new(0, 18808);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 18807), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_49(address_space: &mut AddressSpace) {
    // DataType
    let name = "CartesianCoordinates";
    let node_id = NodeId::new(0, 18809);
    let node = DataType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_50(address_space: &mut AddressSpace) {
    // DataType
    let name = "3DCartesianCoordinates";
    let node_id = NodeId::new(0, 18810);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 18809), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_51(address_space: &mut AddressSpace) {
    // DataType
    let name = "Orientation";
    let node_id = NodeId::new(0, 18811);
    let node = DataType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_52(address_space: &mut AddressSpace) {
    // DataType
    let name = "3DOrientation";
    let node_id = NodeId::new(0, 18812);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 18811), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_53(address_space: &mut AddressSpace) {
    // DataType
    let name = "Frame";
    let node_id = NodeId::new(0, 18813);
    let node = DataType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_54(address_space: &mut AddressSpace) {
    // DataType
    let name = "3DFrame";
    let node_id = NodeId::new(0, 18814);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 18813), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_55(address_space: &mut AddressSpace) {
    // DataType
    let name = "OpenFileMode";
    let node_id = NodeId::new(0, 11939);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11940), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 29), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_56(address_space: &mut AddressSpace) {
    // DataType
    let name = "IdentityCriteriaType";
    let node_id = NodeId::new(0, 15632);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 15633), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 29), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_57(address_space: &mut AddressSpace) {
    // DataType
    let name = "IdentityMappingRuleType";
    let node_id = NodeId::new(0, 15634);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_58(address_space: &mut AddressSpace) {
    // DataType
    let name = "CurrencyUnitType";
    let node_id = NodeId::new(0, 23498);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_59(address_space: &mut AddressSpace) {
    // DataType
    let name = "BuildInfo";
    let node_id = NodeId::new(0, 338);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_60(address_space: &mut AddressSpace) {
    // DataType
    let name = "RedundancySupport";
    let node_id = NodeId::new(0, 851);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 7611), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 29), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_61(address_space: &mut AddressSpace) {
    // DataType
    let name = "ServerState";
    let node_id = NodeId::new(0, 852);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 7612), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 29), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_62(address_space: &mut AddressSpace) {
    // DataType
    let name = "RedundantServerDataType";
    let node_id = NodeId::new(0, 853);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_63(address_space: &mut AddressSpace) {
    // DataType
    let name = "EndpointUrlListDataType";
    let node_id = NodeId::new(0, 11943);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_64(address_space: &mut AddressSpace) {
    // DataType
    let name = "NetworkGroupDataType";
    let node_id = NodeId::new(0, 11944);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_65(address_space: &mut AddressSpace) {
    // DataType
    let name = "SamplingIntervalDiagnosticsDataType";
    let node_id = NodeId::new(0, 856);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_66(address_space: &mut AddressSpace) {
    // DataType
    let name = "ServerDiagnosticsSummaryDataType";
    let node_id = NodeId::new(0, 859);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_67(address_space: &mut AddressSpace) {
    // DataType
    let name = "ServerStatusDataType";
    let node_id = NodeId::new(0, 862);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_68(address_space: &mut AddressSpace) {
    // DataType
    let name = "SessionDiagnosticsDataType";
    let node_id = NodeId::new(0, 865);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_69(address_space: &mut AddressSpace) {
    // DataType
    let name = "SessionSecurityDiagnosticsDataType";
    let node_id = NodeId::new(0, 868);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_70(address_space: &mut AddressSpace) {
    // DataType
    let name = "ServiceCounterDataType";
    let node_id = NodeId::new(0, 871);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_71(address_space: &mut AddressSpace) {
    // DataType
    let name = "StatusResult";
    let node_id = NodeId::new(0, 299);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_72(address_space: &mut AddressSpace) {
    // DataType
    let name = "SubscriptionDiagnosticsDataType";
    let node_id = NodeId::new(0, 874);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_73(address_space: &mut AddressSpace) {
    // DataType
    let name = "ModelChangeStructureVerbMask";
    let node_id = NodeId::new(0, 11941);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11942), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 29), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_74(address_space: &mut AddressSpace) {
    // DataType
    let name = "ModelChangeStructureDataType";
    let node_id = NodeId::new(0, 877);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_75(address_space: &mut AddressSpace) {
    // DataType
    let name = "SemanticChangeStructureDataType";
    let node_id = NodeId::new(0, 897);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 22), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_76(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "FromState";
    let node_id = NodeId::new(0, 51);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "ToTransition")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 32), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_77(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "ToState";
    let node_id = NodeId::new(0, 52);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "FromTransition")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 32), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_78(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "HasCause";
    let node_id = NodeId::new(0, 53);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "MayBeCausedBy")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 32), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_79(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "HasEffect";
    let node_id = NodeId::new(0, 54);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "MayBeEffectedBy")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 32), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_80(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "HasSubStateMachine";
    let node_id = NodeId::new(0, 117);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "SubStateMachineOf")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 32), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_81(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "HasGuard";
    let node_id = NodeId::new(0, 15112);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "GuardOf")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 47), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_82(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "HasDictionaryEntry";
    let node_id = NodeId::new(0, 17597);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "DictionaryEntryOf")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 32), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_83(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "HasInterface";
    let node_id = NodeId::new(0, 17603);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "InterfaceOf")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 32), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_84(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "HasAddIn";
    let node_id = NodeId::new(0, 17604);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "AddInOf")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 47), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_85(address_space: &mut AddressSpace) {
    // Variable
    let name = "DataTypeVersion";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 104);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 12), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 69), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_86(address_space: &mut AddressSpace) {
    // Variable
    let name = "DictionaryFragment";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 105);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 15), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 69), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_87(address_space: &mut AddressSpace) {
    // Variable
    let name = "DataTypeVersion";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 106);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 12), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 72), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_88(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamespaceUri";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 107);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 12), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 72), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_89(address_space: &mut AddressSpace) {
    // Variable
    let name = "Deprecated";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15001);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 1), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 72), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_90(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamingRule";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 111);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 120), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 77), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_91(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamingRule";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 112);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 120), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_92(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamingRule";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 113);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 120), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_93(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamingRule";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 114);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 120), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 83), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_94(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamingRule";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11509);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 120), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 11508), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_95(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamingRule";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11511);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 120), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 11510), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_96(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamespaceUri";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15958);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 12), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 15957), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_97(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamespaceVersion";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15959);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 12), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 15957), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_98(address_space: &mut AddressSpace) {
    // Variable
    let name = "NamespacePublicationDate";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15960);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 13), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 15957), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_99(address_space: &mut AddressSpace) {
    // Variable
    let name = "IsNamespaceSubset";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15961);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 1), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 15957), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_100(address_space: &mut AddressSpace) {
    // Variable
    let name = "StaticNodeIdTypes";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15962);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 256), Some(1), Some(0), value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 15957), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}