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 = "StateOperationalByParent";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18740);
    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, 18741), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 18742), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 18743), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 18729), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_5(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalFromError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18745);
    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, 18746), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 18747), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 18748), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 18729), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_9(address_space: &mut AddressSpace) {
    // Variable
    let name = "StatePausedByParent";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18750);
    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, 18751), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 18752), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 18753), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 18729), &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, 18751);
    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, 18750), &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, 18752);
    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, 18750), &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, 18753);
    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, 18750), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_13(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateDisabledByMethod";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18755);
    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, 18756), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 18757), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 18758), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 18729), &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, 18756);
    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, 18755), &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, 18757);
    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, 18755), &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, 18758);
    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, 18755), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

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

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

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

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

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

fn add_variable_27(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("SecurityPolicyUri"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("FirstTokenId"),
                data_type: NodeId::new(0, 288),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("Keys"),
                data_type: NodeId::new(0, 15),
                value_rank: 1,
                array_dimensions: Some(vec![0]),
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("TimeToNextKey"),
                data_type: NodeId::new(0, 290),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("KeyLifetime"),
                data_type: NodeId::new(0, 290),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
    ];
    let node_id = NodeId::new(0, 15217);
    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, 15215), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

fn add_variable_30(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("SecurityGroupName"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("KeyLifetime"),
                data_type: NodeId::new(0, 290),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("SecurityPolicyUri"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("MaxFutureKeyCount"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("MaxPastKeyCount"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
    ];
    let node_id = NodeId::new(0, 15445);
    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, 15444), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

fn add_variable_33(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, 15617),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
    ];
    let node_id = NodeId::new(0, 17367);
    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, 17366), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

fn add_variable_38(address_space: &mut AddressSpace) {
    // Variable
    let name = "TotalInformation";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17411);
    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, 17412), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17413), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17414), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17409), &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, 17412);
    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, 17411), &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, 17413);
    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, 17411), &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, 17414);
    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, 17411), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_42(address_space: &mut AddressSpace) {
    // Variable
    let name = "TotalError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17416);
    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, 17417), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17418), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17419), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17409), &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, 17417);
    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, 17416), &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, 17418);
    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, 17416), &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, 17419);
    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, 17416), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

fn add_variable_47(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17424);
    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, 17425), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17426), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17429), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17423), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_51(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalByMethod";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17431);
    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, 17432), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17433), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17434), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17423), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_55(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalByParent";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17436);
    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, 17437), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17438), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17439), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17423), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_59(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateOperationalFromError";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17441);
    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, 17442), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17443), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17444), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17423), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_63(address_space: &mut AddressSpace) {
    // Variable
    let name = "StatePausedByParent";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17446);
    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, 17447), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17448), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17449), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17423), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_67(address_space: &mut AddressSpace) {
    // Variable
    let name = "StateDisabledByMethod";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17451);
    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, 17452), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17453), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 17454), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 19725), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17423), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

fn add_variable_73(address_space: &mut AddressSpace) {
    // Variable
    let name = "ConfiguredDataSetReaders";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17460);
    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, 17461), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 63), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17457), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

fn add_variable_77(address_space: &mut AddressSpace) {
    // Variable
    let name = "OperationalDataSetReaders";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17464);
    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, 17466), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 63), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 17457), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

fn add_variable_79(address_space: &mut AddressSpace) {
    // Variable
    let name = "SupportedTransportProfiles";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17481);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 12), Some(1), Some(0), value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 68), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 14443), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_variable_95(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("ConfigurationVersion"),
                data_type: NodeId::new(0, 14593),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("FieldNameAliases"),
                data_type: NodeId::new(0, 12),
                value_rank: 1,
                array_dimensions: Some(vec![0]),
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("PromotedFields"),
                data_type: NodeId::new(0, 1),
                value_rank: 1,
                array_dimensions: Some(vec![0]),
                description: LocalizedText::new("", ""),
            })),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298), &Argument {
                name: UAString::from("VariablesToAdd"),
                data_type: NodeId::new(0, 14273),
                value_rank: 1,
                array_dimensions: Some(vec![0]),
                description: LocalizedText::new("", ""),
            })),
    ];
    let node_id = NodeId::new(0, 14556);
    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, 14555), &ReferenceTypeId::HasProperty, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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