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.Part11.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_object_1(address_space);
    add_object_2(address_space);
    add_object_3(address_space);
    add_object_4(address_space);
    add_object_5(address_space);
    add_object_6(address_space);
    add_object_7(address_space);
    add_object_8(address_space);
    add_object_9(address_space);
    add_object_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_datatype_20(address_space);
    add_datatype_21(address_space);
    add_referencetype_22(address_space);
    add_variable_23(address_space);
    add_variable_24(address_space);
    add_variable_25(address_space);
    add_variable_26(address_space);
    add_variable_27(address_space);
    add_variable_28(address_space);
    add_variable_29(address_space);
    add_variable_30(address_space);
    add_variable_31(address_space);
    add_variable_32(address_space);
    add_variable_33(address_space);
    add_variable_34(address_space);
    add_variable_35(address_space);
    add_variable_36(address_space);
    add_variable_37(address_space);
    add_variable_38(address_space);
    add_variable_39(address_space);
    add_variable_40(address_space);
    add_variable_41(address_space);
    add_variable_42(address_space);
    add_variable_43(address_space);
    add_variable_44(address_space);
    add_variable_45(address_space);
    add_variable_46(address_space);
    add_variable_47(address_space);
    add_variable_48(address_space);
    add_variable_49(address_space);
    add_variable_50(address_space);
    add_variable_51(address_space);
    add_variable_52(address_space);
    add_variable_53(address_space);
    add_variable_54(address_space);
    add_variable_55(address_space);
    add_variable_56(address_space);
    add_variable_57(address_space);
    add_variable_58(address_space);
    add_variable_59(address_space);
    add_variable_60(address_space);
    add_variable_61(address_space);
    add_variable_62(address_space);
    add_variable_63(address_space);
    add_variable_64(address_space);
    add_variable_65(address_space);
    add_variable_66(address_space);
    add_variable_67(address_space);
    add_variable_68(address_space);
    add_variable_69(address_space);
    add_variable_70(address_space);
    add_variable_71(address_space);
    add_variable_72(address_space);
    add_variable_73(address_space);
    add_variable_74(address_space);
    add_variable_75(address_space);
    add_variable_76(address_space);
    add_variable_77(address_space);
    add_variable_78(address_space);
    add_variable_79(address_space);
    add_variable_80(address_space);
    add_variable_81(address_space);
    add_variable_82(address_space);
    add_variable_83(address_space);
    add_variable_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);
}

fn add_object_1(address_space: &mut AddressSpace) {
    // Object
    let name = "HistoryServerCapabilities";
    let node_id = NodeId::new(0, 11192);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11193), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11242), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11273), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11274), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11196), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11197), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11198), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11199), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11200), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11281), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11282), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11283), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11502), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11275), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11201), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 19091), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2268), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}

fn add_object_2(address_space: &mut AddressSpace) {
    // Object
    let name = "AggregateFunctions";
    let node_id = NodeId::new(0, 11201);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 61), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 11192), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_3(address_space: &mut AddressSpace) {
    // Object
    let name = "AggregateConfiguration";
    let node_id = NodeId::new(0, 3059);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11168), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11169), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11170), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11171), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11187), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2318), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_4(address_space: &mut AddressSpace) {
    // Object
    let name = "AggregateFunctions";
    let node_id = NodeId::new(0, 11876);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 61), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2318), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_5(address_space: &mut AddressSpace) {
    // Object
    let name = "HA Configuration";
    let node_id = NodeId::new(0, 11202);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11203), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 11208), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2318), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}

fn add_object_6(address_space: &mut AddressSpace) {
    // Object
    let name = "AggregateConfiguration";
    let node_id = NodeId::new(0, 11203);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11204), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11205), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11206), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11207), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11187), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 11202), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_7(address_space: &mut AddressSpace) {
    // Object
    let name = "AggregateFunctions";
    let node_id = NodeId::new(0, 11172);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 61), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_8(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 893);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 891), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 8244), &ReferenceTypeId::HasDescription, ReferenceDirection::Forward),
        (&NodeId::new(0, 76), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}

fn add_object_9(address_space: &mut AddressSpace) {
    // Object
    let name = "Default XML";
    let node_id = NodeId::new(0, 892);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 891), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 8879), &ReferenceTypeId::HasDescription, ReferenceDirection::Forward),
        (&NodeId::new(0, 76), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}

fn add_object_10(address_space: &mut AddressSpace) {
    // Object
    let name = "Default JSON";
    let node_id = NodeId::new(0, 15382);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 891), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 76), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}

fn add_objecttype_11(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "HistoricalDataConfigurationType";
    let node_id = NodeId::new(0, 2318);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3059), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 11876), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2323), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2324), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2325), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2326), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2327), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2328), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11499), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11500), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19092), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_12(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "HistoryServerCapabilitiesType";
    let node_id = NodeId::new(0, 2330);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2331), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2332), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11268), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11269), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2334), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2335), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2336), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2337), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2338), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11278), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11279), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11280), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11501), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11270), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11172), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 19094), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 58), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_13(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditHistoryEventUpdateEventType";
    let node_id = NodeId::new(0, 2999);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3025), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3028), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3003), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3029), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3030), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2104), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_14(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditHistoryValueUpdateEventType";
    let node_id = NodeId::new(0, 3006);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3026), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3031), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3032), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3033), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2104), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_15(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditHistoryAnnotationUpdateEventType";
    let node_id = NodeId::new(0, 19095);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 19293), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19294), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19295), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2104), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

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

