opcua 0.12.0

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

fn add_variable_2(address_space: &mut AddressSpace) {
    // Variable
    let name = "Id";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2756);
    let node =
        Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2755),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

fn add_variable_6(address_space: &mut AddressSpace) {
    // Variable
    let name = "Id";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2763);
    let node =
        Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2762),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

fn add_variable_11(address_space: &mut AddressSpace) {
    // Variable
    let name = "CurrentState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2772);
    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, 3728),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2760),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2771),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_13(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastTransition";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2773);
    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, 3732),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2767),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2771),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_15(address_space: &mut AddressSpace) {
    // Variable
    let name = "AvailableStates";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17635);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 17),
        Some(1),
        Some(0),
        value,
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2771),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_16(address_space: &mut AddressSpace) {
    // Variable
    let name = "AvailableTransitions";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17636);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 17),
        Some(1),
        Some(0),
        value,
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2771),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

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

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

fn add_variable_23(address_space: &mut AddressSpace) {
    // Variable
    let name = "Denominator";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 17713);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 7), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17709),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

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

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

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

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

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

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

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

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

fn add_variable_36(address_space: &mut AddressSpace) {
    // Variable
    let name = "CartesianCoordinates";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18801);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 18809),
        None,
        None,
        value,
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18772),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18786),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_37(address_space: &mut AddressSpace) {
    // Variable
    let name = "Orientation";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18787);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 18811),
        None,
        None,
        value,
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18779),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18786),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

fn add_variable_41(address_space: &mut AddressSpace) {
    // Variable
    let name = "CartesianCoordinates";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18796);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 18810),
        None,
        None,
        value,
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18798),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18799),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18800),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18774),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18791),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

fn add_variable_45(address_space: &mut AddressSpace) {
    // Variable
    let name = "Orientation";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 18792);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 18812),
        None,
        None,
        value,
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19074),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19075),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19076),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18781),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18791),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

fn add_variable_49(address_space: &mut AddressSpace) {
    // Variable
    let name = "Transition";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2774);
    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, 3754),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2762),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2311),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_50(address_space: &mut AddressSpace) {
    // Variable
    let name = "Id";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3754);
    let node =
        Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2774),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_51(address_space: &mut AddressSpace) {
    // Variable
    let name = "FromState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2775);
    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, 3746),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2755),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2311),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_52(address_space: &mut AddressSpace) {
    // Variable
    let name = "Id";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3746);
    let node =
        Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2775),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_53(address_space: &mut AddressSpace) {
    // Variable
    let name = "ToState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2776);
    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, 3750),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2755),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2311),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_54(address_space: &mut AddressSpace) {
    // Variable
    let name = "Id";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3750);
    let node =
        Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2776),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_55(address_space: &mut AddressSpace) {
    // Variable
    let name = "OldStateId";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2777);
    let node =
        Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2315),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_56(address_space: &mut AddressSpace) {
    // Variable
    let name = "NewStateId";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2778);
    let node =
        Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2315),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_variable_86(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("DirectoryNodeId"),
            data_type: NodeId::new(0, 17),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 16350);
    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, 16348),
                &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("FileName"),
                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("RequestFileOpen"),
                data_type: NodeId::new(0, 1),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 16352);
    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, 16351),
                &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("FileNodeId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 16353);
    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, 16351),
                &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("ObjectToDelete"),
            data_type: NodeId::new(0, 17),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 16355);
    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, 16354),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

fn add_variable_92(address_space: &mut AddressSpace) {
    // Variable
    let name = "ClientProcessingTimeout";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15745);
    let node =
        Variable::new_data_value(&node_id, name, name, NodeId::new(0, 290), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15744),
                &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("GenerateOptions"),
            data_type: NodeId::new(0, 24),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 15747);
    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, 15746),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_94(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileNodeId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                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("CompletionStateMachine"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 15748);
    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, 15746),
                &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("GenerateOptions"),
            data_type: NodeId::new(0, 24),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 16359);
    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, 15749),
                &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("FileNodeId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 15750);
    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, 15749),
                &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("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 15752);
    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, 15751),
                &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("CompletionStateMachine"),
            data_type: NodeId::new(0, 17),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 15753);
    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, 15751),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_99(address_space: &mut AddressSpace) {
    // Variable
    let name = "CurrentState";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15755);
    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, 15756),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2760),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15754),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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