Features_FeatureCollection.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// C++接口JA API的头文件
//--------------------------------------------------------------------------
//
// 源文件:
//     Features_FeatureCollection.ja
//
// 生成工具:
//     apiwrap
//
// 警告:
//    此文件为自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <iterator>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/BasePart.hxx>
#include <NXOpen/ErrorList.hxx>
#include <NXOpen/Features_CopyPasteBuilder.hxx>
#include <NXOpen/Features_Feature.hxx>
#include <NXOpen/Features_FeatureReplayBuilder.hxx>
#include <NXOpen/Features_JoinCurvesBuilder.hxx>
#include <NXOpen/Features_PaintParametersBuilder.hxx>
#include <NXOpen/Features_RasterImage.hxx>
#include <NXOpen/Features_ReferenceMapperBuilder.hxx>
#include <NXOpen/Features_RemoveParametersBuilder.hxx>
#include <NXOpen/Features_ReplaceFeatureBuilder.hxx>
#include <NXOpen/Features_SketchConversionReport.hxx>
#include <NXOpen/Features_ThroughCurveMeshBuilder.hxx>
#include <NXOpen/Features_ThroughCurvesBuilder.hxx>
#include <NXOpen/HumanPosturePrediction.hxx>
#include <NXOpen/TaggedObjectCollection.hxx>
#include <NXOpen/Session.hxx>
#include <NXOpen/TaggedObject.hxx>
#include <NXOpen/ugmath.hxx>
#include <NXOpen/libnxopencpp_features_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 Features
    {
        class FeatureCollection;
    }
    class BasePart;
    namespace Features
    {
        class Feature;
    }
    class Body;
    class Curve;
    class CutView;
    namespace Die
    {
        class DieCollection;
    }
    class Edge;
    class ErrorList;
    class Expression;
    class Face;
    namespace Features
    {
        class AECDesignCollection;
    }
    namespace Features
    {
        class AOCSBuilder;
    }
    namespace Features
    {
        class AVDACollection;
    }
    namespace Features
    {
        class AdaptiveShell;
    }
    namespace Features
    {
        class AdaptiveShellBuilder;
    }
    namespace Features
    {
        class AdmMoveFace;
    }
    namespace Features
    {
        class AdmMoveFaceBuilder;
    }
namespace Features
    {
        class AdmOffsetRegion;
    }
    namespace Features
    {
        class AdmOffsetRegionBuilder;
    }
    namespace Features
    {
        class AdmResizeFace;
    }
    namespace Features
    {
        class AdmResizeFaceBuilder;
    }
    namespace Features
    {
        class AeroCollection;
    }
    namespace Features
    {
        class AestheticFaceBlend;
    }
    namespace Features
    {
        class AestheticFaceBlendBuilder;
    }
    namespace Features
    {
        class AlgorithmicFeatureBuilder;
    }
    namespace Features
    {
        class AnalyzePocket;
    }
    namespace Features
    {
        class AnalyzePocketBuilder;
    }
    namespace Features
    {
        class AngularDim;
    }
    namespace Features
    {
        class AngularDimBuilder;
    }
    namespace Features
    {
        class AssemblyCut;
    }
    namespace Features
    {
        class AssemblyCutBuilder;
    }
    namespace Features
    {
        class AutomotiveCollection;
    }
    namespace Features
    {
        class BlendPocket;
    }
    namespace Features
    {
        class BlendPocketBuilder;
    }
    namespace Features
    {
        class BlockFeatureBuilder;
    }
    namespace Features
    {
        class BodyByEquation;
    }
    namespace Features
    {
        class BodyByEquationBuilder;
    }
    namespace Features
    {
        class BooleanBuilder;
    }
    namespace Features
    {
        class BooleanFeature;
    }
    namespace Features
    {
        class BoundedPlane;
    }
    namespace Features
    {
        class BoundedPlaneBuilder;
    }
    namespace Features
    {
        class BridgeCurve;
    }
namespace Features
    {
        class BridgeCurveBuilder;
    }
    namespace Features
    {
        class BridgeCurveBuilderEx;
    }
    namespace Features
    {
        class BridgeSurface;
    }
    namespace Features
    {
        class BridgeSurfaceBuilder;
    }
    namespace Features
    {
        class Centerline;
    }
    namespace Features
    {
        class CenterlineBuilder;
    }
    namespace Features
    {
        class ChamferBuilder;
    }
    namespace Features
    {
        class ChangeFace;
    }
    namespace Features
    {
        class ChangeFaceBuilder;
    }
    namespace Features
    {
        class ChangeShellThickness;
    }
    namespace Features
    {
        class ChangeShellThicknessBuilder;
    }
    namespace Features
    {
        class CircularBlendCurve;
    }
    namespace Features
    {
        class CircularBlendCurveBuilder;
    }
    namespace Features
    {
        class Coaxial;
    }
    namespace Features
    {
        class CoaxialBuilder;
    }
    namespace Features
    {
        class ColorFaceBuilder;
    }
    namespace Features
    {
        class ColorFeatureBuilder;
    }
    namespace Features
    {
        class ColorFeatureGroupBuilder;
    }
    namespace Features
    {
        class CombinePattern;
    }
    namespace Features
    {
        class CombinePatternBuilder;
    }
    namespace Features
    {
        class CombinedProjection;
    }
    namespace Features
    {
        class CombinedProjectionBuilder;
    }
    namespace Features
    {
        class CompositeCurveBuilder;
    }
    namespace Features
    {
        class ConcaveFaces;
    }
    namespace Features
    {
        class ConcaveFacesBuilder;
    }
namespace Features
    {
        class Cone;
    }
    namespace Features
    {
        class ConeBuilder;
    }
    namespace Features
    {
        class ContourRib;
    }
    namespace Features
    {
        class ContourRibBuilder;
    }
    namespace Features
    {
        class CoplanarBuilder;
    }
    namespace Features
    {
        class CopyFaceBuilder;
    }
    namespace Features
    {
        class CopyPasteBuilder;
    }
    namespace Features
    {
        class CurveFeatureCollection;
    }
    namespace Features
    {
        class CurveLengthBuilder;
    }
    namespace Features
    {
        class CurveOnSurface;
    }
    namespace Features
    {
        class CurveOnSurfaceBuilder;
    }
    namespace Features
    {
        class CustomAttributeCollection;
    }
    namespace Features
    {
        class CustomFeatureBuilder;
    }
    namespace Features
    {
        class CustomFeatureDataCollection;
    }
    namespace Features
    {
        class CutFaceBuilder;
    }
    namespace Features
    {
        class CylinderBuilder;
    }
    namespace Features
    {
        class DatumAxisBuilder;
    }
    namespace Features
    {
        class DatumCsysBuilder;
    }
    namespace Features
    {
        class DatumPlaneBuilder;
    }
    namespace Features
    {
        class DeformDefinitionBuilder;
    }
    namespace Features
    {
        class DeleteBody;
    }
    namespace Features
    {
        class DeleteBodyBuilder;
    }
    namespace Features
    {
        class DeleteEdge;
    }
    namespace Features
    {
        class DeleteEdgeBuilder;
    }
    namespace Features
    {
        class DeleteFaceBuilder;
    }
namespace Features
    {
        class DesignFeatureCollection;
    }
    namespace Features
    {
        class DesignGroup;
    }
    namespace Features
    {
        class DesignGroupBuilder;
    }
    namespace Features
    {
        class DetailFeatureCollection;
    }
    namespace Features
    {
        class DividefaceBuilder;
    }
    namespace Features
    {
        class DraftBodyBuilder;
    }
    namespace Features
    {
        class DraftBuilder;
    }
    namespace Features
    {
        class DraftingSplineBuilder;
    }
    namespace Features
    {
        class EdgeBlendBuilder;
    }
    namespace Features
    {
        class EdgeSymmetryBuilder;
    }
    namespace Features
    {
        class EditCrossSection;
    }
    namespace Features
    {
        class EditCrossSectionBuilder;
    }
    namespace Features
    {
        class EditDimensionBuilder;
    }
    namespace Features
    {
        class EditWithRollbackManager;
    }
    namespace Features
    {
        class EmbedManagerBuilder;
    }
    namespace Features
    {
        class EmbossBody;
    }
    namespace Features
    {
        class EmbossBodyBuilder;
    }
    namespace Features
    {
        class EmbossBuilder;
    }
    namespace Features
    {
        class Enlarge;
    }
    namespace Features
    {
        class EnlargeBuilder;
    }
    namespace Features
    {
        class Extension;
    }
    namespace Features
    {
        class ExtensionBuilder;
    }
    namespace Features
    {
        class ExtractFaceBuilder;
    }
    namespace Features
    {
        class ExtrudeBuilder;
    }
    namespace Features
    {
        class FaceBlendBuilder;
    }
namespace Features
    {
        class FeatureBuilder;
    }
    namespace Features
    {
        class FeatureGroup;
    }
    namespace Features
    {
        class FeatureReplayBuilder;
    }
    namespace Features
    {
        class FitCurve;
    }
    namespace Features
    {
        class FitCurveBuilder;
    }
    namespace Features
    {
        class FitSurface;
    }
    namespace Features
    {
        class FitSurfaceBuilder;
    }
    namespace Features
    {
        class Fixed;
    }
    namespace Features
    {
        class FixedBuilder;
    }
    namespace Features
    {
        class FlowBlend;
    }
    namespace Features
    {
        class FlowBlendBuilder;
    }
    namespace Features
    {
        class FreeTransformerBuilder;
    }
    namespace Features
    {
        class FreeformCurveCollection;
    }
    namespace Features
    {
        class FreeformSurfaceCollection;
    }
    namespace Features
    {
        class GCToolsFeatureCollection;
    }
    namespace Features
    {
        class GeneralConic;
    }
    namespace Features
    {
        class GeneralConicBuilder;
    }
    namespace Features
    {
        class GeodesicSketchCollection;
    }
    namespace Features
    {
        class GeomcopyBuilder;
    }
    namespace Features
    {
        class GlobalShaping;
    }
    namespace Features
    {
        class GlobalShapingBuilder;
    }
    namespace Features
    {
        class GroupBody;
    }
    namespace Features
    {
        class GroupBodyBuilder;
    }
    namespace Features
    {
        class GroupEdge;
    }
    namespace Features
    {
        class GroupEdgeBuilder;
    }
