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.Part12.xml by tools/schema/gen_address_space.js
// DO NOT EDIT THIS FILE

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

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

#[allow(unused_variables)]
pub fn populate_address_space(address_space: &mut AddressSpace) {
    add_variable_1(address_space);
    add_variable_2(address_space);
    add_variable_3(address_space);
    add_variable_4(address_space);
    add_variable_5(address_space);
    add_variable_6(address_space);
    add_variable_7(address_space);
    add_variable_8(address_space);
    add_variable_9(address_space);
    add_variable_10(address_space);
    add_variable_11(address_space);
    add_variable_12(address_space);
    add_variable_13(address_space);
    add_variable_14(address_space);
    add_variable_15(address_space);
    add_variable_16(address_space);
    add_variable_17(address_space);
    add_variable_18(address_space);
    add_variable_19(address_space);
    add_variable_20(address_space);
    add_variable_21(address_space);
    add_variable_22(address_space);
    add_variable_23(address_space);
    add_variable_24(address_space);
    add_variable_25(address_space);
    add_variable_26(address_space);
    add_variable_27(address_space);
    add_variable_28(address_space);
    add_variable_29(address_space);
    add_variable_30(address_space);
    add_variable_31(address_space);
    add_variable_32(address_space);
    add_variable_33(address_space);
    add_variable_34(address_space);
    add_variable_35(address_space);
    add_variable_36(address_space);
    add_variable_37(address_space);
    add_variable_38(address_space);
    add_variable_39(address_space);
    add_variable_40(address_space);
    add_variable_41(address_space);
    add_variable_42(address_space);
    add_variable_43(address_space);
    add_variable_44(address_space);
    add_variable_45(address_space);
    add_variable_46(address_space);
    add_variable_47(address_space);
    add_variable_48(address_space);
    add_variable_49(address_space);
    add_variable_50(address_space);
    add_variable_51(address_space);
    add_variable_52(address_space);
    add_variable_53(address_space);
    add_variable_54(address_space);
    add_variable_55(address_space);
    add_variable_56(address_space);
    add_variable_57(address_space);
    add_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_variable_1(address_space: &mut AddressSpace) {
    // Variable
    let name = "OpenCount";
    let value = Variant::Empty;
    let node_id = NodeId::new(0, 13921);
    let node = Variable::new_data_value(&node_id, name, name, NodeId::new(0, 5), None, None, value);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13917),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_2(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Mode"),
            data_type: NodeId::new(0, 3),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13924);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13923),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_3(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13925);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13923),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_4(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13927);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13926),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_5(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Length"),
                data_type: NodeId::new(0, 6),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 13929);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13928),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_6(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Data"),
            data_type: NodeId::new(0, 15),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13930);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13928),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_7(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Data"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 13932);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13931),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_8(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13934);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13933),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_9(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Position"),
            data_type: NodeId::new(0, 9),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13935);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13933),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_10(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Position"),
                data_type: NodeId::new(0, 9),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 13937);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13936),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_12(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Masks"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13940);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13939),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_13(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13941);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13939),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

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

fn add_variable_19(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Mode"),
            data_type: NodeId::new(0, 3),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13959);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13958),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_20(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13960);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13958),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_21(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13962);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13961),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_22(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Length"),
                data_type: NodeId::new(0, 6),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 13964);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13963),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_23(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Data"),
            data_type: NodeId::new(0, 15),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13965);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13963),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_24(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Data"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 13967);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13966),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_25(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13969);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13968),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_26(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Position"),
            data_type: NodeId::new(0, 9),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13970);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13968),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_27(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("FileHandle"),
                data_type: NodeId::new(0, 7),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Position"),
                data_type: NodeId::new(0, 9),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 13972);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13971),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_variable_29(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Masks"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13975);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13974),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_30(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("FileHandle"),
            data_type: NodeId::new(0, 7),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 13976);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13974),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

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

fn add_variable_36(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("CertificateGroupId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("CertificateTypeId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Certificate"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("IssuerCertificates"),
                data_type: NodeId::new(0, 15),
                value_rank: 1,
                array_dimensions: Some(vec![0]),
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("PrivateKeyFormat"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("PrivateKey"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 12617);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12616),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_37(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("ApplyChangesRequired"),
            data_type: NodeId::new(0, 1),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 12618);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12616),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_38(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("CertificateGroupId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("CertificateTypeId"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("SubjectName"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("RegeneratePrivateKey"),
                data_type: NodeId::new(0, 1),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("Nonce"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 12732);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12731),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_39(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("CertificateRequest"),
            data_type: NodeId::new(0, 15),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 12733);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12731),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_40(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("Certificates"),
            data_type: NodeId::new(0, 15),
            value_rank: 1,
            array_dimensions: Some(vec![0]),
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 12776);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12775),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

