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_object_1(address_space);
    add_object_2(address_space);
    add_object_3(address_space);
    add_object_4(address_space);
    add_object_5(address_space);
    add_object_6(address_space);
    add_object_7(address_space);
    add_object_8(address_space);
    add_object_9(address_space);
    add_object_10(address_space);
    add_object_11(address_space);
    add_object_12(address_space);
    add_object_13(address_space);
    add_object_14(address_space);
    add_object_15(address_space);
    add_object_16(address_space);
    add_object_17(address_space);
    add_object_18(address_space);
    add_object_19(address_space);
    add_object_20(address_space);
    add_object_21(address_space);
    add_object_22(address_space);
    add_object_23(address_space);
    add_object_24(address_space);
    add_object_25(address_space);
    add_object_26(address_space);
    add_object_27(address_space);
    add_object_28(address_space);
    add_object_29(address_space);
    add_object_30(address_space);
    add_object_31(address_space);
    add_object_32(address_space);
    add_object_33(address_space);
    add_object_34(address_space);
    add_object_35(address_space);
    add_object_36(address_space);
    add_object_37(address_space);
    add_object_38(address_space);
    add_object_39(address_space);
    add_object_40(address_space);
    add_object_41(address_space);
    add_object_42(address_space);
    add_object_43(address_space);
    add_object_44(address_space);
    add_object_45(address_space);
    add_object_46(address_space);
    add_object_47(address_space);
    add_object_48(address_space);
    add_object_49(address_space);
    add_object_50(address_space);
    add_object_51(address_space);
    add_object_52(address_space);
    add_object_53(address_space);
    add_object_54(address_space);
    add_object_55(address_space);
    add_object_56(address_space);
    add_object_57(address_space);
    add_object_58(address_space);
    add_object_59(address_space);
    add_object_60(address_space);
    add_object_61(address_space);
    add_object_62(address_space);
    add_object_63(address_space);
    add_object_64(address_space);
    add_objecttype_65(address_space);
    add_objecttype_66(address_space);
    add_objecttype_67(address_space);
    add_objecttype_68(address_space);
    add_objecttype_69(address_space);
    add_objecttype_70(address_space);
    add_objecttype_71(address_space);
    add_objecttype_72(address_space);
    add_objecttype_73(address_space);
    add_objecttype_74(address_space);
    add_objecttype_75(address_space);
    add_objecttype_76(address_space);
    add_objecttype_77(address_space);
    add_objecttype_78(address_space);
    add_objecttype_79(address_space);
    add_objecttype_80(address_space);
    add_objecttype_81(address_space);
    add_objecttype_82(address_space);
    add_objecttype_83(address_space);
    add_objecttype_84(address_space);
    add_objecttype_85(address_space);
    add_objecttype_86(address_space);
    add_objecttype_87(address_space);
    add_objecttype_88(address_space);
    add_objecttype_89(address_space);
    add_objecttype_90(address_space);
    add_objecttype_91(address_space);
    add_objecttype_92(address_space);
    add_objecttype_93(address_space);
    add_objecttype_94(address_space);
    add_objecttype_95(address_space);
    add_objecttype_96(address_space);
    add_objecttype_97(address_space);
    add_objecttype_98(address_space);
    add_objecttype_99(address_space);
    add_objecttype_100(address_space);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_objecttype_65(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "BaseObjectType";
    let node_id = NodeId::new(0, 58);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert::<ObjectType, ReferenceTypeId>(node, None);
}

