diff --git a/WeighUI/lib/WeighingDDSTypeTypeObjectSupport.cxx b/WeighUI/lib/WeighingDDSTypeTypeObjectSupport.cxx
new file mode 100644
index 0000000..7aa2e0c
--- /dev/null
+++ b/WeighUI/lib/WeighingDDSTypeTypeObjectSupport.cxx
@@ -0,0 +1,3292 @@
+// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*!
+ * @file WeighingDDSTypeTypeObjectSupport.cxx
+ * Source file containing the implementation to register the TypeObject representation of the described types in the IDL file
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#include "WeighingDDSTypeTypeObjectSupport.hpp"
+
+#include <mutex>
+#include <string>
+
+#include <fastcdr/xcdr/external.hpp>
+#include <fastcdr/xcdr/optional.hpp>
+#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/log/Log.hpp>
+#include <fastdds/dds/xtypes/common.hpp>
+#include <fastdds/dds/xtypes/type_representation/ITypeObjectRegistry.hpp>
+#include <fastdds/dds/xtypes/type_representation/TypeObject.hpp>
+#include <fastdds/dds/xtypes/type_representation/TypeObjectUtils.hpp>
+
+#include "WeighingDDSType.hpp"
+
+
+using namespace eprosima::fastdds::dds::xtypes;
+
+namespace WeighingSystem {
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_ScaleInfo_type_identifier(
+        TypeIdentifierPair& type_ids_ScaleInfo)
+{
+
+    ReturnCode_t return_code_ScaleInfo {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_ScaleInfo =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::ScaleInfo", type_ids_ScaleInfo);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_ScaleInfo)
+    {
+        StructTypeFlag struct_flags_ScaleInfo = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_ScaleInfo = "WeighingSystem::ScaleInfo";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_ScaleInfo;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_ScaleInfo;
+        CompleteTypeDetail detail_ScaleInfo = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ScaleInfo, ann_custom_ScaleInfo, type_name_ScaleInfo.to_string());
+        CompleteStructHeader header_ScaleInfo;
+        header_ScaleInfo = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ScaleInfo);
+        CompleteStructMemberSeq member_seq_ScaleInfo;
+        {
+            TypeIdentifierPair type_ids_HasVehicle;
+            ReturnCode_t return_code_HasVehicle {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_HasVehicle =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_HasVehicle);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_HasVehicle)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "HasVehicle Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_HasVehicle = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_HasVehicle = 0x00000000;
+            bool common_HasVehicle_ec {false};
+            CommonStructMember common_HasVehicle {TypeObjectUtils::build_common_struct_member(member_id_HasVehicle, member_flags_HasVehicle, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_HasVehicle, common_HasVehicle_ec))};
+            if (!common_HasVehicle_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure HasVehicle member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_HasVehicle = "HasVehicle";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_HasVehicle;
+            ann_custom_ScaleInfo.reset();
+            CompleteMemberDetail detail_HasVehicle = TypeObjectUtils::build_complete_member_detail(name_HasVehicle, member_ann_builtin_HasVehicle, ann_custom_ScaleInfo);
+            CompleteStructMember member_HasVehicle = TypeObjectUtils::build_complete_struct_member(common_HasVehicle, detail_HasVehicle);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_HasVehicle);
+        }
+        {
+            TypeIdentifierPair type_ids_WeightOK;
+            ReturnCode_t return_code_WeightOK {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_WeightOK =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_WeightOK);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_WeightOK)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "WeightOK Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_WeightOK = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_WeightOK = 0x00000001;
+            bool common_WeightOK_ec {false};
+            CommonStructMember common_WeightOK {TypeObjectUtils::build_common_struct_member(member_id_WeightOK, member_flags_WeightOK, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_WeightOK, common_WeightOK_ec))};
+            if (!common_WeightOK_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure WeightOK member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_WeightOK = "WeightOK";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_WeightOK;
+            ann_custom_ScaleInfo.reset();
+            CompleteMemberDetail detail_WeightOK = TypeObjectUtils::build_complete_member_detail(name_WeightOK, member_ann_builtin_WeightOK, ann_custom_ScaleInfo);
+            CompleteStructMember member_WeightOK = TypeObjectUtils::build_complete_struct_member(common_WeightOK, detail_WeightOK);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_WeightOK);
+        }
+        {
+            TypeIdentifierPair type_ids_State;
+            ReturnCode_t return_code_State {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_State =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_State);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_State)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "State Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_State = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_State = 0x00000002;
+            bool common_State_ec {false};
+            CommonStructMember common_State {TypeObjectUtils::build_common_struct_member(member_id_State, member_flags_State, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_State, common_State_ec))};
+            if (!common_State_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure State member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_State = "State";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_State;
+            ann_custom_ScaleInfo.reset();
+            CompleteMemberDetail detail_State = TypeObjectUtils::build_complete_member_detail(name_State, member_ann_builtin_State, ann_custom_ScaleInfo);
+            CompleteStructMember member_State = TypeObjectUtils::build_complete_struct_member(common_State, detail_State);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_State);
+        }
+        {
+            TypeIdentifierPair type_ids_Value;
+            ReturnCode_t return_code_Value {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_Value =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_Value);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Value)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "Value Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_Value = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_Value = 0x00000003;
+            bool common_Value_ec {false};
+            CommonStructMember common_Value {TypeObjectUtils::build_common_struct_member(member_id_Value, member_flags_Value, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Value, common_Value_ec))};
+            if (!common_Value_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Value member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_Value = "Value";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Value;
+            ann_custom_ScaleInfo.reset();
+            CompleteMemberDetail detail_Value = TypeObjectUtils::build_complete_member_detail(name_Value, member_ann_builtin_Value, ann_custom_ScaleInfo);
+            CompleteStructMember member_Value = TypeObjectUtils::build_complete_struct_member(common_Value, detail_Value);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_Value);
+        }
+        {
+            TypeIdentifierPair type_ids_StableValue;
+            ReturnCode_t return_code_StableValue {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_StableValue =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_StableValue);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_StableValue)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "StableValue Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_StableValue = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_StableValue = 0x00000004;
+            bool common_StableValue_ec {false};
+            CommonStructMember common_StableValue {TypeObjectUtils::build_common_struct_member(member_id_StableValue, member_flags_StableValue, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_StableValue, common_StableValue_ec))};
+            if (!common_StableValue_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure StableValue member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_StableValue = "StableValue";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_StableValue;
+            ann_custom_ScaleInfo.reset();
+            CompleteMemberDetail detail_StableValue = TypeObjectUtils::build_complete_member_detail(name_StableValue, member_ann_builtin_StableValue, ann_custom_ScaleInfo);
+            CompleteStructMember member_StableValue = TypeObjectUtils::build_complete_struct_member(common_StableValue, detail_StableValue);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleInfo, member_StableValue);
+        }
+        CompleteStructType struct_type_ScaleInfo = TypeObjectUtils::build_complete_struct_type(struct_flags_ScaleInfo, header_ScaleInfo, member_seq_ScaleInfo);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_ScaleInfo, type_name_ScaleInfo.to_string(), type_ids_ScaleInfo))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::ScaleInfo already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_ScaleCommand_type_identifier(
+        TypeIdentifierPair& type_ids_ScaleCommand)
+{
+
+    ReturnCode_t return_code_ScaleCommand {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_ScaleCommand =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::ScaleCommand", type_ids_ScaleCommand);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_ScaleCommand)
+    {
+        StructTypeFlag struct_flags_ScaleCommand = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_ScaleCommand = "WeighingSystem::ScaleCommand";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_ScaleCommand;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_ScaleCommand;
+        CompleteTypeDetail detail_ScaleCommand = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ScaleCommand, ann_custom_ScaleCommand, type_name_ScaleCommand.to_string());
+        CompleteStructHeader header_ScaleCommand;
+        header_ScaleCommand = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ScaleCommand);
+        CompleteStructMemberSeq member_seq_ScaleCommand;
+        {
+            TypeIdentifierPair type_ids_Enable;
+            ReturnCode_t return_code_Enable {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_Enable =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_Enable);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Enable)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "Enable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_Enable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_Enable = 0x00000000;
+            bool common_Enable_ec {false};
+            CommonStructMember common_Enable {TypeObjectUtils::build_common_struct_member(member_id_Enable, member_flags_Enable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Enable, common_Enable_ec))};
+            if (!common_Enable_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Enable member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_Enable = "Enable";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Enable;
+            ann_custom_ScaleCommand.reset();
+            CompleteMemberDetail detail_Enable = TypeObjectUtils::build_complete_member_detail(name_Enable, member_ann_builtin_Enable, ann_custom_ScaleCommand);
+            CompleteStructMember member_Enable = TypeObjectUtils::build_complete_struct_member(common_Enable, detail_Enable);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleCommand, member_Enable);
+        }
+        {
+            TypeIdentifierPair type_ids_ResetZero;
+            ReturnCode_t return_code_ResetZero {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_ResetZero =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_ResetZero);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ResetZero)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "ResetZero Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_ResetZero = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_ResetZero = 0x00000001;
+            bool common_ResetZero_ec {false};
+            CommonStructMember common_ResetZero {TypeObjectUtils::build_common_struct_member(member_id_ResetZero, member_flags_ResetZero, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ResetZero, common_ResetZero_ec))};
+            if (!common_ResetZero_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ResetZero member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_ResetZero = "ResetZero";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ResetZero;
+            ann_custom_ScaleCommand.reset();
+            CompleteMemberDetail detail_ResetZero = TypeObjectUtils::build_complete_member_detail(name_ResetZero, member_ann_builtin_ResetZero, ann_custom_ScaleCommand);
+            CompleteStructMember member_ResetZero = TypeObjectUtils::build_complete_struct_member(common_ResetZero, detail_ResetZero);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ScaleCommand, member_ResetZero);
+        }
+        CompleteStructType struct_type_ScaleCommand = TypeObjectUtils::build_complete_struct_type(struct_flags_ScaleCommand, header_ScaleCommand, member_seq_ScaleCommand);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_ScaleCommand, type_name_ScaleCommand.to_string(), type_ids_ScaleCommand))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::ScaleCommand already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_WeightInfoOk_type_identifier(
+        TypeIdentifierPair& type_ids_WeightInfoOk)
+{
+
+    ReturnCode_t return_code_WeightInfoOk {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_WeightInfoOk =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::WeightInfoOk", type_ids_WeightInfoOk);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_WeightInfoOk)
+    {
+        StructTypeFlag struct_flags_WeightInfoOk = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_WeightInfoOk = "WeighingSystem::WeightInfoOk";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_WeightInfoOk;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_WeightInfoOk;
+        CompleteTypeDetail detail_WeightInfoOk = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_WeightInfoOk, ann_custom_WeightInfoOk, type_name_WeightInfoOk.to_string());
+        CompleteStructHeader header_WeightInfoOk;
+        header_WeightInfoOk = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_WeightInfoOk);
+        CompleteStructMemberSeq member_seq_WeightInfoOk;
+        {
+            TypeIdentifierPair type_ids_GrossDeviceID;
+            ReturnCode_t return_code_GrossDeviceID {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_GrossDeviceID =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_GrossDeviceID);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossDeviceID)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "GrossDeviceID Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_GrossDeviceID = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_GrossDeviceID = 0x00000000;
+            bool common_GrossDeviceID_ec {false};
+            CommonStructMember common_GrossDeviceID {TypeObjectUtils::build_common_struct_member(member_id_GrossDeviceID, member_flags_GrossDeviceID, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossDeviceID, common_GrossDeviceID_ec))};
+            if (!common_GrossDeviceID_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossDeviceID member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_GrossDeviceID = "GrossDeviceID";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossDeviceID;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_GrossDeviceID = TypeObjectUtils::build_complete_member_detail(name_GrossDeviceID, member_ann_builtin_GrossDeviceID, ann_custom_WeightInfoOk);
+            CompleteStructMember member_GrossDeviceID = TypeObjectUtils::build_complete_struct_member(common_GrossDeviceID, detail_GrossDeviceID);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossDeviceID);
+        }
+        {
+            TypeIdentifierPair type_ids_GrossDeviceName;
+            ReturnCode_t return_code_GrossDeviceName {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_GrossDeviceName =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_GrossDeviceName);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossDeviceName)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_GrossDeviceName))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_GrossDeviceName = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_GrossDeviceName = 0x00000001;
+            bool common_GrossDeviceName_ec {false};
+            CommonStructMember common_GrossDeviceName {TypeObjectUtils::build_common_struct_member(member_id_GrossDeviceName, member_flags_GrossDeviceName, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossDeviceName, common_GrossDeviceName_ec))};
+            if (!common_GrossDeviceName_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossDeviceName member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_GrossDeviceName = "GrossDeviceName";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossDeviceName;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_GrossDeviceName = TypeObjectUtils::build_complete_member_detail(name_GrossDeviceName, member_ann_builtin_GrossDeviceName, ann_custom_WeightInfoOk);
+            CompleteStructMember member_GrossDeviceName = TypeObjectUtils::build_complete_struct_member(common_GrossDeviceName, detail_GrossDeviceName);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossDeviceName);
+        }
+        {
+            TypeIdentifierPair type_ids_GrossDeviceType;
+            ReturnCode_t return_code_GrossDeviceType {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_GrossDeviceType =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_GrossDeviceType);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossDeviceType)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_GrossDeviceType))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_GrossDeviceType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_GrossDeviceType = 0x00000002;
+            bool common_GrossDeviceType_ec {false};
+            CommonStructMember common_GrossDeviceType {TypeObjectUtils::build_common_struct_member(member_id_GrossDeviceType, member_flags_GrossDeviceType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossDeviceType, common_GrossDeviceType_ec))};
+            if (!common_GrossDeviceType_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossDeviceType member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_GrossDeviceType = "GrossDeviceType";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossDeviceType;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_GrossDeviceType = TypeObjectUtils::build_complete_member_detail(name_GrossDeviceType, member_ann_builtin_GrossDeviceType, ann_custom_WeightInfoOk);
+            CompleteStructMember member_GrossDeviceType = TypeObjectUtils::build_complete_struct_member(common_GrossDeviceType, detail_GrossDeviceType);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossDeviceType);
+        }
+        {
+            TypeIdentifierPair type_ids_TareDeviceID;
+            ReturnCode_t return_code_TareDeviceID {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_TareDeviceID =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_TareDeviceID);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareDeviceID)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "TareDeviceID Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_TareDeviceID = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_TareDeviceID = 0x00000003;
+            bool common_TareDeviceID_ec {false};
+            CommonStructMember common_TareDeviceID {TypeObjectUtils::build_common_struct_member(member_id_TareDeviceID, member_flags_TareDeviceID, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareDeviceID, common_TareDeviceID_ec))};
+            if (!common_TareDeviceID_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareDeviceID member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_TareDeviceID = "TareDeviceID";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareDeviceID;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_TareDeviceID = TypeObjectUtils::build_complete_member_detail(name_TareDeviceID, member_ann_builtin_TareDeviceID, ann_custom_WeightInfoOk);
+            CompleteStructMember member_TareDeviceID = TypeObjectUtils::build_complete_struct_member(common_TareDeviceID, detail_TareDeviceID);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareDeviceID);
+        }
+        {
+            TypeIdentifierPair type_ids_TareDeviceName;
+            ReturnCode_t return_code_TareDeviceName {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_TareDeviceName =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_TareDeviceName);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareDeviceName)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_TareDeviceName))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_TareDeviceName = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_TareDeviceName = 0x00000004;
+            bool common_TareDeviceName_ec {false};
+            CommonStructMember common_TareDeviceName {TypeObjectUtils::build_common_struct_member(member_id_TareDeviceName, member_flags_TareDeviceName, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareDeviceName, common_TareDeviceName_ec))};
+            if (!common_TareDeviceName_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareDeviceName member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_TareDeviceName = "TareDeviceName";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareDeviceName;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_TareDeviceName = TypeObjectUtils::build_complete_member_detail(name_TareDeviceName, member_ann_builtin_TareDeviceName, ann_custom_WeightInfoOk);
+            CompleteStructMember member_TareDeviceName = TypeObjectUtils::build_complete_struct_member(common_TareDeviceName, detail_TareDeviceName);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareDeviceName);
+        }
+        {
+            TypeIdentifierPair type_ids_TareDeviceType;
+            ReturnCode_t return_code_TareDeviceType {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_TareDeviceType =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_TareDeviceType);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareDeviceType)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_TareDeviceType))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_TareDeviceType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_TareDeviceType = 0x00000005;
+            bool common_TareDeviceType_ec {false};
+            CommonStructMember common_TareDeviceType {TypeObjectUtils::build_common_struct_member(member_id_TareDeviceType, member_flags_TareDeviceType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareDeviceType, common_TareDeviceType_ec))};
+            if (!common_TareDeviceType_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareDeviceType member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_TareDeviceType = "TareDeviceType";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareDeviceType;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_TareDeviceType = TypeObjectUtils::build_complete_member_detail(name_TareDeviceType, member_ann_builtin_TareDeviceType, ann_custom_WeightInfoOk);
+            CompleteStructMember member_TareDeviceType = TypeObjectUtils::build_complete_struct_member(common_TareDeviceType, detail_TareDeviceType);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareDeviceType);
+        }
+        {
+            TypeIdentifierPair type_ids_EnterpriseName;
+            ReturnCode_t return_code_EnterpriseName {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_EnterpriseName =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_EnterpriseName);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_EnterpriseName)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_EnterpriseName))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_EnterpriseName = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_EnterpriseName = 0x00000006;
+            bool common_EnterpriseName_ec {false};
+            CommonStructMember common_EnterpriseName {TypeObjectUtils::build_common_struct_member(member_id_EnterpriseName, member_flags_EnterpriseName, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_EnterpriseName, common_EnterpriseName_ec))};
+            if (!common_EnterpriseName_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure EnterpriseName member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_EnterpriseName = "EnterpriseName";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_EnterpriseName;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_EnterpriseName = TypeObjectUtils::build_complete_member_detail(name_EnterpriseName, member_ann_builtin_EnterpriseName, ann_custom_WeightInfoOk);
+            CompleteStructMember member_EnterpriseName = TypeObjectUtils::build_complete_struct_member(common_EnterpriseName, detail_EnterpriseName);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_EnterpriseName);
+        }
+        {
+            TypeIdentifierPair type_ids_BillNumber;
+            ReturnCode_t return_code_BillNumber {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BillNumber =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_BillNumber);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BillNumber)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_BillNumber))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_BillNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BillNumber = 0x00000007;
+            bool common_BillNumber_ec {false};
+            CommonStructMember common_BillNumber {TypeObjectUtils::build_common_struct_member(member_id_BillNumber, member_flags_BillNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BillNumber, common_BillNumber_ec))};
+            if (!common_BillNumber_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BillNumber member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BillNumber = "BillNumber";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BillNumber;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_BillNumber = TypeObjectUtils::build_complete_member_detail(name_BillNumber, member_ann_builtin_BillNumber, ann_custom_WeightInfoOk);
+            CompleteStructMember member_BillNumber = TypeObjectUtils::build_complete_struct_member(common_BillNumber, detail_BillNumber);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_BillNumber);
+        }
+        {
+            TypeIdentifierPair type_ids_CarNumber;
+            ReturnCode_t return_code_CarNumber {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_CarNumber =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_CarNumber);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_CarNumber)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_CarNumber))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_CarNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_CarNumber = 0x00000008;
+            bool common_CarNumber_ec {false};
+            CommonStructMember common_CarNumber {TypeObjectUtils::build_common_struct_member(member_id_CarNumber, member_flags_CarNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_CarNumber, common_CarNumber_ec))};
+            if (!common_CarNumber_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure CarNumber member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_CarNumber = "CarNumber";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_CarNumber;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_CarNumber = TypeObjectUtils::build_complete_member_detail(name_CarNumber, member_ann_builtin_CarNumber, ann_custom_WeightInfoOk);
+            CompleteStructMember member_CarNumber = TypeObjectUtils::build_complete_struct_member(common_CarNumber, detail_CarNumber);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_CarNumber);
+        }
+        {
+            TypeIdentifierPair type_ids_Supplier;
+            ReturnCode_t return_code_Supplier {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_Supplier =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_Supplier);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Supplier)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_Supplier))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_Supplier = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_Supplier = 0x00000009;
+            bool common_Supplier_ec {false};
+            CommonStructMember common_Supplier {TypeObjectUtils::build_common_struct_member(member_id_Supplier, member_flags_Supplier, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Supplier, common_Supplier_ec))};
+            if (!common_Supplier_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Supplier member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_Supplier = "Supplier";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Supplier;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_Supplier = TypeObjectUtils::build_complete_member_detail(name_Supplier, member_ann_builtin_Supplier, ann_custom_WeightInfoOk);
+            CompleteStructMember member_Supplier = TypeObjectUtils::build_complete_struct_member(common_Supplier, detail_Supplier);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Supplier);
+        }
+        {
+            TypeIdentifierPair type_ids_GoodsType;
+            ReturnCode_t return_code_GoodsType {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_GoodsType =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_GoodsType);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GoodsType)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_GoodsType))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_GoodsType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_GoodsType = 0x0000000a;
+            bool common_GoodsType_ec {false};
+            CommonStructMember common_GoodsType {TypeObjectUtils::build_common_struct_member(member_id_GoodsType, member_flags_GoodsType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GoodsType, common_GoodsType_ec))};
+            if (!common_GoodsType_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GoodsType member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_GoodsType = "GoodsType";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GoodsType;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_GoodsType = TypeObjectUtils::build_complete_member_detail(name_GoodsType, member_ann_builtin_GoodsType, ann_custom_WeightInfoOk);
+            CompleteStructMember member_GoodsType = TypeObjectUtils::build_complete_struct_member(common_GoodsType, detail_GoodsType);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GoodsType);
+        }
+        {
+            TypeIdentifierPair type_ids_GrossWeight;
+            ReturnCode_t return_code_GrossWeight {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_GrossWeight =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_GrossWeight);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossWeight)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "GrossWeight Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_GrossWeight = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_GrossWeight = 0x0000000b;
+            bool common_GrossWeight_ec {false};
+            CommonStructMember common_GrossWeight {TypeObjectUtils::build_common_struct_member(member_id_GrossWeight, member_flags_GrossWeight, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossWeight, common_GrossWeight_ec))};
+            if (!common_GrossWeight_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossWeight member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_GrossWeight = "GrossWeight";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossWeight;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_GrossWeight = TypeObjectUtils::build_complete_member_detail(name_GrossWeight, member_ann_builtin_GrossWeight, ann_custom_WeightInfoOk);
+            CompleteStructMember member_GrossWeight = TypeObjectUtils::build_complete_struct_member(common_GrossWeight, detail_GrossWeight);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossWeight);
+        }
+        {
+            TypeIdentifierPair type_ids_GrossTime;
+            ReturnCode_t return_code_GrossTime {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_GrossTime =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_GrossTime);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossTime)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_GrossTime))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_GrossTime = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_GrossTime = 0x0000000c;
+            bool common_GrossTime_ec {false};
+            CommonStructMember common_GrossTime {TypeObjectUtils::build_common_struct_member(member_id_GrossTime, member_flags_GrossTime, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossTime, common_GrossTime_ec))};
+            if (!common_GrossTime_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossTime member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_GrossTime = "GrossTime";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossTime;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_GrossTime = TypeObjectUtils::build_complete_member_detail(name_GrossTime, member_ann_builtin_GrossTime, ann_custom_WeightInfoOk);
+            CompleteStructMember member_GrossTime = TypeObjectUtils::build_complete_struct_member(common_GrossTime, detail_GrossTime);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossTime);
+        }
+        {
+            TypeIdentifierPair type_ids_GrossOperater;
+            ReturnCode_t return_code_GrossOperater {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_GrossOperater =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_GrossOperater);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_GrossOperater)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_GrossOperater))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_GrossOperater = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_GrossOperater = 0x0000000d;
+            bool common_GrossOperater_ec {false};
+            CommonStructMember common_GrossOperater {TypeObjectUtils::build_common_struct_member(member_id_GrossOperater, member_flags_GrossOperater, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_GrossOperater, common_GrossOperater_ec))};
+            if (!common_GrossOperater_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure GrossOperater member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_GrossOperater = "GrossOperater";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_GrossOperater;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_GrossOperater = TypeObjectUtils::build_complete_member_detail(name_GrossOperater, member_ann_builtin_GrossOperater, ann_custom_WeightInfoOk);
+            CompleteStructMember member_GrossOperater = TypeObjectUtils::build_complete_struct_member(common_GrossOperater, detail_GrossOperater);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_GrossOperater);
+        }
+        {
+            TypeIdentifierPair type_ids_Tare;
+            ReturnCode_t return_code_Tare {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_Tare =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_Tare);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Tare)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "Tare Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_Tare = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_Tare = 0x0000000e;
+            bool common_Tare_ec {false};
+            CommonStructMember common_Tare {TypeObjectUtils::build_common_struct_member(member_id_Tare, member_flags_Tare, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Tare, common_Tare_ec))};
+            if (!common_Tare_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Tare member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_Tare = "Tare";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Tare;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_Tare = TypeObjectUtils::build_complete_member_detail(name_Tare, member_ann_builtin_Tare, ann_custom_WeightInfoOk);
+            CompleteStructMember member_Tare = TypeObjectUtils::build_complete_struct_member(common_Tare, detail_Tare);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Tare);
+        }
+        {
+            TypeIdentifierPair type_ids_TareTime;
+            ReturnCode_t return_code_TareTime {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_TareTime =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_TareTime);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareTime)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_TareTime))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_TareTime = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_TareTime = 0x0000000f;
+            bool common_TareTime_ec {false};
+            CommonStructMember common_TareTime {TypeObjectUtils::build_common_struct_member(member_id_TareTime, member_flags_TareTime, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareTime, common_TareTime_ec))};
+            if (!common_TareTime_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareTime member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_TareTime = "TareTime";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareTime;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_TareTime = TypeObjectUtils::build_complete_member_detail(name_TareTime, member_ann_builtin_TareTime, ann_custom_WeightInfoOk);
+            CompleteStructMember member_TareTime = TypeObjectUtils::build_complete_struct_member(common_TareTime, detail_TareTime);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareTime);
+        }
+        {
+            TypeIdentifierPair type_ids_TareOperater;
+            ReturnCode_t return_code_TareOperater {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_TareOperater =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_TareOperater);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TareOperater)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_TareOperater))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_TareOperater = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_TareOperater = 0x00000010;
+            bool common_TareOperater_ec {false};
+            CommonStructMember common_TareOperater {TypeObjectUtils::build_common_struct_member(member_id_TareOperater, member_flags_TareOperater, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TareOperater, common_TareOperater_ec))};
+            if (!common_TareOperater_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TareOperater member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_TareOperater = "TareOperater";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TareOperater;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_TareOperater = TypeObjectUtils::build_complete_member_detail(name_TareOperater, member_ann_builtin_TareOperater, ann_custom_WeightInfoOk);
+            CompleteStructMember member_TareOperater = TypeObjectUtils::build_complete_struct_member(common_TareOperater, detail_TareOperater);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TareOperater);
+        }
+        {
+            TypeIdentifierPair type_ids_Suttle;
+            ReturnCode_t return_code_Suttle {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_Suttle =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_Suttle);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Suttle)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "Suttle Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_Suttle = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_Suttle = 0x00000011;
+            bool common_Suttle_ec {false};
+            CommonStructMember common_Suttle {TypeObjectUtils::build_common_struct_member(member_id_Suttle, member_flags_Suttle, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Suttle, common_Suttle_ec))};
+            if (!common_Suttle_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Suttle member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_Suttle = "Suttle";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Suttle;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_Suttle = TypeObjectUtils::build_complete_member_detail(name_Suttle, member_ann_builtin_Suttle, ann_custom_WeightInfoOk);
+            CompleteStructMember member_Suttle = TypeObjectUtils::build_complete_struct_member(common_Suttle, detail_Suttle);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Suttle);
+        }
+        {
+            TypeIdentifierPair type_ids_duduction1;
+            ReturnCode_t return_code_duduction1 {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_duduction1 =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_duduction1);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_duduction1)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "duduction1 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_duduction1 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_duduction1 = 0x00000012;
+            bool common_duduction1_ec {false};
+            CommonStructMember common_duduction1 {TypeObjectUtils::build_common_struct_member(member_id_duduction1, member_flags_duduction1, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_duduction1, common_duduction1_ec))};
+            if (!common_duduction1_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure duduction1 member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_duduction1 = "duduction1";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_duduction1;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_duduction1 = TypeObjectUtils::build_complete_member_detail(name_duduction1, member_ann_builtin_duduction1, ann_custom_WeightInfoOk);
+            CompleteStructMember member_duduction1 = TypeObjectUtils::build_complete_struct_member(common_duduction1, detail_duduction1);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_duduction1);
+        }
+        {
+            TypeIdentifierPair type_ids_duduction2;
+            ReturnCode_t return_code_duduction2 {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_duduction2 =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_duduction2);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_duduction2)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "duduction2 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_duduction2 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_duduction2 = 0x00000013;
+            bool common_duduction2_ec {false};
+            CommonStructMember common_duduction2 {TypeObjectUtils::build_common_struct_member(member_id_duduction2, member_flags_duduction2, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_duduction2, common_duduction2_ec))};
+            if (!common_duduction2_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure duduction2 member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_duduction2 = "duduction2";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_duduction2;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_duduction2 = TypeObjectUtils::build_complete_member_detail(name_duduction2, member_ann_builtin_duduction2, ann_custom_WeightInfoOk);
+            CompleteStructMember member_duduction2 = TypeObjectUtils::build_complete_struct_member(common_duduction2, detail_duduction2);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_duduction2);
+        }
+        {
+            TypeIdentifierPair type_ids_duduction3;
+            ReturnCode_t return_code_duduction3 {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_duduction3 =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_duduction3);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_duduction3)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "duduction3 Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_duduction3 = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_duduction3 = 0x00000014;
+            bool common_duduction3_ec {false};
+            CommonStructMember common_duduction3 {TypeObjectUtils::build_common_struct_member(member_id_duduction3, member_flags_duduction3, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_duduction3, common_duduction3_ec))};
+            if (!common_duduction3_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure duduction3 member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_duduction3 = "duduction3";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_duduction3;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_duduction3 = TypeObjectUtils::build_complete_member_detail(name_duduction3, member_ann_builtin_duduction3, ann_custom_WeightInfoOk);
+            CompleteStructMember member_duduction3 = TypeObjectUtils::build_complete_struct_member(common_duduction3, detail_duduction3);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_duduction3);
+        }
+        {
+            TypeIdentifierPair type_ids_INCoalYard;
+            ReturnCode_t return_code_INCoalYard {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_INCoalYard =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_INCoalYard);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_INCoalYard)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_INCoalYard))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_INCoalYard = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_INCoalYard = 0x00000015;
+            bool common_INCoalYard_ec {false};
+            CommonStructMember common_INCoalYard {TypeObjectUtils::build_common_struct_member(member_id_INCoalYard, member_flags_INCoalYard, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_INCoalYard, common_INCoalYard_ec))};
+            if (!common_INCoalYard_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure INCoalYard member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_INCoalYard = "INCoalYard";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_INCoalYard;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_INCoalYard = TypeObjectUtils::build_complete_member_detail(name_INCoalYard, member_ann_builtin_INCoalYard, ann_custom_WeightInfoOk);
+            CompleteStructMember member_INCoalYard = TypeObjectUtils::build_complete_struct_member(common_INCoalYard, detail_INCoalYard);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_INCoalYard);
+        }
+        {
+            TypeIdentifierPair type_ids_OutCoalYard;
+            ReturnCode_t return_code_OutCoalYard {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_OutCoalYard =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_OutCoalYard);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_OutCoalYard)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_OutCoalYard))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_OutCoalYard = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_OutCoalYard = 0x00000016;
+            bool common_OutCoalYard_ec {false};
+            CommonStructMember common_OutCoalYard {TypeObjectUtils::build_common_struct_member(member_id_OutCoalYard, member_flags_OutCoalYard, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_OutCoalYard, common_OutCoalYard_ec))};
+            if (!common_OutCoalYard_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure OutCoalYard member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_OutCoalYard = "OutCoalYard";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_OutCoalYard;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_OutCoalYard = TypeObjectUtils::build_complete_member_detail(name_OutCoalYard, member_ann_builtin_OutCoalYard, ann_custom_WeightInfoOk);
+            CompleteStructMember member_OutCoalYard = TypeObjectUtils::build_complete_struct_member(common_OutCoalYard, detail_OutCoalYard);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_OutCoalYard);
+        }
+        {
+            TypeIdentifierPair type_ids_BatchNumber;
+            ReturnCode_t return_code_BatchNumber {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BatchNumber =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_BatchNumber);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BatchNumber)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_BatchNumber))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_BatchNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BatchNumber = 0x00000017;
+            bool common_BatchNumber_ec {false};
+            CommonStructMember common_BatchNumber {TypeObjectUtils::build_common_struct_member(member_id_BatchNumber, member_flags_BatchNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BatchNumber, common_BatchNumber_ec))};
+            if (!common_BatchNumber_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BatchNumber member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BatchNumber = "BatchNumber";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BatchNumber;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_BatchNumber = TypeObjectUtils::build_complete_member_detail(name_BatchNumber, member_ann_builtin_BatchNumber, ann_custom_WeightInfoOk);
+            CompleteStructMember member_BatchNumber = TypeObjectUtils::build_complete_struct_member(common_BatchNumber, detail_BatchNumber);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_BatchNumber);
+        }
+        {
+            TypeIdentifierPair type_ids_Warning;
+            ReturnCode_t return_code_Warning {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_Warning =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_Warning);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Warning)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_Warning))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_Warning = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_Warning = 0x00000018;
+            bool common_Warning_ec {false};
+            CommonStructMember common_Warning {TypeObjectUtils::build_common_struct_member(member_id_Warning, member_flags_Warning, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Warning, common_Warning_ec))};
+            if (!common_Warning_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Warning member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_Warning = "Warning";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Warning;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_Warning = TypeObjectUtils::build_complete_member_detail(name_Warning, member_ann_builtin_Warning, ann_custom_WeightInfoOk);
+            CompleteStructMember member_Warning = TypeObjectUtils::build_complete_struct_member(common_Warning, detail_Warning);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Warning);
+        }
+        {
+            TypeIdentifierPair type_ids_Tips;
+            ReturnCode_t return_code_Tips {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_Tips =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_Tips);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Tips)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_Tips))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_Tips = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_Tips = 0x00000019;
+            bool common_Tips_ec {false};
+            CommonStructMember common_Tips {TypeObjectUtils::build_common_struct_member(member_id_Tips, member_flags_Tips, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Tips, common_Tips_ec))};
+            if (!common_Tips_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Tips member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_Tips = "Tips";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Tips;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_Tips = TypeObjectUtils::build_complete_member_detail(name_Tips, member_ann_builtin_Tips, ann_custom_WeightInfoOk);
+            CompleteStructMember member_Tips = TypeObjectUtils::build_complete_struct_member(common_Tips, detail_Tips);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_Tips);
+        }
+        {
+            TypeIdentifierPair type_ids_TicketType;
+            ReturnCode_t return_code_TicketType {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_TicketType =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_TicketType);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TicketType)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_TicketType))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_TicketType = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_TicketType = 0x0000001a;
+            bool common_TicketType_ec {false};
+            CommonStructMember common_TicketType {TypeObjectUtils::build_common_struct_member(member_id_TicketType, member_flags_TicketType, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TicketType, common_TicketType_ec))};
+            if (!common_TicketType_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TicketType member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_TicketType = "TicketType";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TicketType;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_TicketType = TypeObjectUtils::build_complete_member_detail(name_TicketType, member_ann_builtin_TicketType, ann_custom_WeightInfoOk);
+            CompleteStructMember member_TicketType = TypeObjectUtils::build_complete_struct_member(common_TicketType, detail_TicketType);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TicketType);
+        }
+        {
+            TypeIdentifierPair type_ids_IsPrintTicker;
+            ReturnCode_t return_code_IsPrintTicker {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_IsPrintTicker =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_IsPrintTicker);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_IsPrintTicker)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "IsPrintTicker Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_IsPrintTicker = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_IsPrintTicker = 0x0000001b;
+            bool common_IsPrintTicker_ec {false};
+            CommonStructMember common_IsPrintTicker {TypeObjectUtils::build_common_struct_member(member_id_IsPrintTicker, member_flags_IsPrintTicker, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_IsPrintTicker, common_IsPrintTicker_ec))};
+            if (!common_IsPrintTicker_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure IsPrintTicker member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_IsPrintTicker = "IsPrintTicker";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_IsPrintTicker;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_IsPrintTicker = TypeObjectUtils::build_complete_member_detail(name_IsPrintTicker, member_ann_builtin_IsPrintTicker, ann_custom_WeightInfoOk);
+            CompleteStructMember member_IsPrintTicker = TypeObjectUtils::build_complete_struct_member(common_IsPrintTicker, detail_IsPrintTicker);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_IsPrintTicker);
+        }
+        {
+            TypeIdentifierPair type_ids_OrderNumber;
+            ReturnCode_t return_code_OrderNumber {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_OrderNumber =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_OrderNumber);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_OrderNumber)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_OrderNumber))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_OrderNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_OrderNumber = 0x0000001c;
+            bool common_OrderNumber_ec {false};
+            CommonStructMember common_OrderNumber {TypeObjectUtils::build_common_struct_member(member_id_OrderNumber, member_flags_OrderNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_OrderNumber, common_OrderNumber_ec))};
+            if (!common_OrderNumber_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure OrderNumber member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_OrderNumber = "OrderNumber";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_OrderNumber;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_OrderNumber = TypeObjectUtils::build_complete_member_detail(name_OrderNumber, member_ann_builtin_OrderNumber, ann_custom_WeightInfoOk);
+            CompleteStructMember member_OrderNumber = TypeObjectUtils::build_complete_struct_member(common_OrderNumber, detail_OrderNumber);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_OrderNumber);
+        }
+        {
+            TypeIdentifierPair type_ids_VehicleAndVesselNumber;
+            ReturnCode_t return_code_VehicleAndVesselNumber {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_VehicleAndVesselNumber =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_VehicleAndVesselNumber);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_VehicleAndVesselNumber)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_VehicleAndVesselNumber))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_VehicleAndVesselNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_VehicleAndVesselNumber = 0x0000001d;
+            bool common_VehicleAndVesselNumber_ec {false};
+            CommonStructMember common_VehicleAndVesselNumber {TypeObjectUtils::build_common_struct_member(member_id_VehicleAndVesselNumber, member_flags_VehicleAndVesselNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_VehicleAndVesselNumber, common_VehicleAndVesselNumber_ec))};
+            if (!common_VehicleAndVesselNumber_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure VehicleAndVesselNumber member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_VehicleAndVesselNumber = "VehicleAndVesselNumber";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_VehicleAndVesselNumber;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_VehicleAndVesselNumber = TypeObjectUtils::build_complete_member_detail(name_VehicleAndVesselNumber, member_ann_builtin_VehicleAndVesselNumber, ann_custom_WeightInfoOk);
+            CompleteStructMember member_VehicleAndVesselNumber = TypeObjectUtils::build_complete_struct_member(common_VehicleAndVesselNumber, detail_VehicleAndVesselNumber);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_VehicleAndVesselNumber);
+        }
+        {
+            TypeIdentifierPair type_ids_ReceiveCompany;
+            ReturnCode_t return_code_ReceiveCompany {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_ReceiveCompany =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_ReceiveCompany);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_ReceiveCompany)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_ReceiveCompany))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_ReceiveCompany = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_ReceiveCompany = 0x0000001e;
+            bool common_ReceiveCompany_ec {false};
+            CommonStructMember common_ReceiveCompany {TypeObjectUtils::build_common_struct_member(member_id_ReceiveCompany, member_flags_ReceiveCompany, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_ReceiveCompany, common_ReceiveCompany_ec))};
+            if (!common_ReceiveCompany_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure ReceiveCompany member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_ReceiveCompany = "ReceiveCompany";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_ReceiveCompany;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_ReceiveCompany = TypeObjectUtils::build_complete_member_detail(name_ReceiveCompany, member_ann_builtin_ReceiveCompany, ann_custom_WeightInfoOk);
+            CompleteStructMember member_ReceiveCompany = TypeObjectUtils::build_complete_struct_member(common_ReceiveCompany, detail_ReceiveCompany);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_ReceiveCompany);
+        }
+        {
+            TypeIdentifierPair type_ids_TransportCompany;
+            ReturnCode_t return_code_TransportCompany {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_TransportCompany =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_TransportCompany);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_TransportCompany)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_TransportCompany))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_TransportCompany = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_TransportCompany = 0x0000001f;
+            bool common_TransportCompany_ec {false};
+            CommonStructMember common_TransportCompany {TypeObjectUtils::build_common_struct_member(member_id_TransportCompany, member_flags_TransportCompany, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_TransportCompany, common_TransportCompany_ec))};
+            if (!common_TransportCompany_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure TransportCompany member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_TransportCompany = "TransportCompany";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_TransportCompany;
+            ann_custom_WeightInfoOk.reset();
+            CompleteMemberDetail detail_TransportCompany = TypeObjectUtils::build_complete_member_detail(name_TransportCompany, member_ann_builtin_TransportCompany, ann_custom_WeightInfoOk);
+            CompleteStructMember member_TransportCompany = TypeObjectUtils::build_complete_struct_member(common_TransportCompany, detail_TransportCompany);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoOk, member_TransportCompany);
+        }
+        CompleteStructType struct_type_WeightInfoOk = TypeObjectUtils::build_complete_struct_type(struct_flags_WeightInfoOk, header_WeightInfoOk, member_seq_WeightInfoOk);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_WeightInfoOk, type_name_WeightInfoOk.to_string(), type_ids_WeightInfoOk))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::WeightInfoOk already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_WeightInfoError_type_identifier(
+        TypeIdentifierPair& type_ids_WeightInfoError)
+{
+
+    ReturnCode_t return_code_WeightInfoError {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_WeightInfoError =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::WeightInfoError", type_ids_WeightInfoError);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_WeightInfoError)
+    {
+        StructTypeFlag struct_flags_WeightInfoError = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_WeightInfoError = "WeighingSystem::WeightInfoError";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_WeightInfoError;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_WeightInfoError;
+        CompleteTypeDetail detail_WeightInfoError = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_WeightInfoError, ann_custom_WeightInfoError, type_name_WeightInfoError.to_string());
+        CompleteStructHeader header_WeightInfoError;
+        header_WeightInfoError = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_WeightInfoError);
+        CompleteStructMemberSeq member_seq_WeightInfoError;
+        {
+            TypeIdentifierPair type_ids_CarNumber;
+            ReturnCode_t return_code_CarNumber {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_CarNumber =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_CarNumber);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_CarNumber)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_CarNumber))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_CarNumber = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_CarNumber = 0x00000000;
+            bool common_CarNumber_ec {false};
+            CommonStructMember common_CarNumber {TypeObjectUtils::build_common_struct_member(member_id_CarNumber, member_flags_CarNumber, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_CarNumber, common_CarNumber_ec))};
+            if (!common_CarNumber_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure CarNumber member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_CarNumber = "CarNumber";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_CarNumber;
+            ann_custom_WeightInfoError.reset();
+            CompleteMemberDetail detail_CarNumber = TypeObjectUtils::build_complete_member_detail(name_CarNumber, member_ann_builtin_CarNumber, ann_custom_WeightInfoError);
+            CompleteStructMember member_CarNumber = TypeObjectUtils::build_complete_struct_member(common_CarNumber, detail_CarNumber);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoError, member_CarNumber);
+        }
+        {
+            TypeIdentifierPair type_ids_Warning;
+            ReturnCode_t return_code_Warning {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_Warning =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_Warning);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_Warning)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_Warning))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_Warning = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_Warning = 0x00000001;
+            bool common_Warning_ec {false};
+            CommonStructMember common_Warning {TypeObjectUtils::build_common_struct_member(member_id_Warning, member_flags_Warning, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_Warning, common_Warning_ec))};
+            if (!common_Warning_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure Warning member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_Warning = "Warning";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_Warning;
+            ann_custom_WeightInfoError.reset();
+            CompleteMemberDetail detail_Warning = TypeObjectUtils::build_complete_member_detail(name_Warning, member_ann_builtin_Warning, ann_custom_WeightInfoError);
+            CompleteStructMember member_Warning = TypeObjectUtils::build_complete_struct_member(common_Warning, detail_Warning);
+            TypeObjectUtils::add_complete_struct_member(member_seq_WeightInfoError, member_Warning);
+        }
+        CompleteStructType struct_type_WeightInfoError = TypeObjectUtils::build_complete_struct_type(struct_flags_WeightInfoError, header_WeightInfoError, member_seq_WeightInfoError);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_WeightInfoError, type_name_WeightInfoError.to_string(), type_ids_WeightInfoError))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::WeightInfoError already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_BarCommandUpdate_type_identifier(
+        TypeIdentifierPair& type_ids_BarCommandUpdate)
+{
+
+    ReturnCode_t return_code_BarCommandUpdate {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_BarCommandUpdate =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::BarCommandUpdate", type_ids_BarCommandUpdate);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_BarCommandUpdate)
+    {
+        StructTypeFlag struct_flags_BarCommandUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_BarCommandUpdate = "WeighingSystem::BarCommandUpdate";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_BarCommandUpdate;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_BarCommandUpdate;
+        CompleteTypeDetail detail_BarCommandUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_BarCommandUpdate, ann_custom_BarCommandUpdate, type_name_BarCommandUpdate.to_string());
+        CompleteStructHeader header_BarCommandUpdate;
+        header_BarCommandUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_BarCommandUpdate);
+        CompleteStructMemberSeq member_seq_BarCommandUpdate;
+        {
+            TypeIdentifierPair type_ids_FrontBarSignalUp;
+            ReturnCode_t return_code_FrontBarSignalUp {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontBarSignalUp =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_FrontBarSignalUp);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontBarSignalUp)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontBarSignalUp Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontBarSignalUp = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontBarSignalUp = 0x00000000;
+            bool common_FrontBarSignalUp_ec {false};
+            CommonStructMember common_FrontBarSignalUp {TypeObjectUtils::build_common_struct_member(member_id_FrontBarSignalUp, member_flags_FrontBarSignalUp, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontBarSignalUp, common_FrontBarSignalUp_ec))};
+            if (!common_FrontBarSignalUp_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontBarSignalUp member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontBarSignalUp = "FrontBarSignalUp";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontBarSignalUp;
+            ann_custom_BarCommandUpdate.reset();
+            CompleteMemberDetail detail_FrontBarSignalUp = TypeObjectUtils::build_complete_member_detail(name_FrontBarSignalUp, member_ann_builtin_FrontBarSignalUp, ann_custom_BarCommandUpdate);
+            CompleteStructMember member_FrontBarSignalUp = TypeObjectUtils::build_complete_struct_member(common_FrontBarSignalUp, detail_FrontBarSignalUp);
+            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_FrontBarSignalUp);
+        }
+        {
+            TypeIdentifierPair type_ids_FrontBarSignalDown;
+            ReturnCode_t return_code_FrontBarSignalDown {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontBarSignalDown =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_FrontBarSignalDown);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontBarSignalDown)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontBarSignalDown Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontBarSignalDown = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontBarSignalDown = 0x00000001;
+            bool common_FrontBarSignalDown_ec {false};
+            CommonStructMember common_FrontBarSignalDown {TypeObjectUtils::build_common_struct_member(member_id_FrontBarSignalDown, member_flags_FrontBarSignalDown, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontBarSignalDown, common_FrontBarSignalDown_ec))};
+            if (!common_FrontBarSignalDown_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontBarSignalDown member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontBarSignalDown = "FrontBarSignalDown";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontBarSignalDown;
+            ann_custom_BarCommandUpdate.reset();
+            CompleteMemberDetail detail_FrontBarSignalDown = TypeObjectUtils::build_complete_member_detail(name_FrontBarSignalDown, member_ann_builtin_FrontBarSignalDown, ann_custom_BarCommandUpdate);
+            CompleteStructMember member_FrontBarSignalDown = TypeObjectUtils::build_complete_struct_member(common_FrontBarSignalDown, detail_FrontBarSignalDown);
+            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_FrontBarSignalDown);
+        }
+        {
+            TypeIdentifierPair type_ids_FrontBarEnable;
+            ReturnCode_t return_code_FrontBarEnable {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontBarEnable =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_FrontBarEnable);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontBarEnable)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontBarEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontBarEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontBarEnable = 0x00000002;
+            bool common_FrontBarEnable_ec {false};
+            CommonStructMember common_FrontBarEnable {TypeObjectUtils::build_common_struct_member(member_id_FrontBarEnable, member_flags_FrontBarEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontBarEnable, common_FrontBarEnable_ec))};
+            if (!common_FrontBarEnable_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontBarEnable member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontBarEnable = "FrontBarEnable";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontBarEnable;
+            ann_custom_BarCommandUpdate.reset();
+            CompleteMemberDetail detail_FrontBarEnable = TypeObjectUtils::build_complete_member_detail(name_FrontBarEnable, member_ann_builtin_FrontBarEnable, ann_custom_BarCommandUpdate);
+            CompleteStructMember member_FrontBarEnable = TypeObjectUtils::build_complete_struct_member(common_FrontBarEnable, detail_FrontBarEnable);
+            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_FrontBarEnable);
+        }
+        {
+            TypeIdentifierPair type_ids_BackBarSignalUp;
+            ReturnCode_t return_code_BackBarSignalUp {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackBarSignalUp =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_BackBarSignalUp);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackBarSignalUp)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackBarSignalUp Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackBarSignalUp = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackBarSignalUp = 0x00000003;
+            bool common_BackBarSignalUp_ec {false};
+            CommonStructMember common_BackBarSignalUp {TypeObjectUtils::build_common_struct_member(member_id_BackBarSignalUp, member_flags_BackBarSignalUp, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackBarSignalUp, common_BackBarSignalUp_ec))};
+            if (!common_BackBarSignalUp_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackBarSignalUp member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackBarSignalUp = "BackBarSignalUp";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackBarSignalUp;
+            ann_custom_BarCommandUpdate.reset();
+            CompleteMemberDetail detail_BackBarSignalUp = TypeObjectUtils::build_complete_member_detail(name_BackBarSignalUp, member_ann_builtin_BackBarSignalUp, ann_custom_BarCommandUpdate);
+            CompleteStructMember member_BackBarSignalUp = TypeObjectUtils::build_complete_struct_member(common_BackBarSignalUp, detail_BackBarSignalUp);
+            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_BackBarSignalUp);
+        }
+        {
+            TypeIdentifierPair type_ids_BackBarSignalDown;
+            ReturnCode_t return_code_BackBarSignalDown {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackBarSignalDown =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_BackBarSignalDown);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackBarSignalDown)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackBarSignalDown Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackBarSignalDown = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackBarSignalDown = 0x00000004;
+            bool common_BackBarSignalDown_ec {false};
+            CommonStructMember common_BackBarSignalDown {TypeObjectUtils::build_common_struct_member(member_id_BackBarSignalDown, member_flags_BackBarSignalDown, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackBarSignalDown, common_BackBarSignalDown_ec))};
+            if (!common_BackBarSignalDown_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackBarSignalDown member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackBarSignalDown = "BackBarSignalDown";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackBarSignalDown;
+            ann_custom_BarCommandUpdate.reset();
+            CompleteMemberDetail detail_BackBarSignalDown = TypeObjectUtils::build_complete_member_detail(name_BackBarSignalDown, member_ann_builtin_BackBarSignalDown, ann_custom_BarCommandUpdate);
+            CompleteStructMember member_BackBarSignalDown = TypeObjectUtils::build_complete_struct_member(common_BackBarSignalDown, detail_BackBarSignalDown);
+            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_BackBarSignalDown);
+        }
+        {
+            TypeIdentifierPair type_ids_BackBarEnable;
+            ReturnCode_t return_code_BackBarEnable {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackBarEnable =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_BackBarEnable);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackBarEnable)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackBarEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackBarEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackBarEnable = 0x00000005;
+            bool common_BackBarEnable_ec {false};
+            CommonStructMember common_BackBarEnable {TypeObjectUtils::build_common_struct_member(member_id_BackBarEnable, member_flags_BackBarEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackBarEnable, common_BackBarEnable_ec))};
+            if (!common_BackBarEnable_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackBarEnable member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackBarEnable = "BackBarEnable";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackBarEnable;
+            ann_custom_BarCommandUpdate.reset();
+            CompleteMemberDetail detail_BackBarEnable = TypeObjectUtils::build_complete_member_detail(name_BackBarEnable, member_ann_builtin_BackBarEnable, ann_custom_BarCommandUpdate);
+            CompleteStructMember member_BackBarEnable = TypeObjectUtils::build_complete_struct_member(common_BackBarEnable, detail_BackBarEnable);
+            TypeObjectUtils::add_complete_struct_member(member_seq_BarCommandUpdate, member_BackBarEnable);
+        }
+        CompleteStructType struct_type_BarCommandUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_BarCommandUpdate, header_BarCommandUpdate, member_seq_BarCommandUpdate);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_BarCommandUpdate, type_name_BarCommandUpdate.to_string(), type_ids_BarCommandUpdate))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::BarCommandUpdate already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_LightsCommandUpdate_type_identifier(
+        TypeIdentifierPair& type_ids_LightsCommandUpdate)
+{
+
+    ReturnCode_t return_code_LightsCommandUpdate {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_LightsCommandUpdate =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::LightsCommandUpdate", type_ids_LightsCommandUpdate);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_LightsCommandUpdate)
+    {
+        StructTypeFlag struct_flags_LightsCommandUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_LightsCommandUpdate = "WeighingSystem::LightsCommandUpdate";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_LightsCommandUpdate;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_LightsCommandUpdate;
+        CompleteTypeDetail detail_LightsCommandUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_LightsCommandUpdate, ann_custom_LightsCommandUpdate, type_name_LightsCommandUpdate.to_string());
+        CompleteStructHeader header_LightsCommandUpdate;
+        header_LightsCommandUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_LightsCommandUpdate);
+        CompleteStructMemberSeq member_seq_LightsCommandUpdate;
+        {
+            TypeIdentifierPair type_ids_FrontLEDSignal;
+            ReturnCode_t return_code_FrontLEDSignal {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontLEDSignal =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_FrontLEDSignal);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontLEDSignal)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontLEDSignal Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontLEDSignal = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontLEDSignal = 0x00000000;
+            bool common_FrontLEDSignal_ec {false};
+            CommonStructMember common_FrontLEDSignal {TypeObjectUtils::build_common_struct_member(member_id_FrontLEDSignal, member_flags_FrontLEDSignal, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontLEDSignal, common_FrontLEDSignal_ec))};
+            if (!common_FrontLEDSignal_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontLEDSignal member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontLEDSignal = "FrontLEDSignal";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontLEDSignal;
+            ann_custom_LightsCommandUpdate.reset();
+            CompleteMemberDetail detail_FrontLEDSignal = TypeObjectUtils::build_complete_member_detail(name_FrontLEDSignal, member_ann_builtin_FrontLEDSignal, ann_custom_LightsCommandUpdate);
+            CompleteStructMember member_FrontLEDSignal = TypeObjectUtils::build_complete_struct_member(common_FrontLEDSignal, detail_FrontLEDSignal);
+            TypeObjectUtils::add_complete_struct_member(member_seq_LightsCommandUpdate, member_FrontLEDSignal);
+        }
+        {
+            TypeIdentifierPair type_ids_FrontLEDEnable;
+            ReturnCode_t return_code_FrontLEDEnable {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontLEDEnable =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_FrontLEDEnable);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontLEDEnable)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontLEDEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontLEDEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontLEDEnable = 0x00000001;
+            bool common_FrontLEDEnable_ec {false};
+            CommonStructMember common_FrontLEDEnable {TypeObjectUtils::build_common_struct_member(member_id_FrontLEDEnable, member_flags_FrontLEDEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontLEDEnable, common_FrontLEDEnable_ec))};
+            if (!common_FrontLEDEnable_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontLEDEnable member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontLEDEnable = "FrontLEDEnable";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontLEDEnable;
+            ann_custom_LightsCommandUpdate.reset();
+            CompleteMemberDetail detail_FrontLEDEnable = TypeObjectUtils::build_complete_member_detail(name_FrontLEDEnable, member_ann_builtin_FrontLEDEnable, ann_custom_LightsCommandUpdate);
+            CompleteStructMember member_FrontLEDEnable = TypeObjectUtils::build_complete_struct_member(common_FrontLEDEnable, detail_FrontLEDEnable);
+            TypeObjectUtils::add_complete_struct_member(member_seq_LightsCommandUpdate, member_FrontLEDEnable);
+        }
+        {
+            TypeIdentifierPair type_ids_BackLEDSignal;
+            ReturnCode_t return_code_BackLEDSignal {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackLEDSignal =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_BackLEDSignal);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackLEDSignal)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackLEDSignal Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackLEDSignal = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackLEDSignal = 0x00000002;
+            bool common_BackLEDSignal_ec {false};
+            CommonStructMember common_BackLEDSignal {TypeObjectUtils::build_common_struct_member(member_id_BackLEDSignal, member_flags_BackLEDSignal, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackLEDSignal, common_BackLEDSignal_ec))};
+            if (!common_BackLEDSignal_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackLEDSignal member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackLEDSignal = "BackLEDSignal";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackLEDSignal;
+            ann_custom_LightsCommandUpdate.reset();
+            CompleteMemberDetail detail_BackLEDSignal = TypeObjectUtils::build_complete_member_detail(name_BackLEDSignal, member_ann_builtin_BackLEDSignal, ann_custom_LightsCommandUpdate);
+            CompleteStructMember member_BackLEDSignal = TypeObjectUtils::build_complete_struct_member(common_BackLEDSignal, detail_BackLEDSignal);
+            TypeObjectUtils::add_complete_struct_member(member_seq_LightsCommandUpdate, member_BackLEDSignal);
+        }
+        {
+            TypeIdentifierPair type_ids_BackLEDEnable;
+            ReturnCode_t return_code_BackLEDEnable {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackLEDEnable =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_BackLEDEnable);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackLEDEnable)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackLEDEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackLEDEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackLEDEnable = 0x00000003;
+            bool common_BackLEDEnable_ec {false};
+            CommonStructMember common_BackLEDEnable {TypeObjectUtils::build_common_struct_member(member_id_BackLEDEnable, member_flags_BackLEDEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackLEDEnable, common_BackLEDEnable_ec))};
+            if (!common_BackLEDEnable_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackLEDEnable member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackLEDEnable = "BackLEDEnable";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackLEDEnable;
+            ann_custom_LightsCommandUpdate.reset();
+            CompleteMemberDetail detail_BackLEDEnable = TypeObjectUtils::build_complete_member_detail(name_BackLEDEnable, member_ann_builtin_BackLEDEnable, ann_custom_LightsCommandUpdate);
+            CompleteStructMember member_BackLEDEnable = TypeObjectUtils::build_complete_struct_member(common_BackLEDEnable, detail_BackLEDEnable);
+            TypeObjectUtils::add_complete_struct_member(member_seq_LightsCommandUpdate, member_BackLEDEnable);
+        }
+        CompleteStructType struct_type_LightsCommandUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_LightsCommandUpdate, header_LightsCommandUpdate, member_seq_LightsCommandUpdate);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_LightsCommandUpdate, type_name_LightsCommandUpdate.to_string(), type_ids_LightsCommandUpdate))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::LightsCommandUpdate already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_InfraredCommandUpdate_type_identifier(
+        TypeIdentifierPair& type_ids_InfraredCommandUpdate)
+{
+
+    ReturnCode_t return_code_InfraredCommandUpdate {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_InfraredCommandUpdate =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::InfraredCommandUpdate", type_ids_InfraredCommandUpdate);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_InfraredCommandUpdate)
+    {
+        StructTypeFlag struct_flags_InfraredCommandUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_InfraredCommandUpdate = "WeighingSystem::InfraredCommandUpdate";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_InfraredCommandUpdate;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_InfraredCommandUpdate;
+        CompleteTypeDetail detail_InfraredCommandUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_InfraredCommandUpdate, ann_custom_InfraredCommandUpdate, type_name_InfraredCommandUpdate.to_string());
+        CompleteStructHeader header_InfraredCommandUpdate;
+        header_InfraredCommandUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_InfraredCommandUpdate);
+        CompleteStructMemberSeq member_seq_InfraredCommandUpdate;
+        {
+            TypeIdentifierPair type_ids_FrontResistanceUnLock;
+            ReturnCode_t return_code_FrontResistanceUnLock {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontResistanceUnLock =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_FrontResistanceUnLock);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontResistanceUnLock)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontResistanceUnLock Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontResistanceUnLock = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontResistanceUnLock = 0x00000000;
+            bool common_FrontResistanceUnLock_ec {false};
+            CommonStructMember common_FrontResistanceUnLock {TypeObjectUtils::build_common_struct_member(member_id_FrontResistanceUnLock, member_flags_FrontResistanceUnLock, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontResistanceUnLock, common_FrontResistanceUnLock_ec))};
+            if (!common_FrontResistanceUnLock_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontResistanceUnLock member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontResistanceUnLock = "FrontResistanceUnLock";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontResistanceUnLock;
+            ann_custom_InfraredCommandUpdate.reset();
+            CompleteMemberDetail detail_FrontResistanceUnLock = TypeObjectUtils::build_complete_member_detail(name_FrontResistanceUnLock, member_ann_builtin_FrontResistanceUnLock, ann_custom_InfraredCommandUpdate);
+            CompleteStructMember member_FrontResistanceUnLock = TypeObjectUtils::build_complete_struct_member(common_FrontResistanceUnLock, detail_FrontResistanceUnLock);
+            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredCommandUpdate, member_FrontResistanceUnLock);
+        }
+        {
+            TypeIdentifierPair type_ids_FrontResistanceEnable;
+            ReturnCode_t return_code_FrontResistanceEnable {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontResistanceEnable =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_FrontResistanceEnable);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontResistanceEnable)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontResistanceEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontResistanceEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontResistanceEnable = 0x00000001;
+            bool common_FrontResistanceEnable_ec {false};
+            CommonStructMember common_FrontResistanceEnable {TypeObjectUtils::build_common_struct_member(member_id_FrontResistanceEnable, member_flags_FrontResistanceEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontResistanceEnable, common_FrontResistanceEnable_ec))};
+            if (!common_FrontResistanceEnable_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontResistanceEnable member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontResistanceEnable = "FrontResistanceEnable";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontResistanceEnable;
+            ann_custom_InfraredCommandUpdate.reset();
+            CompleteMemberDetail detail_FrontResistanceEnable = TypeObjectUtils::build_complete_member_detail(name_FrontResistanceEnable, member_ann_builtin_FrontResistanceEnable, ann_custom_InfraredCommandUpdate);
+            CompleteStructMember member_FrontResistanceEnable = TypeObjectUtils::build_complete_struct_member(common_FrontResistanceEnable, detail_FrontResistanceEnable);
+            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredCommandUpdate, member_FrontResistanceEnable);
+        }
+        {
+            TypeIdentifierPair type_ids_BackResistanceUnLock;
+            ReturnCode_t return_code_BackResistanceUnLock {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackResistanceUnLock =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_BackResistanceUnLock);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackResistanceUnLock)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackResistanceUnLock Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackResistanceUnLock = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackResistanceUnLock = 0x00000002;
+            bool common_BackResistanceUnLock_ec {false};
+            CommonStructMember common_BackResistanceUnLock {TypeObjectUtils::build_common_struct_member(member_id_BackResistanceUnLock, member_flags_BackResistanceUnLock, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackResistanceUnLock, common_BackResistanceUnLock_ec))};
+            if (!common_BackResistanceUnLock_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackResistanceUnLock member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackResistanceUnLock = "BackResistanceUnLock";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackResistanceUnLock;
+            ann_custom_InfraredCommandUpdate.reset();
+            CompleteMemberDetail detail_BackResistanceUnLock = TypeObjectUtils::build_complete_member_detail(name_BackResistanceUnLock, member_ann_builtin_BackResistanceUnLock, ann_custom_InfraredCommandUpdate);
+            CompleteStructMember member_BackResistanceUnLock = TypeObjectUtils::build_complete_struct_member(common_BackResistanceUnLock, detail_BackResistanceUnLock);
+            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredCommandUpdate, member_BackResistanceUnLock);
+        }
+        {
+            TypeIdentifierPair type_ids_BackResistanceEnable;
+            ReturnCode_t return_code_BackResistanceEnable {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackResistanceEnable =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_bool", type_ids_BackResistanceEnable);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackResistanceEnable)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackResistanceEnable Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackResistanceEnable = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackResistanceEnable = 0x00000003;
+            bool common_BackResistanceEnable_ec {false};
+            CommonStructMember common_BackResistanceEnable {TypeObjectUtils::build_common_struct_member(member_id_BackResistanceEnable, member_flags_BackResistanceEnable, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackResistanceEnable, common_BackResistanceEnable_ec))};
+            if (!common_BackResistanceEnable_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackResistanceEnable member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackResistanceEnable = "BackResistanceEnable";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackResistanceEnable;
+            ann_custom_InfraredCommandUpdate.reset();
+            CompleteMemberDetail detail_BackResistanceEnable = TypeObjectUtils::build_complete_member_detail(name_BackResistanceEnable, member_ann_builtin_BackResistanceEnable, ann_custom_InfraredCommandUpdate);
+            CompleteStructMember member_BackResistanceEnable = TypeObjectUtils::build_complete_struct_member(common_BackResistanceEnable, detail_BackResistanceEnable);
+            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredCommandUpdate, member_BackResistanceEnable);
+        }
+        CompleteStructType struct_type_InfraredCommandUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_InfraredCommandUpdate, header_InfraredCommandUpdate, member_seq_InfraredCommandUpdate);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_InfraredCommandUpdate, type_name_InfraredCommandUpdate.to_string(), type_ids_InfraredCommandUpdate))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::InfraredCommandUpdate already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_BarUpdate_type_identifier(
+        TypeIdentifierPair& type_ids_BarUpdate)
+{
+
+    ReturnCode_t return_code_BarUpdate {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_BarUpdate =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::BarUpdate", type_ids_BarUpdate);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_BarUpdate)
+    {
+        StructTypeFlag struct_flags_BarUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_BarUpdate = "WeighingSystem::BarUpdate";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_BarUpdate;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_BarUpdate;
+        CompleteTypeDetail detail_BarUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_BarUpdate, ann_custom_BarUpdate, type_name_BarUpdate.to_string());
+        CompleteStructHeader header_BarUpdate;
+        header_BarUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_BarUpdate);
+        CompleteStructMemberSeq member_seq_BarUpdate;
+        {
+            TypeIdentifierPair type_ids_FrontBarState;
+            ReturnCode_t return_code_FrontBarState {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontBarState =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_FrontBarState);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontBarState)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontBarState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontBarState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontBarState = 0x00000000;
+            bool common_FrontBarState_ec {false};
+            CommonStructMember common_FrontBarState {TypeObjectUtils::build_common_struct_member(member_id_FrontBarState, member_flags_FrontBarState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontBarState, common_FrontBarState_ec))};
+            if (!common_FrontBarState_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontBarState member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontBarState = "FrontBarState";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontBarState;
+            ann_custom_BarUpdate.reset();
+            CompleteMemberDetail detail_FrontBarState = TypeObjectUtils::build_complete_member_detail(name_FrontBarState, member_ann_builtin_FrontBarState, ann_custom_BarUpdate);
+            CompleteStructMember member_FrontBarState = TypeObjectUtils::build_complete_struct_member(common_FrontBarState, detail_FrontBarState);
+            TypeObjectUtils::add_complete_struct_member(member_seq_BarUpdate, member_FrontBarState);
+        }
+        {
+            TypeIdentifierPair type_ids_BackBarState;
+            ReturnCode_t return_code_BackBarState {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackBarState =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_BackBarState);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackBarState)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackBarState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackBarState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackBarState = 0x00000001;
+            bool common_BackBarState_ec {false};
+            CommonStructMember common_BackBarState {TypeObjectUtils::build_common_struct_member(member_id_BackBarState, member_flags_BackBarState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackBarState, common_BackBarState_ec))};
+            if (!common_BackBarState_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackBarState member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackBarState = "BackBarState";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackBarState;
+            ann_custom_BarUpdate.reset();
+            CompleteMemberDetail detail_BackBarState = TypeObjectUtils::build_complete_member_detail(name_BackBarState, member_ann_builtin_BackBarState, ann_custom_BarUpdate);
+            CompleteStructMember member_BackBarState = TypeObjectUtils::build_complete_struct_member(common_BackBarState, detail_BackBarState);
+            TypeObjectUtils::add_complete_struct_member(member_seq_BarUpdate, member_BackBarState);
+        }
+        CompleteStructType struct_type_BarUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_BarUpdate, header_BarUpdate, member_seq_BarUpdate);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_BarUpdate, type_name_BarUpdate.to_string(), type_ids_BarUpdate))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::BarUpdate already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_LightsUpdate_type_identifier(
+        TypeIdentifierPair& type_ids_LightsUpdate)
+{
+
+    ReturnCode_t return_code_LightsUpdate {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_LightsUpdate =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::LightsUpdate", type_ids_LightsUpdate);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_LightsUpdate)
+    {
+        StructTypeFlag struct_flags_LightsUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_LightsUpdate = "WeighingSystem::LightsUpdate";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_LightsUpdate;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_LightsUpdate;
+        CompleteTypeDetail detail_LightsUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_LightsUpdate, ann_custom_LightsUpdate, type_name_LightsUpdate.to_string());
+        CompleteStructHeader header_LightsUpdate;
+        header_LightsUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_LightsUpdate);
+        CompleteStructMemberSeq member_seq_LightsUpdate;
+        {
+            TypeIdentifierPair type_ids_FrontLEDState;
+            ReturnCode_t return_code_FrontLEDState {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontLEDState =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_FrontLEDState);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontLEDState)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontLEDState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontLEDState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontLEDState = 0x00000000;
+            bool common_FrontLEDState_ec {false};
+            CommonStructMember common_FrontLEDState {TypeObjectUtils::build_common_struct_member(member_id_FrontLEDState, member_flags_FrontLEDState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontLEDState, common_FrontLEDState_ec))};
+            if (!common_FrontLEDState_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontLEDState member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontLEDState = "FrontLEDState";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontLEDState;
+            ann_custom_LightsUpdate.reset();
+            CompleteMemberDetail detail_FrontLEDState = TypeObjectUtils::build_complete_member_detail(name_FrontLEDState, member_ann_builtin_FrontLEDState, ann_custom_LightsUpdate);
+            CompleteStructMember member_FrontLEDState = TypeObjectUtils::build_complete_struct_member(common_FrontLEDState, detail_FrontLEDState);
+            TypeObjectUtils::add_complete_struct_member(member_seq_LightsUpdate, member_FrontLEDState);
+        }
+        {
+            TypeIdentifierPair type_ids_BackLEDState;
+            ReturnCode_t return_code_BackLEDState {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackLEDState =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_BackLEDState);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackLEDState)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackLEDState Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackLEDState = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackLEDState = 0x00000001;
+            bool common_BackLEDState_ec {false};
+            CommonStructMember common_BackLEDState {TypeObjectUtils::build_common_struct_member(member_id_BackLEDState, member_flags_BackLEDState, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackLEDState, common_BackLEDState_ec))};
+            if (!common_BackLEDState_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackLEDState member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackLEDState = "BackLEDState";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackLEDState;
+            ann_custom_LightsUpdate.reset();
+            CompleteMemberDetail detail_BackLEDState = TypeObjectUtils::build_complete_member_detail(name_BackLEDState, member_ann_builtin_BackLEDState, ann_custom_LightsUpdate);
+            CompleteStructMember member_BackLEDState = TypeObjectUtils::build_complete_struct_member(common_BackLEDState, detail_BackLEDState);
+            TypeObjectUtils::add_complete_struct_member(member_seq_LightsUpdate, member_BackLEDState);
+        }
+        CompleteStructType struct_type_LightsUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_LightsUpdate, header_LightsUpdate, member_seq_LightsUpdate);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_LightsUpdate, type_name_LightsUpdate.to_string(), type_ids_LightsUpdate))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::LightsUpdate already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_InfraredUpdate_type_identifier(
+        TypeIdentifierPair& type_ids_InfraredUpdate)
+{
+
+    ReturnCode_t return_code_InfraredUpdate {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_InfraredUpdate =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::InfraredUpdate", type_ids_InfraredUpdate);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_InfraredUpdate)
+    {
+        StructTypeFlag struct_flags_InfraredUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_InfraredUpdate = "WeighingSystem::InfraredUpdate";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_InfraredUpdate;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_InfraredUpdate;
+        CompleteTypeDetail detail_InfraredUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_InfraredUpdate, ann_custom_InfraredUpdate, type_name_InfraredUpdate.to_string());
+        CompleteStructHeader header_InfraredUpdate;
+        header_InfraredUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_InfraredUpdate);
+        CompleteStructMemberSeq member_seq_InfraredUpdate;
+        {
+            TypeIdentifierPair type_ids_FrontResistanceSignal;
+            ReturnCode_t return_code_FrontResistanceSignal {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_FrontResistanceSignal =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_FrontResistanceSignal);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_FrontResistanceSignal)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "FrontResistanceSignal Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_FrontResistanceSignal = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_FrontResistanceSignal = 0x00000000;
+            bool common_FrontResistanceSignal_ec {false};
+            CommonStructMember common_FrontResistanceSignal {TypeObjectUtils::build_common_struct_member(member_id_FrontResistanceSignal, member_flags_FrontResistanceSignal, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_FrontResistanceSignal, common_FrontResistanceSignal_ec))};
+            if (!common_FrontResistanceSignal_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure FrontResistanceSignal member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_FrontResistanceSignal = "FrontResistanceSignal";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_FrontResistanceSignal;
+            ann_custom_InfraredUpdate.reset();
+            CompleteMemberDetail detail_FrontResistanceSignal = TypeObjectUtils::build_complete_member_detail(name_FrontResistanceSignal, member_ann_builtin_FrontResistanceSignal, ann_custom_InfraredUpdate);
+            CompleteStructMember member_FrontResistanceSignal = TypeObjectUtils::build_complete_struct_member(common_FrontResistanceSignal, detail_FrontResistanceSignal);
+            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredUpdate, member_FrontResistanceSignal);
+        }
+        {
+            TypeIdentifierPair type_ids_BackResistanceSignal;
+            ReturnCode_t return_code_BackResistanceSignal {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_BackResistanceSignal =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_BackResistanceSignal);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_BackResistanceSignal)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "BackResistanceSignal Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_BackResistanceSignal = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_BackResistanceSignal = 0x00000001;
+            bool common_BackResistanceSignal_ec {false};
+            CommonStructMember common_BackResistanceSignal {TypeObjectUtils::build_common_struct_member(member_id_BackResistanceSignal, member_flags_BackResistanceSignal, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_BackResistanceSignal, common_BackResistanceSignal_ec))};
+            if (!common_BackResistanceSignal_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure BackResistanceSignal member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_BackResistanceSignal = "BackResistanceSignal";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_BackResistanceSignal;
+            ann_custom_InfraredUpdate.reset();
+            CompleteMemberDetail detail_BackResistanceSignal = TypeObjectUtils::build_complete_member_detail(name_BackResistanceSignal, member_ann_builtin_BackResistanceSignal, ann_custom_InfraredUpdate);
+            CompleteStructMember member_BackResistanceSignal = TypeObjectUtils::build_complete_struct_member(common_BackResistanceSignal, detail_BackResistanceSignal);
+            TypeObjectUtils::add_complete_struct_member(member_seq_InfraredUpdate, member_BackResistanceSignal);
+        }
+        CompleteStructType struct_type_InfraredUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_InfraredUpdate, header_InfraredUpdate, member_seq_InfraredUpdate);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_InfraredUpdate, type_name_InfraredUpdate.to_string(), type_ids_InfraredUpdate))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::InfraredUpdate already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_LicenseSnapUpdate_type_identifier(
+        TypeIdentifierPair& type_ids_LicenseSnapUpdate)
+{
+
+    ReturnCode_t return_code_LicenseSnapUpdate {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_LicenseSnapUpdate =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::LicenseSnapUpdate", type_ids_LicenseSnapUpdate);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_LicenseSnapUpdate)
+    {
+        StructTypeFlag struct_flags_LicenseSnapUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_LicenseSnapUpdate = "WeighingSystem::LicenseSnapUpdate";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_LicenseSnapUpdate;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_LicenseSnapUpdate;
+        CompleteTypeDetail detail_LicenseSnapUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_LicenseSnapUpdate, ann_custom_LicenseSnapUpdate, type_name_LicenseSnapUpdate.to_string());
+        CompleteStructHeader header_LicenseSnapUpdate;
+        header_LicenseSnapUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_LicenseSnapUpdate);
+        CompleteStructMemberSeq member_seq_LicenseSnapUpdate;
+        {
+            TypeIdentifierPair type_ids_NewTag;
+            ReturnCode_t return_code_NewTag {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_NewTag =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_NewTag);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_NewTag)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "NewTag Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_NewTag = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_NewTag = 0x00000000;
+            bool common_NewTag_ec {false};
+            CommonStructMember common_NewTag {TypeObjectUtils::build_common_struct_member(member_id_NewTag, member_flags_NewTag, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_NewTag, common_NewTag_ec))};
+            if (!common_NewTag_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure NewTag member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_NewTag = "NewTag";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_NewTag;
+            ann_custom_LicenseSnapUpdate.reset();
+            CompleteMemberDetail detail_NewTag = TypeObjectUtils::build_complete_member_detail(name_NewTag, member_ann_builtin_NewTag, ann_custom_LicenseSnapUpdate);
+            CompleteStructMember member_NewTag = TypeObjectUtils::build_complete_struct_member(common_NewTag, detail_NewTag);
+            TypeObjectUtils::add_complete_struct_member(member_seq_LicenseSnapUpdate, member_NewTag);
+        }
+        {
+            TypeIdentifierPair type_ids_License;
+            ReturnCode_t return_code_License {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_License =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_License);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_License)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_License))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_License = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_License = 0x00000001;
+            bool common_License_ec {false};
+            CommonStructMember common_License {TypeObjectUtils::build_common_struct_member(member_id_License, member_flags_License, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_License, common_License_ec))};
+            if (!common_License_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure License member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_License = "License";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_License;
+            ann_custom_LicenseSnapUpdate.reset();
+            CompleteMemberDetail detail_License = TypeObjectUtils::build_complete_member_detail(name_License, member_ann_builtin_License, ann_custom_LicenseSnapUpdate);
+            CompleteStructMember member_License = TypeObjectUtils::build_complete_struct_member(common_License, detail_License);
+            TypeObjectUtils::add_complete_struct_member(member_seq_LicenseSnapUpdate, member_License);
+        }
+        CompleteStructType struct_type_LicenseSnapUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_LicenseSnapUpdate, header_LicenseSnapUpdate, member_seq_LicenseSnapUpdate);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_LicenseSnapUpdate, type_name_LicenseSnapUpdate.to_string(), type_ids_LicenseSnapUpdate))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::LicenseSnapUpdate already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_Voice_type_identifier(
+        TypeIdentifierPair& type_ids_Voice)
+{
+
+    ReturnCode_t return_code_Voice {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_Voice =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::Voice", type_ids_Voice);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_Voice)
+    {
+        StructTypeFlag struct_flags_Voice = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_Voice = "WeighingSystem::Voice";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_Voice;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_Voice;
+        CompleteTypeDetail detail_Voice = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_Voice, ann_custom_Voice, type_name_Voice.to_string());
+        CompleteStructHeader header_Voice;
+        header_Voice = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_Voice);
+        CompleteStructMemberSeq member_seq_Voice;
+        {
+            TypeIdentifierPair type_ids_VoiceID;
+            ReturnCode_t return_code_VoiceID {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_VoiceID =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_int32_t", type_ids_VoiceID);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_VoiceID)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "VoiceID Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_VoiceID = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_VoiceID = 0x00000000;
+            bool common_VoiceID_ec {false};
+            CommonStructMember common_VoiceID {TypeObjectUtils::build_common_struct_member(member_id_VoiceID, member_flags_VoiceID, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_VoiceID, common_VoiceID_ec))};
+            if (!common_VoiceID_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure VoiceID member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_VoiceID = "VoiceID";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_VoiceID;
+            ann_custom_Voice.reset();
+            CompleteMemberDetail detail_VoiceID = TypeObjectUtils::build_complete_member_detail(name_VoiceID, member_ann_builtin_VoiceID, ann_custom_Voice);
+            CompleteStructMember member_VoiceID = TypeObjectUtils::build_complete_struct_member(common_VoiceID, detail_VoiceID);
+            TypeObjectUtils::add_complete_struct_member(member_seq_Voice, member_VoiceID);
+        }
+        {
+            TypeIdentifierPair type_ids_VoiceContent;
+            ReturnCode_t return_code_VoiceContent {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_VoiceContent =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_VoiceContent);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_VoiceContent)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_VoiceContent))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_VoiceContent = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_VoiceContent = 0x00000001;
+            bool common_VoiceContent_ec {false};
+            CommonStructMember common_VoiceContent {TypeObjectUtils::build_common_struct_member(member_id_VoiceContent, member_flags_VoiceContent, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_VoiceContent, common_VoiceContent_ec))};
+            if (!common_VoiceContent_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure VoiceContent member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_VoiceContent = "VoiceContent";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_VoiceContent;
+            ann_custom_Voice.reset();
+            CompleteMemberDetail detail_VoiceContent = TypeObjectUtils::build_complete_member_detail(name_VoiceContent, member_ann_builtin_VoiceContent, ann_custom_Voice);
+            CompleteStructMember member_VoiceContent = TypeObjectUtils::build_complete_struct_member(common_VoiceContent, detail_VoiceContent);
+            TypeObjectUtils::add_complete_struct_member(member_seq_Voice, member_VoiceContent);
+        }
+        CompleteStructType struct_type_Voice = TypeObjectUtils::build_complete_struct_type(struct_flags_Voice, header_Voice, member_seq_Voice);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_Voice, type_name_Voice.to_string(), type_ids_Voice))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::Voice already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_SummaryUpdate_type_identifier(
+        TypeIdentifierPair& type_ids_SummaryUpdate)
+{
+
+    ReturnCode_t return_code_SummaryUpdate {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_SummaryUpdate =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::SummaryUpdate", type_ids_SummaryUpdate);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_SummaryUpdate)
+    {
+        StructTypeFlag struct_flags_SummaryUpdate = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_SummaryUpdate = "WeighingSystem::SummaryUpdate";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_SummaryUpdate;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_SummaryUpdate;
+        CompleteTypeDetail detail_SummaryUpdate = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_SummaryUpdate, ann_custom_SummaryUpdate, type_name_SummaryUpdate.to_string());
+        CompleteStructHeader header_SummaryUpdate;
+        header_SummaryUpdate = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_SummaryUpdate);
+        CompleteStructMemberSeq member_seq_SummaryUpdate;
+        {
+            TypeIdentifierPair type_ids_License;
+            ReturnCode_t return_code_License {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_License =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_License);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_License)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_License))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_License = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_License = 0x00000000;
+            bool common_License_ec {false};
+            CommonStructMember common_License {TypeObjectUtils::build_common_struct_member(member_id_License, member_flags_License, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_License, common_License_ec))};
+            if (!common_License_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure License member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_License = "License";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_License;
+            ann_custom_SummaryUpdate.reset();
+            CompleteMemberDetail detail_License = TypeObjectUtils::build_complete_member_detail(name_License, member_ann_builtin_License, ann_custom_SummaryUpdate);
+            CompleteStructMember member_License = TypeObjectUtils::build_complete_struct_member(common_License, detail_License);
+            TypeObjectUtils::add_complete_struct_member(member_seq_SummaryUpdate, member_License);
+        }
+        {
+            TypeIdentifierPair type_ids_StableValue;
+            ReturnCode_t return_code_StableValue {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_StableValue =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_float", type_ids_StableValue);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_StableValue)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "StableValue Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_StableValue = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_StableValue = 0x00000001;
+            bool common_StableValue_ec {false};
+            CommonStructMember common_StableValue {TypeObjectUtils::build_common_struct_member(member_id_StableValue, member_flags_StableValue, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_StableValue, common_StableValue_ec))};
+            if (!common_StableValue_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure StableValue member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_StableValue = "StableValue";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_StableValue;
+            ann_custom_SummaryUpdate.reset();
+            CompleteMemberDetail detail_StableValue = TypeObjectUtils::build_complete_member_detail(name_StableValue, member_ann_builtin_StableValue, ann_custom_SummaryUpdate);
+            CompleteStructMember member_StableValue = TypeObjectUtils::build_complete_struct_member(common_StableValue, detail_StableValue);
+            TypeObjectUtils::add_complete_struct_member(member_seq_SummaryUpdate, member_StableValue);
+        }
+        CompleteStructType struct_type_SummaryUpdate = TypeObjectUtils::build_complete_struct_type(struct_flags_SummaryUpdate, header_SummaryUpdate, member_seq_SummaryUpdate);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_SummaryUpdate, type_name_SummaryUpdate.to_string(), type_ids_SummaryUpdate))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::SummaryUpdate already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_ReadCardReq_type_identifier(
+        TypeIdentifierPair& type_ids_ReadCardReq)
+{
+
+    ReturnCode_t return_code_ReadCardReq {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_ReadCardReq =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::ReadCardReq", type_ids_ReadCardReq);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_ReadCardReq)
+    {
+        StructTypeFlag struct_flags_ReadCardReq = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_ReadCardReq = "WeighingSystem::ReadCardReq";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_ReadCardReq;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_ReadCardReq;
+        CompleteTypeDetail detail_ReadCardReq = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ReadCardReq, ann_custom_ReadCardReq, type_name_ReadCardReq.to_string());
+        CompleteStructHeader header_ReadCardReq;
+        header_ReadCardReq = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ReadCardReq);
+        CompleteStructMemberSeq member_seq_ReadCardReq;
+        {
+            TypeIdentifierPair type_ids_index;
+            ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_index =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_uint32_t", type_ids_index);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_index)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "index Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_index = 0x00000000;
+            bool common_index_ec {false};
+            CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))};
+            if (!common_index_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_index = "index";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_index;
+            ann_custom_ReadCardReq.reset();
+            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_ReadCardReq);
+            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ReadCardReq, member_index);
+        }
+        {
+            TypeIdentifierPair type_ids_msg;
+            ReturnCode_t return_code_msg {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_msg =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded", type_ids_msg);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+            {
+                return_code_msg =
+                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                    "anonymous_sequence_byte_unbounded", type_ids_msg);
+
+                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+                {
+                    return_code_msg =
+                        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                        "_byte", type_ids_msg);
+
+                    if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                                "Sequence element TypeIdentifier unknown to TypeObjectRegistry.");
+                        return;
+                    }
+                    bool element_identifier_anonymous_sequence_byte_unbounded_ec {false};
+                    TypeIdentifier* element_identifier_anonymous_sequence_byte_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_sequence_byte_unbounded_ec))};
+                    if (!element_identifier_anonymous_sequence_byte_unbounded_ec)
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent.");
+                        return;
+                    }
+                    EquivalenceKind equiv_kind_anonymous_sequence_byte_unbounded = EK_COMPLETE;
+                    if (TK_NONE == type_ids_msg.type_identifier2()._d())
+                    {
+                        equiv_kind_anonymous_sequence_byte_unbounded = EK_BOTH;
+                    }
+                    CollectionElementFlag element_flags_anonymous_sequence_byte_unbounded = 0;
+                    PlainCollectionHeader header_anonymous_sequence_byte_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_byte_unbounded, element_flags_anonymous_sequence_byte_unbounded);
+                    {
+                        SBound bound = 0;
+                        PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_byte_unbounded, bound,
+                                    eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_sequence_byte_unbounded));
+                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                                TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_byte_unbounded", type_ids_msg))
+                        {
+                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                                "anonymous_sequence_byte_unbounded already registered in TypeObjectRegistry for a different type.");
+                        }
+                    }
+                }
+                bool element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec {false};
+                TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec))};
+                if (!element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec)
+                {
+                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded inconsistent element TypeIdentifier.");
+                    return;
+                }
+                return_code_msg =
+                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                    "anonymous_string_unbounded", type_ids_msg);
+
+                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+                {
+                    {
+                        SBound bound = 0;
+                        StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                                TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                                "anonymous_string_unbounded", type_ids_msg))
+                        {
+                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                                "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                        }
+                    }
+                }
+                bool key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec {false};
+                TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec))};
+                if (!key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec)
+                {
+                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded inconsistent key TypeIdentifier.");
+                    return;
+                }
+                EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = EK_BOTH;
+                if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d()) ||
+                        (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->seq_sdefn().header().equiv_kind()) ||
+                        (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->seq_ldefn().header().equiv_kind()) ||
+                        (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->array_sdefn().header().equiv_kind()) ||
+                        (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->array_ldefn().header().equiv_kind()) ||
+                        (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_sdefn().header().equiv_kind())) ||
+                        (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_ldefn().header().equiv_kind())))
+                {
+                    equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = EK_COMPLETE;
+                }
+                CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = 0;
+                CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = 0;
+                PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded, element_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded);
+                {
+                    SBound bound = 0;
+                    PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded, bound,
+                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded,
+                                eprosima::fastcdr::external<TypeIdentifier>(key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded));
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded", type_ids_msg))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_msg = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_msg = 0x00000001;
+            bool common_msg_ec {false};
+            CommonStructMember common_msg {TypeObjectUtils::build_common_struct_member(member_id_msg, member_flags_msg, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, common_msg_ec))};
+            if (!common_msg_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure msg member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_msg = "msg";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_msg;
+            ann_custom_ReadCardReq.reset();
+            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_ReadCardReq);
+            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ReadCardReq, member_msg);
+        }
+        CompleteStructType struct_type_ReadCardReq = TypeObjectUtils::build_complete_struct_type(struct_flags_ReadCardReq, header_ReadCardReq, member_seq_ReadCardReq);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_ReadCardReq, type_name_ReadCardReq.to_string(), type_ids_ReadCardReq))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::ReadCardReq already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_ReadCardRsp_type_identifier(
+        TypeIdentifierPair& type_ids_ReadCardRsp)
+{
+
+    ReturnCode_t return_code_ReadCardRsp {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_ReadCardRsp =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::ReadCardRsp", type_ids_ReadCardRsp);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_ReadCardRsp)
+    {
+        StructTypeFlag struct_flags_ReadCardRsp = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_ReadCardRsp = "WeighingSystem::ReadCardRsp";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_ReadCardRsp;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_ReadCardRsp;
+        CompleteTypeDetail detail_ReadCardRsp = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_ReadCardRsp, ann_custom_ReadCardRsp, type_name_ReadCardRsp.to_string());
+        CompleteStructHeader header_ReadCardRsp;
+        header_ReadCardRsp = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_ReadCardRsp);
+        CompleteStructMemberSeq member_seq_ReadCardRsp;
+        {
+            TypeIdentifierPair type_ids_index;
+            ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_index =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_uint32_t", type_ids_index);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_index)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "index Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_index = 0x00000000;
+            bool common_index_ec {false};
+            CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))};
+            if (!common_index_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_index = "index";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_index;
+            ann_custom_ReadCardRsp.reset();
+            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_ReadCardRsp);
+            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ReadCardRsp, member_index);
+        }
+        {
+            TypeIdentifierPair type_ids_msg;
+            ReturnCode_t return_code_msg {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_msg =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded", type_ids_msg);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+            {
+                return_code_msg =
+                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                    "anonymous_sequence_byte_unbounded", type_ids_msg);
+
+                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+                {
+                    return_code_msg =
+                        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                        "_byte", type_ids_msg);
+
+                    if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                                "Sequence element TypeIdentifier unknown to TypeObjectRegistry.");
+                        return;
+                    }
+                    bool element_identifier_anonymous_sequence_byte_unbounded_ec {false};
+                    TypeIdentifier* element_identifier_anonymous_sequence_byte_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_sequence_byte_unbounded_ec))};
+                    if (!element_identifier_anonymous_sequence_byte_unbounded_ec)
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Sequence element TypeIdentifier inconsistent.");
+                        return;
+                    }
+                    EquivalenceKind equiv_kind_anonymous_sequence_byte_unbounded = EK_COMPLETE;
+                    if (TK_NONE == type_ids_msg.type_identifier2()._d())
+                    {
+                        equiv_kind_anonymous_sequence_byte_unbounded = EK_BOTH;
+                    }
+                    CollectionElementFlag element_flags_anonymous_sequence_byte_unbounded = 0;
+                    PlainCollectionHeader header_anonymous_sequence_byte_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_sequence_byte_unbounded, element_flags_anonymous_sequence_byte_unbounded);
+                    {
+                        SBound bound = 0;
+                        PlainSequenceSElemDefn seq_sdefn = TypeObjectUtils::build_plain_sequence_s_elem_defn(header_anonymous_sequence_byte_unbounded, bound,
+                                    eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_sequence_byte_unbounded));
+                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                                TypeObjectUtils::build_and_register_s_sequence_type_identifier(seq_sdefn, "anonymous_sequence_byte_unbounded", type_ids_msg))
+                        {
+                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                                "anonymous_sequence_byte_unbounded already registered in TypeObjectRegistry for a different type.");
+                        }
+                    }
+                }
+                bool element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec {false};
+                TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec))};
+                if (!element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec)
+                {
+                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded inconsistent element TypeIdentifier.");
+                    return;
+                }
+                return_code_msg =
+                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                    "anonymous_string_unbounded", type_ids_msg);
+
+                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+                {
+                    {
+                        SBound bound = 0;
+                        StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                                TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                                "anonymous_string_unbounded", type_ids_msg))
+                        {
+                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                                "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                        }
+                    }
+                }
+                bool key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec {false};
+                TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec))};
+                if (!key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded_ec)
+                {
+                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded inconsistent key TypeIdentifier.");
+                    return;
+                }
+                EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = EK_BOTH;
+                if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d()) ||
+                        (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->seq_sdefn().header().equiv_kind()) ||
+                        (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->seq_ldefn().header().equiv_kind()) ||
+                        (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->array_sdefn().header().equiv_kind()) ||
+                        (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->array_ldefn().header().equiv_kind()) ||
+                        (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_sdefn().header().equiv_kind())) ||
+                        (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded->map_ldefn().header().equiv_kind())))
+                {
+                    equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = EK_COMPLETE;
+                }
+                CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = 0;
+                CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = 0;
+                PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded, element_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded);
+                {
+                    SBound bound = 0;
+                    PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded, bound,
+                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded,
+                                eprosima::fastcdr::external<TypeIdentifier>(key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded));
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded", type_ids_msg))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_map_anonymous_string_unbounded_anonymous_sequence_byte_unbounded_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_msg = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_msg = 0x00000001;
+            bool common_msg_ec {false};
+            CommonStructMember common_msg {TypeObjectUtils::build_common_struct_member(member_id_msg, member_flags_msg, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, common_msg_ec))};
+            if (!common_msg_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure msg member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_msg = "msg";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_msg;
+            ann_custom_ReadCardRsp.reset();
+            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_ReadCardRsp);
+            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
+            TypeObjectUtils::add_complete_struct_member(member_seq_ReadCardRsp, member_msg);
+        }
+        CompleteStructType struct_type_ReadCardRsp = TypeObjectUtils::build_complete_struct_type(struct_flags_ReadCardRsp, header_ReadCardRsp, member_seq_ReadCardRsp);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_ReadCardRsp, type_name_ReadCardRsp.to_string(), type_ids_ReadCardRsp))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::ReadCardRsp already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_PrintReq_type_identifier(
+        TypeIdentifierPair& type_ids_PrintReq)
+{
+
+    ReturnCode_t return_code_PrintReq {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_PrintReq =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::PrintReq", type_ids_PrintReq);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_PrintReq)
+    {
+        StructTypeFlag struct_flags_PrintReq = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_PrintReq = "WeighingSystem::PrintReq";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_PrintReq;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_PrintReq;
+        CompleteTypeDetail detail_PrintReq = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_PrintReq, ann_custom_PrintReq, type_name_PrintReq.to_string());
+        CompleteStructHeader header_PrintReq;
+        header_PrintReq = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_PrintReq);
+        CompleteStructMemberSeq member_seq_PrintReq;
+        {
+            TypeIdentifierPair type_ids_index;
+            ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_index =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_uint32_t", type_ids_index);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_index)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "index Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_index = 0x00000000;
+            bool common_index_ec {false};
+            CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))};
+            if (!common_index_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_index = "index";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_index;
+            ann_custom_PrintReq.reset();
+            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_PrintReq);
+            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
+            TypeObjectUtils::add_complete_struct_member(member_seq_PrintReq, member_index);
+        }
+        {
+            TypeIdentifierPair type_ids_msg;
+            ReturnCode_t return_code_msg {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_msg =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded", type_ids_msg);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+            {
+                return_code_msg =
+                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                    "anonymous_string_unbounded", type_ids_msg);
+
+                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+                {
+                    {
+                        SBound bound = 0;
+                        StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                                TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                                "anonymous_string_unbounded", type_ids_msg))
+                        {
+                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                                "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                        }
+                    }
+                }
+                bool element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec {false};
+                TypeIdentifier* element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec))};
+                if (!element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec)
+                {
+                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded inconsistent element TypeIdentifier.");
+                    return;
+                }
+                return_code_msg =
+                    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                    "anonymous_string_unbounded", type_ids_msg);
+
+                if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+                {
+                    {
+                        SBound bound = 0;
+                        StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                                TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                                "anonymous_string_unbounded", type_ids_msg))
+                        {
+                            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                                "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                        }
+                    }
+                }
+                bool key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec {false};
+                TypeIdentifier* key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded {new TypeIdentifier(TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec))};
+                if (!key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded_ec)
+                {
+                    EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded inconsistent key TypeIdentifier.");
+                    return;
+                }
+                EquivalenceKind equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = EK_BOTH;
+                if ((EK_COMPLETE == key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d()) ||
+                        (TI_PLAIN_SEQUENCE_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->seq_sdefn().header().equiv_kind()) ||
+                        (TI_PLAIN_SEQUENCE_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->seq_ldefn().header().equiv_kind()) ||
+                        (TI_PLAIN_ARRAY_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->array_sdefn().header().equiv_kind()) ||
+                        (TI_PLAIN_ARRAY_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->array_ldefn().header().equiv_kind()) ||
+                        (TI_PLAIN_MAP_SMALL == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->map_sdefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->map_sdefn().header().equiv_kind())) ||
+                        (TI_PLAIN_MAP_LARGE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->_d() && (EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->map_ldefn().key_identifier()->_d() || EK_COMPLETE == element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded->map_ldefn().header().equiv_kind())))
+                {
+                    equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = EK_COMPLETE;
+                }
+                CollectionElementFlag element_flags_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = 0;
+                CollectionElementFlag key_flags_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = 0;
+                PlainCollectionHeader header_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded = TypeObjectUtils::build_plain_collection_header(equiv_kind_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded, element_flags_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded);
+                {
+                    SBound bound = 0;
+                    PlainMapSTypeDefn map_sdefn = TypeObjectUtils::build_plain_map_s_type_defn(header_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded, bound,
+                                eprosima::fastcdr::external<TypeIdentifier>(element_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded), key_flags_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded,
+                                eprosima::fastcdr::external<TypeIdentifier>(key_identifier_anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded));
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_map_type_identifier(map_sdefn, "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded", type_ids_msg))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_map_anonymous_string_unbounded_anonymous_string_unbounded_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_msg = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_msg = 0x00000001;
+            bool common_msg_ec {false};
+            CommonStructMember common_msg {TypeObjectUtils::build_common_struct_member(member_id_msg, member_flags_msg, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, common_msg_ec))};
+            if (!common_msg_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure msg member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_msg = "msg";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_msg;
+            ann_custom_PrintReq.reset();
+            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_PrintReq);
+            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
+            TypeObjectUtils::add_complete_struct_member(member_seq_PrintReq, member_msg);
+        }
+        CompleteStructType struct_type_PrintReq = TypeObjectUtils::build_complete_struct_type(struct_flags_PrintReq, header_PrintReq, member_seq_PrintReq);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_PrintReq, type_name_PrintReq.to_string(), type_ids_PrintReq))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::PrintReq already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+// TypeIdentifier is returned by reference: dependent structures/unions are registered in this same method
+void register_PrintRsp_type_identifier(
+        TypeIdentifierPair& type_ids_PrintRsp)
+{
+
+    ReturnCode_t return_code_PrintRsp {eprosima::fastdds::dds::RETCODE_OK};
+    return_code_PrintRsp =
+        eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+        "WeighingSystem::PrintRsp", type_ids_PrintRsp);
+    if (eprosima::fastdds::dds::RETCODE_OK != return_code_PrintRsp)
+    {
+        StructTypeFlag struct_flags_PrintRsp = TypeObjectUtils::build_struct_type_flag(eprosima::fastdds::dds::xtypes::ExtensibilityKind::APPENDABLE,
+                false, false);
+        QualifiedTypeName type_name_PrintRsp = "WeighingSystem::PrintRsp";
+        eprosima::fastcdr::optional<AppliedBuiltinTypeAnnotations> type_ann_builtin_PrintRsp;
+        eprosima::fastcdr::optional<AppliedAnnotationSeq> ann_custom_PrintRsp;
+        CompleteTypeDetail detail_PrintRsp = TypeObjectUtils::build_complete_type_detail(type_ann_builtin_PrintRsp, ann_custom_PrintRsp, type_name_PrintRsp.to_string());
+        CompleteStructHeader header_PrintRsp;
+        header_PrintRsp = TypeObjectUtils::build_complete_struct_header(TypeIdentifier(), detail_PrintRsp);
+        CompleteStructMemberSeq member_seq_PrintRsp;
+        {
+            TypeIdentifierPair type_ids_index;
+            ReturnCode_t return_code_index {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_index =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "_uint32_t", type_ids_index);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_index)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                        "index Structure member TypeIdentifier unknown to TypeObjectRegistry.");
+                return;
+            }
+            StructMemberFlag member_flags_index = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_index = 0x00000000;
+            bool common_index_ec {false};
+            CommonStructMember common_index {TypeObjectUtils::build_common_struct_member(member_id_index, member_flags_index, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_index, common_index_ec))};
+            if (!common_index_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure index member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_index = "index";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_index;
+            ann_custom_PrintRsp.reset();
+            CompleteMemberDetail detail_index = TypeObjectUtils::build_complete_member_detail(name_index, member_ann_builtin_index, ann_custom_PrintRsp);
+            CompleteStructMember member_index = TypeObjectUtils::build_complete_struct_member(common_index, detail_index);
+            TypeObjectUtils::add_complete_struct_member(member_seq_PrintRsp, member_index);
+        }
+        {
+            TypeIdentifierPair type_ids_msg;
+            ReturnCode_t return_code_msg {eprosima::fastdds::dds::RETCODE_OK};
+            return_code_msg =
+                eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->type_object_registry().get_type_identifiers(
+                "anonymous_string_unbounded", type_ids_msg);
+
+            if (eprosima::fastdds::dds::RETCODE_OK != return_code_msg)
+            {
+                {
+                    SBound bound = 0;
+                    StringSTypeDefn string_sdefn = TypeObjectUtils::build_string_s_type_defn(bound);
+                    if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                            TypeObjectUtils::build_and_register_s_string_type_identifier(string_sdefn,
+                            "anonymous_string_unbounded", type_ids_msg))
+                    {
+                        EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                            "anonymous_string_unbounded already registered in TypeObjectRegistry for a different type.");
+                    }
+                }
+            }
+            StructMemberFlag member_flags_msg = TypeObjectUtils::build_struct_member_flag(eprosima::fastdds::dds::xtypes::TryConstructFailAction::DISCARD,
+                    false, false, false, false);
+            MemberId member_id_msg = 0x00000001;
+            bool common_msg_ec {false};
+            CommonStructMember common_msg {TypeObjectUtils::build_common_struct_member(member_id_msg, member_flags_msg, TypeObjectUtils::retrieve_complete_type_identifier(type_ids_msg, common_msg_ec))};
+            if (!common_msg_ec)
+            {
+                EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION, "Structure msg member TypeIdentifier inconsistent.");
+                return;
+            }
+            MemberName name_msg = "msg";
+            eprosima::fastcdr::optional<AppliedBuiltinMemberAnnotations> member_ann_builtin_msg;
+            ann_custom_PrintRsp.reset();
+            CompleteMemberDetail detail_msg = TypeObjectUtils::build_complete_member_detail(name_msg, member_ann_builtin_msg, ann_custom_PrintRsp);
+            CompleteStructMember member_msg = TypeObjectUtils::build_complete_struct_member(common_msg, detail_msg);
+            TypeObjectUtils::add_complete_struct_member(member_seq_PrintRsp, member_msg);
+        }
+        CompleteStructType struct_type_PrintRsp = TypeObjectUtils::build_complete_struct_type(struct_flags_PrintRsp, header_PrintRsp, member_seq_PrintRsp);
+        if (eprosima::fastdds::dds::RETCODE_BAD_PARAMETER ==
+                TypeObjectUtils::build_and_register_struct_type_object(struct_type_PrintRsp, type_name_PrintRsp.to_string(), type_ids_PrintRsp))
+        {
+            EPROSIMA_LOG_ERROR(XTYPES_TYPE_REPRESENTATION,
+                    "WeighingSystem::PrintRsp already registered in TypeObjectRegistry for a different type.");
+        }
+    }
+}
+
+} // namespace WeighingSystem
+
diff --git a/WeighUI/lib/WeighingDDSTypeTypeObjectSupport.hpp b/WeighUI/lib/WeighingDDSTypeTypeObjectSupport.hpp
new file mode 100644
index 0000000..8436294
--- /dev/null
+++ b/WeighUI/lib/WeighingDDSTypeTypeObjectSupport.hpp
@@ -0,0 +1,267 @@
+// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*!
+ * @file WeighingDDSTypeTypeObjectSupport.hpp
+ * Header file containing the API required to register the TypeObject representation of the described types in the IDL file
+ *
+ * This file was generated by the tool fastddsgen.
+ */
+
+#ifndef FAST_DDS_GENERATED__WEIGHINGSYSTEM_WEIGHINGDDSTYPE_TYPE_OBJECT_SUPPORT_HPP
+#define FAST_DDS_GENERATED__WEIGHINGSYSTEM_WEIGHINGDDSTYPE_TYPE_OBJECT_SUPPORT_HPP
+
+#include <fastdds/dds/xtypes/type_representation/TypeObject.hpp>
+
+
+#if defined(_WIN32)
+#if defined(EPROSIMA_USER_DLL_EXPORT)
+#define eProsima_user_DllExport __declspec( dllexport )
+#else
+#define eProsima_user_DllExport
+#endif  // EPROSIMA_USER_DLL_EXPORT
+#else
+#define eProsima_user_DllExport
+#endif  // _WIN32
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
+
+namespace WeighingSystem {
+/**
+ * @brief Register ScaleInfo related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_ScaleInfo_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register ScaleCommand related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_ScaleCommand_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register WeightInfoOk related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_WeightInfoOk_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register WeightInfoError related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_WeightInfoError_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register BarCommandUpdate related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_BarCommandUpdate_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register LightsCommandUpdate related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_LightsCommandUpdate_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register InfraredCommandUpdate related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_InfraredCommandUpdate_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register BarUpdate related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_BarUpdate_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register LightsUpdate related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_LightsUpdate_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register InfraredUpdate related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_InfraredUpdate_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register LicenseSnapUpdate related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_LicenseSnapUpdate_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register Voice related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_Voice_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register SummaryUpdate related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_SummaryUpdate_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register ReadCardReq related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_ReadCardReq_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register ReadCardRsp related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_ReadCardRsp_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register PrintReq related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_PrintReq_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+/**
+ * @brief Register PrintRsp related TypeIdentifier.
+ *        Fully-descriptive TypeIdentifiers are directly registered.
+ *        Hash TypeIdentifiers require to fill the TypeObject information and hash it, consequently, the TypeObject is
+ *        indirectly registered as well.
+ *
+ * @param[out] TypeIdentifier of the registered type.
+ *             The returned TypeIdentifier corresponds to the complete TypeIdentifier in case of hashed TypeIdentifiers.
+ *             Invalid TypeIdentifier is returned in case of error.
+ */
+eProsima_user_DllExport void register_PrintRsp_type_identifier(
+        eprosima::fastdds::dds::xtypes::TypeIdentifierPair& type_ids);
+
+} // namespace WeighingSystem
+
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
+
+#endif // FAST_DDS_GENERATED__WEIGHINGSYSTEM_WEIGHINGDDSTYPE_TYPE_OBJECT_SUPPORT_HPP