rplc_opcua 0.12.4

// OPCUA for Rust
// SPDX-License-Identifier: MPL-2.0
// Copyright (C) 2017-2022 Adam Lock
// This file was autogenerated from Opc.Ua.NodeSet2.Part14.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 = "Priority";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17739);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 3), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17725), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_2(address_space: &mut AddressSpace) {
    // Variable
    let name = "LocaleIds";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17740);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 295), Some(1), Some(0), value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17725), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_6(address_space: &mut AddressSpace) {
    // Variable
    let name = "DataSetWriterProperties";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17490);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 14533), Some(1), Some(0), value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17743), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_7(address_space: &mut AddressSpace) {
    // Variable
    let name = "State";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17750);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 14647), 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, 17749), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_8(address_space: &mut AddressSpace) {
    // Variable
    let name = "DiagnosticsLevel";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17813);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 19723), 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, 17812), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_9(address_space: &mut AddressSpace) {
    // Variable
    let name = "TotalInformation";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17814);
    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, 17815), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17816), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17817), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17812), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_13(address_space: &mut AddressSpace) {
    // Variable
    let name = "TotalError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17819);
    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, 17820), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17821), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17822), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17812), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

fn add_variable_18(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17827);
    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, 17828), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17829), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17830), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_22(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalByMethod";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17832);
    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, 17833), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17834), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17835), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_26(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalByParent";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17837);
    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, 17838), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17839), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17840), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_30(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalFromError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17842);
    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, 17843), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17844), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17845), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_34(address_space: &mut AddressSpace) {
    // Variable
    let name = "StatePausedByParent";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17847);
    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, 17848), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17849), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17850), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_38(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateDisabledByMethod";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17853);
    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, 17854), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17855), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17856), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_42(address_space: &mut AddressSpace) {
    // Variable
    let name = "SentNetworkMessages";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17859);
    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, 17864), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17871), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17872), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_46(address_space: &mut AddressSpace) {
    // Variable
    let name = "FailedTransmissions";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17874);
    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, 17878), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17885), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17892), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_50(address_space: &mut AddressSpace) {
    // Variable
    let name = "EncryptionErrors";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17900);
    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, 17901), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17902), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17903), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 17826), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

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

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

fn add_variable_58(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("Configuration"),
                data_type: NodeId::new(0, 15597),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
    ];
    let node_id = NodeId::new(0, 17976);
    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, 17969), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_59(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("DataSetWriterNodeId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
    ];
    let node_id = NodeId::new(0, 17987);
    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, 17969), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_60(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("DataSetWriterNodeId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
    ];
    let node_id = NodeId::new(0, 17993);
    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, 17992), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

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

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

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

fn add_variable_69(address_space: &mut AddressSpace) {
    // Variable
    let name = "DataSetReaderProperties";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17492);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 14533), Some(1), Some(0), value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 18076), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_70(address_space: &mut AddressSpace) {
    // Variable
    let name = "State";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18089);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 14647), 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, 18088), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_71(address_space: &mut AddressSpace) {
    // Variable
    let name = "DiagnosticsLevel";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 21016);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 19723), 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, 21015), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_72(address_space: &mut AddressSpace) {
    // Variable
    let name = "TotalInformation";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 21017);
    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, 21018), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21019), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21020), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 21015), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_76(address_space: &mut AddressSpace) {
    // Variable
    let name = "TotalError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 21022);
    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, 21023), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21024), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21025), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 21015), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

fn add_variable_81(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 21030);
    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, 21031), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21032), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21033), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 21029), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_85(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalByMethod";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 21035);
    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, 21036), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21037), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21038), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 21029), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_89(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalByParent";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 21040);
    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, 21041), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21042), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21043), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 21029), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_93(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalFromError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 21045);
    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, 21046), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21047), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21048), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 21029), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_97(address_space: &mut AddressSpace) {
    // Variable
    let name = "StatePausedByParent";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 21050);
    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, 21051), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21052), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 21053), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 21029), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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