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.Part8.xml by tools/schema/gen_address_space.js
// DO NOT EDIT THIS FILE

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

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

#[allow(unused_variables)]
pub fn populate_address_space(address_space: &mut AddressSpace) {
    add_object_1(address_space);
    add_object_2(address_space);
    add_object_3(address_space);
    add_object_4(address_space);
    add_object_5(address_space);
    add_object_6(address_space);
    add_object_7(address_space);
    add_object_8(address_space);
    add_object_9(address_space);
    add_object_10(address_space);
    add_object_11(address_space);
    add_object_12(address_space);
    add_object_13(address_space);
    add_object_14(address_space);
    add_object_15(address_space);
    add_object_16(address_space);
    add_object_17(address_space);
    add_object_18(address_space);
    add_datatype_19(address_space);
    add_datatype_20(address_space);
    add_datatype_21(address_space);
    add_datatype_22(address_space);
    add_datatype_23(address_space);
    add_datatype_24(address_space);
    add_datatype_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_variabletype_53(address_space);
    add_variabletype_54(address_space);
    add_variabletype_55(address_space);
    add_variabletype_56(address_space);
    add_variabletype_57(address_space);
    add_variabletype_58(address_space);
    add_variabletype_59(address_space);
    add_variabletype_60(address_space);
    add_variabletype_61(address_space);
    add_variabletype_62(address_space);
    add_variabletype_63(address_space);
    add_variabletype_64(address_space);
    add_variabletype_65(address_space);
    add_variabletype_66(address_space);
    add_variabletype_67(address_space);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_variabletype_53(address_space: &mut AddressSpace) {
    // VariableType
    let name = "DataItemType";
    let node_id = NodeId::new(0, 2365);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), false, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2366), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2367), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 63), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_54(address_space: &mut AddressSpace) {
    // VariableType
    let name = "BaseAnalogType";
    let node_id = NodeId::new(0, 15318);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 26), false, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 17567), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17568), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17569), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2365), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_55(address_space: &mut AddressSpace) {
    // VariableType
    let name = "AnalogItemType";
    let node_id = NodeId::new(0, 2368);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 26), false, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2369), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 15318), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_56(address_space: &mut AddressSpace) {
    // VariableType
    let name = "AnalogUnitType";
    let node_id = NodeId::new(0, 17497);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 26), false, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 17502), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 15318), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_57(address_space: &mut AddressSpace) {
    // VariableType
    let name = "AnalogUnitRangeType";
    let node_id = NodeId::new(0, 17570);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 26), false, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 17575), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2368), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_58(address_space: &mut AddressSpace) {
    // VariableType
    let name = "DiscreteItemType";
    let node_id = NodeId::new(0, 2372);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), true, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2365), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_59(address_space: &mut AddressSpace) {
    // VariableType
    let name = "TwoStateDiscreteType";
    let node_id = NodeId::new(0, 2373);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 1), false, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2374), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2375), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2372), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_60(address_space: &mut AddressSpace) {
    // VariableType
    let name = "MultiStateDiscreteType";
    let node_id = NodeId::new(0, 2376);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 28), false, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2377), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2372), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_61(address_space: &mut AddressSpace) {
    // VariableType
    let name = "MultiStateValueDiscreteType";
    let node_id = NodeId::new(0, 11238);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 26), false, -2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11241), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 11461), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2372), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_62(address_space: &mut AddressSpace) {
    // VariableType
    let name = "ArrayItemType";
    let node_id = NodeId::new(0, 12021);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), true, 0);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 12024), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12025), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12026), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12027), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12028), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2365), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_63(address_space: &mut AddressSpace) {
    // VariableType
    let name = "YArrayItemType";
    let node_id = NodeId::new(0, 12029);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), false, 1);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 12037), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12021), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_64(address_space: &mut AddressSpace) {
    // VariableType
    let name = "XYArrayItemType";
    let node_id = NodeId::new(0, 12038);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 12080), false, 1);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 12046), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12021), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_65(address_space: &mut AddressSpace) {
    // VariableType
    let name = "ImageItemType";
    let node_id = NodeId::new(0, 12047);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), false, 2);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 12055), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12056), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12021), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_66(address_space: &mut AddressSpace) {
    // VariableType
    let name = "CubeItemType";
    let node_id = NodeId::new(0, 12057);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), false, 3);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 12065), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12066), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12067), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12021), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_67(address_space: &mut AddressSpace) {
    // VariableType
    let name = "NDimensionArrayItemType";
    let node_id = NodeId::new(0, 12068);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), false, 0);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 12076), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 12021), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}