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_variabletype_1(address_space);
    add_variabletype_2(address_space);
    add_variabletype_3(address_space);
    add_variabletype_4(address_space);
    add_variabletype_5(address_space);
    add_variabletype_6(address_space);
    add_variabletype_7(address_space);
    add_variabletype_8(address_space);
    add_variabletype_9(address_space);
    add_variabletype_10(address_space);
    add_variabletype_11(address_space);
    add_variabletype_12(address_space);
    add_variabletype_13(address_space);
    add_variabletype_14(address_space);
    add_variabletype_15(address_space);
    add_variabletype_16(address_space);
    add_variabletype_17(address_space);
    add_variabletype_18(address_space);
    add_variabletype_19(address_space);
    add_variabletype_20(address_space);
    add_variabletype_21(address_space);
    add_variabletype_22(address_space);
    add_variabletype_23(address_space);
    add_variabletype_24(address_space);
    add_variabletype_25(address_space);
    add_variabletype_26(address_space);
    add_variabletype_27(address_space);
    add_variabletype_28(address_space);
    add_method_29(address_space);
    add_method_30(address_space);
    add_method_31(address_space);
    add_method_32(address_space);
    add_method_33(address_space);
    add_method_34(address_space);
    add_method_35(address_space);
    add_method_36(address_space);
    add_method_37(address_space);
    add_method_38(address_space);
    add_method_39(address_space);
    add_method_40(address_space);
    add_method_41(address_space);
    add_method_42(address_space);
    add_method_43(address_space);
    add_method_44(address_space);
    add_method_45(address_space);
    add_method_46(address_space);
    add_method_47(address_space);
    add_method_48(address_space);
    add_method_49(address_space);
    add_method_50(address_space);
    add_method_51(address_space);
    add_method_52(address_space);
    add_method_53(address_space);
    add_method_54(address_space);
    add_method_55(address_space);
    add_method_56(address_space);
    add_method_57(address_space);
    add_method_58(address_space);
    add_method_59(address_space);
    add_method_60(address_space);
    add_method_61(address_space);
    add_method_62(address_space);
    add_method_63(address_space);
    add_method_64(address_space);
    add_method_65(address_space);
    add_method_66(address_space);
    add_method_67(address_space);
    add_method_68(address_space);
    add_method_69(address_space);
    add_method_70(address_space);
    add_method_71(address_space);
    add_method_72(address_space);
    add_method_73(address_space);
    add_method_74(address_space);
    add_method_75(address_space);
    add_method_76(address_space);
    add_method_77(address_space);
    add_method_78(address_space);
    add_method_79(address_space);
    add_method_80(address_space);
    add_method_81(address_space);
    add_method_82(address_space);
    add_method_83(address_space);
    add_method_84(address_space);
    add_method_85(address_space);
    add_method_86(address_space);
    add_method_87(address_space);
    add_method_88(address_space);
    add_method_89(address_space);
    add_method_90(address_space);
    add_method_91(address_space);
    add_method_92(address_space);
    add_method_93(address_space);
    add_method_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);
    add_method_100(address_space);
}