fn add_objecttype_17(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditHistoryRawModifyDeleteEventType";
    let node_id = NodeId::new(0, 3014);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3015), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3016), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3017), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3034), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3012), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_18(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditHistoryAtTimeDeleteEventType";
    let node_id = NodeId::new(0, 3019);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3020), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3021), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3012), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_19(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditHistoryEventDeleteEventType";
    let node_id = NodeId::new(0, 3022);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3023), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3024), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3012), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_datatype_20(address_space: &mut AddressSpace) {
    // DataType
    let name = "Annotation";
    let node_id = NodeId::new(0, 891);
    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_21(address_space: &mut AddressSpace) {
    // DataType
    let name = "ExceptionDeviationFormat";
    let node_id = NodeId::new(0, 890);
    let node = DataType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 7614), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 29), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_referencetype_22(address_space: &mut AddressSpace) {
    // ReferenceType
    let name = "HasHistoricalConfiguration";
    let node_id = NodeId::new(0, 56);
    let node = ReferenceType::new(&node_id, name, name, Some(LocalizedText::new("", "HistoricalConfigurationOf")), false, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 44), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_23(address_space: &mut AddressSpace) {
    // Variable
    let name = "AccessHistoryDataCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11193);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_24(address_space: &mut AddressSpace) {
    // Variable
    let name = "AccessHistoryEventsCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11242);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

fn add_variable_27(address_space: &mut AddressSpace) {
    // Variable
    let name = "InsertDataCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11196);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_28(address_space: &mut AddressSpace) {
    // Variable
    let name = "ReplaceDataCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11197);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_29(address_space: &mut AddressSpace) {
    // Variable
    let name = "UpdateDataCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11198);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_30(address_space: &mut AddressSpace) {
    // Variable
    let name = "DeleteRawCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11199);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_31(address_space: &mut AddressSpace) {
    // Variable
    let name = "DeleteAtTimeCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11200);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_32(address_space: &mut AddressSpace) {
    // Variable
    let name = "InsertEventCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11281);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_33(address_space: &mut AddressSpace) {
    // Variable
    let name = "ReplaceEventCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11282);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_34(address_space: &mut AddressSpace) {
    // Variable
    let name = "UpdateEventCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11283);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_35(address_space: &mut AddressSpace) {
    // Variable
    let name = "DeleteEventCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11502);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_36(address_space: &mut AddressSpace) {
    // Variable
    let name = "InsertAnnotationCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11275);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_37(address_space: &mut AddressSpace) {
    // Variable
    let name = "ServerTimestampSupported";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 19091);
    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, 11192), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_38(address_space: &mut AddressSpace) {
    // Variable
    let name = "Annotations";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11214);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 891), Some(-2), None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}

fn add_variable_39(address_space: &mut AddressSpace) {
    // Variable
    let name = "TreatUncertainAsBad";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11168);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 3059), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_40(address_space: &mut AddressSpace) {
    // Variable
    let name = "PercentDataBad";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11169);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 3), 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, 3059), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_41(address_space: &mut AddressSpace) {
    // Variable
    let name = "PercentDataGood";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11170);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 3), 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, 3059), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_42(address_space: &mut AddressSpace) {
    // Variable
    let name = "UseSlopedExtrapolation";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11171);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 3059), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_43(address_space: &mut AddressSpace) {
    // Variable
    let name = "Stepped";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2323);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_44(address_space: &mut AddressSpace) {
    // Variable
    let name = "Definition";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2324);
    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, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_45(address_space: &mut AddressSpace) {
    // Variable
    let name = "MaxTimeInterval";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2325);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 290), 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, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_46(address_space: &mut AddressSpace) {
    // Variable
    let name = "MinTimeInterval";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2326);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 290), 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, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_47(address_space: &mut AddressSpace) {
    // Variable
    let name = "ExceptionDeviation";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2327);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 11), 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, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_48(address_space: &mut AddressSpace) {
    // Variable
    let name = "ExceptionDeviationFormat";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2328);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 890), 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, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_49(address_space: &mut AddressSpace) {
    // Variable
    let name = "StartOfArchive";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11499);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 294), 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, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_50(address_space: &mut AddressSpace) {
    // Variable
    let name = "StartOfOnlineArchive";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11500);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 294), 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, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_51(address_space: &mut AddressSpace) {
    // Variable
    let name = "ServerTimestampSupported";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 19092);
    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, 2318), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_52(address_space: &mut AddressSpace) {
    // Variable
    let name = "TreatUncertainAsBad";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11204);
    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, 11203), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

