Routing_RouteManager.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
//  C++接口的路由管理头文件
//--------------------------------------------------------------------------
//
//  源文件:
//     Routing_RouteManager.ja
//
//  生成工具:
//     apiwrap
//
//  警告:
//    此文件为自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/BasePart.hxx>
#include <NXOpen/FileNew.hxx>
#include <NXOpen/Routing_AddFontBuilder.hxx>
#include <NXOpen/Routing_AlignStockBuilder.hxx>
#include <NXOpen/Routing_AssignPathBuilder.hxx>
#include <NXOpen/Routing_AssignTerminalsBuilder.hxx>
#include <NXOpen/Routing_AssignTerminalsItemBuilder.hxx>
#include <NXOpen/Routing_AttributeHolder.hxx>
#include <NXOpen/Routing_BranchPathNumberingBuilder.hxx>
#include <NXOpen/Routing_CharacteristicList.hxx>
#include <NXOpen/Routing_CompareRunsBuilder.hxx>
#include <NXOpen/Routing_CustomManager.hxx>
#include <NXOpen/Routing_DefineRunBuilder.hxx>
#include <NXOpen/Routing_DesignRuleViolationCollection.hxx>
#include <NXOpen/Routing_DuctReinforcementBuilder.hxx>
#include <NXOpen/Routing_Electrical_ElectricalStockDevice.hxx>
#include <NXOpen/Routing_Electrical_PathArrangementBuilder.hxx>
#include <NXOpen/Routing_Electrical_SplicePositionBuilder.hxx>
#include <NXOpen/Routing_FindByAttributesBuilder.hxx>
#include <NXOpen/Routing_HandrailBuilder.hxx>
#include <NXOpen/Routing_MergeStocksBuilder.hxx>
#include <NXOpen/Routing_NamingPatternBuilder.hxx>
#include <NXOpen/Routing_PlatformCreatorBuilder.hxx>
#include <NXOpen/Routing_PortArrayListItemBuilder.hxx>
#include <NXOpen/Routing_PortArraysBuilder.hxx>
#include <NXOpen/Routing_QualifyPortBuilder.hxx>
#include <NXOpen/Routing_ReuseLibrary.hxx>
#include <NXOpen/Routing_Run.hxx>
#include <NXOpen/Routing_RunItem.hxx>
#include <NXOpen/Routing_StockDataRefreshBuilder.hxx>
#include <NXOpen/Routing_StockPartConverterBuilder.hxx>
#include <NXOpen/Routing_WindCatcherBuilder.hxx>
#include <NXOpen/TaggedObject.hxx>
#include <NXOpen/ugmath.hxx>
#include <NXOpen/libnxopencpp_routing_exports.hxx>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace NXOpen
{
    namespace Routing
    {
        class RouteManager;
    }
    class Part;
    namespace Assemblies
    {
        class Component;
    }
    class Body;
    class CoordinateSystem;
    class Curve;
    class Direction;
    class FileNew;
    namespace Formboard
    {
        class FormboardManager;
    }
    class NXObject;
    class Point;
    namespace Routing
    {
        class AddFontBuilder;
    }
    namespace Routing
    {
        class AdvanceToRsdBuilder;
    }
    namespace Routing
    {
        class AlignStockBuilder;
    }
    namespace Routing
    {
        class Anchor;
    }
namespace Routing
    {
        class AnchorBuilder;
    }
    namespace Routing
    {
        class AnchorCollection;
    }
    namespace Routing
    {
        class AssignCornerBuilder;
    }
    namespace Routing
    {
        class AssignDiscontinuityBuilder;
    }
    namespace Routing
    {
        class AssignPathBuilder;
    }
    namespace Routing
    {
        class AssignTerminalsBuilder;
    }
    namespace Routing
    {
        class AssignTerminalsItemBuilder;
    }
    namespace Routing
    {
        class AttributeHolder;
    }
    namespace Routing
    {
        class BendCornerCollection;
    }
    namespace Routing
    {
        class BendReportManager;
    }
    namespace Routing
    {
        class BranchPathNumberingBuilder;
    }
    namespace Routing
    {
        class BuiltInPath;
    }
    namespace Routing
    {
        class BuiltInPathBuilder;
    }
    namespace Routing
    {
        class BuiltInPathCollection;
    }
    namespace Routing
    {
        class CablewayNetwork;
    }
    namespace Routing
    {
        class CablewayNetworkBuilder;
    }
    namespace Routing
    {
        class CablewayNetworkCollection;
    }
    namespace Routing
    {
        class CharacteristicList;
    }
    namespace Routing
    {
        class ClockPartBuilder;
    }
    namespace Routing
    {
        class CompareRunsBuilder;
    }
    namespace Routing
    {
        class ConnectPathBuilder;
    }
    namespace Routing
    {
        class ConnectedCurvesBuilder;
    }
    namespace Routing
    {
        class ControlPoint;
    }
    namespace Routing
    {
        class ControlPointCollection;
    }
    namespace Routing
    {
        class CopeCornerCollection;
    }
namespace Routing
{
    class CornerCollection;
}
namespace Routing
{
    class CreateFabricationBuilder;
}
namespace Routing
{
    class CrossSection;
}
namespace Routing
{
    class CrossSectionBuilder;
}
namespace Routing
{
    class CrossSectionCollection;
}
namespace Routing
{
    class DefineRunBuilder;
}
namespace Routing
{
    class DeleteFontsBuilder;
}
namespace Routing
{
    class DeleteGapsBuilder;
}
namespace Routing
{
    class DeleteObjectsBuilder;
}
namespace Routing
{
    class DesignRuleCollection;
}
namespace Routing
{
    class DesignRuleViolation;
}
namespace Routing
{
    class DesignRuleViolationCollection;
}
namespace Routing
{
    class DesignRuleViolationLocationCollection;
}
namespace Routing
{
    class DesignRuleViolationViewer;
}
namespace Routing
{
    class DiscontinuityCornerCollection;
}
namespace Routing
{
    class DivisionsBuilder;
}
namespace Routing
{
    class DuctReinforcementBuilder;
}
namespace Routing
{
    class DuctSizeCalculatorBuilder;
}
namespace Routing
{
    class EditBendAngleBuilder;
}
namespace Routing
{
    class EditCharacteristicsBuilder;
}
namespace Routing
{
    class EditLineSegmentBuilder;
}
namespace Routing
{
    class EditPlacePartBuilder;
}
namespace Routing
{
    class ElbowSnapSettings;
}
namespace Routing
{
    namespace Electrical
    {
        class AssignProxyBuilder;
    }
}
namespace Routing
{
    namespace Electrical
    {
        class CableConnectionCollection;
    }
}
    namespace Routing
    {
        namespace Electrical
        {
            class CableDevice;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class CablewaysBuilder;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class CablewaysLayoutBuilder;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class CablewaysLayoutViewCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class ConnectionCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class ConnectorDeviceCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class DerivativeDeviceCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class ElectricalDeviceRelationshipCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class ElectricalFormatCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class ElectricalNavigatorFilterCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class ElectricalStockDevice;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class ElectricalStockDeviceCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class HarnessDevice;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class HarnessDeviceCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class JumperConnectionCollection;
        }
}
    namespace Routing
    {
        namespace Electrical
        {
            class NonPathConnectionCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class PathArrangementBuilder;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class PathConnectionCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class SplicePointCollection;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class SplicePositionBuilder;
        }
    }
    namespace Routing
    {
        namespace Electrical
        {
            class SystemDeviceCollection;
        }
    }
    namespace Routing
    {
        class EndFormBuilder;
    }
    namespace Routing
    {
        class FillerCollection;
    }
    namespace Routing
    {
        class FillerStockBuilder;
    }
    namespace Routing
    {
        class FindByAttributesBuilder;
    }
    namespace Routing
    {
        class FittingOverstock;
    }
    namespace Routing
    {
        class FittingOverstockBuilder;
    }
    namespace Routing
    {
        class FittingOverstockCollection;
    }
    namespace Routing
    {
        class FittingPortCollection;
    }
    namespace Routing
    {
        class FixturePortCollection;
    }
    namespace Routing
    {
        class FormboardPlacementCoordinateSystemBuilder;
    }
    namespace Routing
    {
        class GapDisplayBuilder;
    }
    namespace Routing
    {
        class HandrailBuilder;
    }
    namespace Routing
    {
        class ISegment;
    }
    namespace Routing
    {
        class InfoObjectsBuilder;
    }
    namespace Routing
    {
        class InstanceNameLookupBuilder;
    }
namespace Routing
    {
        class IntegrateRunsBuilder;
    }
    namespace Routing
    {
        class InterfaceTerminalRelationshipCollection;
    }
    namespace Routing
    {
        class LineSegment;
    }
    namespace Routing
    {
        class LinearPathBuilder;
    }
    namespace Routing
    {
        class LinearPathSettings;
    }
    namespace Routing
    {
        class ManualRouteBuilder;
    }
    namespace Routing
    {
        class MergeStocksBuilder;
    }
    namespace Routing
    {
        class MiterCornerCollection;
    }
    namespace Routing
    {
        class MiteredBendCornerCollection;
    }
    namespace Routing
    {
        class ModelTerminalsBuilder;
    }
    namespace Routing
    {
        class MultiPortCollection;
    }
    namespace Routing
    {
        class NamingPatternBuilder;
    }
    namespace Routing
    {
        class OffsetPathCollection;
    }
    namespace Routing
    {
        class Overstock;
    }
    namespace Routing
    {
        class OverstockApplicationCollection;
    }
    namespace Routing
    {
        class OverstockBuilder;
    }
    namespace Routing
    {
        class OverstockFacesBuilder;
    }
    namespace Routing
    {
        class PathStockBuilder;
    }
    namespace Routing
    {
        class PlaceElbowsBuilder;
    }
    namespace Routing
    {
        class PlacePartBuilder;
    }
    namespace Routing
    {
        class PlacementSolutionsBuilder;
    }
    namespace Routing
    {
        class PlatformCreatorBuilder;
    }
    namespace Routing
    {
        class PlatformFeature;
    }
    namespace Routing
    {
        class Port;
    }
    namespace Routing
    {
        class PortArrayListItemBuilder;
    }
namespace Routing
    {
        class PortArraysBuilder;
    }
    namespace Routing
    {
        class PortCollection;
    }
    namespace Routing
    {
        class PortConnection;
    }
    namespace Routing
    {
        class PortConnectionCollection;
    }
    namespace Routing
    {
        class ProxyPortCollection;
    }
    namespace Routing
    {
        class QualifyPortBuilder;
    }
    namespace Routing
    {
        class QuickPathBuilder;
    }
    namespace Routing
    {
        class RemoveDiscontinuityBuilder;
    }
    namespace Routing
    {
        class ReuseLibrary;
    }
    namespace Routing
    {
        class RootObject;
    }
    namespace Routing
    {
        class RouteLogicalAssociationCollection;
    }
    namespace Routing
    {
        class RoutePartDescriptorCollection;
    }
    namespace Routing
    {
        class RouteSweptFoldBuilder;
    }
    namespace Routing
    {
        class RouteSweptTwistBuilder;
    }
    namespace Routing
    {
        class RoutingSystemCollection;
    }
    namespace Routing
    {
        class Run;
    }
    namespace Routing
    {
        class RunCollection;
    }
    namespace Routing
    {
        class RunItem;
    }
    namespace Routing
    {
        class SBendCornerCollection;
    }
    namespace Routing
    {
        class SimplifyPathBuilder;
    }
    namespace Routing
    {
        class SpaceReservationBuilder;
    }
    namespace Routing
    {
        class SplinePathBuilder;
    }
    namespace Routing
    {
        class SplitDuctBuilder;
    }
    namespace Routing
    {
        class SplitRunBuilder;
    }
    namespace Routing
    {
        class Stock;
    }
namespace Routing
    {
        class StockBrowserBuilder;
    }
    namespace Routing
    {
        class StockBuilder;
    }
    namespace Routing
    {
        class StockCollection;
    }
    namespace Routing
    {
        class StockColorBuilder;
    }
    namespace Routing
    {
        class StockDataCollection;
    }
    namespace Routing
    {
        class StockDataRefreshBuilder;
    }
    namespace Routing
    {
        class StockOffsetPointBuilder;
    }
    namespace Routing
    {
        class StockOffsetPortCollection;
    }
    namespace Routing
    {
        class StockPartConverterBuilder;
    }
    namespace Routing
    {
        class StockStyleBuilder;
    }
    namespace Routing
    {
        class StockTransitionBuilder;
    }
    namespace Routing
    {
        class SubdivideSegmentBuilder;
    }
    namespace Routing
    {
        class TerminalPortBuilder;
    }
    namespace Routing
    {
        class TerminalPortCollection;
    }
    namespace Routing
    {
        class TransformPathBuilder;
    }
    namespace Routing
    {
        class UnifyPathBuilder;
    }
    namespace Routing
    {
        class WatertightFittingsBuilder;
    }
    namespace Routing
    {
        class WindCatcher;
    }
    namespace Routing
    {
        class WindCatcherBuilder;
    }
    namespace Routing
    {
        class WireCollection;
    }
    class TaggedObject;
    class Xform;
    namespace Routing
    {
        class RouteManagerImpl;
        class NXOPENCPP_ROUTINGEXPORT  RouteManager
        {
            public: enum PartType
            {
                PartTypePart ,
                PartTypeStock ,
                PartTypeFabrication ,
                PartTypeStockComponent ,
                PartTypeWireComponent ,
                PartTypeOverstock ,
                PartTypeLogical ,
                PartTypeTemplateAssy ,
                PartTypeConnector ,
                PartTypeSplice ,
                PartTypeDevice ,
                PartTypeFiller ,
                PartTypeUnknown  = -1
            };

            public: enum BomLevel
            {
                BomLevelSummery ,
                BomLevelItemized
            };

            public: enum BomStockLength
            {
                BomStockLengthSingleSum ,
                BomStockLengthListEach
            };

            public: enum BomFabrication
            {
                BomFabricationOff ,
                BomFabricationOn
            };

            public: enum BomBlankLines
            {
                BomBlankLinesOff ,
                BomBlankLinesOn
            };

            public: enum FixPosition
            {
                FixPositionOff ,
                FixPositionOn
            };

            public: enum JsonInformation
            {
                JsonInformationSplice ,
                JsonInformationClocking ,
                JsonInformationTwist ,
                JsonInformationAll
            };

            public: enum ImportMode
            {
                ImportModeUpdate = 700,
                ImportModeMerge,
                ImportModeAppend,
                ImportModeDerivative
            };

            public: enum RootType
            {
                RootTypeTop,
                RootTypeStock,
                RootTypeWire,
                RootTypePart
            };

            public: enum ColumnStatus
            {
                ColumnStatusNotHidden,
                ColumnStatusHidden
            };

            public: enum FindObjectType
            {
                FindObjectTypeHarness ,
                FindObjectTypeCable ,
                FindObjectTypeShield ,
                FindObjectTypeConnector ,
                FindObjectTypeDevice ,
                FindObjectTypeConnection ,
                FindObjectTypeWire ,
                FindObjectTypeUnknown  = -1
            };

            public:
            struct SearchCriteria
            {
                public: NXOpen::Routing::RouteManager::FindObjectType ObjectType;
                public: NXOpen::Routing::Electrical::HarnessDevice * OwningHarness;
                public: NXString ApplicationName;
                public: NXString UniqueID;
                public: SearchCriteria() :
                    ObjectType((NXOpen::Routing::RouteManager::FindObjectType)0),
                    OwningHarness(),
                    ApplicationName(),
                    UniqueID()
{
                }
                public: SearchCriteria(NXOpen::Routing::RouteManager::FindObjectType objectTypeInitial ,
                        NXOpen::Routing::Electrical::HarnessDevice * owningHarnessInitial ,
                        const NXString &applicationNameInitial ,
                        const NXString &uniqueIDInitial ) :
                    ObjectType(objectTypeInitial),
                    OwningHarness(owningHarnessInitial),
                    ApplicationName(applicationNameInitial),
                    UniqueID(uniqueIDInitial)
                {
                }
            };
            private: RouteManagerImpl * m_routemanager_impl;
            private: NXOpen::Part* m_owner;
            public: explicit RouteManager(NXOpen::Part *owner);
            public:
            tag_t Tag() const;
            public: ~RouteManager();
            public: double GetLengthTolerance
            (
            );
            public: NXOpen::Direction * DownDirection
            (
            );
            public: void SetDownDirection
            (
                NXOpen::Direction * downDirection 
            );
            public: NXOpen::Direction * CreateNewDownDirection
            (
            );
            public: NXOpen::Routing::RouteManager::PartType PartTypeFlag
            (
            );
            public: void SetPartTypeFlag
            (
                NXOpen::Routing::RouteManager::PartType type 
            );
            public: void InsertIntoStock
            (
                NXOpen::Assemblies::Component * component 
            );
            public: void LiftFromStock
            (
                NXOpen::Assemblies::Component * component 
            );
            public: NXOpen::Part * LoadPart
            (
                NXOpen::Routing::CharacteristicList * partEntry 
            );
            public: void LogConcurrent
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: std::vector<NXOpen::NXObject *> GetConcurrent
            (
            );
            public: void ExportHx2ml
            (
                const NXString & hx2mlFilename 
            );
            void ExportHx2ml
            (
                const char * hx2mlFilename 
            );
            public: void ExportPlmxml
            (
                const NXString & plmxmlFilename 
            );
            void ExportPlmxml
            (
                const char * plmxmlFilename 
            );
            public: void ImportHx2ml
            (
                const NXString & hx2mlFilename ,
                NXOpen::Routing::RouteManager::ImportMode importOperation 
            );
            void ImportHx2ml
            (
                const char * hx2mlFilename ,
                NXOpen::Routing::RouteManager::ImportMode importOperation 
            );
            public: void ImportPlmxml
            (
                const NXString & plmxmlFilename ,
                NXOpen::Routing::RouteManager::ImportMode importOperation 
            );
            void ImportPlmxml
            (
                const char * plmxmlFilename ,
                NXOpen::Routing::RouteManager::ImportMode importOperation 
            );
            public: void ImportLegacyComponentFile
            (
                const NXString & importFilename ,
                NXOpen::Routing::RouteManager::ImportMode importOperation ,
                const NXString & importFormatName 
            );
            void ImportLegacyComponentFile
            (
                const char * importFilename ,
                NXOpen::Routing::RouteManager::ImportMode importOperation ,
                const char * importFormatName 
            );
            public: void ExportLegacyComponentFile
            (
                const NXString & exportFilename ,
                const NXString & exportFormatName 
            );
            void ExportLegacyComponentFile
            (
                const char * exportFilename ,
                const char * exportFormatName 
            );
            public: void ImportLegacyHarnessFile
            (
                const NXString & importFilename ,
                NXOpen::Routing::RouteManager::ImportMode importOperation ,
                const NXString & importFormatName 
            );
            void ImportLegacyHarnessFile
            (
                const char * importFilename ,
                NXOpen::Routing::RouteManager::ImportMode importOperation ,
                const char * importFormatName 
            );
            public: void ExportLegacyHarnessFile
            (
                const NXString & exportFilename ,
                const NXString & exportFormatName 
            );
            void ExportLegacyHarnessFile
            (
                const char * exportFilename ,
                const char * exportFormatName 
            );
            public: void ViewNetlistHistory
            (
            );
            public: void EraseNetlistHistory
            (
            );
            public: NX_DEPRECATED("Deprecated in NX1847.0.0.  Use NXOpen::Routing::RouteManager::CheckDesignRules instead.") void CheckDesignRules
            (
                NXOpen::Routing::DesignRuleViolationCollection::Mode mode  ,
                NXOpen::Routing::DesignRuleViolationCollection::Reason reason  ,
                const std::vector<NXOpen::NXObject *> & objects ,
                std::vector<NXOpen::Routing::DesignRuleViolation *> & violations 
            );
            public: void CheckDesignRules
            (
                NXOpen::Routing::DesignRuleViolationCollection::Mode mode ,
                NXOpen::Routing::CustomManager::DesignRuleReason reason ,
                const std::vector<NXOpen::NXObject *> & objects ,
                std::vector<NXOpen::Routing::DesignRuleViolation *> & violations 
            );
            public: void PlaceCutElbow
            (
                NXOpen::Routing::CharacteristicList * loadCharx ,
                NXOpen::Routing::CharacteristicList * applyCharx ,
                NXOpen::Routing::ControlPoint * rcp 
            );
            public: std::vector<NXOpen::NXObject *> DeletePath
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: void UnifyPath
            (
                NXOpen::TaggedObject * inputObject ,
                NXOpen::Routing::CharacteristicList * newCharxList 
            );
            public: void RepositionPartOccurrence
            (
                NXOpen::Assemblies::Component * partOcc  ,
                const NXOpen::Point3d & position ,
                const NXOpen::Matrix3x3 & transform 
            );
            public: NXOpen::Assemblies::Component * RouteReplacePart
            (
                NXOpen::Assemblies::Component * oldOcc  ,
                NXOpen::Part * newPart  ,
                const NXString & compName  ,
                const NXString & refset  ,
                int occLayer 
            );
            NXOpen::Assemblies::Component * RouteReplacePart
            (
                NXOpen::Assemblies::Component * oldOcc  ,
                NXOpen::Part * newPart  ,
                const char * compName  ,
                const char * refset  ,
                int occLayer 
            );
            public: void ReplaceComponents
            (
                NXOpen::Assemblies::Component * oldOcc  ,
                NXOpen::Assemblies::Component * newOcc  ,
                const NXString & refsetName 
            );
            void ReplaceComponents
            (
                NXOpen::Assemblies::Component * oldOcc  ,
                NXOpen::Assemblies::Component * newOcc  ,
                const char * refsetName 
            );
            public: void ReplaceComponents
            (
                NXOpen::Assemblies::Component * oldOcc ,
                NXOpen::Assemblies::Component * newOcc ,
                const NXString & refsetName ,
                NXOpen::Routing::RouteManager::FixPosition fixPosition 
            );
            void ReplaceComponents
            (
                NXOpen::Assemblies::Component * oldOcc ,
                NXOpen::Assemblies::Component * newOcc ,
                const char * refsetName ,
                NXOpen::Routing::RouteManager::FixPosition fixPosition 
            );
            public: std::vector<NXOpen::NXObject *> TransformObjects
            (
                bool allStock ,
                const std::vector<NXOpen::Routing::Stock *> & specifiedStocks ,
                const std::vector<NXOpen::NXObject *> & objects ,
                const NXOpen::Point3d & position ,
                const NXOpen::Matrix3x3 & transform ,
                bool copyOperation 
            );
            public: bool MergeDuplicateRcps
            (
                double tolerance ,
                const std::vector<NXOpen::Routing::ControlPoint *> & rcps 
            );
            public: void RemoveComponents
            (
                const std::vector<NXOpen::Assemblies::Component *> & components 
            );
            public: void ConnectPartPorts
            (
                NXOpen::Assemblies::Component * component 
            );
            public: NXOpen::Part * BuildFabrication
            (
                const NXString & filename ,
                const std::vector<NXOpen::NXObject *> & objects ,
                NXOpen::Routing::CharacteristicList * charxData 
            );
            NXOpen::Part * BuildFabrication
            (
                const char * filename ,
                const std::vector<NXOpen::NXObject *> & objects ,
                NXOpen::Routing::CharacteristicList * charxData 
            );
            public: NX_DEPRECATED("Deprecated in NX1847.0.0.  Use NXOpen::Routing::RouteManager::BuildFabricationWithFileNewBuilder instead.") NXOpen::Part * BuildFabrication
            (
                const NXString & filename ,
                const std::vector<NXOpen::NXObject *> & objects ,
                NXOpen::Routing::CharacteristicList * optionalCharxData ,
                NXOpen::Routing::CharacteristicList * requiredCharxData 
            );
            NXOpen::Part * BuildFabrication
            (
                const char * filename ,
                const std::vector<NXOpen::NXObject *> & objects ,
                NXOpen::Routing::CharacteristicList * optionalCharxData ,
                NXOpen::Routing::CharacteristicList * requiredCharxData 
            );
            public: NXOpen::Part * BuildFabricationWithFileNewBuilder
            (
                NXOpen::FileNew * builder  ,
                const std::vector<NXOpen::NXObject *> & objects ,
                NXOpen::Routing::CharacteristicList * optionalCharxData ,
                NXOpen::Routing::CharacteristicList * requiredCharxData 
            );
            public: void CreateBom
            (
                NXOpen::Routing::RouteManager::BomLevel level ,
                NXOpen::Routing::RouteManager::BomStockLength length ,
                NXOpen::Routing::RouteManager::BomFabrication fabNumbering ,
                NXOpen::Routing::RouteManager::BomBlankLines blankLines ,
                NXOpen::Part * formatFilePart 
            );
            public: NXOpen::Part * ImportPartListFormatFile
            (
                const NXString & fileName 
            );
            NXOpen::Part * ImportPartListFormatFile
            (
                const char * fileName 
            );
            public: NXOpen::Routing::LinearPathBuilder * CreateLinearPathBuilder
            (
            );
            public: NXOpen::Routing::ElbowSnapSettings * CreateElbowSnapSettings
            (
            );
            public: NXOpen::Routing::PathStockBuilder * CreatePathStockBuilder
            (
            );
            public: NXOpen::Routing::LinearPathSettings * CreateLinearPathSettings
            (
            );
            public: NXOpen::Routing::QuickPathBuilder * CreateQuickPathBuilder
            (
            );
            public: NXOpen::Routing::DesignRuleViolationViewer * CreateDesignRuleViolationViewer
            (
                const std::vector<NXOpen::NXObject *> & violations 
            );
            public: NXOpen::Routing::DesignRuleViolationViewer * CreateDesignRuleViolationViewer
            (
            );
            public: NXOpen::Routing::DeleteObjectsBuilder * CreateDeleteObjectsBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::InfoObjectsBuilder * CreateInfoObjectsBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::ConnectedCurvesBuilder * CreateConnectedCurvesBuilder
            (
            );
            public: NXOpen::Routing::SimplifyPathBuilder * CreateSimplifyPathBuilder
            (
                const std::vector<NXOpen::Routing::ISegment *> & segments 
            );
            public: NXOpen::Routing::SimplifyPathBuilder * CreateSimplifyPathBuilder2
            (
                NXOpen::Assemblies::Component * workOcc ,
                const std::vector<NXOpen::Routing::ISegment *> & segments 
            );
            public: NXOpen::Routing::EditLineSegmentBuilder * CreateEditLineSegmentBuilder
            (
                NXOpen::Routing::LineSegment * line 
            );
            public: NXOpen::Routing::SubdivideSegmentBuilder * CreateSubdivideSegmentBuilder
            (
                NXOpen::NXObject * segment ,
                const NXOpen::Point3d & pickPoint 
            );
            public: NXOpen::Routing::SplinePathBuilder * CreateSplinePathBuilder
            (
                NXOpen::Curve * spline 
            );
            public: NXOpen::Routing::StockOffsetPointBuilder * CreateStockOffsetPointBuilder
            (
                NXOpen::NXObject * pointOrRcp 
            );
            public: NXOpen::Routing::TransformPathBuilder * CreateTransformPathBuilder
            (
                const std::vector<NXOpen::NXObject *> & objs 
            );
            public: NXOpen::Routing::AssignCornerBuilder * CreateAssignCornerBuilder
            (
            );
            public: NXOpen::Routing::AssignCornerBuilder * CreateAssignCornerBuilder
            (
                NXOpen::NXObject * selectedObject 
            );
            public: NXOpen::Routing::SpaceReservationBuilder * CreateSpaceReservationBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::OverstockBuilder * CreateOverstockBuilder
            (
                NXOpen::Routing::Overstock * overstock 
            );
            public: NXOpen::Routing::FillerStockBuilder * CreateFillerStockBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::StockStyleBuilder * CreateStockStyleBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::StockBuilder * CreateStockBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::StockBrowserBuilder * CreateStockBrowserBuilder
            (
            );
            public: NXString CopyOverstock
            (
            );
            public: NXOpen::Routing::RouteSweptTwistBuilder * CreateRouteSweptTwistBuilder
            (
                NXOpen::NXObject * objects 
            );
            public: NXOpen::Routing::RouteSweptFoldBuilder * CreateRouteSweptFoldBuilder
            (
                NXOpen::NXObject * selectedStock ,
                NXOpen::NXObject * editFoldObj 
            );
            public: NXOpen::Routing::StockColorBuilder * CreateStockColorBuilder
            (
            );
            public: NXOpen::Routing::RemoveDiscontinuityBuilder * CreateRemoveDiscontinuityBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::UnifyPathBuilder * CreateUnifyPathBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::ClockPartBuilder * CreateClockPartBuilder
            (
                NXOpen::NXObject * selectedPort 
            );
            public: NXOpen::Routing::ConnectPathBuilder * CreateConnectPathBuilder
            (
            );
            public: NXOpen::Routing::OverstockFacesBuilder * CreateOverstockFacesBuilder
            (
            );
            public: NXOpen::Routing::Electrical::CablewaysBuilder * CreateCablewaysBuilder
            (
            );
            public: NXOpen::Routing::Electrical::CablewaysBuilder * CreateCablewaysBuilderWithObjects
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::Electrical::CablewaysLayoutBuilder * CreateCablewaysLayoutBuilder
            (
            );
            public: NXOpen::Routing::EditCharacteristicsBuilder * CreateEditCharacteristicsBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::PlacePartBuilder * CreateRoutingPlacePartBuilder
            (
                NXOpen::Routing::CharacteristicList * partCharx ,
                const NXOpen::Point3d & placementPos ,
                NXOpen::TaggedObject * placementObj 
            );
            public: NXOpen::Routing::PlacePartBuilder * CreatePlacePartBuilder
            (
                const NXString & nodeIdentifier ,
                int filteredPtbRowIndex ,
                const NXOpen::Point3d & placementPos ,
                NXOpen::TaggedObject * placementObj 
            );
            NXOpen::Routing::PlacePartBuilder * CreatePlacePartBuilder
            (
                const char * nodeIdentifier ,
                int filteredPtbRowIndex ,
                const NXOpen::Point3d & placementPos ,
                NXOpen::TaggedObject * placementObj 
            );
            public: NXOpen::Routing::PlacePartBuilder * CreatePlacePartBuilderFS
            (
                const NXString & nodeIdentifier ,
                NXOpen::Routing::CharacteristicList * fileSelectCharx ,
                const NXOpen::Point3d & placementPos ,
                NXOpen::TaggedObject * placementObj ,
                bool replacePartOp 
            );
            NXOpen::Routing::PlacePartBuilder * CreatePlacePartBuilderFS
            (
                const char * nodeIdentifier ,
                NXOpen::Routing::CharacteristicList * fileSelectCharx ,
                const NXOpen::Point3d & placementPos ,
                NXOpen::TaggedObject * placementObj ,
                bool replacePartOp 
            );
            public: NXOpen::Routing::PlacePartBuilder * CreatePlacePartBuilderPTS
            (
                NXOpen::TaggedObject * ptsPart ,
                NXOpen::TaggedObject * ptsInstance ,
                const NXOpen::Point3d & placementPos ,
                NXOpen::TaggedObject * placementObj 
            );
            public: NXOpen::Routing::EditPlacePartBuilder * CreateEditPlacePartBuilder
            (
                NXOpen::Assemblies::Component * partOcc 
            );
            public: NXOpen::Routing::PlacementSolutionsBuilder * CreatePlacementSolutionsBuilder
            (
            );
            public: NXOpen::Routing::StockTransitionBuilder * CreateStockTransitionBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::FittingOverstockBuilder * CreateFittingOverstockBuilder
            (
                NXOpen::Routing::FittingOverstock * overstock 
            );
            public: NXOpen::Routing::ModelTerminalsBuilder * ModelTerminalsBuilder
            (
            );
            public: NXOpen::Routing::TerminalPortBuilder * TerminalPortBuilder
            (
            );
            public: NXOpen::Routing::AssignDiscontinuityBuilder * CreateAssignDiscontinuityBuilder
            (
                NXOpen::NXObject * selectedPoint 
            );
            public: NXOpen::Routing::ManualRouteBuilder * CreateManualRouteBuilder
            (
                NXOpen::Routing::Electrical::ElectricalStockDevice::RouteLevel routeLevel ,
                NXOpen::Routing::Electrical::ElectricalStockDevice * elecStockDevice 
            );
            public: NXOpen::Routing::SplitDuctBuilder * CreateSplitDuctBuilder
            (
            );
            public: NXOpen::Routing::HandrailBuilder * CreateHandrailBuilder
            (
            );
            public: NXOpen::Routing::DivisionsBuilder * CreateDivisionsBuilder
            (
                NXOpen::NXObject * selectedPort ,
                bool isAbsoluteFlow 
            );
            public: NXOpen::Routing::EditBendAngleBuilder * CreateEditBendAngleBuilder
            (
                NXOpen::NXObject * bendRcp 
            );
            public: void GenerateCablewaysLayoutData
            (
                NXOpen::Curve * segment ,
                NXOpen::Xform * xform ,
                double width ,
                double height ,
                int gridFactor ,
                std::vector<NXOpen::Point *> & points  ,
                std::vector<NXOpen::Routing::Electrical::CableDevice *> & cables 
            );
            public: void GetAllBIPComponents
            (
                std::vector<NXOpen::Assemblies::Component *> & components 
            );
            public: bool ComponentHasBIPGeometry
            (
                NXOpen::Assemblies::Component * bipComponent 
            );
            public: void PromoteBIPGeometry
            (
                NXOpen::Assemblies::Component * bipComponent 
            );
            public: NXOpen::Routing::CreateFabricationBuilder * CreateFabricationBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::SplitRunBuilder * SplitRunBuilder
            (
                NXOpen::Routing::Run * run 
            );
            public: NXOpen::Routing::InstanceNameLookupBuilder * CreateInstanceNameLookupBuilder
            (
            );
            public: NXOpen::Routing::WatertightFittingsBuilder * CreateWatertightFittingsBuilder
            (
            );
            public: NXOpen::Routing::IntegrateRunsBuilder * IntegrateRunsBuilder
            (
                NXOpen::Routing::Run * firstRun ,
                NXOpen::Routing::Run * secondRun 
            );
            public: NXOpen::Routing::DuctSizeCalculatorBuilder * CreateDuctSizeCalculatorBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::Electrical::AssignProxyBuilder * CreateAssignProxyBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: void AssembleConnectionsImportedFromSubAssemblies
            (
            );
            public: NXOpen::Routing::RunItem * CreateRunItem
            (
                const NXString & referenceID ,
                NXOpen::Routing::RunItem::Type itemType ,
                NXOpen::Routing::CharacteristicList * attributes 
            );
            NXOpen::Routing::RunItem * CreateRunItem
            (
                const char * referenceID ,
                NXOpen::Routing::RunItem::Type itemType ,
                NXOpen::Routing::CharacteristicList * attributes 
            );
            public: NXOpen::Routing::FindByAttributesBuilder * CreateFindByAttributesBuilder
            (
            );
            public: NXOpen::Routing::DuctReinforcementBuilder * CreateDuctReinforcementBuilderForStock
            (
                NXOpen::NXObject * ductReinforcement 
            );
            public: NXOpen::Routing::WindCatcherBuilder * CreateWindCatcherBuilder
            (
                NXOpen::Routing::WindCatcher * windCatcher 
            );
            public: NXOpen::Routing::PlatformCreatorBuilder * CreatePlatformCreatorBuilder
            (
            );
            public: NXOpen::Routing::PlatformCreatorBuilder * CreatePlatformCreatorBuilder
            (
                NXOpen::Routing::PlatformFeature * platformFeature 
            );
            public: NXOpen::Routing::AssignPathBuilder * CreateAssignPathBuilder
            (
                NXOpen::Routing::Run * run 
            );
            public: NXOpen::Routing::AttributeHolder * CreateAttributeHolder
            (
            );
            public: NXOpen::Routing::DefineRunBuilder * CreateDefineRunBuilder
            (
                NXOpen::Routing::Run * selectedRun 
            );
            public: NXOpen::Routing::GapDisplayBuilder * CreateGapDisplayBuilder
            (
            );
            public: NXOpen::Routing::AddFontBuilder * CreateAddFontBuilder
            (
            );
            public: NXOpen::Routing::DeleteFontsBuilder * CreateDeleteFontsBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: NXOpen::Routing::DeleteGapsBuilder * CreateDeleteGapsBuilder
            (
                const std::vector<NXOpen::NXObject *> & objects 
            );
            public: void ImportRunsNative
            (
                const NXString & path 
            );
            void ImportRunsNative
            (
                const char * path 
            );
            public: void ImportRunsManaged
            (
                const NXString & itemPartNumber  ,
                const NXString & itemRevision 
            );
            void ImportRunsManaged
            (
                const char * itemPartNumber  ,
                const char * itemRevision 
            );
            public: NXOpen::Routing::CompareRunsBuilder * CreateCompareRunsBuilder
            (
                NXOpen::Routing::Run * run 
            );
            public: bool HasAllReferencingStockComponentsLoaded
            (
                NXOpen::TaggedObject * objectToValidate 
            );
            public: NXOpen::Routing::BranchPathNumberingBuilder * CreateBranchPathNumberingBuilder
            (
            );
            public: void PlacePostPlacementParts
            (
                NXOpen::Assemblies::Component * placedPart  ,
                NXOpen::Routing::CharacteristicList * postPartCharx  ,
                std::vector<NXOpen::Assemblies::Component *> & postParts 
            );
            public: NXOpen::Routing::MergeStocksBuilder * CreateMergeStocksBuilder
            (
            );
            public: NXOpen::Routing::StockDataRefreshBuilder * CreateStockDataRefreshBuilder
            (
            );
            public: NXOpen::Routing::StockPartConverterBuilder * CreateStockPartConverterBuilder
            (
            );
            public: NXString RecreateStockComponents
            (
            );
            public: void ConvertSplineSegments
            (
                std::vector<NXOpen::Routing::ISegment *> & splineSegments ,
                std::vector<double> & originalSplineLengths ,
                std::vector<double> & newSplineLengths 
            );
            public: void ModelConnectionPostPlacementGasket
            (
                NXOpen::Assemblies::Component * placedPart ,
                NXOpen::Routing::PortConnection * connection ,
                NXOpen::Routing::ReuseLibrary::ReportInBom reportInBOM ,
                NXOpen::Routing::CharacteristicList * gasketCharx ,
                NXOpen::Routing::PortConnection ** connectionOne ,
                NXOpen::Routing::PortConnection ** connectionTwo 
            );
            public: void ModelConnectionPostPlacementGasketBetweenFlanges
            (
                NXOpen::Assemblies::Component * placedPart ,
                NXOpen::Routing::PortConnection * connection ,
                NXOpen::Routing::ReuseLibrary::ReportInBom reportInBOM ,
                NXOpen::Routing::CharacteristicList * gasketCharx ,
                NXOpen::Routing::PortConnection ** connectionOne ,
                NXOpen::Routing::PortConnection ** connectionTwo ,
                NXOpen::Assemblies::Component ** modeledGasket 
            );
            public: void ModelConnectionPostPlacementWeldGap
            (
                NXOpen::Assemblies::Component * placedPart ,
                NXOpen::Routing::PortConnection * connection ,
                double gapValue 
            );
            public: void CreateConnectionPostPlacementUdo
            (
                NXOpen::Routing::ReuseLibrary::PartType udoType ,
                int numberOfItems ,
                NXOpen::Routing::ReuseLibrary::ReportInBom reportInBOM ,
                NXOpen::Routing::CharacteristicList * udoCharx ,
                const std::vector<NXOpen::Routing::PortConnection *> & connectionsToLink 
            );
            public: std::vector<NXOpen::Routing::Run *> GetReferencingRuns
            (
                NXOpen::NXObject * object 
            );
            public: NXOpen::Routing::AlignStockBuilder * CreateAlignStockBuilder
            (
            );
            public: void DesignateFormboardPlacementCSys
            (
                NXOpen::CoordinateSystem * csys 
            );
            public: void RemoveFormboardPlacementCSysDesignation
            (
            );
            public: NXOpen::Routing::Electrical::PathArrangementBuilder * CreatePathArrangementBuilder
            (
            );
            public: bool IsStockComponent
            (
                NXOpen::Assemblies::Component * inputComponent 
            );
            public: NXOpen::Routing::RootObject * FindRoutingObject
            (
                const NXOpen::Routing::RouteManager::SearchCriteria & searchCriteria 
            );
            public: std::vector<NXOpen::Routing::ISegment *> FindRoutingSegments
            (
                const NXString & guid 
            );
            std::vector<NXOpen::Routing::ISegment *> FindRoutingSegments
            (
                const char * guid 
            );
            public: NXOpen::Routing::ControlPoint * FindRoutingControlPoint
            (
                const NXString & guid 
            );
            NXOpen::Routing::ControlPoint * FindRoutingControlPoint
            (
                const char * guid 
            );
            public: void DeselectAllObjectsInNavigators
            (
            );
            public: void SelectObjectInNavigator
            (
                NXOpen::Routing::RootObject * objectToSelect 
            );
            public: void SelectObjectsInNavigator
            (
                const std::vector<NXOpen::Routing::RootObject *> & objectsToSelect 
            );
            public: void GetSelectedObjectsInNavigators
            (
                std::vector<NXOpen::Routing::RootObject *> & selectedObjects 
            );
            public: NXOpen::Routing::Stock * GetStockFromBody
            (
                NXOpen::Body * body 
            );
            public: bool IsConnectionNavigatorOpen
            (
            );
            public: void OpenConnectionNavigator
            (
            );
            public: bool IsComponentNavigatorOpen
            (
            );
            public: void OpenComponentNavigator
            (
            );
            public: NXOpen::Routing::PlaceElbowsBuilder * CreateRoutingPlaceElbowsBuilder
            (
            );
            public: NXOpen::Routing::BuiltInPathBuilder * CreateBuiltInPathBuilder
            (
                NXOpen::Routing::BuiltInPath * bipObject 
            );

            public: NXOpen::Routing::CablewayNetworkBuilder * CreateCablewayNetworkBuilder
            (
                NXOpen::Routing::CablewayNetwork * cablewayObject 
            );

            public: NXOpen::Routing::AnchorBuilder * CreateAnchorBuilder
            (
                NXOpen::Routing::Anchor * anchorObject 
            );
            public: NXOpen::Routing::CrossSectionBuilder * CreateCrossSectionBuilder
            (
                NXOpen::Routing::CrossSection * crossSectionObject 
            );
            public: NXOpen::Routing::FormboardPlacementCoordinateSystemBuilder * CreateFormboardPlacementCoordinateSystemBuilder
            (
                NXOpen::CoordinateSystem * csysObject 
            );
            public: NXOpen::Routing::EndFormBuilder * CreateRoutingEndFormBuilder
            (
            );
            public: NXOpen::Routing::QualifyPortBuilder * CreateQualifyPortBuilder
            (
                NXOpen::Routing::Port * port 
            );
            public: NXOpen::Routing::AssignTerminalsBuilder * CreateAssignTerminalsBuilder
            (
                NXOpen::Routing::Port * port 
            );
            public: NXOpen::Routing::AssignTerminalsItemBuilder * CreateAssignTerminalsItemBuilder
            (
                NXOpen::Routing::Port * port 
            );
            public: NXOpen::Routing::NamingPatternBuilder * CreateNamingPatternBuilder
            (
            );
            public: NXOpen::Routing::PortArraysBuilder * CreatePortArraysBuilder
            (
                NXOpen::Routing::Port * port 
            );
            public: NXOpen::Routing::PortArrayListItemBuilder * CreatePortArrayListItemBuilder
            (
            );
            public: void ImportFromCapital
            (
            );
            public: bool IsDirectIntegrationwithCapitalEnabled
            (
            );
            public: NXOpen::Routing::Electrical::SplicePositionBuilder * CreateSplicePositionBuilder
            (
                NXOpen::Point * splicePoint 
            );
            public: void UnlinkContextDiagram
            (
            );
            public: void DeleteBundleSolids
            (
            );
            public: void HighLightPathandBundleSolids
            (
                NXOpen::Routing::ControlPoint * controlPoint1  ,
                NXOpen::Routing::ControlPoint * controlPoint2  ,
                const NXString & bundleId 
            );
            void HighLightPathandBundleSolids
            (
                NXOpen::Routing::ControlPoint * controlPoint1  ,
                NXOpen::Routing::ControlPoint * controlPoint2  ,
                const char * bundleId 
            );
            public: void ExportSpliceObjects
            (
                const NXString & jsonFilename 
            );
            void ExportSpliceObjects
            (
                const char * jsonFilename 
            );
            public: bool IsRoutingPart
            (
            );
            public: void RemoveIdentifierFromNonRoutingParts
            (
            );
            public: void ExportJson
            (
                NXOpen::Routing::RouteManager::JsonInformation infoType  ,
                const NXString & jsonFileName 
            );
            void ExportJson
            (
                NXOpen::Routing::RouteManager::JsonInformation infoType  ,
                const char * jsonFileName 
            );
            public: void ExportZipFile
            (
                const NXString & zipFilename 
            );
            void ExportZipFile
            (
                const char * zipFilename 
            );
            public: void ImportZipFile
            (
                const NXString & zipFilename  ,
                NXOpen::Routing::RouteManager::ImportMode importOperation 
            );
            void ImportZipFile
            (
                const char * zipFilename  ,
                NXOpen::Routing::RouteManager::ImportMode importOperation 
            );
            public: void ExportJsonFromHarnessDevice
            (
                NXOpen::Routing::Electrical::HarnessDevice * harnessDeviceTag  ,
                NXOpen::Routing::RouteManager::JsonInformation infoType  ,
                const NXString & jsonFileName 
            );
            void ExportJsonFromHarnessDevice
            (
                NXOpen::Routing::Electrical::HarnessDevice * harnessDeviceTag  ,
                NXOpen::Routing::RouteManager::JsonInformation infoType  ,
                const char * jsonFileName 
            );
            public: NXOpen::Routing::AdvanceToRsdBuilder * CreateAdvanceToRsdBuilder
            (
            );
            public: void QualifyModuleAssemblyPart
            (
            );
            public: void DisQualifyModuleAssemblyPart
            (
            );
            public: NXOpen::Routing::BuiltInPathCollection *BuiltInPaths();

            public: NXOpen::Routing::CablewayNetworkCollection *CablewayNetworks();

            public: NXOpen::Routing::ControlPointCollection *ControlPoints();
            public: NXOpen::Routing::PortCollection *Ports();
            public: NXOpen::Routing::PortConnectionCollection *PortConnections();
            public: NXOpen::Routing::FixturePortCollection *FixturePorts();
            public: NXOpen::Routing::FittingPortCollection *FittingPorts();
            public: NXOpen::Routing::MultiPortCollection *MultiPorts();
            public: NXOpen::Routing::TerminalPortCollection *TerminalPorts();
            public: NXOpen::Routing::ProxyPortCollection *ProxyPorts();
            public: NXOpen::Routing::StockOffsetPortCollection *StockOffsetPorts();
            public: NXOpen::Routing::OffsetPathCollection *OffsetPaths();
            public: NXOpen::Routing::RunCollection *Runs();
            public: NXOpen::Routing::RoutingSystemCollection *RoutingSystems();
            public: NXOpen::Routing::RouteLogicalAssociationCollection *RouteLogicalAssociations();
            public: NXOpen::Routing::CornerCollection *Corners();
            public: NXOpen::Routing::BendCornerCollection *BendCorners();
            public: NXOpen::Routing::CopeCornerCollection *CopeCorners();
            public: NXOpen::Routing::DiscontinuityCornerCollection *DiscontinuityCorners();
            public: NXOpen::Routing::MiterCornerCollection *MiterCorners();
            public: NXOpen::Routing::SBendCornerCollection *SBendCorners();
            public: NXOpen::Routing::MiteredBendCornerCollection *MiteredBendCorners();
            public: NXOpen::Routing::RoutePartDescriptorCollection *RoutePartDescriptors();
            public: NXOpen::Routing::AnchorCollection *Anchors();
            public: NXOpen::Routing::StockCollection *Stocks();
            public: NXOpen::Routing::StockDataCollection *StockDatas();
            public: NXOpen::Routing::CrossSectionCollection *CrossSections();
            public: NXOpen::Routing::WireCollection *Wires();
            public: NXOpen::Routing::OverstockApplicationCollection *OverstockApplications();
            public: NXOpen::Routing::FillerCollection *Fillers();
            public: NXOpen::Routing::Electrical::CableConnectionCollection *CableConnections();
            public: NXOpen::Routing::Electrical::NonPathConnectionCollection *NonPathConnections();
            public: NXOpen::Routing::Electrical::ConnectorDeviceCollection *ConnectorDevices();
            public: NXOpen::Routing::Electrical::HarnessDeviceCollection *HarnessDevices();
            public: NXOpen::Routing::Electrical::DerivativeDeviceCollection *DerivativeDevices();
            public: NXOpen::Routing::Electrical::SystemDeviceCollection *SystemDevices();
            public: NXOpen::Routing::Electrical::ElectricalStockDeviceCollection *ElectricalStockDevice();
            public: NXOpen::Routing::Electrical::PathConnectionCollection *PathConnections();
            public: NXOpen::Routing::InterfaceTerminalRelationshipCollection *InterfaceTerminalRelationships();
            public: NXOpen::Routing::Electrical::JumperConnectionCollection *JumperConnections();
            public: NXOpen::Routing::Electrical::ElectricalDeviceRelationshipCollection *ElectricalDeviceRelationships();
            public: NXOpen::Routing::DesignRuleCollection *DesignRules();
            public: NXOpen::Routing::DesignRuleViolationCollection *DesignRulesViolation();
            public: NXOpen::Routing::DesignRuleViolationLocationCollection *DesignRuleViolationLocation();
            public: NXOpen::Routing::Electrical::ConnectionCollection *ElectricalConnections();
            public: NXOpen::Routing::Electrical::ElectricalFormatCollection *ElectricalFormats();
            public: NXOpen::Routing::Electrical::ElectricalNavigatorFilterCollection *ElectricalNavigatorFilters();
            public: NXOpen::Formboard::FormboardManager *FormboardManager();
            public: NXOpen::Routing::Electrical::CablewaysLayoutViewCollection *CablewaysLayoutViews();
            public: NXOpen::Routing::FittingOverstockCollection *FittingOverstock();
            public: NXOpen::Routing::Electrical::SplicePointCollection *SplicePoints();
            public: NXOpen::Routing::ReuseLibrary *ReuseLibrary();
            public: NXOpen::Routing::BendReportManager *BendReportManager();
        }; //lint !e1712 default constructor not defined for class
    }
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#ifdef __GNUC__
#ifndef NX_NO_GCC_DEPRECATION_WARNINGS
#pragma GCC diagnostic warning "-Wdeprecated-declarations"
#endif
#endif
#undef EXPORTLIBRARY