fn add_objecttype_66(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "FolderType";
    let node_id = NodeId::new(0, 61);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 58),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_objecttype_67(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "DataTypeSystemType";
    let node_id = NodeId::new(0, 75);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 58),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_objecttype_68(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "DataTypeEncodingType";
    let node_id = NodeId::new(0, 76);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 58),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_objecttype_69(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ModellingRuleType";
    let node_id = NodeId::new(0, 77);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 111),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_70(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ServerType";
    let node_id = NodeId::new(0, 2004);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2005),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2006),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15003),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2007),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2008),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2742),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12882),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17612),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2009),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2010),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2011),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2012),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11527),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11489),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12871),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12746),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12883),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_71(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ServerCapabilitiesType";
    let node_id = NodeId::new(0, 2013);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2014),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2016),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2017),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2732),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2733),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2734),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 3049),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11549),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11550),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12910),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11551),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2019),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2754),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11562),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16295),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_72(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ServerDiagnosticsType";
    let node_id = NodeId::new(0, 2020);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2021),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2022),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2023),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2744),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2025),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_73(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "SessionsDiagnosticsSummaryType";
    let node_id = NodeId::new(0, 2026);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2027),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2028),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12097),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_74(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "SessionDiagnosticsObjectType";
    let node_id = NodeId::new(0, 2029);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2030),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2031),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2032),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_75(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "VendorServerInfoType";
    let node_id = NodeId::new(0, 2033);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 58),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_objecttype_76(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "ServerRedundancyType";
    let node_id = NodeId::new(0, 2034);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2035),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_77(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "TransparentRedundancyType";
    let node_id = NodeId::new(0, 2036);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2037),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2038),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2034),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_78(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "NonTransparentRedundancyType";
    let node_id = NodeId::new(0, 2039);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2040),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2034),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_79(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "NonTransparentNetworkRedundancyType";
    let node_id = NodeId::new(0, 11945);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11948),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2039),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_80(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "OperationLimitsType";
    let node_id = NodeId::new(0, 11564);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11565),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12161),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12162),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11567),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12163),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12164),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11569),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11570),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11571),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11572),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11573),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11574),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 61),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_81(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "FileType";
    let node_id = NodeId::new(0, 11575);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11576),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12686),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12687),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11579),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13341),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11580),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11583),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11585),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11588),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11590),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11593),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_82(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AddressSpaceFileType";
    let node_id = NodeId::new(0, 11595);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11615),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11575),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_83(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "NamespaceMetadataType";
    let node_id = NodeId::new(0, 11616);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11617),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11618),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11619),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11620),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11621),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11622),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11623),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11624),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16137),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16138),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16139),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_84(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "NamespacesType";
    let node_id = NodeId::new(0, 11645);
    let node = ObjectType::new(&node_id, name, name, false);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 11646),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_85(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "BaseEventType";
    let node_id = NodeId::new(0, 2041);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2042),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2043),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2044),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2045),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2046),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2047),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 3190),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2050),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2051),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_86(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditEventType";
    let node_id = NodeId::new(0, 2052);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2053),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2054),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2055),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2056),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2057),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2041),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_87(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditSecurityEventType";
    let node_id = NodeId::new(0, 2058);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17615),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2052),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_88(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditChannelEventType";
    let node_id = NodeId::new(0, 2059);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2745),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2058),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_89(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditOpenSecureChannelEventType";
    let node_id = NodeId::new(0, 2060);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2061),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2746),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2062),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2063),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2065),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2066),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2059),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_90(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditSessionEventType";
    let node_id = NodeId::new(0, 2069);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2070),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2058),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_91(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCreateSessionEventType";
    let node_id = NodeId::new(0, 2071);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2072),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2073),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2747),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2074),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2069),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_92(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditUrlMismatchEventType";
    let node_id = NodeId::new(0, 2748);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2749),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2071),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_93(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditActivateSessionEventType";
    let node_id = NodeId::new(0, 2075);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2076),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2077),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11485),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2069),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_94(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCancelEventType";
    let node_id = NodeId::new(0, 2078);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2079),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2069),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_95(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCertificateEventType";
    let node_id = NodeId::new(0, 2080);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2081),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2058),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_96(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCertificateDataMismatchEventType";
    let node_id = NodeId::new(0, 2082);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 2083),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2084),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2080),
                &ReferenceTypeId::HasSubtype,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_objecttype_97(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCertificateExpiredEventType";
    let node_id = NodeId::new(0, 2085);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 2080),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_objecttype_98(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCertificateInvalidEventType";
    let node_id = NodeId::new(0, 2086);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 2080),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_objecttype_99(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCertificateUntrustedEventType";
    let node_id = NodeId::new(0, 2087);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 2080),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}

fn add_objecttype_100(address_space: &mut AddressSpace) {
    // ObjectType
    let name = "AuditCertificateRevokedEventType";
    let node_id = NodeId::new(0, 2088);
    let node = ObjectType::new(&node_id, name, name, true);
    let _ = address_space.insert(
        node,
        Some(&[(
            &NodeId::new(0, 2080),
            &ReferenceTypeId::HasSubtype,
            ReferenceDirection::Inverse,
        )]),
    );
}