namespace Features
    {
        class GroupFace;
    }
    namespace Features
    {
        class GroupFaceBuilder;
    }
    namespace Features
    {
        class GuidedExtensionBuilderEx;
    }
    namespace Features
    {
        class Helix;
    }
    namespace Features
    {
        class HelixBuilder;
    }
    namespace Features
    {
        class HoleFeatureBuilder;
    }
    namespace Features
    {
        class HolePackage;
    }
    namespace Features
    {
        class HolePackageBuilder;
    }
    namespace Features
    {
        class HumanBuilder;
    }
    namespace Features
    {
        class IForm;
    }
    namespace Features
    {
        class IFormBuilder;
    }
    namespace Features
    {
        class ImprintObject;
    }
    namespace Features
    {
        class ImprintObjectBuilder;
    }
    namespace Features
    {
        class InstanceFeature;
    }
    namespace Features
    {
        class InstanceFeatureBuilder;
    }
    namespace Features
    {
        class IntersectionCurveBuilder;
    }
    namespace Features
    {
        class IsolateFeature;
    }
    namespace Features
    {
        class IsolateFeatureBuilder;
    }
    namespace Features
    {
        class IsoparametricCurves;
    }
    namespace Features
    {
        class IsoparametricCurvesBuilder;
    }
    namespace Features
    {
        class JoinCurvesBuilder;
    }
    namespace Features
    {
        class LabelChamfer;
    }
    namespace Features
    {
        class LabelChamferBuilder;
    }
    namespace Features
    {
        class LabelNotchBlend;
    }
    namespace Features
    {
        class LabelNotchBlendBuilder;
    }
namespace Features
    {
        class LatticeFeatureCollection;
    }
    namespace Features
    {
        class LawCurve;
    }
    namespace Features
    {
        class LawCurveBuilder;
    }
    namespace Features
    {
        class LawExtension;
    }
    namespace Features
    {
        class LawExtensionBuilder;
    }
    namespace Features
    {
        class LawExtensionBuilderEx;
    }
    namespace Features
    {
        class LinearDimension;
    }
    namespace Features
    {
        class LinearDimensionBuilder;
    }
    namespace Features
    {
        class LinkedFacet;
    }
    namespace Features
    {
        class LinkedFacetBuilder;
    }
    namespace Features
    {
        class MakeOffset;
    }
    namespace Features
    {
        class MakeOffsetBuilder;
    }
    namespace Features
    {
        class Maple;
    }
    namespace Features
    {
        class MapleBuilder;
    }
    namespace Features
    {
        class MasterCutBuilder;
    }
    namespace Features
    {
        class MatchEdge;
    }
    namespace Features
    {
        class MatchEdgeBuilder;
    }
    namespace Features
    {
        class MathIntegration;
    }
    namespace Features
    {
        class MathIntegrationBuilder;
    }
    namespace Features
    {
        class MeshSurfaceBuilder;
    }
    namespace Features
    {
        class MeshTransformerBuilder;
    }
    namespace Features
    {
        class MidSurfaceBuilder;
    }
    namespace Features
    {
        class MidSurfaceByFacePairsBuilder;
    }
    namespace Features
    {
        class MidSurfaceByTwoSheetsBuilder;
    }
    namespace Features
    {
        class MidSurfaceUserDefined;
    }
namespace Features
    {
        class MidSurfaceUserDefinedBuilder;
    }
    namespace Features
    {
        class Mirror;
    }
    namespace Features
    {
        class MirrorBodyBuilder;
    }
    namespace Features
    {
        class MirrorBuilder;
    }
    namespace Features
    {
        class MirrorCurveBuilder;
    }
    namespace Features
    {
        class MirrorFaceBuilder;
    }
    namespace Features
    {
        class MirrorFeatureBuilder;
    }
    namespace Features
    {
        class MorphMeshCollection;
    }
    namespace Features
    {
        class MoveBody;
    }
    namespace Features
    {
        class MoveBodyBuilder;
    }
    namespace Features
    {
        class MoveFaceBuilder;
    }
    namespace Features
    {
        class NSidedSurface;
    }
    namespace Features
    {
        class NSidedSurfaceBuilder;
    }
    namespace Features
    {
        class OffsetCurveBuilder;
    }
    namespace Features
    {
        class OffsetEmbossBuilder;
    }
    namespace Features
    {
        class OffsetFaceBuilder;
    }
    namespace Features
    {
        class OffsetRegionBuilder;
    }
    namespace Features
    {
        class OffsetSurfaceBuilder;
    }
    namespace Features
    {
        class OptimizeCurveBuilder;
    }
    namespace Features
    {
        class OptimizeFaceBuilder;
    }
    namespace Features
    {
        class OvercrownBuilder;
    }
    namespace Features
    {
        class PaintParametersBuilder;
    }
    namespace Features
    {
        class Parallel;
    }
    namespace Features
    {
        class ParallelBuilder;
    }
    namespace Features
    {
        class PartModule;
    }
namespace Features
    {
        class PartModuleBuilder;
    }
    namespace Features
    {
        class PasteFaceBuilder;
    }
    namespace Features
    {
        class PatchBuilder;
    }
    namespace Features
    {
        class PatchOpeningsBuilder;
    }
    namespace Features
    {
        class PatternBody;
    }
    namespace Features
    {
        class PatternBodyBuilder;
    }
    namespace Features
    {
        class PatternFaceBuilder;
    }
    namespace Features
    {
        class PatternFaceFeature;
    }
    namespace Features
    {
        class PatternFaceFeatureBuilder;
    }
    namespace Features
    {
        class PatternFeatureBuilder;
    }
    namespace Features
    {
        class PatternGeometry;
    }
    namespace Features
    {
        class PatternGeometryBuilder;
    }
    namespace Features
    {
        class Perpendicular;
    }
    namespace Features
    {
        class PerpendicularBuilder;
    }
    namespace Features
    {
        class PointSet;
    }
    namespace Features
    {
        class PointSetBuilder;
    }
    namespace Features
    {
        class PoleSmoothing;
    }
    namespace Features
    {
        class PoleSmoothingBuilder;
    }
    namespace Features
    {
        class PrintCsysFeatureCollection;
    }
    namespace Features
    {
        class ProjectCurveBuilder;
    }
    namespace Features
    {
        class Promotion;
    }
    namespace Features
    {
        class PromotionBuilder;
    }
    namespace Features
    {
        class PullFace;
    }
    namespace Features
    {
        class PullFaceBuilder;
    }
    namespace Features
    {
        class RPOBuilder;
    }
namespace Features
    {
        class RadialDimension;
    }
    namespace Features
    {
        class RadialDimensionBuilder;
    }
    namespace Features
    {
        class RadiateFace;
    }
    namespace Features
    {
        class RadiateFaceBuilder;
    }
    namespace Features
    {
        class RapidSurface;
    }
    namespace Features
    {
        class RapidSurfaceBuilder;
    }
    namespace Features
    {
        class RasterImage;
    }
    namespace Features
    {
        class ReferenceMapperBuilder;
    }
    namespace Features
    {
        class RefitFace;
    }
    namespace Features
    {
        class RefitFaceBuilder;
    }
    namespace Features
    {
        class RemoveParametersBuilder;
    }
    namespace Features
    {
        class ReorderBlends;
    }
    namespace Features
    {
        class ReorderBlendsBuilder;
    }
    namespace Features
    {
        class ReplaceBlend;
    }
    namespace Features
    {
        class ReplaceBlendBuilder;
    }
    namespace Features
    {
        class ReplaceFaceBuilder;
    }
    namespace Features
    {
        class ReplaceFeatureBuilder;
    }
    namespace Features
    {
        class ResizeBlendBuilder;
    }
    namespace Features
    {
        class ResizeChamfer;
    }
    namespace Features
    {
        class ResizeChamferBuilder;
    }
    namespace Features
    {
        class ResizeFaceBuilder;
    }
    namespace Features
    {
        class ResizeHole;
    }
    namespace Features
    {
        class ResizeHoleBuilder;
    }
    namespace Features
    {
        class ResizePattern;
    }
    namespace Features
    {
        class ResizePatternBuilder;
    }
namespace Features
    {
        class ResizePlaneBuilder;
    }
    namespace Features
    {
        class RevolveBuilder;
    }
    namespace Features
    {
        class RibbonBuilder;
    }
    namespace Features
    {
        class RuledBuilder;
    }
    namespace Features
    {
        class ScaleBuilder;
    }
    namespace Features
    {
        class SectionCurveBuilder;
    }
    namespace Features
    {
        class SectionEdit;
    }
    namespace Features
    {
        class SectionEditBuilder;
    }
    namespace Features
    {
        class SectionInertiaAnalysis;
    }
    namespace Features
    {
        class SectionInertiaAnalysisBuilder;
    }
    namespace Features
    {
        class SectionSurface;
    }
    namespace Features
    {
        class SectionSurfaceBuilder;
    }
    namespace Features
    {
        class SectionSurfaceBuilderEx;
    }
    namespace Features
    {
        class SewBuilder;
    }
    namespace Features
    {
        namespace SheetMetal
        {
            class AeroSheetmetalManager;
        }
    }
    namespace Features
    {
        namespace SheetMetal
        {
            class SheetmetalManager;
        }
    }
    namespace Features
    {
        class ShellBuilder;
    }
    namespace Features
    {
        class ShellFace;
    }
    namespace Features
    {
        class ShellFaceBuilder;
    }
    namespace Features
    {
        class ShipCollection;
    }
    namespace Features
    {
        class ShowRelatedFacesBuilder;
    }
    namespace Features
    {
        class SilhouetteFlange;
    }
    namespace Features
    {
        class SilhouetteFlangeBuilder;
    }
    namespace Features
    {
        class SketchConversionReport;
    }
