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.Part9.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_variable_1(address_space);
    add_variable_2(address_space);
    add_variable_3(address_space);
    add_variable_4(address_space);
    add_variable_5(address_space);
    add_variable_6(address_space);
    add_variable_7(address_space);
    add_variable_8(address_space);
    add_variable_9(address_space);
    add_variable_10(address_space);
    add_variable_11(address_space);
    add_variable_12(address_space);
    add_variable_13(address_space);
    add_variable_14(address_space);
    add_variable_15(address_space);
    add_variable_16(address_space);
    add_variable_17(address_space);
    add_variable_18(address_space);
    add_variable_19(address_space);
    add_variable_20(address_space);
    add_variable_21(address_space);
    add_variable_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);
    add_variable_95(address_space);
    add_variable_96(address_space);
    add_variable_97(address_space);
    add_variable_98(address_space);
    add_variable_99(address_space);
    add_variable_100(address_space);
}

fn add_variable_1(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastSeverity";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 16434);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 5), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16435),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9002),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16406),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_3(address_space: &mut AddressSpace) {
    // Variable
    let name = "Comment";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 16436);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16437),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9002),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16406),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

fn add_variable_6(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("EventId"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Comment"),
                data_type: NodeId::new(0, 21),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 16442);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, 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, 16441),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_7(address_space: &mut AddressSpace) {
    // Variable
    let name = "AckedState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 16443);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16444),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8995),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16406),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_9(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("EventId"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Comment"),
                data_type: NodeId::new(0, 21),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 16462);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, 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, 16461),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_10(address_space: &mut AddressSpace) {
    // Variable
    let name = "ActiveState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 16465);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16466),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8995),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16406),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_variable_24(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("ShelvingTime"),
            data_type: NodeId::new(0, 290),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 2991);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, 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, 2949),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_variable_41(address_space: &mut AddressSpace) {
    // Variable
    let name = "ActiveState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 9398);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 9399),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8995),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9341),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_43(address_space: &mut AddressSpace) {
    // Variable
    let name = "CurrentState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 9456);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 9457),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2760),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9455),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_45(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastTransition";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 9461);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 9462),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9465),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2767),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9455),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

fn add_variable_48(address_space: &mut AddressSpace) {
    // Variable
    let name = "ActiveState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 9963);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 9964),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8995),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9906),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_50(address_space: &mut AddressSpace) {
    // Variable
    let name = "HighHighState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 10020);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 10021),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10025),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10027),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10028),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8995),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9906),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

fn add_variable_55(address_space: &mut AddressSpace) {
    // Variable
    let name = "HighState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 10029);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 10030),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10034),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10036),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10037),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8995),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9906),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

fn add_variable_60(address_space: &mut AddressSpace) {
    // Variable
    let name = "LowState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 10038);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 10039),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10043),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10045),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10046),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8995),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9906),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

fn add_variable_65(address_space: &mut AddressSpace) {
    // Variable
    let name = "LowLowState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 10047);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 21), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 10048),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10052),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10054),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 10055),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8995),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 9906),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_variable_92(address_space: &mut AddressSpace) {
    // Variable
    let name = "AlarmCount";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17280);
    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, 63),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17279),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_93(address_space: &mut AddressSpace) {
    // Variable
    let name = "StartTime";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17991);
    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, 63),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17279),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_94(address_space: &mut AddressSpace) {
    // Variable
    let name = "MaximumActiveState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17281);
    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, 63),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17279),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_95(address_space: &mut AddressSpace) {
    // Variable
    let name = "MaximumUnAck";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17282);
    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, 63),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17279),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_96(address_space: &mut AddressSpace) {
    // Variable
    let name = "CurrentAlarmRate";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17284);
    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, 17285),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17277),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17279),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_98(address_space: &mut AddressSpace) {
    // Variable
    let name = "MaximumAlarmRate";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17286);
    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, 17287),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17277),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17279),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_100(address_space: &mut AddressSpace) {
    // Variable
    let name = "MaximumReAlarmCount";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17283);
    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, 63),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17279),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}