fn add_variabletype_1(address_space: &mut AddressSpace) {
    // VariableType
    let name = "ServerDiagnosticsSummaryType";
    let node_id = NodeId::new(0, 2150);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 859), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2151),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2152),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2153),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2154),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2155),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2156),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2157),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2159),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2160),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2161),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2162),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2163),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_2(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SamplingIntervalDiagnosticsArrayType";
    let node_id = NodeId::new(0, 2164);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 856), false, 1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12779),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_3(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SamplingIntervalDiagnosticsType";
    let node_id = NodeId::new(0, 2165);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 856), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2166),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11697),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11698),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11699),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_4(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SubscriptionDiagnosticsArrayType";
    let node_id = NodeId::new(0, 2171);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 874), false, 1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12784),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_5(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SubscriptionDiagnosticsType";
    let node_id = NodeId::new(0, 2172);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 874), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2173),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2174),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2175),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2176),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2177),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8888),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2179),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2180),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2181),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2182),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2183),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2184),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2185),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2186),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2187),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2188),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2189),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2190),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2191),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2998),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2193),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8889),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8890),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8891),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8892),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8893),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8894),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8895),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8896),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8897),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8902),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_6(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SessionDiagnosticsArrayType";
    let node_id = NodeId::new(0, 2196);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 865), false, 1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12816),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_7(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SessionDiagnosticsVariableType";
    let node_id = NodeId::new(0, 2197);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 865), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2198),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2199),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2200),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2201),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2202),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2203),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2204),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 3050),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2205),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2206),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2207),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2208),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2209),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 8900),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11892),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2217),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2218),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2219),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2220),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2221),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2222),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2223),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2224),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2225),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2226),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2227),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2228),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2229),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2230),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2231),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2232),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2233),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2234),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2235),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2236),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2237),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2238),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2239),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2240),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2241),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2242),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2730),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2731),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_8(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SessionSecurityDiagnosticsArrayType";
    let node_id = NodeId::new(0, 2243);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 868), false, 1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12860),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_9(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SessionSecurityDiagnosticsType";
    let node_id = NodeId::new(0, 2244);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 868), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2245),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2246),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2247),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2248),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2249),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2250),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2251),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2252),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 3058),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_10(address_space: &mut AddressSpace) {
    // VariableType
    let name = "OptionSetType";
    let node_id = NodeId::new(0, 11487);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11488),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11701),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_11(address_space: &mut AddressSpace) {
    // VariableType
    let name = "SelectionListType";
    let node_id = NodeId::new(0, 16309);
    let node = VariableType::new(&node_id, name, name, NodeId::null(), false, -2);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17632),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17633),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16312),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_12(address_space: &mut AddressSpace) {
    // VariableType
    let name = "AudioVariableType";
    let node_id = NodeId::new(0, 17986);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 16307), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17988),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17989),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17990),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_13(address_space: &mut AddressSpace) {
    // VariableType
    let name = "StateVariableType";
    let node_id = NodeId::new(0, 2755);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 21), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2756),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2757),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2758),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2759),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_14(address_space: &mut AddressSpace) {
    // VariableType
    let name = "TransitionVariableType";
    let node_id = NodeId::new(0, 2762);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 21), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2763),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2764),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2765),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2766),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11456),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_15(address_space: &mut AddressSpace) {
    // VariableType
    let name = "FiniteStateVariableType";
    let node_id = NodeId::new(0, 2760);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 21), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2761),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2755),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_16(address_space: &mut AddressSpace) {
    // VariableType
    let name = "FiniteTransitionVariableType";
    let node_id = NodeId::new(0, 2767);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 21), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2768),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2762),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_17(address_space: &mut AddressSpace) {
    // VariableType
    let name = "GuardVariableType";
    let node_id = NodeId::new(0, 15113);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 21), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 63),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_variabletype_18(address_space: &mut AddressSpace) {
    // VariableType
    let name = "ExpressionGuardVariableType";
    let node_id = NodeId::new(0, 15128);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 21), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15129),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15113),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_19(address_space: &mut AddressSpace) {
    // VariableType
    let name = "ElseGuardVariableType";
    let node_id = NodeId::new(0, 15317);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 21), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 15113),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_variabletype_20(address_space: &mut AddressSpace) {
    // VariableType
    let name = "RationalNumberType";
    let node_id = NodeId::new(0, 17709);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18806), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17712),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17713),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_21(address_space: &mut AddressSpace) {
    // VariableType
    let name = "VectorType";
    let node_id = NodeId::new(0, 17714);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18807), true, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17715),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_22(address_space: &mut AddressSpace) {
    // VariableType
    let name = "3DVectorType";
    let node_id = NodeId::new(0, 17716);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18808), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18769),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18770),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18771),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17714),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_23(address_space: &mut AddressSpace) {
    // VariableType
    let name = "CartesianCoordinatesType";
    let node_id = NodeId::new(0, 18772);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18809), true, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18773),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_24(address_space: &mut AddressSpace) {
    // VariableType
    let name = "3DCartesianCoordinatesType";
    let node_id = NodeId::new(0, 18774);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18810), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18776),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18777),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18778),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18772),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_25(address_space: &mut AddressSpace) {
    // VariableType
    let name = "OrientationType";
    let node_id = NodeId::new(0, 18779);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18811), true, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18780),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_26(address_space: &mut AddressSpace) {
    // VariableType
    let name = "3DOrientationType";
    let node_id = NodeId::new(0, 18781);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18812), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18783),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18784),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18785),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18779),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_27(address_space: &mut AddressSpace) {
    // VariableType
    let name = "FrameType";
    let node_id = NodeId::new(0, 18786);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18813), true, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18801),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18787),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18788),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18789),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18790),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 63),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variabletype_28(address_space: &mut AddressSpace) {
    // VariableType
    let name = "3DFrameType";
    let node_id = NodeId::new(0, 18791);
    let node = VariableType::new(&node_id, name, name, NodeId::new(0, 18814), false, -1);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18796),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18792),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18786),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_29(address_space: &mut AddressSpace) {
    // Method
    let name = "GetMonitoredItems";
    let node_id = NodeId::new(0, 11489);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11490),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11491),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2004),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_30(address_space: &mut AddressSpace) {
    // Method
    let name = "ResendData";
    let node_id = NodeId::new(0, 12871);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12872),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2004),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_31(address_space: &mut AddressSpace) {
    // Method
    let name = "SetSubscriptionDurable";
    let node_id = NodeId::new(0, 12746);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12747),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12748),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2004),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_32(address_space: &mut AddressSpace) {
    // Method
    let name = "RequestServerStateChange";
    let node_id = NodeId::new(0, 12883);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12884),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2004),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_33(address_space: &mut AddressSpace) {
    // Method
    let name = "AddRole";
    let node_id = NodeId::new(0, 16296);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16297),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16298),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16295),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_34(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveRole";
    let node_id = NodeId::new(0, 16299);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16300),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16295),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_35(address_space: &mut AddressSpace) {
    // Method
    let name = "Open";
    let node_id = NodeId::new(0, 11580);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11581),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11582),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11575),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_36(address_space: &mut AddressSpace) {
    // Method
    let name = "Close";
    let node_id = NodeId::new(0, 11583);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11584),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11575),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_37(address_space: &mut AddressSpace) {
    // Method
    let name = "Read";
    let node_id = NodeId::new(0, 11585);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11586),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11587),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11575),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_38(address_space: &mut AddressSpace) {
    // Method
    let name = "Write";
    let node_id = NodeId::new(0, 11588);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11589),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11575),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_39(address_space: &mut AddressSpace) {
    // Method
    let name = "GetPosition";
    let node_id = NodeId::new(0, 11590);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11591),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11592),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11575),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_40(address_space: &mut AddressSpace) {
    // Method
    let name = "SetPosition";
    let node_id = NodeId::new(0, 11593);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11594),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11575),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_41(address_space: &mut AddressSpace) {
    // Method
    let name = "ExportNamespace";
    let node_id = NodeId::new(0, 11615);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11595),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_42(address_space: &mut AddressSpace) {
    // Method
    let name = "Open";
    let node_id = NodeId::new(0, 11629);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11630),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11631),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11624),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_43(address_space: &mut AddressSpace) {
    // Method
    let name = "Close";
    let node_id = NodeId::new(0, 11632);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11633),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11624),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_44(address_space: &mut AddressSpace) {
    // Method
    let name = "Read";
    let node_id = NodeId::new(0, 11634);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11635),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11636),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11624),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_45(address_space: &mut AddressSpace) {
    // Method
    let name = "Write";
    let node_id = NodeId::new(0, 11637);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11638),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11624),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_46(address_space: &mut AddressSpace) {
    // Method
    let name = "GetPosition";
    let node_id = NodeId::new(0, 11639);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11640),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11641),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11624),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_47(address_space: &mut AddressSpace) {
    // Method
    let name = "SetPosition";
    let node_id = NodeId::new(0, 11642);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11643),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11624),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_48(address_space: &mut AddressSpace) {
    // Method
    let name = "AddRole";
    let node_id = NodeId::new(0, 16301);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16302),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16303),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15606),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_49(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveRole";
    let node_id = NodeId::new(0, 16304);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16305),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15606),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_50(address_space: &mut AddressSpace) {
    // Method
    let name = "GetMonitoredItems";
    let node_id = NodeId::new(0, 11492);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11493),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11494),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2253),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_51(address_space: &mut AddressSpace) {
    // Method
    let name = "ResendData";
    let node_id = NodeId::new(0, 12873);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12874),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2253),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_52(address_space: &mut AddressSpace) {
    // Method
    let name = "SetSubscriptionDurable";
    let node_id = NodeId::new(0, 12749);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12750),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12751),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2253),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_53(address_space: &mut AddressSpace) {
    // Method
    let name = "RequestServerStateChange";
    let node_id = NodeId::new(0, 12886);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12887),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2253),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_54(address_space: &mut AddressSpace) {
    // Method
    let name = "CreateDirectory";
    let node_id = NodeId::new(0, 13355);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13356),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13357),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13354),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_55(address_space: &mut AddressSpace) {
    // Method
    let name = "CreateFile";
    let node_id = NodeId::new(0, 13358);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13359),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13360),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13354),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_56(address_space: &mut AddressSpace) {
    // Method
    let name = "Delete";
    let node_id = NodeId::new(0, 17718);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17719),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13354),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_57(address_space: &mut AddressSpace) {
    // Method
    let name = "MoveOrCopy";
    let node_id = NodeId::new(0, 13363);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13364),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13365),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13354),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_58(address_space: &mut AddressSpace) {
    // Method
    let name = "Open";
    let node_id = NodeId::new(0, 13372);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13373),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13374),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13366),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_59(address_space: &mut AddressSpace) {
    // Method
    let name = "Close";
    let node_id = NodeId::new(0, 13375);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13376),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13366),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_60(address_space: &mut AddressSpace) {
    // Method
    let name = "Read";
    let node_id = NodeId::new(0, 13377);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13378),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13379),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13366),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_61(address_space: &mut AddressSpace) {
    // Method
    let name = "Write";
    let node_id = NodeId::new(0, 13380);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13381),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13366),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_62(address_space: &mut AddressSpace) {
    // Method
    let name = "GetPosition";
    let node_id = NodeId::new(0, 13382);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13383),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13384),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13366),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_63(address_space: &mut AddressSpace) {
    // Method
    let name = "SetPosition";
    let node_id = NodeId::new(0, 13385);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13386),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13366),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_64(address_space: &mut AddressSpace) {
    // Method
    let name = "CreateDirectory";
    let node_id = NodeId::new(0, 13387);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13388),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13389),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13353),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_65(address_space: &mut AddressSpace) {
    // Method
    let name = "CreateFile";
    let node_id = NodeId::new(0, 13390);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13391),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13392),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13353),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_66(address_space: &mut AddressSpace) {
    // Method
    let name = "Delete";
    let node_id = NodeId::new(0, 13393);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13394),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13353),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_67(address_space: &mut AddressSpace) {
    // Method
    let name = "MoveOrCopy";
    let node_id = NodeId::new(0, 13395);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13396),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13397),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13353),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_68(address_space: &mut AddressSpace) {
    // Method
    let name = "CreateDirectory";
    let node_id = NodeId::new(0, 16348);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16349),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16350),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16314),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_69(address_space: &mut AddressSpace) {
    // Method
    let name = "CreateFile";
    let node_id = NodeId::new(0, 16351);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16352),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16353),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16314),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_70(address_space: &mut AddressSpace) {
    // Method
    let name = "Delete";
    let node_id = NodeId::new(0, 16354);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16355),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16314),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_71(address_space: &mut AddressSpace) {
    // Method
    let name = "MoveOrCopy";
    let node_id = NodeId::new(0, 16356);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16357),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16358),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16314),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_72(address_space: &mut AddressSpace) {
    // Method
    let name = "GenerateFileForRead";
    let node_id = NodeId::new(0, 15746);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15747),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15748),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15744),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_73(address_space: &mut AddressSpace) {
    // Method
    let name = "GenerateFileForWrite";
    let node_id = NodeId::new(0, 15749);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16359),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15750),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15744),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_74(address_space: &mut AddressSpace) {
    // Method
    let name = "CloseAndCommit";
    let node_id = NodeId::new(0, 15751);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15752),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15753),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15744),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

