rplc_opcua 0.12.4

// OPCUA for Rust
// SPDX-License-Identifier: MPL-2.0
// Copyright (C) 2017-2022 Adam Lock
// This file was autogenerated from Opc.Ua.NodeSet2.Part10.xml by tools/schema/gen_address_space.js
// DO NOT EDIT THIS FILE

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

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

#[allow(unused_variables)]
pub fn populate_address_space(address_space: &mut AddressSpace) {
    add_object_1(address_space);
    add_object_2(address_space);
    add_object_3(address_space);
    add_object_4(address_space);
    add_object_5(address_space);
    add_object_6(address_space);
    add_object_7(address_space);
    add_object_8(address_space);
    add_object_9(address_space);
    add_object_10(address_space);
    add_object_11(address_space);
    add_object_12(address_space);
    add_object_13(address_space);
    add_object_14(address_space);
    add_object_15(address_space);
    add_object_16(address_space);
    add_object_17(address_space);
    add_object_18(address_space);
    add_object_19(address_space);
    add_object_20(address_space);
    add_objecttype_21(address_space);
    add_objecttype_22(address_space);
    add_objecttype_23(address_space);
    add_objecttype_24(address_space);
    add_datatype_25(address_space);
    add_datatype_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_variabletype_93(address_space);
    add_variabletype_94(address_space);
    add_method_95(address_space);
    add_method_96(address_space);
    add_method_97(address_space);
    add_method_98(address_space);
    add_method_99(address_space);
}

fn add_object_1(address_space: &mut AddressSpace) {
    // Object
    let name = "FinalResultData";
    let node_id = NodeId::new(0, 3850);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 58), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_2(address_space: &mut AddressSpace) {
    // Object
    let name = "Halted";
    let node_id = NodeId::new(0, 2406);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2407), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2307), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_3(address_space: &mut AddressSpace) {
    // Object
    let name = "Ready";
    let node_id = NodeId::new(0, 2400);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2401), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2307), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_4(address_space: &mut AddressSpace) {
    // Object
    let name = "Running";
    let node_id = NodeId::new(0, 2402);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2403), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2307), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_5(address_space: &mut AddressSpace) {
    // Object
    let name = "Suspended";
    let node_id = NodeId::new(0, 2404);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2405), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2307), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_6(address_space: &mut AddressSpace) {
    // Object
    let name = "HaltedToReady";
    let node_id = NodeId::new(0, 2408);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2409), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_7(address_space: &mut AddressSpace) {
    // Object
    let name = "ReadyToRunning";
    let node_id = NodeId::new(0, 2410);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2411), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_8(address_space: &mut AddressSpace) {
    // Object
    let name = "RunningToHalted";
    let node_id = NodeId::new(0, 2412);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2413), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_9(address_space: &mut AddressSpace) {
    // Object
    let name = "RunningToReady";
    let node_id = NodeId::new(0, 2414);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2415), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_10(address_space: &mut AddressSpace) {
    // Object
    let name = "RunningToSuspended";
    let node_id = NodeId::new(0, 2416);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2417), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_11(address_space: &mut AddressSpace) {
    // Object
    let name = "SuspendedToRunning";
    let node_id = NodeId::new(0, 2418);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2419), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_12(address_space: &mut AddressSpace) {
    // Object
    let name = "SuspendedToHalted";
    let node_id = NodeId::new(0, 2420);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2421), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_13(address_space: &mut AddressSpace) {
    // Object
    let name = "SuspendedToReady";
    let node_id = NodeId::new(0, 2422);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2423), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_object_14(address_space: &mut AddressSpace) {
    // Object
    let name = "ReadyToHalted";
    let node_id = NodeId::new(0, 2424);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2425), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2310), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

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