fn add_variable_45(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("ResourceUri"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("ProfileUri"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("EndpointUrls"),
                data_type: NodeId::new(0, 12),
                value_rank: 1,
                array_dimensions: Some(vec![0]),
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 17523);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17522),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_46(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![Variant::from(ExtensionObject::from_encodable(
        NodeId::new(0, 298),
        &Argument {
            name: UAString::from("CredentialNodeId"),
            data_type: NodeId::new(0, 17),
            value_rank: -1,
            array_dimensions: None,
            description: LocalizedText::new("", ""),
        },
    ))];
    let node_id = NodeId::new(0, 17524);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17522),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

fn add_variable_51(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("CredentialId"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("RequestedSecurityPolicyUri"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 17535);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17534),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_52(address_space: &mut AddressSpace) {
    // Variable
    let name = "OutputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("PublicKey"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("RevisedSecurityPolicyUri"),
                data_type: NodeId::new(0, 17),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 17536);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17534),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_variable_53(address_space: &mut AddressSpace) {
    // Variable
    let name = "InputArguments";
    let value = vec![
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("CredentialId"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("CredentialSecret"),
                data_type: NodeId::new(0, 15),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("CertificateThumbprint"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
        Variant::from(ExtensionObject::from_encodable(
            NodeId::new(0, 298),
            &Argument {
                name: UAString::from("SecurityPolicyUri"),
                data_type: NodeId::new(0, 12),
                value_rank: -1,
                array_dimensions: None,
                description: LocalizedText::new("", ""),
            },
        )),
    ];
    let node_id = NodeId::new(0, 18007);
    let node = Variable::new_data_value(
        &node_id,
        name,
        name,
        NodeId::new(0, 296),
        Some(1),
        Some(0),
        (VariantTypeId::ExtensionObject, value),
    );
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 68),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18006),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

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

fn add_method_58(address_space: &mut AddressSpace) {
    // Method
    let name = "OpenWithMasks";
    let node_id = NodeId::new(0, 12543);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12544),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12545),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12522),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_59(address_space: &mut AddressSpace) {
    // Method
    let name = "CloseAndUpdate";
    let node_id = NodeId::new(0, 12546);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12705),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12547),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12522),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_60(address_space: &mut AddressSpace) {
    // Method
    let name = "AddCertificate";
    let node_id = NodeId::new(0, 12548);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12549),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12522),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_61(address_space: &mut AddressSpace) {
    // Method
    let name = "RemoveCertificate";
    let node_id = NodeId::new(0, 12550);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 12551),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12522),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_62(address_space: &mut AddressSpace) {
    // Method
    let name = "Open";
    let node_id = NodeId::new(0, 13605);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13606),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13607),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13599),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_64(address_space: &mut AddressSpace) {
    // Method
    let name = "Read";
    let node_id = NodeId::new(0, 13610);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13611),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13612),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13599),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

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

fn add_method_68(address_space: &mut AddressSpace) {
    // Method
    let name = "OpenWithMasks";
    let node_id = NodeId::new(0, 13621);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13622),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13623),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13599),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_69(address_space: &mut AddressSpace) {
    // Method
    let name = "Disable";
    let node_id = NodeId::new(0, 19483);
    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, 19450),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_70(address_space: &mut AddressSpace) {
    // Method
    let name = "Enable";
    let node_id = NodeId::new(0, 19484);
    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, 19450),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_71(address_space: &mut AddressSpace) {
    // Method
    let name = "AddComment";
    let node_id = NodeId::new(0, 19485);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19486),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19450),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_73(address_space: &mut AddressSpace) {
    // Method
    let name = "Disable";
    let node_id = NodeId::new(0, 20176);
    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, 20143),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_74(address_space: &mut AddressSpace) {
    // Method
    let name = "Enable";
    let node_id = NodeId::new(0, 20177);
    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, 20143),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

fn add_method_77(address_space: &mut AddressSpace) {
    // Method
    let name = "GetRejectedList";
    let node_id = NodeId::new(0, 23526);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 23527),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 12555),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

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

fn add_method_80(address_space: &mut AddressSpace) {
    // Method
    let name = "Read";
    let node_id = NodeId::new(0, 13826);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13827),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13828),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13815),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_82(address_space: &mut AddressSpace) {
    // Method
    let name = "GetPosition";
    let node_id = NodeId::new(0, 13831);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13832),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13833),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13815),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_84(address_space: &mut AddressSpace) {
    // Method
    let name = "OpenWithMasks";
    let node_id = NodeId::new(0, 13837);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13838),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13839),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13815),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_85(address_space: &mut AddressSpace) {
    // Method
    let name = "Open";
    let node_id = NodeId::new(0, 13855);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13856),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13857),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13849),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_87(address_space: &mut AddressSpace) {
    // Method
    let name = "Read";
    let node_id = NodeId::new(0, 13860);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13861),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13862),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13849),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_89(address_space: &mut AddressSpace) {
    // Method
    let name = "GetPosition";
    let node_id = NodeId::new(0, 13865);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13866),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13867),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13849),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_91(address_space: &mut AddressSpace) {
    // Method
    let name = "OpenWithMasks";
    let node_id = NodeId::new(0, 13871);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13872),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13873),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13849),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_92(address_space: &mut AddressSpace) {
    // Method
    let name = "Open";
    let node_id = NodeId::new(0, 13889);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13890),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13891),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13883),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_94(address_space: &mut AddressSpace) {
    // Method
    let name = "Read";
    let node_id = NodeId::new(0, 13894);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13895),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13896),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13883),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_96(address_space: &mut AddressSpace) {
    // Method
    let name = "GetPosition";
    let node_id = NodeId::new(0, 13899);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13900),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13901),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13883),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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

fn add_method_98(address_space: &mut AddressSpace) {
    // Method
    let name = "OpenWithMasks";
    let node_id = NodeId::new(0, 13905);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13906),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13907),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13883),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_method_99(address_space: &mut AddressSpace) {
    // Method
    let name = "Open";
    let node_id = NodeId::new(0, 13923);
    let node = Method::new(&node_id, name, name, true, true);
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 13924),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13925),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 13917),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

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