fn add_method_77(address_space: &mut AddressSpace) {
    // Method
    let name = "AddRole";
    let node_id = NodeId::new(0, 15997);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15998),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15999),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15607),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_78(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveRole";
    let node_id = NodeId::new(0, 16000);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16001),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15607),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_79(address_space: &mut AddressSpace) {
    // Method
    let name = "AddIdentity";
    let node_id = NodeId::new(0, 15624);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15625),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15620),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_80(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveIdentity";
    let node_id = NodeId::new(0, 15626);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15627),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15620),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_81(address_space: &mut AddressSpace) {
    // Method
    let name = "AddApplication";
    let node_id = NodeId::new(0, 16176);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16177),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15620),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_82(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveApplication";
    let node_id = NodeId::new(0, 16178);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16179),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15620),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_83(address_space: &mut AddressSpace) {
    // Method
    let name = "AddEndpoint";
    let node_id = NodeId::new(0, 16180);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16181),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15620),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_84(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveEndpoint";
    let node_id = NodeId::new(0, 16182);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16183),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15620),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_85(address_space: &mut AddressSpace) {
    // Method
    let name = "AddIdentity";
    let node_id = NodeId::new(0, 15648);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15649),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15644),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_86(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveIdentity";
    let node_id = NodeId::new(0, 15650);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15651),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15644),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_87(address_space: &mut AddressSpace) {
    // Method
    let name = "AddApplication";
    let node_id = NodeId::new(0, 16195);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16196),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15644),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_88(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveApplication";
    let node_id = NodeId::new(0, 16197);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16198),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15644),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_89(address_space: &mut AddressSpace) {
    // Method
    let name = "AddEndpoint";
    let node_id = NodeId::new(0, 16199);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16200),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15644),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_90(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveEndpoint";
    let node_id = NodeId::new(0, 16201);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16202),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15644),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_91(address_space: &mut AddressSpace) {
    // Method
    let name = "AddIdentity";
    let node_id = NodeId::new(0, 15660);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15661),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15656),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_92(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveIdentity";
    let node_id = NodeId::new(0, 15662);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15663),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15656),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_93(address_space: &mut AddressSpace) {
    // Method
    let name = "AddApplication";
    let node_id = NodeId::new(0, 16206);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16207),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15656),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_94(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveApplication";
    let node_id = NodeId::new(0, 16208);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16209),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15656),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_95(address_space: &mut AddressSpace) {
    // Method
    let name = "AddEndpoint";
    let node_id = NodeId::new(0, 16210);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16211),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15656),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_96(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveEndpoint";
    let node_id = NodeId::new(0, 16212);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16213),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15656),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_97(address_space: &mut AddressSpace) {
    // Method
    let name = "AddIdentity";
    let node_id = NodeId::new(0, 15672);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15673),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15668),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_98(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveIdentity";
    let node_id = NodeId::new(0, 15674);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15675),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15668),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_99(address_space: &mut AddressSpace) {
    // Method
    let name = "AddApplication";
    let node_id = NodeId::new(0, 16217);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16218),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15668),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_100(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveApplication";
    let node_id = NodeId::new(0, 16219);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16220),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15668),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}