fn add_objecttype_21(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ProgramStateMachineType";
    let node_id = NodeId::new(0, 2391);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3830), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3835), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2392), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2393), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2394), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2395), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2396), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2397), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2398), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2399), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3850), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2406), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2400), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2402), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2404), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2408), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2410), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2412), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2414), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2416), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2418), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2420), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2422), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2424), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2426), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2427), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2428), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2429), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2430), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2771), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_22(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ProgramTransitionEventType";
    let node_id = NodeId::new(0, 2378);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2379), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2311), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_23(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditProgramTransitionEventType";
    let node_id = NodeId::new(0, 11856);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11875), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2315), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_objecttype_24(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ProgramTransitionAuditEventType";
    let node_id = NodeId::new(0, 3806);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3825), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 2315), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

fn add_variable_30(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastTransition";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3835);
    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, 3836), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3838), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3839), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2767), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 78), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

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

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

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

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

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

fn add_variable_41(address_space: &mut AddressSpace) {
    // Variable
    let name = "ProgramDiagnostic";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 2399);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 15396), None, None, value);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 3840), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3841), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3842), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3843), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 3844), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3845), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3846), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3847), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15038), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15040), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3848), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 3849), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15383), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
        (&NodeId::new(0, 80), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

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

fn add_variable_48(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastMethodInputArguments";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3846);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 296), Some(1), Some(0), 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, 2399), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_49(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastMethodOutputArguments";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 3847);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 296), Some(1), Some(0), 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, 2399), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_50(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastMethodInputValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15038);
    let node = Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, Some(1), Some(0), 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, 2399), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_51(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastMethodOutputValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15040);
    let node = Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, Some(1), Some(0), 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, 2399), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_variable_87(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastMethodInputArguments";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15390);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 296), Some(1), Some(0), 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, 15383), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_88(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastMethodOutputArguments";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15391);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 296), Some(1), Some(0), 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, 15383), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_89(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastMethodInputValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15392);
    let node = Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, Some(1), Some(0), 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, 15383), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_variable_90(address_space: &mut AddressSpace) {
    // Variable
    let name = "LastMethodOutputValues";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 15393);
    let node = Variable::new_data_value(&node_id, name, name, DataTypeId::Boolean, Some(1), Some(0), 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, 15383), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

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

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

fn add_variabletype_93(address_space: &mut AddressSpace) {
    // VariableType
    let name = "ProgramDiagnosticType";
    let node_id = NodeId::new(0, 2380);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 894), false, -1);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 2381), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2382), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2383), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2384), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2385), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2386), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2387), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2388), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2389), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 2390), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 63), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_variabletype_94(address_space: &mut AddressSpace) {
    // VariableType
    let name = "ProgramDiagnostic2Type";
    let node_id = NodeId::new(0, 15383);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 15396), false, -1);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 15384), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15385), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15386), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15387), &ReferenceTypeId::HasProperty, ReferenceDirection::Forward),
        (&NodeId::new(0, 15388), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15389), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15390), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15391), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15392), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15393), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15394), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 15395), &ReferenceTypeId::HasComponent, ReferenceDirection::Forward),
        (&NodeId::new(0, 63), &ReferenceTypeId::HasSubtype, ReferenceDirection::Inverse),
    ]));
}

fn add_method_95(address_space: &mut AddressSpace) {
    // Method
    let name = "Start";
    let node_id = NodeId::new(0, 2426);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11508), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_method_96(address_space: &mut AddressSpace) {
    // Method
    let name = "Suspend";
    let node_id = NodeId::new(0, 2427);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11508), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_method_97(address_space: &mut AddressSpace) {
    // Method
    let name = "Resume";
    let node_id = NodeId::new(0, 2428);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11508), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_method_98(address_space: &mut AddressSpace) {
    // Method
    let name = "Halt";
    let node_id = NodeId::new(0, 2429);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11508), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}

fn add_method_99(address_space: &mut AddressSpace) {
    // Method
    let name = "Reset";
    let node_id = NodeId::new(0, 2430);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 11508), &ReferenceTypeId::HasModellingRule, ReferenceDirection::Forward),
        (&NodeId::new(0, 2391), &ReferenceTypeId::HasComponent, ReferenceDirection::Inverse),
    ]));
}