namespace Features
    {
        class SketchFitCurveBuilder;
    }
    namespace Features
    {
        class SketchSplineBuilder;
    }
    namespace Features
    {
        class SmoothSpline;
    }
    namespace Features
    {
        class SmoothSplineBuilder;
    }
    namespace Features
    {
        class SnipSurface;
    }
    namespace Features
    {
        class SnipSurfaceBuilder;
    }
    namespace Features
    {
        class Sphere;
    }
    namespace Features
    {
        class SphereBuilder;
    }
    namespace Features
    {
        class SphericalCorner;
    }
    namespace Features
    {
        class SphericalCornerBuilder;
    }
    namespace Features
    {
        class SplitBody;
    }
    namespace Features
    {
        class SplitBodyBuilder;
    }
    namespace Features
    {
        class StepExpressionBuilder;
    }
    namespace Features
    {
        class StructureDesignCollection;
    }
    namespace Features
    {
        class StudioSpline;
    }
    namespace Features
    {
        class StudioSplineBuilder;
    }
    namespace Features
    {
        class StudioSplineBuilderEx;
    }
    namespace Features
    {
        class StudioSurfaceBuilder;
    }
    namespace Features
    {
        class StudioXform;
    }
    namespace Features
    {
        class StudioXformBuilderEx;
    }
    namespace Features
    {
        class StyledBlend;
    }
    namespace Features
    {
        class StyledBlendBuilder;
    }
    namespace Features
    {
        class StyledCorner;
    }
    namespace Features
    {
        class StyledCornerBuilder;
    }
    namespace Features
    {
        class StyledSweepBuilder;
    }
namespace Features
    {
        class SweepAlongGuide;
    }
    namespace Features
    {
        class SweepAlongGuideBuilder;
    }
    namespace Features
    {
        class SweepFeatureCollection;
    }
    namespace Features
    {
        class Swept;
    }
    namespace Features
    {
        class SweptBuilder;
    }
    namespace Features
    {
        class Symmetric;
    }
    namespace Features
    {
        class SymmetricBuilder;
    }
    namespace Features
    {
        class SynchronousCurveCollection;
    }
    namespace Features
    {
        class SynchronousEdgeCollection;
    }
    namespace Features
    {
        class Tangent;
    }
    namespace Features
    {
        class TangentBuilder;
    }
    namespace Features
    {
        class Text;
    }
    namespace Features
    {
        class TextBuilder;
    }
    namespace Features
    {
        class ThickenBuilder;
    }
    namespace Features
    {
        class Thread;
    }
    namespace Features
    {
        class ThreadBuilder;
    }
    namespace Features
    {
        class ThroughCurveMeshBuilder;
    }
    namespace Features
    {
        class ThroughCurvesBuilder;
    }
    namespace Features
    {
        class ToolingCollection;
    }
    namespace Features
    {
        class ToolingFeatureCollection;
    }
    namespace Features
    {
        class TrimBody2;
    }
    namespace Features
    {
        class TrimBody2Builder;
    }
    namespace Features
    {
        class TrimBodyBuilder;
    }
    namespace Features
    {
        class TrimCurve;
    }
    namespace Features
    {
        class TrimCurve2;
    }
namespace Features
    {
        class TrimCurve2Builder;
    }
    namespace Features
    {
        class TrimCurveBuilder;
    }
    namespace Features
    {
        class TrimExtendBuilder;
    }
    namespace Features
    {
        class TrimFeatureCollection;
    }
    namespace Features
    {
        class TrimSheetBuilder;
    }
    namespace Features
    {
        class TubeBuilder;
    }
    namespace Features
    {
        class Unsew;
    }
    namespace Features
    {
        class UnsewBuilder;
    }
    namespace Features
    {
        class UntrimBuilder;
    }
    namespace Features
    {
        class UserDefinedObjectFeatureBuilder;
    }
    namespace Features
    {
        class VarOffsetFace;
    }
    namespace Features
    {
        class VarOffsetFaceBuilder;
    }
    namespace Features
    {
        class VariableOffset;
    }
    namespace Features
    {
        class VariableOffsetBuilder;
    }
    namespace Features
    {
        class VarsweepBuilder;
    }
    namespace Features
    {
        class VehicleDesignCollection;
    }
    namespace Features
    {
        class VirtualBlendEdgeBuilder;
    }
    namespace Features
    {
        class VirtualCurve;
    }
    namespace Features
    {
        class VirtualCurveBuilder;
    }
    namespace Features
    {
        class WaveDatumBuilder;
    }
    namespace Features
    {
        class WavePointBuilder;
    }
    namespace Features
    {
        class WaveRoutingBuilder;
    }
    namespace Features
    {
        class WaveSketchBuilder;
    }
    namespace Features
    {
        class WrapBuilder;
    }
    namespace Features
    {
        class WrapGeometry;
    }