fn add_variable_55(address_space: &mut AddressSpace) {
    // Variable
    let name = "UseSlopedExtrapolation";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11207);
    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, 11203), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_56(address_space: &mut AddressSpace) {
    // Variable
    let name = "Stepped";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11208);
    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, 11202), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_57(address_space: &mut AddressSpace) {
    // Variable
    let name = "HistoricalEventFilter";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11215);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 725), Some(-2), None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}

fn add_variable_58(address_space: &mut AddressSpace) {
    // Variable
    let name = "AccessHistoryDataCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2331);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_59(address_space: &mut AddressSpace) {
    // Variable
    let name = "AccessHistoryEventsCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2332);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_60(address_space: &mut AddressSpace) {
    // Variable
    let name = "MaxReturnDataValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11268);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 7), 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, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_61(address_space: &mut AddressSpace) {
    // Variable
    let name = "MaxReturnEventValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11269);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 7), 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, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_62(address_space: &mut AddressSpace) {
    // Variable
    let name = "InsertDataCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2334);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_63(address_space: &mut AddressSpace) {
    // Variable
    let name = "ReplaceDataCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2335);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_64(address_space: &mut AddressSpace) {
    // Variable
    let name = "UpdateDataCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2336);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_65(address_space: &mut AddressSpace) {
    // Variable
    let name = "DeleteRawCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2337);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_66(address_space: &mut AddressSpace) {
    // Variable
    let name = "DeleteAtTimeCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2338);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_67(address_space: &mut AddressSpace) {
    // Variable
    let name = "InsertEventCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11278);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_68(address_space: &mut AddressSpace) {
    // Variable
    let name = "ReplaceEventCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11279);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_69(address_space: &mut AddressSpace) {
    // Variable
    let name = "UpdateEventCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11280);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_70(address_space: &mut AddressSpace) {
    // Variable
    let name = "DeleteEventCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11501);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_71(address_space: &mut AddressSpace) {
    // Variable
    let name = "InsertAnnotationCapability";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 11270);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_72(address_space: &mut AddressSpace) {
    // Variable
    let name = "ServerTimestampSupported";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 19094);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2330), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_73(address_space: &mut AddressSpace) {
    // Variable
    let name = "UpdatedNode";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3025);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 17), 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, 2999), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_74(address_space: &mut AddressSpace) {
    // Variable
    let name = "PerformInsertReplace";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3028);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 11293), 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, 2999), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_75(address_space: &mut AddressSpace) {
    // Variable
    let name = "Filter";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3003);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 725), 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, 2999), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_76(address_space: &mut AddressSpace) {
    // Variable
    let name = "NewValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3029);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 920), Some(1), Some(0), 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, 2999), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_77(address_space: &mut AddressSpace) {
    // Variable
    let name = "OldValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3030);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 920), Some(1), Some(0), 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, 2999), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_78(address_space: &mut AddressSpace) {
    // Variable
    let name = "UpdatedNode";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3026);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 17), 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, 3006), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_79(address_space: &mut AddressSpace) {
    // Variable
    let name = "PerformInsertReplace";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3031);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 11293), 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, 3006), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_80(address_space: &mut AddressSpace) {
    // Variable
    let name = "NewValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3032);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 23), Some(1), Some(0), 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, 3006), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_81(address_space: &mut AddressSpace) {
    // Variable
    let name = "OldValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3033);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 23), Some(1), Some(0), 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, 3006), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_82(address_space: &mut AddressSpace) {
    // Variable
    let name = "PerformInsertReplace";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 19293);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 11293), 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, 19095), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_83(address_space: &mut AddressSpace) {
    // Variable
    let name = "NewValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 19294);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 23), Some(1), Some(0), 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, 19095), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_84(address_space: &mut AddressSpace) {
    // Variable
    let name = "OldValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 19295);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 23), Some(1), Some(0), 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, 19095), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_85(address_space: &mut AddressSpace) {
    // Variable
    let name = "UpdatedNode";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3027);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 17), 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, 3012), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_86(address_space: &mut AddressSpace) {
    // Variable
    let name = "IsDeleteModified";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3015);
    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, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 3014), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_87(address_space: &mut AddressSpace) {
    // Variable
    let name = "StartTime";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3016);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 294), 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, 3014), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_88(address_space: &mut AddressSpace) {
    // Variable
    let name = "EndTime";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3017);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 294), 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, 3014), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_89(address_space: &mut AddressSpace) {
    // Variable
    let name = "OldValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3034);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 23), Some(1), Some(0), 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, 3014), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_90(address_space: &mut AddressSpace) {
    // Variable
    let name = "ReqTimes";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3020);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 294), Some(1), Some(0), 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, 3019), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_91(address_space: &mut AddressSpace) {
    // Variable
    let name = "OldValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3021);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 23), Some(1), Some(0), 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, 3019), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_92(address_space: &mut AddressSpace) {
    // Variable
    let name = "EventIds";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3023);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 15), Some(1), Some(0), 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, 3022), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_93(address_space: &mut AddressSpace) {
    // Variable
    let name = "OldValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3024);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 920), 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, 3022), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_94(address_space: &mut AddressSpace) {
    // Variable
    let name = "EnumStrings";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 7614);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), Some(1), Some(0), 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, 890), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}