opcua 0.12.0

// OPCUA for Rust
// SPDX-License-Identifier: MPL-2.0
// Copyright (C) 2017-2024 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,
            ),
        ]),
    );
}