namespace Features
    {
        class WrapGeometryBuilder;
    }
    namespace Features
    {
        class WrapUnwrap;
    }
    namespace GeometricUtilities
    {
        class ConvertFeatureGroupsToDesignGroupsBuilder;
    }
    namespace GeometricUtilities
    {
        class ConvertFeatureGroupsToModulesBuilder;
    }
    namespace GeometricUtilities
    {
        class MoveToGroupBuilder;
    }
    namespace GeometricUtilities
    {
        class NestModuleBuilder;
    }
    namespace GeometricUtilities
    {
        class PartModuleRelationshipBuilder;
    }
    namespace GeometricUtilities
    {
        class RenameLinkedPartModulePartBuilder;
    }
    namespace GeometricUtilities
    {
        class RenewFeatureBuilder;
    }
    namespace GeometricUtilities
    {
        class UnnestModuleBuilder;
    }
    class HumanPosturePrediction;
    class HumanPosturePredictionBuilder;
    class NXObject;
    class Spline;
    namespace Weld
    {
        class WeldManager;
    }
    namespace Features
    {
        class FeatureCollectionImpl;
        class NXOPENCPP_FEATURESEXPORT  FeatureCollection : public NXOpen::TaggedObjectCollection
        {
            public: enum ReorderType
            {
                ReorderTypeInto ,
                ReorderTypeBefore ,
                ReorderTypeAfter
            };
            private: FeatureCollectionImpl * m_featurecollection_impl;
            private: NXOpen::BasePart* m_owner;
            public: explicit FeatureCollection(NXOpen::BasePart *owner);
            public:
            tag_t Tag() const;
            public: ~FeatureCollection();
            //lint -sem(NXOpen::Features::FeatureCollection::iterator::copy,initializer)
            class iterator : public std::iterator<std::forward_iterator_tag, NXOpen::Features::Feature *>
            {
            public:
                iterator() : m_context(nullptr), m_current(NULL_TAG)
                {
                    // coverity[uninit_member]
                } //lint !e1401 m_state 未初始化

                explicit iterator(NXOpen::Features::FeatureCollection *context) : m_context(context), m_current(NULL_TAG)
                {
                    // coverity[uninit_member]
                }//lint !e1401 m_state 未初始化

                iterator(const iterator &other): m_context(nullptr), m_current(NULL_TAG)
                {
                    copy(other);
                }

                iterator &operator =(const iterator &other)
                {
                    if (&other != this)
copy(other);
                    return *this;
                }

                bool operator ==(const iterator &other) const
                {
                    return m_current == other.m_current && m_context == other.m_context;
                }

                bool operator !=(const iterator &other) const
                {
                    return !operator == (other);
                }

                NXOPENCPP_FEATURESEXPORT  value_type operator * () const;
                iterator & operator ++()
                {
                    next();
                    return *this;
                }

                iterator operator ++(int)
                {
                    iterator tmp(*this);
                    ++*this;
                    return tmp;
                }
            private:
                void copy(const iterator &other)
                {
                    m_context = other.m_context;
                    m_current = other.m_current;
                    for (int i = 0; i < sizeof(m_state)/sizeof(m_state[0]); i++)
                         m_state[i] = other.m_state[i];
                }
                NXOPENCPP_FEATURESEXPORT  void next();
                NXOpen::Features::FeatureCollection *m_context;
                tag_t m_current;
                unsigned int m_state[8];
            };

            iterator begin();
            iterator end()
            {
                return iterator(this);
            }

            public: NXOpen::Features::MeshSurfaceBuilder * CreateMeshSurfaceBuilder
            (
                NXOpen::Features::Feature * meshSurf 
            );
            public: NXOpen::Features::BlockFeatureBuilder * CreateBlockFeatureBuilder
            (
                NXOpen::Features::Feature * block 
            );
            public: NXOpen::Features::CopyPasteBuilder * CreateCopyPasteBuilder
            (
                const std::vector<NXOpen::NXObject *> & features 
            );
            public: NXOpen::Features::ReferenceMapperBuilder * CreateReferenceMapperBuilder
            (
                NXOpen::Features::FeatureBuilder * booleanBuilderTag 
            );
            public: NXOpen::Features::ExtrudeBuilder * CreateExtrudeBuilder
            (
                NXOpen::Features::Feature * extrude 
            );
            public: NXOpen::Features::UserDefinedObjectFeatureBuilder * CreateUserDefinedObjectFeatureBuilder
            (
                NXOpen::Features::Feature * udoFeature 
            );
            public: NXOpen::Features::RevolveBuilder * CreateRevolveBuilder
            (
                NXOpen::Features::Feature * revolve 
            );
            public: NXOpen::Features::EmbossBuilder * CreateEmbossBuilder
            (
                NXOpen::Features::Feature * emboss 
            );
            public: NXOpen::Features::OffsetEmbossBuilder * CreateOffsetEmbossBuilder
            (
                NXOpen::Features::Feature * offsetEmboss 
            );
            public: NXOpen::Features::DividefaceBuilder * CreateDividefaceBuilder
            (
                NXOpen::Features::Feature * divideface 
            );
            public: NXOpen::Features::OvercrownBuilder * CreateOvercrownFeatureBuilder
            (
                NXOpen::Features::Feature * overcrown 
            );
            public: NXOpen::Features::CurveLengthBuilder * CreateCurvelengthBuilder
            (
                NXOpen::Features::Feature * curvelength 
            );
            public: NXOpen::Features::DatumAxisBuilder * CreateDatumAxisBuilder
            (
                NXOpen::Features::Feature * datumAxis 
            );
            public: NXOpen::Features::DatumPlaneBuilder * CreateDatumPlaneBuilder
            (
                NXOpen::Features::Feature * dplane 
            );
            public: NXOpen::Features::ResizePlaneBuilder * CreateResizePlaneBuilder
            (
                NXOpen::Features::Feature * resizePlane 
            );
            public: NXOpen::Features::HoleFeatureBuilder * CreateHoleFeatureBuilder
            (
                NXOpen::Features::Feature * hole 
            );
            public: NXOpen::Features::RPOBuilder * CreateRpoBuilder
            (
                NXOpen::Features::Feature * rpo 
            );
            public: NXOpen::Features::ChamferBuilder * CreateChamferBuilder
            (
                NXOpen::Features::Feature * chamfer 
            );
            public: NXOpen::Features::EdgeBlendBuilder * CreateEdgeBlendBuilder
            (
                NXOpen::Features::Feature * edgeblend 
            );
            public: std::vector<NXOpen::Features::BooleanFeature *> CreateUniteFeature
            (
                NXOpen::Body * targetBody ,
                bool retainTargetBody ,
                const std::vector<NXOpen::Body *> & toolBodies ,
                bool retainToolBodies ,
                bool allowNonAssociativeBoolean ,
                bool* nonAssociativeBoolean ,
                bool* unparameterizedSolids 
            );
            public: std::vector<NXOpen::Features::BooleanFeature *> CreateSubtractFeature
            (
                NXOpen::Body * targetBody ,
                bool retainTargetBody ,
                const std::vector<NXOpen::Body *> & toolBodies ,
                bool retainToolBodies ,
                bool allowNonAssociativeBoolean ,
                bool* nonAssociativeBoolean ,
                bool* unparameterizedSolids 
            );
            public: std::vector<NXOpen::Features::BooleanFeature *> CreateIntersectFeature
            (
                NXOpen::Body * targetBody ,
                bool retainTargetBody ,
                const std::vector<NXOpen::Body *> & toolBodies ,
                bool retainToolBodies ,
                bool allowNonAssociativeBoolean ,
                bool* nonAssociativeBoolean ,
                bool* unparameterizedSolids 
            );
            public: NXOpen::Features::VarsweepBuilder * CreateVarsweepBuilder
            (
                NXOpen::Features::Feature * varsweep 
            );
            public: NXOpen::Features::FaceBlendBuilder * CreateFaceBlendBuilder
            (
                NXOpen::Features::Feature * faceBlend 
            );
            public: std::vector<NXOpen::Features::Feature *> GetFeatures
            (
            );
            public: NXOpen::Features::Feature * FindObject
            (
                const NXString & journalIdentifier 
            );
            NXOpen::Features::Feature * FindObject
            (
                const char * journalIdentifier 
            );
            public: void SuppressFeatures
            (
                const std::vector<NXOpen::Features::Feature *> & features 
            );
            public: std::vector<NXOpen::Features::Feature *> UnsuppressFeatures
            (
                const std::vector<NXOpen::Features::Feature *> & features 
            );
            public: NXOpen::ErrorList * CreateSnapshotsOfFeatures
            (
                const std::vector<NXOpen::Features::Feature *> & features 
            );
            public: void DeleteSnapshot
            (
                NXOpen::Features::Feature * feature 
            );
            public: NXOpen::Features::Feature * GetAssociatedFeature
            (
                NXOpen::NXObject * object 
            );
            public: NXOpen::Features::HumanBuilder * CreateHumanBuilder
            (
                NXOpen::Features::Feature * human 
            );
            public: NXOpen::HumanPosturePredictionBuilder * CreateHumanPosturePredictionBuilder
            (
                NXOpen::HumanPosturePrediction * posturePrediction 
            );
            public: NXOpen::Features::OffsetSurfaceBuilder * CreateOffsetSurfaceBuilder
            (
                NXOpen::Features::Feature * offsetSurface 
            );
            public: NXOpen::Features::RibbonBuilder * CreateRibbonBuilder
            (
                NXOpen::Features::Feature * ribbon 
            );
            public: NXOpen::Features::PatchBuilder * CreatePatchBuilder
            (
                NXOpen::Features::Feature * patch 
            );
            public: NXOpen::Features::BooleanBuilder * CreateBooleanBuilder
            (
                NXOpen::Features::BooleanFeature * booleanFeature 
            );
            public: NXOpen::Features::BooleanBuilder * CreateBooleanBuilderUsingCollector
            (
                NXOpen::Features::BooleanFeature * booleanFeature 
            );
            public: NXOpen::Features::TrimBodyBuilder * CreateTrimBodyBuilder
            (
                NXOpen::Features::Feature * trimbodyFeat 
            );
            public: NXOpen::Features::ShellBuilder * CreateShellBuilder
            (
                NXOpen::Features::Feature * shell 
            );
            public: NXOpen::Features::DatumCsysBuilder * CreateDatumCsysBuilder
            (
                NXOpen::Features::Feature * datumCsys 
            );
            public: NXOpen::Features::DraftBuilder * CreateDraftBuilder
            (
                NXOpen::Features::Feature * draft 
            );
            public: NXOpen::Features::RasterImage * CreateRasterImage
            (
                const NXOpen::Point3d & origin ,
                const NXOpen::Matrix3x3 & matrix ,
                double length ,
                double height ,
                const NXString & imageFileName ,
                double translucency ,
                NXOpen::Features::RasterImage::MaxTextureSize maximumTextureSize 
            );
            NXOpen::Features::RasterImage * CreateRasterImage
            (
                const NXOpen::Point3d & origin ,
                const NXOpen::Matrix3x3 & matrix ,
                double length ,
                double height ,
                const char * imageFileName ,
                double translucency ,
                NXOpen::Features::RasterImage::MaxTextureSize maximumTextureSize 
            );
            public: NXOpen::Features::MasterCutBuilder * CreateMasterCutBuilder
            (
                NXOpen::Features::Feature * masterCut 
            );
            public: NXOpen::Features::AOCSBuilder * CreateAocsBuilder
            (
                NXOpen::Features::Feature * aocs 
            );
            public: NXOpen::Features::OffsetFaceBuilder * CreateOffsetFaceBuilder
            (
                NXOpen::Features::Feature * offsetface 
            );
            public: NXOpen::Features::TubeBuilder * CreateTubeBuilder
            (
                NXOpen::Features::Feature * tube 
            );
            public: NXOpen::Features::MirrorFeatureBuilder * CreateMirrorFeatureBuilder
            (
                NXOpen::Features::Feature * mirrorFea 
            );
            public: NXOpen::Features::MirrorBuilder * CreateMirrorBuilder
            (
                NXOpen::Features::Mirror * mirrorFeature 
            );
            public: NXOpen::Features::ScaleBuilder * CreateScaleBuilder
            (
                NXOpen::Features::Feature * scale 
            );
            public: NXOpen::Features::SewBuilder * CreateSewBuilder
            (
                NXOpen::Features::Feature * sew 
            );
            public: NXOpen::Features::SectionCurveBuilder * CreateSectionCurveBuilder
            (
                NXOpen::Features::Feature * sectionCurves 
            );
            public: NXOpen::Features::IntersectionCurveBuilder * CreateIntersectionCurveBuilder
            (
                NXOpen::Features::Feature * intersectionCurve 
            );
            public: NXOpen::Features::ThickenBuilder * CreateThickenBuilder
            (
                NXOpen::Features::Feature * thicken 
            );
            public: NXOpen::Features::TrimExtendBuilder * CreateTrimExtendBuilder
            (
                NXOpen::Features::Feature * trimExtend 
            );
            public: NXOpen::Features::GeomcopyBuilder * CreateGeomcopyBuilder
            (
                NXOpen::Features::Feature * geomcopy 
            );
            public: NXOpen::Features::ProjectCurveBuilder * CreateProjectCurveBuilder
            (
                NXOpen::Features::Feature * projectCurve 
            );
            public: NXOpen::Features::ExtractFaceBuilder * CreateExtractFaceBuilder
            (
                NXOpen::Features::Feature * copyFace 
            );
            public: NXOpen::Features::JoinCurvesBuilder * CreateJoinCurvesBuilder
            (
                NXOpen::Features::Feature * joinCurves 
            );
            public: NX_DEPRECATED("Deprecated in NX8.0.0.  Use NXOpen::Features::FeatureCollection::CreateStudioSplineBuilderEx instead.") NXOpen::Features::StudioSplineBuilder * CreateStudioSplineBuilder
            (
                NXOpen::Features::StudioSpline * splineFeature 
            );
            public: NXOpen::Features::CurveOnSurfaceBuilder * CreateCurveOnSurfaceBuilder
            (
                NXOpen::Features::CurveOnSurface * cosFeature 
            );
            public: NXOpen::Features::UntrimBuilder * CreateUntrimBuilder
            (
                NXOpen::Features::Feature * untrim 
            );
            public: NXOpen::Features::WaveDatumBuilder * CreateWaveDatumBuilder
            (
                NXOpen::Features::Feature * wavedatum 
            );
            public: NXOpen::Features::WaveSketchBuilder * CreateWaveSketchBuilder
            (
                NXOpen::Features::Feature * wavesketch 
            );
            public: NXOpen::Features::WaveRoutingBuilder * CreateWaveRoutingBuilder
            (
                NXOpen::Features::Feature * waverouting 
            );
            public: NXOpen::Features::WavePointBuilder * CreateWavePointBuilder
            (
                NXOpen::Features::Feature * wavepoint 
            );
            public: NXOpen::Features::TrimSheetBuilder * CreateTrimsheetBuilder
            (
                NXOpen::Features::Feature * trimSheet 
            );
            public: NXOpen::Features::CircularBlendCurveBuilder * CreateCircularBlendCurveBuilder
            (
                NXOpen::Features::CircularBlendCurve * circularBlendCurve 
            );
            public: NXOpen::Features::RapidSurfaceBuilder * CreateRapidSurfaceBuilder
            (
                NXOpen::Features::RapidSurface * rapidSurface 
            );
            public: NXOpen::Features::UnsewBuilder * CreateUnsewBuilder
            (
                NXOpen::Features::Unsew * unsew 
            );
            public: NXOpen::Features::MirrorBodyBuilder * CreateMirrorBodyBuilder
            (
                NXOpen::Features::Feature * mirrorBody 
            );
            public: NXOpen::Features::DraftBodyBuilder * CreateDraftBodyBuilder
            (
                NXOpen::Features::Feature * draftBody 
            );
            public: std::vector<NXOpen::Features::Feature *> GetPartFeaturesWithNewAlerts
            (
            );
            public: std::vector<NXOpen::Features::Feature *> GetAllPartFeaturesWithAlerts
            (
            );
            public: NXOpen::Features::GlobalShapingBuilder * CreateGlobalShapingBuilder
            (
                NXOpen::Features::GlobalShaping * globalShaping 
            );
            public: NXOpen::Features::TrimCurveBuilder * CreateTrimCurveBuilder
            (
                NXOpen::Features::TrimCurve * trimCurve 
            );
            public: NXOpen::Features::TrimCurveBuilder * CreateTrimCurveBuilder
            (
                NXOpen::Spline * trimCurve 
            );
            public: NXOpen::Features::OffsetCurveBuilder * CreateOffsetCurveBuilder
            (
                NXOpen::Features::Feature * offsetCurve 
            );
            public: void DeleteAllPartInformationalFeatureAlerts
            (
            );
            public: NXOpen::Features::ThroughCurveMeshBuilder * CreateThroughCurveMeshBuilder
            (
                NXOpen::Features::Feature * throughCurveMesh 
            );
            public: NX_DEPRECATED("在 NX8.5.0 版本中已废弃。请使用 NXOpen::Features::FeatureCollection::CreateBridgeCurveBuilderEx 替代。") NXOpen::Features::BridgeCurveBuilder * CreateBridgeCurveBuilder
            (
                NXOpen::Features::Feature * bridgeCurve 
            );
            public: NXOpen::Features::SweptBuilder * CreateSweptBuilder
            (
                NXOpen::Features::Swept * swept 
            );
            public: NXOpen::Features::CylinderBuilder * CreateCylinderBuilder
            (
                NXOpen::Features::Feature * cylinder 
            );
            public: NXOpen::Features::CompositeCurveBuilder * CreateCompositeCurveBuilder
            (
                NXOpen::Features::Feature * compositeCurve 
            );
            public: NXOpen::Features::ThroughCurvesBuilder * CreateThroughCurvesBuilder
            (
                NXOpen::Features::Feature * throughCurves 
            );
            public: NXOpen::Features::StudioSurfaceBuilder * CreateStudioSurfaceBuilder
            (
                NXOpen::Features::Feature * studioSurface 
            );
            public: NXOpen::Features::SectionInertiaAnalysisBuilder * CreateSectionInertiaAnalysisBuilder
            (
                NXOpen::Features::SectionInertiaAnalysis * sectionInertiaAnalysis 
            );
            public: bool GetIsMasterCutVisibleInView
            (
                NXOpen::Features::Feature * masterCut ,
                NXOpen::CutView * view 
            );
            public: NXOpen::Features::DeleteFaceBuilder * CreateDeleteFaceBuilder
            (
                NXOpen::Features::Feature * deleteFace 
            );
            public: NXOpen::Features::ResizeBlendBuilder * CreateResizeBlendBuilder
            (
                NXOpen::Features::Feature * resizeBlend 
            );
            public: NXOpen::Features::PatchOpeningsBuilder * CreatePatchOpeningsBuilder
            (
                NXOpen::Features::Feature * patchOpenings 
            );
            public: NXOpen::Features::MoveFaceBuilder * CreateMoveFaceBuilder
            (
                NXOpen::Features::Feature * moveFace 
            );
            public: NXOpen::Features::OffsetRegionBuilder * CreateOffsetRegionBuilder
            (
                NXOpen::Features::Feature * offsetRegion 
            );
            public: NXOpen::Features::PatternFaceBuilder * CreatePatternFaceBuilder
            (
                NXOpen::Features::Feature * patternFace 
            );
            public: NXOpen::Features::ResizeFaceBuilder * CreateResizeFaceBuilder
            (
                NXOpen::Features::Feature * resizeFace 
            );
            public: NXOpen::Features::ReplaceFaceBuilder * CreateReplaceFaceBuilder
            (
                NXOpen::Features::Feature * replaceFace 
            );
            public: NXOpen::Features::RuledBuilder * CreateRuledBuilder
            (
                NXOpen::Features::Feature * ruled 
            );
            public: NXOpen::Features::NSidedSurfaceBuilder * CreateNSidedSurfaceBuilder
            (
                NXOpen::Features::NSidedSurface * nsidedSurface 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Use NXOpen::Features::FeatureCollection::CreateSectionSurfaceBuilderEx instead.") NXOpen::Features::SectionSurfaceBuilder * CreateSectionSurfaceBuilder
            (
                NXOpen::Features::SectionSurface * sectionSurface 
            );
            public: NXOpen::Features::CoplanarBuilder * CreateCoplanarBuilder
            (
                NXOpen::Features::Feature * coplanar 
            );
            public: NXOpen::Features::SnipSurfaceBuilder * CreateSnipSurfaceBuilder
            (
                NXOpen::Features::SnipSurface * snipSurface 
            );
            public: NXOpen::Features::LinearDimensionBuilder * CreateLinearDimensionBuilder
            (
                NXOpen::Features::LinearDimension * linearDimension 
            );
            public: NXOpen::Features::EnlargeBuilder * CreateEnlargeBuilder
            (
                NXOpen::Features::Enlarge * enlargeFeature 
            );
            public: NXOpen::Features::LawExtensionBuilder * CreateLawExtensionBuilder
            (
                NXOpen::Features::LawExtension * lawExtension 
            );
            public: NXOpen::Features::LawExtensionBuilderEx * CreateLawExtensionBuilderEx
            (
                NXOpen::Features::Feature * lawExtension 
            );
            public: NXOpen::Features::GuidedExtensionBuilderEx * CreateGuidedExtensionBuilderEx
            (
                NXOpen::Features::Feature * guidedExtension 
            );
            public: NXOpen::Features::FreeTransformerBuilder * CreateFreeTransformerBuilder
            (
                NXOpen::Features::Feature * freeTransformer 
            );
            public: NXOpen::Features::MeshTransformerBuilder * CreateMeshTransformerBuilder
            (
                NXOpen::Features::Feature * meshTransformer 
            );
            public: NXOpen::Features::CombinedProjectionBuilder * CreateCombinedProjectionBuilder
            (
                NXOpen::Features::CombinedProjection * combinedProjection 
            );
            public: NXOpen::Features::StyledSweepBuilder * CreateStyledSweepBuilder
            (
                NXOpen::Features::Feature * styledSweep 
            );
            public: NXOpen::Features::CutFaceBuilder * CreateCutFaceBuilder
            (
                NXOpen::Features::Feature * cutFace 
            );
            public: NXOpen::Features::ConeBuilder * CreateConeBuilder
            (
                NXOpen::Features::Cone * cone 
            );
            public: NXOpen::Features::SphereBuilder * CreateSphereBuilder
            (
                NXOpen::Features::Sphere * sphere 
            );
            public: NXOpen::Features::CopyFaceBuilder * CreateCopyFaceBuilder
            (
                NXOpen::Features::Feature * copyFace 
            );
            public: NXOpen::Features::PasteFaceBuilder * CreatePasteFaceBuilder
            (
                NXOpen::Features::Feature * pasteFace 
            );
            public: NXOpen::Features::PoleSmoothingBuilder * CreatePoleSmoothingBuilder
            (
                NXOpen::Features::PoleSmoothing * poleSmoothing 
            );
            public: NXOpen::Features::AdmMoveFaceBuilder * CreateAdmMoveFaceBuilder
            (
                NXOpen::Features::AdmMoveFace * admMoveFace 
            );
            public: NXOpen::Features::WrapGeometryBuilder * CreateWrapGeometryBuilder
            (
                NXOpen::Features::WrapGeometry * wrapGeometry 
            );
            public: NXOpen::Features::GroupFaceBuilder * CreateGroupFaceBuilder
            (
                NXOpen::Features::GroupFace * groupFace 
            );
            public: NXOpen::Features::ColorFaceBuilder * CreateColorFaceBuilder
            (
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Use Features::VehicleDesignCollection::CreateSeatBeltAnchorageBuilder instead.") NXOpen::Features::FeatureBuilder * CreateSeatBeltAnchorageBuilder
            (
                NXOpen::Features::Feature * seatBeltAnchorage 
            );
            public: NXOpen::Features::BoundedPlaneBuilder * CreateBoundedPlaneBuilder
            (
                NXOpen::Features::BoundedPlane * boundedPlane 
            );
            public: NXOpen::Features::AssemblyCutBuilder * CreateAssemblyCutBuilder
            (
                NXOpen::Features::AssemblyCut * assemblyCut 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Use NXOpen::Features::VehicleDesignCollection::CreateReflectionDataBuilder instead.") NXOpen::Features::FeatureBuilder * CreateReflectionDataBuilder
            (
                NXOpen::Features::Feature * reflectionData 
            );
            public: NXOpen::Features::WrapBuilder * CreateWrapBuilder
            (
                NXOpen::Features::WrapUnwrap * wrap 
            );
            public: NXOpen::Features::RemoveParametersBuilder * CreateRemoveParametersBuilder
            (
            );
            public: NXOpen::Features::MatchEdgeBuilder * CreateMatchEdgeBuilder
            (
                NXOpen::Features::MatchEdge * matchEdge 
            );
            public: NXOpen::Features::RadialDimensionBuilder * CreateRadialDimensionBuilder
            (
                NXOpen::Features::RadialDimension * radialDimension 
            );
            public: NXOpen::Features::StyledBlendBuilder * CreateStyledBlendBuilder
            (
                NXOpen::Features::StyledBlend * styledBlend 
            );
            public: NXOpen::Features::HolePackageBuilder * CreateHolePackageBuilder
            (
                NXOpen::Features::HolePackage * holePackage 
            );
            public: NXOpen::Features::StudioXformBuilderEx * CreateStudioXformBuilderEx
            (
                NXOpen::Features::StudioXform * studioXform1 
            );
            public: NXOpen::Features::SweepAlongGuideBuilder * CreateSweepAlongGuideBuilder
            (
                NXOpen::Features::SweepAlongGuide * sweepAlongGuide 
            );
            public: NXOpen::Features::ParallelBuilder * CreateParallelBuilder
            (
                NXOpen::Features::Parallel * parallel 
            );
            public: NXOpen::Features::CoaxialBuilder * CreateCoaxialBuilder
            (
                NXOpen::Features::Coaxial * coaxial 
            );
            public: NXOpen::Features::PerpendicularBuilder * CreatePerpendicularBuilder
            (
                NXOpen::Features::Perpendicular * perpendicular 
            );
            public: NXOpen::Features::TangentBuilder * CreateTangentBuilder
            (
                NXOpen::Features::Tangent * tangent 
            );
            public: NXOpen::Features::AdmResizeFaceBuilder * CreateAdmResizeFaceBuilder
            (
                NXOpen::Features::AdmResizeFace * admResizeFace 
            );
            public: NXOpen::Features::StyledCornerBuilder * CreateStyledCornerBuilder
            (
                NXOpen::Features::StyledCorner * styledCorner 
            );
            public: NXOpen::Features::AdmOffsetRegionBuilder * CreateAdmOffsetRegionBuilder
            (
                NXOpen::Features::AdmOffsetRegion * offsetRegion 
            );
            public: NXOpen::Features::MirrorFaceBuilder * CreateMirrorFaceBuilder
            (
                NXOpen::Features::Feature * mirrorFace 
            );
            public: NXOpen::Features::PointSetBuilder * CreatePointSetBuilder
            (
                NXOpen::Features::PointSet * pointSet 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Use NXOpen::Features::VehicleDesignCollection::CreateWindshieldDatumBuilder  instead.") NXOpen::Features::FeatureBuilder * CreateWindshieldDatumBuilder
            (
                NXOpen::Features::Feature * windshieldDatum 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Use NXOpen::Features::VehicleDesignCollection::CreateVisionPlaneBuilder instead.") NXOpen::Features::FeatureBuilder * CreateVisionPlaneBuilder
            (
                NXOpen::Features::Feature * visionPlane 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Use NXOpen::Features::VehicleDesignCollection::CreateHoodVisibilityBuilder instead.") NXOpen::Features::FeatureBuilder * CreateHoodVisibilityBuilder
            (
                NXOpen::Features::Feature * hoodVisibility 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Use NXOpen::Features::VehicleDesignCollection::CreatePedestrianProtectionBuilder  instead.") NXOpen::Features::FeatureBuilder * CreatePedestrianProtectionBuilder
            (
                NXOpen::Features::Feature * pedestrianProtection 
            );
            public: void SuspendModelDelayBeforeReorder
            (
            );
            public: void ReorderFeature
            (
                const std::vector<NXOpen::Features::Feature *> & features ,
                NXOpen::Features::Feature * target ,
                NXOpen::Features::FeatureCollection::ReorderType beforeOrAfter 
            );
            public: void RestoreModelDelayAfterReorder
            (
            );
            public: NXOpen::Features::MirrorCurveBuilder * CreateMirrorCurveBuilder
            (
                NXOpen::Features::Feature * mirrorCurve 
            );
            public: NXOpen::Features::PromotionBuilder * CreatePromotionBuilder
            (
                NXOpen::Features::Promotion * promotion 
            );
            public: NXOpen::Features::RefitFaceBuilder * CreateRefitFaceBuilder
            (
                NXOpen::Features::RefitFace * refitFace 
            );
            public: NXOpen::Features::EditDimensionBuilder * CreateEditDimensionBuilder
            (
            );
            public: NXOpen::Features::AdaptiveShellBuilder * CreateAdaptiveShellBuilder
            (
                NXOpen::Features::AdaptiveShell * shellFace 
            );
            public: NXOpen::Features::ShellFaceBuilder * CreateShellFaceBuilder
            (
                NXOpen::Features::ShellFace * shellFace 
            );
            public: NXOpen::Features::ChangeShellThicknessBuilder * CreateChangeShellThicknessBuilder
            (
                NXOpen::Features::ChangeShellThickness * shellFace 
            );
            public: NXOpen::Features::LinkedFacetBuilder * CreateLinkedFacetBuilder
            (
                NXOpen::Features::LinkedFacet * linkedFacet 
            );
            public: NXOpen::Features::SilhouetteFlangeBuilder * CreateSilhouetteFlangeBuilder
            (
                NXOpen::Features::SilhouetteFlange * silhouetteFlange 
            );
            public: NXOpen::Features::ReplaceFeatureBuilder * CreateReplaceFeatureBuilder
            (
            );
            public: NXOpen::Features::PaintParametersBuilder * CreatePaintParametersBuilder
            (
            );
            public: NXOpen::Features::SmoothSplineBuilder * CreateSmoothSplineBuilder
            (
                NXOpen::Features::SmoothSpline * smoothSpline 
            );
            public: NXOpen::Features::SymmetricBuilder * CreateSymmetricBuilder
            (
                NXOpen::Features::Symmetric * symmetric 
            );
            public: NXOpen::Features::FeatureReplayBuilder * CreateFeatureReplayBuilder
            (
            );
            public: NXOpen::Features::SplitBodyBuilder * CreateSplitBodyBuilder
            (
                NXOpen::Features::SplitBody * splitBody 
            );
            public: NXOpen::Features::SplitBodyBuilder * CreateSplitBodyBuilderUsingCollector
            (
                NXOpen::Features::SplitBody * splitBody 
            );
            public: NXOpen::Features::TrimBody2Builder * CreateTrimBody2Builder
            (
                NXOpen::Features::TrimBody2 * trimBody2 
            );
            public: NXOpen::Features::AngularDimBuilder * CreateAngularDimensionBuilder
            (
                NXOpen::Features::AngularDim * angularDimension 
            );
            public: NXOpen::Features::SectionEditBuilder * CreateSectionEditBuilder
            (
                NXOpen::Features::SectionEdit * sectionEdit 
            );
            public: NXOpen::Features::PullFaceBuilder * CreatePullFaceBuilder
            (
                NXOpen::Features::PullFace * pullFace 
            );
            public: NXOpen::Features::MidSurfaceByFacePairsBuilder * CreateMidSurfaceByFacePairsBuilder
            (
                NXOpen::Features::Feature * midSurfaceByFacePairs 
            );
            public: NXOpen::Features::MidSurfaceBuilder * CreateMidSurfaceBuilder
            (
                NXOpen::Features::Feature * midSurface 
            );
            public: NXOpen::Features::MidSurfaceByTwoSheetsBuilder * CreateMidSurfaceByTwoSheetsBuilder
            (
                NXOpen::Features::Feature * midSurfaceByTwoSheets 
            );
            public: NXOpen::Features::MidSurfaceUserDefinedBuilder * CreateMidSurfaceUserDefinedBuilder
            (
                NXOpen::Features::MidSurfaceUserDefined * midsurfaceUserDefined 
            );
            public: NXOpen::Features::PatternFeatureBuilder * CreatePatternFeatureBuilder
            (
                NXOpen::Features::Feature * patternFeature 
            );
            public: NXOpen::Features::InstanceFeatureBuilder * CreateInstanceFeatureBuilder
            (
                NXOpen::Features::InstanceFeature * instanceFeature 
            );
            public: NXOpen::Features::InstanceFeatureBuilder * CreateInstanceFeatureBuilder
            (
                const std::vector<NXOpen::Features::InstanceFeature *> & instanceFeatures ,
                bool forClocking 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Use Features::VehicleDesignCollection::CreateHoodVisibilityBuilder instead.") NXOpen::Features::FeatureBuilder * CreateVehicleCoordinateSystemBuilder
            (
                NXOpen::Features::Feature * vehicleCoordinateSystem 
            );
            public: NXOpen::Features::AestheticFaceBlendBuilder * CreateAestheticFaceBlendBuilder
            (
                NXOpen::Features::AestheticFaceBlend * aestheticFaceBlend 
            );
            public: NXOpen::Features::EdgeSymmetryBuilder * CreateEdgeSymmetryBuilder
            (
                NXOpen::Features::Feature * edgeSymmetry 
            );
            public: NXOpen::Features::ReplaceBlendBuilder * CreateReplaceBlendBuilder
            (
                NXOpen::Features::ReplaceBlend * replaceBlend 
            );
            public: NXOpen::Features::SketchConversionReport * ReplaceWithIndependentSketch
            (
                const std::vector<NXOpen::Features::Feature *> & features 
            );
            public: NXOpen::Features::MakeOffsetBuilder * CreateMakeOffsetBuilder
            (
                NXOpen::Features::MakeOffset * makeOffset 
            );
            public: NXOpen::Features::OptimizeFaceBuilder * CreateOptimizeFaceBuilder
            (
            );
            public: NXOpen::Features::ShowRelatedFacesBuilder * CreateShowRelatedFacesBuilder
            (
            );
            public: NXOpen::Features::FixedBuilder * CreateFixedBuilder
            (
                NXOpen::Features::Fixed * makeFix 
            );
            public: NXOpen::Features::LabelChamferBuilder * CreateLabelChamferBuilder
            (
                NXOpen::Features::LabelChamfer * labelChamfer 
            );
            public: NXOpen::Features::ResizeChamferBuilder * CreateResizeChamferBuilder
            (
                NXOpen::Features::ResizeChamfer * resizeChamfer 
            );
            public: NX_DEPRECATED("Deprecated in NX12.0.0.  Use NXOpen::Features::FeatureCollection::CreateMathIntegrationBuilder instead.") NXOpen::Features::MapleBuilder * CreateMapleBuilder
            (
                NXOpen::Features::Maple * maple 
            );
            public: NXOpen::Features::MathIntegrationBuilder * CreateMathIntegrationBuilder
            (
                NXOpen::Features::MathIntegration * mathIntegration 
            );
            public: NXOpen::Features::ConcaveFacesBuilder * CreateConcaveFacesBuilder
            (
                NXOpen::Features::ConcaveFaces * concaveFaces 
            );
            public: NXOpen::Features::VirtualCurveBuilder * CreateVirtualCurveBuilder
            (
                NXOpen::Features::VirtualCurve * virtualCurve 
            );
            public: NXOpen::Features::VirtualBlendEdgeBuilder * CreateVirtualBlendEdgeBuilder
            (
            );
            public: NXOpen::Features::IFormBuilder * CreateIformBuilder
            (
                NXOpen::Features::IForm * iform 
            );
            public: NXOpen::Features::LawCurveBuilder * CreateLawCurveBuilder
            (
                NXOpen::Features::LawCurve * lawCurve 
            );
            public: NXOpen::Features::TextBuilder * CreateTextBuilder
            (
                NXOpen::Features::Text * text 
            );
            public: NXOpen::Features::FeatureGroup * ActiveGroup
            (
            );
            public: NXOpen::Features::DeleteEdgeBuilder * CreateDeleteEdgeBuilder
            (
                NXOpen::Features::DeleteEdge * deleteEdge 
            );
            public: NXOpen::Features::CopyPasteBuilder * CreateCopyPasteBuilder2
            (
                const std::vector<NXOpen::NXObject *> & features 
            );
            public: NXOpen::Features::ReorderBlendsBuilder * CreateReorderBlendsBuilder
            (
                NXOpen::Features::ReorderBlends * reorderBlends 
            );
            public: NXOpen::Features::IsoparametricCurvesBuilder * CreateIsoparametricCurvesBuilder
            (
                NXOpen::Features::IsoparametricCurves * isoparametricCurves 
            );
            public: NX_DEPRECATED("Deprecated in NX8.0.0.  Use NXOpen::Features::FeatureCollection::ConvertToSequentialFeatureGroups or NXOpen::Features::FeatureCollection::ConvertToFloatingFeatureGroups instead.") void ConvertToNewFeatureGroups
            (
            );
            public: void ConvertToFloatingFeatureGroups
            (
            );
            public: void ConvertToSequentialFeatureGroups
            (
            );
            public: NXOpen::Features::VariableOffsetBuilder * CreateVariableOffsetBuilder
            (
                NXOpen::Features::VariableOffset * variableOffset 
            );
            public: NXOpen::Features::ExtensionBuilder * CreateExtensionBuilder
            (
                NXOpen::Features::Extension * extension 
            );
            public: NXOpen::Features::StudioSplineBuilderEx * CreateStudioSplineBuilderEx
            (
                NXOpen::NXObject * spline 
            );
            public: NXOpen::Features::SketchSplineBuilder * CreateSketchSplineBuilder
            (
                NXOpen::Spline * spline 
            );
            public: NXOpen::Features::DraftingSplineBuilder * CreateDraftingSplineBuilder
            (
                NXOpen::Spline * spline 
            );
            public: NXOpen::Features::BridgeSurfaceBuilder * CreateBridgeSurfaceBuilder
            (
                NXOpen::Features::BridgeSurface * bridgeSurface 
            );
            public: NXOpen::Features::EditCrossSectionBuilder * CreateEditCrossSectionBuilder
            (
                NXOpen::Features::EditCrossSection * editCrossSection 
            );
            public: NXOpen::Features::LabelNotchBlendBuilder * CreateLabelNotchBlendBuilder
            (
                NXOpen::Features::LabelNotchBlend * labelNotchBlend 
            );
            public: void SetEditWithRollbackFeature
            (
                NXOpen::Features::Feature * feature 
            );
            public: void SetCanResetMcf
            (
                bool canResetMcf 
            );
            public: NXOpen::Features::PartModuleBuilder * CreatePartModuleBuilder
            (
                NXOpen::Features::PartModule * partModule 
            );
            public: NXOpen::GeometricUtilities::PartModuleRelationshipBuilder * CreatePartModuleRelationshipBuilder
            (
                NXOpen::Features::PartModule * partModule 
            );
            public: NXOpen::Features::DeleteBodyBuilder * CreateDeleteBodyBuilder
            (
                NXOpen::Features::DeleteBody * deleteBody 
            );
            public: NXOpen::Features::IsolateFeatureBuilder * CreateIsolateFeatureBuilder
            (
                NXOpen::Features::IsolateFeature * isolateFeature 
            );
            public: NXOpen::Features::HelixBuilder * CreateHelixBuilder
            (
                NXOpen::Features::Helix * helix 
            );
            public: NXOpen::Features::ColorFeatureBuilder * CreateColorFeatureBuilder
            (
            );
            public: NXOpen::Features::ColorFeatureGroupBuilder * CreateColorFeatureGroupBuilder
            (
            );
            public: NXOpen::Features::BridgeCurveBuilderEx * CreateBridgeCurveBuilderEx
            (
                NXOpen::Features::BridgeCurve * bridgeCurve 
            );
            public: NXOpen::Features::FitCurveBuilder * CreateFitCurveBuilder
            (
                NXOpen::Features::FitCurve * fitCurve 
            );
            public: NXOpen::Features::SketchFitCurveBuilder * CreateSketchFitCurveBuilder
            (
                NXOpen::Curve * fitCurve 
            );
            public: NXOpen::Features::EmbossBodyBuilder * CreateEmbossBodyBuilder
            (
                NXOpen::Features::EmbossBody * embossBody 
            );
            public: NXOpen::Features::GeneralConicBuilder * CreateGeneralConicBuilder
            (
                NXOpen::Features::GeneralConic * generalConic 
            );
            public: NXOpen::Features::FitSurfaceBuilder * CreateFitSurfaceBuilder
            (
                NXOpen::Features::FitSurface * fitSurface 
            );
            public: NXOpen::Features::SphericalCornerBuilder * CreateSphericalCornerBuilder
            (
                NXOpen::Features::SphericalCorner * sphericalCorner 
            );
            public: NXOpen::Features::Feature * GetParentFeatureOfFace
            (
                NXOpen::Face * face 
            );
            public: std::vector<NXOpen::Features::Feature *> GetAssociatedFeaturesOfFace
            (
                NXOpen::Face * face 
            );
            public: std::vector<NXOpen::Features::Feature *> GetParentFeaturesOfEdge
            (
                NXOpen::Edge * edge 
            );
            public: std::vector<NXOpen::Features::Feature *> GetAssociatedFeaturesOfEdge
            (
                NXOpen::Edge * edge 
            );
            public: NXOpen::Features::Feature * GetParentFeatureOfBody
            (
                NXOpen::Body * body 
            );
            public: std::vector<NXOpen::Features::Feature *> GetAssociatedFeaturesOfBody
            (
                NXOpen::Body * body 
            );
            public: NXOpen::Features::SectionSurfaceBuilderEx * CreateSectionSurfaceBuilderEx
            (
                NXOpen::Features::SectionSurface * sectionSurfaceEx 
            );
            public: NXOpen::Features::PatternFaceFeatureBuilder * CreatePatternFaceFeatureBuilder
            (
                NXOpen::Features::PatternFaceFeature * patternFaceFeature 
            );
            public: NXOpen::GeometricUtilities::RenameLinkedPartModulePartBuilder * CreateRenameLinkedPartModulePartBuilder
            (
            );
            public: NXOpen::GeometricUtilities::ConvertFeatureGroupsToModulesBuilder * CreateConvertFeatureGroupsToModulesBuilder
            (
            );

            public: NXOpen::GeometricUtilities::ConvertFeatureGroupsToDesignGroupsBuilder * CreateConvertFeatureGroupsToDesignGroupsBuilder
            (
            );

            public: NX_DEPRECATED("Deprecated in NX10.0.0.  Please use NXOpen::Features::FeatureCollection instead.") NXOpen::GeometricUtilities::NestModuleBuilder * CreateNestModuleBuilder
            (
            );
            public: NXOpen::Features::PatternGeometryBuilder * CreatePatternGeometryBuilder
            (
                NXOpen::Features::PatternGeometry * patternGeometry 
            );
            public: NX_DEPRECATED("Deprecated in NX10.0.0.  Please use NXOpen::Features::FeatureCollection instead.") NXOpen::GeometricUtilities::UnnestModuleBuilder * CreateUnnestModuleBuilder
            (
            );
            public: NXOpen::Features::BlendPocketBuilder * CreateBlendPocketBuilder
            (
                NXOpen::Features::BlendPocket * blendPocket 
            );
            public: NXOpen::Features::AnalyzePocketBuilder * CreateAnalyzePocketBuilder
            (
                NXOpen::Features::AnalyzePocket * analyzePocket 
            );
            public: NXOpen::Features::OptimizeCurveBuilder * CreateOptimizeCurveBuilder
            (
            );
            public: void ReorganizeFeature
            (
                const std::vector<NXOpen::Features::Feature *> & features ,
                NXOpen::Features::Feature * target ,
                NXOpen::Features::FeatureCollection::ReorderType beforeOrAfter 
            );
            public: void DeleteInformationalAlerts
            (
                const std::vector<NXOpen::NXObject *> & feature 
            );
            public: void DeleteWarningAlerts
            (
                const std::vector<NXOpen::NXObject *> & feature 
            );
            public: NXOpen::Features::FlowBlendBuilder * CreateFlowBlendBuilder
            (
                NXOpen::Features::FlowBlend * flowBlend 
            );
            public: NXOpen::Features::CustomFeatureBuilder * CreateCustomFeatureBuilder
            (
                NXOpen::Features::Feature * customFeature 
            );
            public: NXOpen::Features::VarOffsetFaceBuilder * CreateVarOffsetFaceBuilder
            (
                NXOpen::Features::VarOffsetFace * varOffsetFace 
            );
            public: NXOpen::GeometricUtilities::RenewFeatureBuilder * CreateRenewFeatureBuilder
            (
            );
            public: NXOpen::Features::EditWithRollbackManager * StartEditWithRollbackManager
            (
                NXOpen::Features::Feature * featureToEdit ,
                NXOpen::Session::UndoMarkId featureEditMark 
            );
            public: NXOpen::Features::TrimCurve2Builder * CreateTrimCurve2FeatureBuilder
            (
                NXOpen::Features::TrimCurve2 * trimCurve2Feature 
            );
            public: NXOpen::Features::EmbedManagerBuilder * CreateEmbedManagerBuilder
            (
            );
            public: NXOpen::Features::BodyByEquationBuilder * CreateBodyByEquationBuilder
            (
                NXOpen::Features::BodyByEquation * facetBodyByEquation 
            );
            public: NXOpen::Features::Feature * InsertNewDesignGroup
            (
                NXOpen::Features::Feature * referenceFeature ,
                NXOpen::Features::FeatureCollection::ReorderType relativeLocation 
            );
            public: NXOpen::Features::DeformDefinitionBuilder * CreateDeformDefinitionBuilder
            (
            );

            public: NXOpen::GeometricUtilities::MoveToGroupBuilder * CreateMoveToGroupBuilder
            (
            );

            public: NXOpen::Features::DesignGroupBuilder * CreateDesignGroupBuilder
            (
                NXOpen::Features::DesignGroup * designGroup 
            );

            public: NXOpen::Features::MoveBodyBuilder * CreateMoveBodyBuilder
            (
                NXOpen::Features::MoveBody * moveBody 
            );
            public: NXOpen::Features::RadiateFaceBuilder * CreateRadiateFaceBuilder
            (
                NXOpen::Features::RadiateFace * radiateFace 
            );
            public: NXOpen::Features::ThreadBuilder * CreateThreadBuilder
            (
                NXOpen::Features::Thread * thread 
            );
            public: NXOpen::Features::ResizeHoleBuilder * CreateResizeHoleBuilder
            (
                NXOpen::Features::ResizeHole * editHole 
            );
            public: NXOpen::Features::AlgorithmicFeatureBuilder * CreateAlgorithmicFeatureBuilder
            (
                NXOpen::Features::Feature * feature 
            );
            public: NXOpen::Features::ResizePatternBuilder * CreateResizePatternBuilder
            (
                NXOpen::Features::ResizePattern * resizePattern 
            );
            public: void ConvertToLatestSplitAlgorithm
            (
            );
            public: NXOpen::Features::ContourRibBuilder * CreateContourRibBuilder
            (
                NXOpen::Features::ContourRib * contourRib 
            );
            public: NX_DEPRECATED("在 NX2206.0.0 中已弃用。请改用 NXOpen::Features::FeatureCollection::CreatePatternBodyBuilder。") NXOpen::Features::CombinePatternBuilder * CreateCombinePatternBuilder
            (
                NXOpen::Features::CombinePattern * combinePattern 
            );
            public: NXOpen::Features::CenterlineBuilder * CreateCenterlineBuilder
            (
                NXOpen::Features::Centerline * centerlineFeature 
            );
            public: NXOpen::Features::ChangeFaceBuilder * CreateChangeFaceBuilder
            (
                NXOpen::Features::ChangeFace * changeFace 
            );
            public: NXOpen::Features::PatternBodyBuilder * CreatePatternBodyBuilder
            (
                NXOpen::Features::PatternBody * combinePattern 
            );

            public: void DoLoggingToMakeFeaturesUpToDate
            (
                const std::vector<NXOpen::Features::Feature *> & features 
            );

            public: NXOpen::Features::GroupEdgeBuilder * CreateGroupEdgeBuilder
            (
                NXOpen::Features::GroupEdge * groupEdge 
            );
            public: NXOpen::Features::GroupBodyBuilder * CreateGroupBodyBuilder
            (
                NXOpen::Features::GroupBody * groupBody 
            );

            public: NXOpen::Features::ImprintObjectBuilder * CreateImprintObjectBuilder
            (
                NXOpen::Features::ImprintObject * imprintObject 
            );

            public: NXOpen::Features::StepExpressionBuilder * CreateStepExpressionBuilder
            (
                NXOpen::Expression * stepExpression ,
                NXOpen::Features::Feature * owningFeature 
            );
            public: NXOpen::Features::SheetMetal::SheetmetalManager *SheetmetalManager();
            public: NXOpen::Features::SheetMetal::AeroSheetmetalManager *AeroSheetmetalManager();
            public: NXOpen::Die::DieCollection *Dies();
            public: NXOpen::Weld::WeldManager *WeldManager();
            public: NXOpen::Features::AutomotiveCollection *AutomotiveCollection();
            public: NXOpen::Features::ShipCollection *ShipCollection();
            public: NXOpen::Features::ToolingCollection *ToolingCollection();
            public: NXOpen::Features::SynchronousEdgeCollection *SynchronousEdgeCollection();
            public: NXOpen::Features::SweepFeatureCollection *SweepFeatureCollection();
            public: NXOpen::Features::SynchronousCurveCollection *SynchronousCurveCollection();
            public: NXOpen::Features::VehicleDesignCollection *VehicleDesignCollection();
            public: NXOpen::Features::DesignFeatureCollection *DesignFeatureCollection();
            public: NXOpen::Features::FreeformCurveCollection *FreeformCurveCollection();
            public: NXOpen::Features::FreeformSurfaceCollection *FreeformSurfaceCollection();
            public: NXOpen::Features::TrimFeatureCollection *TrimFeatureCollection();
            public: NXOpen::Features::ToolingFeatureCollection *ToolingFeatureCollection();
            public: NXOpen::Features::CustomAttributeCollection *CustomAttributeCollection();
            public: NXOpen::Features::AeroCollection *AeroCollection();
            public: NXOpen::Features::CurveFeatureCollection *CurveFeatureCollection();
            public: NXOpen::Features::GeodesicSketchCollection *GeodesicSketchCollection();
            public: NXOpen::Features::CustomFeatureDataCollection *CustomFeatureDataCollection();
            public: NXOpen::Features::LatticeFeatureCollection *LatticeFeatureCollection();
            public: NXOpen::Features::PrintCsysFeatureCollection *PrintCsysFeatureCollection();
            public: NXOpen::Features::DetailFeatureCollection *DetailFeatureCollection();
            public: NXOpen::Features::MorphMeshCollection *MorphMeshCollection();
            public: NXOpen::Features::StructureDesignCollection *StructureDesignCollection();
            public: NXOpen::Features::AECDesignCollection *AECDesignCollection();
            public: NXOpen::Features::GCToolsFeatureCollection *GCToolsFeatureCollection();
            public: NXOpen::Features::AVDACollection *AVDACollection();
        }; //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