ansys-fluent-core 0.34.dev0__py3-none-any.whl → 0.35.dev0__py3-none-any.whl

ansys/fluent/core/generated/datamodel_252/meshing.py

@@ -1302,14 +1302,14 @@ class Root(PyMenu):
                         self.ConnectLabelWildcard = self._ConnectLabelWildcard(self, "ConnectLabelWildcard", service, rules, path)
                         self.AllowDefeaturing = self._AllowDefeaturing(self, "AllowDefeaturing", service, rules, path)
                         self.RelativeShareTopologyTolerance = self._RelativeShareTopologyTolerance(self, "RelativeShareTopologyTolerance", service, rules, path)
-                        self.ShareTopologyAngle = self._ShareTopologyAngle(self, "ShareTopologyAngle", service, rules, path)
+                        self.FluidLabelWildcard = self._FluidLabelWildcard(self, "FluidLabelWildcard", service, rules, path)
                         self.ExecuteJoinIntersect = self._ExecuteJoinIntersect(self, "ExecuteJoinIntersect", service, rules, path)
                         self.Operation = self._Operation(self, "Operation", service, rules, path)
-                        self.FluidLabelWildcard = self._FluidLabelWildcard(self, "FluidLabelWildcard", service, rules, path)
+                        self.ShareTopologyAngle = self._ShareTopologyAngle(self, "ShareTopologyAngle", service, rules, path)
                         self.STToleranceIncrement = self._STToleranceIncrement(self, "STToleranceIncrement", service, rules, path)
-                        self.ShowShareTopologyPreferences = self._ShowShareTopologyPreferences(self, "ShowShareTopologyPreferences", service, rules, path)
-                        self.PerLabelList = self._PerLabelList(self, "PerLabelList", service, rules, path)
                         self.IntfLabelList = self._IntfLabelList(self, "IntfLabelList", service, rules, path)
+                        self.PerLabelList = self._PerLabelList(self, "PerLabelList", service, rules, path)
+                        self.ShowShareTopologyPreferences = self._ShowShareTopologyPreferences(self, "ShowShareTopologyPreferences", service, rules, path)
                         self.AdvancedImprove = self._AdvancedImprove(self, "AdvancedImprove", service, rules, path)
                         self.NumberOfJoinTries = self._NumberOfJoinTries(self, "NumberOfJoinTries", service, rules, path)
 
@@ -1338,9 +1338,9 @@ class Root(PyMenu):
                         Specify the relative tolerance for joining or intersecting face pairs, or the relative tolerance for connecting edge and face pairs.
                         """
 
-                    class _ShareTopologyAngle(PyNumericalCommandArgumentsSubItem):
+                    class _FluidLabelWildcard(PyTextualCommandArgumentsSubItem):
                         """
-                        Specify the threshold angle for joining face pairs.
+                        Argument FluidLabelWildcard.
                         """
 
                     class _ExecuteJoinIntersect(PyTextualCommandArgumentsSubItem):
@@ -1353,9 +1353,9 @@ class Root(PyMenu):
                         Choose whether to apply share topology using the Join-Intersect method where you join and/or intersect the problematic faces, or using the Interface Connect method where you connect edges of overlapping face pairs. Note that imprinting of overlapping faces in SCDM/Discovery is highly recommended for the Interface Connect method.
                         """
 
-                    class _FluidLabelWildcard(PyTextualCommandArgumentsSubItem):
+                    class _ShareTopologyAngle(PyNumericalCommandArgumentsSubItem):
                         """
-                        Argument FluidLabelWildcard.
+                        Specify the threshold angle for joining face pairs.
                         """
 
                     class _STToleranceIncrement(PyNumericalCommandArgumentsSubItem):
@@ -1363,9 +1363,9 @@ class Root(PyMenu):
                         Specify the increment by which the tolerance changes for each attempt to join face pairs.
                         """
 
-                    class _ShowShareTopologyPreferences(PyParameterCommandArgumentsSubItem):
+                    class _IntfLabelList(PyTextualCommandArgumentsSubItem):
                         """
-                        Display advanced options that you may want to apply to the task.
+                        Enter a text string to filter out the list of labels. Use the Filter Text drop-down to provide text and/or regular expressions in filtering the list (for example, using \\*, ?, and []). Choose Use Wildcard to provide wildcard expressions in filtering the list. When you use either ? or \\* in your expression, the matching list item(s) are automatically selected in the list. Use ^, |, and & in your expression to indicate boolean operations for NOT, OR, and AND, respectively.  More...
                         """
 
                     class _PerLabelList(PyTextualCommandArgumentsSubItem):
@@ -1373,9 +1373,9 @@ class Root(PyMenu):
                         Argument PerLabelList.
                         """
 
-                    class _IntfLabelList(PyTextualCommandArgumentsSubItem):
+                    class _ShowShareTopologyPreferences(PyParameterCommandArgumentsSubItem):
                         """
-                        Enter a text string to filter out the list of labels. Use the Filter Text drop-down to provide text and/or regular expressions in filtering the list (for example, using \\*, ?, and []). Choose Use Wildcard to provide wildcard expressions in filtering the list. When you use either ? or \\* in your expression, the matching list item(s) are automatically selected in the list. Use ^, |, and & in your expression to indicate boolean operations for NOT, OR, and AND, respectively.  More...
+                        Display advanced options that you may want to apply to the task.
                         """
 
                     class _AdvancedImprove(PyTextualCommandArgumentsSubItem):
@@ -1526,8 +1526,8 @@ class Root(PyMenu):
                     self.ExposeSide = self._ExposeSide(self, "ExposeSide", service, rules, path)
                     self.MaxAspectRatio = self._MaxAspectRatio(self, "MaxAspectRatio", service, rules, path)
                     self.MinAspectRatio = self._MinAspectRatio(self, "MinAspectRatio", service, rules, path)
-                    self.LastRatioNumLayers = self._LastRatioNumLayers(self, "LastRatioNumLayers", service, rules, path)
                     self.LastRatioPercentage = self._LastRatioPercentage(self, "LastRatioPercentage", service, rules, path)
+                    self.LastRatioNumLayers = self._LastRatioNumLayers(self, "LastRatioNumLayers", service, rules, path)
                     self.GapFactor = self._GapFactor(self, "GapFactor", service, rules, path)
                     self.AdjacentAttachAngle = self._AdjacentAttachAngle(self, "AdjacentAttachAngle", service, rules, path)
 
@@ -1551,14 +1551,14 @@ class Root(PyMenu):
                     Argument MinAspectRatio.
                     """
 
-                class _LastRatioNumLayers(PyNumericalCommandArgumentsSubItem):
+                class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument LastRatioNumLayers.
+                    Argument LastRatioPercentage.
                     """
 
-                class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
+                class _LastRatioNumLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument LastRatioPercentage.
+                    Argument LastRatioNumLayers.
                     """
 
                 class _GapFactor(PyNumericalCommandArgumentsSubItem):
@@ -1773,8 +1773,8 @@ class Root(PyMenu):
                     self.SplitPrism = self._SplitPrism(self, "SplitPrism", service, rules, path)
                     self.InvalidNormalMethod = self._InvalidNormalMethod(self, "InvalidNormalMethod", service, rules, path)
                     self.ShowLocalPrismPreferences = self._ShowLocalPrismPreferences(self, "ShowLocalPrismPreferences", service, rules, path)
-                    self.LastRatioNumLayers = self._LastRatioNumLayers(self, "LastRatioNumLayers", service, rules, path)
                     self.NumberOfSplitLayers = self._NumberOfSplitLayers(self, "NumberOfSplitLayers", service, rules, path)
+                    self.LastRatioNumLayers = self._LastRatioNumLayers(self, "LastRatioNumLayers", service, rules, path)
                     self.AllowedTangencyAtInvalidNormals = self._AllowedTangencyAtInvalidNormals(self, "AllowedTangencyAtInvalidNormals", service, rules, path)
                     self.RemeshAtInvalidNormals = self._RemeshAtInvalidNormals(self, "RemeshAtInvalidNormals", service, rules, path)
                     self.IgnoreBoundaryLayers = self._IgnoreBoundaryLayers(self, "IgnoreBoundaryLayers", service, rules, path)
@@ -1824,14 +1824,14 @@ class Root(PyMenu):
                     Display advanced options that you may want to apply to this task.
                     """
 
-                class _LastRatioNumLayers(PyNumericalCommandArgumentsSubItem):
+                class _NumberOfSplitLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument LastRatioNumLayers.
+                    Indicate the number of split prism layers you wish to apply to each layer that you specified for the boundary layer definition.
                     """
 
-                class _NumberOfSplitLayers(PyNumericalCommandArgumentsSubItem):
+                class _LastRatioNumLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Indicate the number of split prism layers you wish to apply to each layer that you specified for the boundary layer definition.
+                    Argument LastRatioNumLayers.
                     """
 
                 class _AllowedTangencyAtInvalidNormals(PyNumericalCommandArgumentsSubItem):
@@ -2090,12 +2090,12 @@ class Root(PyMenu):
                     self.SphereRadiusFactorAtInvalidNormals = self._SphereRadiusFactorAtInvalidNormals(self, "SphereRadiusFactorAtInvalidNormals", service, rules, path)
                     self.SmoothRingsAtInvalidNormals = self._SmoothRingsAtInvalidNormals(self, "SmoothRingsAtInvalidNormals", service, rules, path)
                     self.Continuous = self._Continuous(self, "Continuous", service, rules, path)
-                    self.SplitPrism = self._SplitPrism(self, "SplitPrism", service, rules, path)
                     self.ModifyAtInvalidNormals = self._ModifyAtInvalidNormals(self, "ModifyAtInvalidNormals", service, rules, path)
+                    self.SplitPrism = self._SplitPrism(self, "SplitPrism", service, rules, path)
                     self.InvalidNormalMethod = self._InvalidNormalMethod(self, "InvalidNormalMethod", service, rules, path)
                     self.LastRatioNumLayers = self._LastRatioNumLayers(self, "LastRatioNumLayers", service, rules, path)
-                    self.ShowLocalPrismPreferences = self._ShowLocalPrismPreferences(self, "ShowLocalPrismPreferences", service, rules, path)
                     self.NumberOfSplitLayers = self._NumberOfSplitLayers(self, "NumberOfSplitLayers", service, rules, path)
+                    self.ShowLocalPrismPreferences = self._ShowLocalPrismPreferences(self, "ShowLocalPrismPreferences", service, rules, path)
                     self.AllowedTangencyAtInvalidNormals = self._AllowedTangencyAtInvalidNormals(self, "AllowedTangencyAtInvalidNormals", service, rules, path)
                     self.RemeshAtInvalidNormals = self._RemeshAtInvalidNormals(self, "RemeshAtInvalidNormals", service, rules, path)
                     self.IgnoreBoundaryLayers = self._IgnoreBoundaryLayers(self, "IgnoreBoundaryLayers", service, rules, path)
@@ -2125,14 +2125,14 @@ class Root(PyMenu):
                     Specify how you would like to improve the generated boundary layer: as a continuous or stair-stepped boundary layer in the specified area(s).
                     """
 
-                class _SplitPrism(PyTextualCommandArgumentsSubItem):
+                class _ModifyAtInvalidNormals(PyTextualCommandArgumentsSubItem):
                     """
-                    Choose whether or not to add split prisms to each layer along the boundary. Not available when the Offset Method Type is set to last-ratio.
+                    Specify whether to automatically change the surface mesh where invalid normal faces are detected. To grow the boundary layer mesh in the proper direction (away from the boundary), normal vectors (valid) are required at the boundary face nodes of the surface mesh. More...
                     """
 
-                class _ModifyAtInvalidNormals(PyTextualCommandArgumentsSubItem):
+                class _SplitPrism(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify whether to automatically change the surface mesh where invalid normal faces are detected. To grow the boundary layer mesh in the proper direction (away from the boundary), normal vectors (valid) are required at the boundary face nodes of the surface mesh. More...
+                    Choose whether or not to add split prisms to each layer along the boundary. Not available when the Offset Method Type is set to last-ratio.
                     """
 
                 class _InvalidNormalMethod(PyTextualCommandArgumentsSubItem):
@@ -2145,14 +2145,14 @@ class Root(PyMenu):
                     Argument LastRatioNumLayers.
                     """
 
-                class _ShowLocalPrismPreferences(PyParameterCommandArgumentsSubItem):
+                class _NumberOfSplitLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Display advanced options that you may want to apply to this task.
+                    Indicate the number of split prism layers you wish to apply to each layer that you specified for the boundary layer definition.
                     """
 
-                class _NumberOfSplitLayers(PyNumericalCommandArgumentsSubItem):
+                class _ShowLocalPrismPreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Indicate the number of split prism layers you wish to apply to each layer that you specified for the boundary layer definition.
+                    Display advanced options that you may want to apply to this task.
                     """
 
                 class _AllowedTangencyAtInvalidNormals(PyNumericalCommandArgumentsSubItem):
@@ -2999,8 +2999,8 @@ class Root(PyMenu):
                     self.SaveSizeFieldFile = self._SaveSizeFieldFile(self, "SaveSizeFieldFile", service, rules, path)
                     self.MaxSize = self._MaxSize(self, "MaxSize", service, rules, path)
                     self.ScopeProximityTo = self._ScopeProximityTo(self, "ScopeProximityTo", service, rules, path)
-                    self.CurvatureNormalAngle = self._CurvatureNormalAngle(self, "CurvatureNormalAngle", service, rules, path)
                     self.PreviewSizefield = self._PreviewSizefield(self, "PreviewSizefield", service, rules, path)
+                    self.CurvatureNormalAngle = self._CurvatureNormalAngle(self, "CurvatureNormalAngle", service, rules, path)
                     self.SaveSizeField = self._SaveSizeField(self, "SaveSizeField", service, rules, path)
                     self.UseSizeFiles = self._UseSizeFiles(self, "UseSizeFiles", service, rules, path)
                     self.AutoCreateScopedSizing = self._AutoCreateScopedSizing(self, "AutoCreateScopedSizing", service, rules, path)
@@ -3030,14 +3030,14 @@ class Root(PyMenu):
                     Argument ScopeProximityTo.
                     """
 
-                class _CurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _PreviewSizefield(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument CurvatureNormalAngle.
+                    Argument PreviewSizefield.
                     """
 
-                class _PreviewSizefield(PyParameterCommandArgumentsSubItem):
+                class _CurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument PreviewSizefield.
+                    Argument CurvatureNormalAngle.
                     """
 
                 class _SaveSizeField(PyParameterCommandArgumentsSubItem):
@@ -4162,23 +4162,23 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.WrapTargetRatio = self._WrapTargetRatio(self, "WrapTargetRatio", service, rules, path)
+                    self.TargeSizeFieldFileName = self._TargeSizeFieldFileName(self, "TargeSizeFieldFileName", service, rules, path)
                     self.WrapTargetSizeFieldRatio = self._WrapTargetSizeFieldRatio(self, "WrapTargetSizeFieldRatio", service, rules, path)
-                    self.AdvancedOptions = self._AdvancedOptions(self, "AdvancedOptions", service, rules, path)
+                    self.WrapTargetBothOptions = self._WrapTargetBothOptions(self, "WrapTargetBothOptions", service, rules, path)
                     self.SolidFluidRaio = self._SolidFluidRaio(self, "SolidFluidRaio", service, rules, path)
                     self.BoundaryLayers = self._BoundaryLayers(self, "BoundaryLayers", service, rules, path)
                     self.EdgeProximityComputation = self._EdgeProximityComputation(self, "EdgeProximityComputation", service, rules, path)
-                    self.WrapTargetBothOptions = self._WrapTargetBothOptions(self, "WrapTargetBothOptions", service, rules, path)
-                    self.ExistingSizeField = self._ExistingSizeField(self, "ExistingSizeField", service, rules, path)
-                    self.TargetSizeFieldFileName = self._TargetSizeFieldFileName(self, "TargetSizeFieldFileName", service, rules, path)
+                    self.AdvancedOptions = self._AdvancedOptions(self, "AdvancedOptions", service, rules, path)
                     self.SolidFluidRatio = self._SolidFluidRatio(self, "SolidFluidRatio", service, rules, path)
+                    self.TargetSizeFieldFileName = self._TargetSizeFieldFileName(self, "TargetSizeFieldFileName", service, rules, path)
+                    self.ExistingSizeField = self._ExistingSizeField(self, "ExistingSizeField", service, rules, path)
                     self.WrapSizeFieldFileName = self._WrapSizeFieldFileName(self, "WrapSizeFieldFileName", service, rules, path)
-                    self.TargeSizeFieldFileName = self._TargeSizeFieldFileName(self, "TargeSizeFieldFileName", service, rules, path)
+                    self.WrapTargetRatio = self._WrapTargetRatio(self, "WrapTargetRatio", service, rules, path)
                     self.WrapTargetRaio = self._WrapTargetRaio(self, "WrapTargetRaio", service, rules, path)
 
-                class _WrapTargetRatio(PyNumericalCommandArgumentsSubItem):
+                class _TargeSizeFieldFileName(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument WrapTargetRatio.
+                    Indicate the name and location of the target size field file (\\*.sf).
                     """
 
                 class _WrapTargetSizeFieldRatio(PyNumericalCommandArgumentsSubItem):
@@ -4186,9 +4186,9 @@ class Root(PyMenu):
                     The ratio of the initial wrap size field and the local target size field.
                     """
 
-                class _AdvancedOptions(PyParameterCommandArgumentsSubItem):
+                class _WrapTargetBothOptions(PyTextualCommandArgumentsSubItem):
                     """
-                    Display advanced options that you may want to apply to the task.
+                    Determine how the size controls are calculated in the Add Local Sizing task: using Both Wrap and Target values, by Target Only (the default), or by Wrap Only. For complex models, computational expense can be lowered by choosing one of the other options. If either Wrap Only or Target Only is selected, then the other values are determined using the Wrap/Target Size Ratio value.
                     """
 
                 class _SolidFluidRaio(PyNumericalCommandArgumentsSubItem):
@@ -4206,14 +4206,14 @@ class Root(PyMenu):
                     For geometries having a very large number of small feature edges, select Yes to speed up the calculation and reduce memory requirements when using a proximity size function.
                     """
 
-                class _WrapTargetBothOptions(PyTextualCommandArgumentsSubItem):
+                class _AdvancedOptions(PyParameterCommandArgumentsSubItem):
                     """
-                    Determine how the size controls are calculated in the Add Local Sizing task: using Both Wrap and Target values, by Target Only (the default), or by Wrap Only. For complex models, computational expense can be lowered by choosing one of the other options. If either Wrap Only or Target Only is selected, then the other values are determined using the Wrap/Target Size Ratio value.
+                    Display advanced options that you may want to apply to the task.
                     """
 
-                class _ExistingSizeField(PyTextualCommandArgumentsSubItem):
+                class _SolidFluidRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Determine which existing size field files will be used: Both Wrap and Target (the default), Target Only, or Wrap Only. For complex models, computational expense can be lowered by choosing one of the other options. If either Wrap Only or Target Only is selected, then the other values are determined using the Wrap/Target Size Ratio value.
+                    Argument SolidFluidRatio.
                     """
 
                 class _TargetSizeFieldFileName(PyTextualCommandArgumentsSubItem):
@@ -4221,9 +4221,9 @@ class Root(PyMenu):
                     Argument TargetSizeFieldFileName.
                     """
 
-                class _SolidFluidRatio(PyNumericalCommandArgumentsSubItem):
+                class _ExistingSizeField(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument SolidFluidRatio.
+                    Determine which existing size field files will be used: Both Wrap and Target (the default), Target Only, or Wrap Only. For complex models, computational expense can be lowered by choosing one of the other options. If either Wrap Only or Target Only is selected, then the other values are determined using the Wrap/Target Size Ratio value.
                     """
 
                 class _WrapSizeFieldFileName(PyTextualCommandArgumentsSubItem):
@@ -4231,9 +4231,9 @@ class Root(PyMenu):
                     Indicate the name and location of the wrap size field file (\\*.sf).
                     """
 
-                class _TargeSizeFieldFileName(PyTextualCommandArgumentsSubItem):
+                class _WrapTargetRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Indicate the name and location of the target size field file (\\*.sf).
+                    Argument WrapTargetRatio.
                     """
 
                 class _WrapTargetRaio(PyNumericalCommandArgumentsSubItem):
@@ -4508,7 +4508,7 @@ class Root(PyMenu):
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
                     self.SizeRelativeLength = self._SizeRelativeLength(self, "SizeRelativeLength", service, rules, path)
-                    self.XmaxRatio = self._XmaxRatio(self, "XmaxRatio", service, rules, path)
+                    self.Xmax = self._Xmax(self, "Xmax", service, rules, path)
                     self.XminRatio = self._XminRatio(self, "XminRatio", service, rules, path)
                     self.YminRatio = self._YminRatio(self, "YminRatio", service, rules, path)
                     self.Zmin = self._Zmin(self, "Zmin", service, rules, path)
@@ -4519,16 +4519,16 @@ class Root(PyMenu):
                     self.Xmin = self._Xmin(self, "Xmin", service, rules, path)
                     self.YmaxRatio = self._YmaxRatio(self, "YmaxRatio", service, rules, path)
                     self.ZmaxRatio = self._ZmaxRatio(self, "ZmaxRatio", service, rules, path)
-                    self.Xmax = self._Xmax(self, "Xmax", service, rules, path)
+                    self.XmaxRatio = self._XmaxRatio(self, "XmaxRatio", service, rules, path)
 
                 class _SizeRelativeLength(PyTextualCommandArgumentsSubItem):
                     """
                     Argument SizeRelativeLength.
                     """
 
-                class _XmaxRatio(PyNumericalCommandArgumentsSubItem):
+                class _Xmax(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument XmaxRatio.
+                    Argument Xmax.
                     """
 
                 class _XminRatio(PyNumericalCommandArgumentsSubItem):
@@ -4581,9 +4581,9 @@ class Root(PyMenu):
                     Argument ZmaxRatio.
                     """
 
-                class _Xmax(PyNumericalCommandArgumentsSubItem):
+                class _XmaxRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Xmax.
+                    Argument XmaxRatio.
                     """
 
             class _OffsetObject(PySingletonCommandArgumentsSubItem):
@@ -4599,17 +4599,17 @@ class Root(PyMenu):
                     self.Y = self._Y(self, "Y", service, rules, path)
                     self.DefeaturingSize = self._DefeaturingSize(self, "DefeaturingSize", service, rules, path)
                     self.AspectRatio = self._AspectRatio(self, "AspectRatio", service, rules, path)
-                    self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
                     self.Rate = self._Rate(self, "Rate", service, rules, path)
-                    self.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", service, rules, path)
+                    self.BoundaryLayerLevels = self._BoundaryLayerLevels(self, "BoundaryLayerLevels", service, rules, path)
+                    self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
                     self.FlowDirection = self._FlowDirection(self, "FlowDirection", service, rules, path)
                     self.MptMethodType = self._MptMethodType(self, "MptMethodType", service, rules, path)
                     self.EdgeSelectionList = self._EdgeSelectionList(self, "EdgeSelectionList", service, rules, path)
-                    self.BoundaryLayerLevels = self._BoundaryLayerLevels(self, "BoundaryLayerLevels", service, rules, path)
-                    self.X = self._X(self, "X", service, rules, path)
+                    self.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", service, rules, path)
                     self.LastRatioPercentage = self._LastRatioPercentage(self, "LastRatioPercentage", service, rules, path)
-                    self.OffsetMethodType = self._OffsetMethodType(self, "OffsetMethodType", service, rules, path)
+                    self.X = self._X(self, "X", service, rules, path)
                     self.FlipDirection = self._FlipDirection(self, "FlipDirection", service, rules, path)
+                    self.OffsetMethodType = self._OffsetMethodType(self, "OffsetMethodType", service, rules, path)
                     self.FirstHeight = self._FirstHeight(self, "FirstHeight", service, rules, path)
                     self.BoundaryLayerHeight = self._BoundaryLayerHeight(self, "BoundaryLayerHeight", service, rules, path)
                     self.CrossWakeGrowthFactor = self._CrossWakeGrowthFactor(self, "CrossWakeGrowthFactor", service, rules, path)
@@ -4644,19 +4644,19 @@ class Root(PyMenu):
                     Argument AspectRatio.
                     """
 
-                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
+                class _Rate(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument NumberOfLayers.
+                    Argument Rate.
                     """
 
-                class _Rate(PyNumericalCommandArgumentsSubItem):
+                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Rate.
+                    Argument BoundaryLayerLevels.
                     """
 
-                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
+                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument WakeGrowthFactor.
+                    Argument NumberOfLayers.
                     """
 
                 class _FlowDirection(PyTextualCommandArgumentsSubItem):
@@ -4674,14 +4674,9 @@ class Root(PyMenu):
                     Argument EdgeSelectionList.
                     """
 
-                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
-                    """
-                    Argument BoundaryLayerLevels.
-                    """
-
-                class _X(PyNumericalCommandArgumentsSubItem):
+                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument X.
+                    Argument WakeGrowthFactor.
                     """
 
                 class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
@@ -4689,9 +4684,9 @@ class Root(PyMenu):
                     Argument LastRatioPercentage.
                     """
 
-                class _OffsetMethodType(PyTextualCommandArgumentsSubItem):
+                class _X(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument OffsetMethodType.
+                    Argument X.
                     """
 
                 class _FlipDirection(PyParameterCommandArgumentsSubItem):
@@ -4699,6 +4694,11 @@ class Root(PyMenu):
                     Argument FlipDirection.
                     """
 
+                class _OffsetMethodType(PyTextualCommandArgumentsSubItem):
+                    """
+                    Argument OffsetMethodType.
+                    """
+
                 class _FirstHeight(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument FirstHeight.
@@ -4873,8 +4873,8 @@ class Root(PyMenu):
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
                     self.CylinderZ2 = self._CylinderZ2(self, "CylinderZ2", service, rules, path)
-                    self.CylinderX2 = self._CylinderX2(self, "CylinderX2", service, rules, path)
                     self.BoxYLength = self._BoxYLength(self, "BoxYLength", service, rules, path)
+                    self.CylinderX2 = self._CylinderX2(self, "CylinderX2", service, rules, path)
                     self.CylinderX1 = self._CylinderX1(self, "CylinderX1", service, rules, path)
                     self.BoxZLength = self._BoxZLength(self, "BoxZLength", service, rules, path)
                     self.CylinderY1 = self._CylinderY1(self, "CylinderY1", service, rules, path)
@@ -4883,8 +4883,8 @@ class Root(PyMenu):
                     self.CylinderZ1 = self._CylinderZ1(self, "CylinderZ1", service, rules, path)
                     self.CylinderRadius1 = self._CylinderRadius1(self, "CylinderRadius1", service, rules, path)
                     self.BoxCenterX = self._BoxCenterX(self, "BoxCenterX", service, rules, path)
-                    self.BoxCenterZ = self._BoxCenterZ(self, "BoxCenterZ", service, rules, path)
                     self.CylinderRadius2 = self._CylinderRadius2(self, "CylinderRadius2", service, rules, path)
+                    self.BoxCenterZ = self._BoxCenterZ(self, "BoxCenterZ", service, rules, path)
                     self.CylinderY2 = self._CylinderY2(self, "CylinderY2", service, rules, path)
 
                 class _CylinderZ2(PyNumericalCommandArgumentsSubItem):
@@ -4892,14 +4892,14 @@ class Root(PyMenu):
                     Argument CylinderZ2.
                     """
 
-                class _CylinderX2(PyNumericalCommandArgumentsSubItem):
+                class _BoxYLength(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument CylinderX2.
+                    Argument BoxYLength.
                     """
 
-                class _BoxYLength(PyNumericalCommandArgumentsSubItem):
+                class _CylinderX2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument BoxYLength.
+                    Argument CylinderX2.
                     """
 
                 class _CylinderX1(PyNumericalCommandArgumentsSubItem):
@@ -4942,14 +4942,14 @@ class Root(PyMenu):
                     Argument BoxCenterX.
                     """
 
-                class _BoxCenterZ(PyNumericalCommandArgumentsSubItem):
+                class _CylinderRadius2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument BoxCenterZ.
+                    Argument CylinderRadius2.
                     """
 
-                class _CylinderRadius2(PyNumericalCommandArgumentsSubItem):
+                class _BoxCenterZ(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument CylinderRadius2.
+                    Argument BoxCenterZ.
                     """
 
                 class _CylinderY2(PyNumericalCommandArgumentsSubItem):
@@ -5186,13 +5186,13 @@ class Root(PyMenu):
                     self.Y = self._Y(self, "Y", service, rules, path)
                     self.DefeaturingSize = self._DefeaturingSize(self, "DefeaturingSize", service, rules, path)
                     self.BoundaryLayerLevels = self._BoundaryLayerLevels(self, "BoundaryLayerLevels", service, rules, path)
-                    self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
-                    self.AspectRatio = self._AspectRatio(self, "AspectRatio", service, rules, path)
                     self.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", service, rules, path)
+                    self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
+                    self.Rate = self._Rate(self, "Rate", service, rules, path)
                     self.FlowDirection = self._FlowDirection(self, "FlowDirection", service, rules, path)
                     self.MptMethodType = self._MptMethodType(self, "MptMethodType", service, rules, path)
                     self.EdgeSelectionList = self._EdgeSelectionList(self, "EdgeSelectionList", service, rules, path)
-                    self.Rate = self._Rate(self, "Rate", service, rules, path)
+                    self.AspectRatio = self._AspectRatio(self, "AspectRatio", service, rules, path)
                     self.LastRatioPercentage = self._LastRatioPercentage(self, "LastRatioPercentage", service, rules, path)
                     self.X = self._X(self, "X", service, rules, path)
                     self.FlipDirection = self._FlipDirection(self, "FlipDirection", service, rules, path)
@@ -5231,19 +5231,19 @@ class Root(PyMenu):
                     Argument BoundaryLayerLevels.
                     """
 
-                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
+                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument NumberOfLayers.
+                    Argument WakeGrowthFactor.
                     """
 
-                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
+                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument AspectRatio.
+                    Argument NumberOfLayers.
                     """
 
-                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
+                class _Rate(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument WakeGrowthFactor.
+                    Argument Rate.
                     """
 
                 class _FlowDirection(PyTextualCommandArgumentsSubItem):
@@ -5261,9 +5261,9 @@ class Root(PyMenu):
                     Choose a single edge zone from the list below for your edge-based collar mesh. Use the Filter Text field to provide text and/or regular expressions in filtering the list. The matching list item(s) are automatically displayed in the list. Use ^, |, and & in your expression to indicate boolean operations for NOT, OR, and AND, respectively.  More...
                     """
 
-                class _Rate(PyNumericalCommandArgumentsSubItem):
+                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Rate.
+                    Argument AspectRatio.
                     """
 
                 class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
@@ -5313,8 +5313,8 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.X_Offset = self._X_Offset(self, "X-Offset", service, rules, path)
                     self.HeightNode = self._HeightNode(self, "HeightNode", service, rules, path)
+                    self.X_Offset = self._X_Offset(self, "X-Offset", service, rules, path)
                     self.HeightBackInc = self._HeightBackInc(self, "HeightBackInc", service, rules, path)
                     self.X1 = self._X1(self, "X1", service, rules, path)
                     self.Y1 = self._Y1(self, "Y1", service, rules, path)
@@ -5331,14 +5331,14 @@ class Root(PyMenu):
                     self.HeightFrontInc = self._HeightFrontInc(self, "HeightFrontInc", service, rules, path)
                     self.Radius1 = self._Radius1(self, "Radius1", service, rules, path)
 
-                class _X_Offset(PyNumericalCommandArgumentsSubItem):
+                class _HeightNode(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument X-Offset.
+                    Argument HeightNode.
                     """
 
-                class _HeightNode(PyTextualCommandArgumentsSubItem):
+                class _X_Offset(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument HeightNode.
+                    Argument X-Offset.
                     """
 
                 class _HeightBackInc(PyNumericalCommandArgumentsSubItem):
@@ -5683,7 +5683,7 @@ class Root(PyMenu):
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
                     self.SizeRelativeLength = self._SizeRelativeLength(self, "SizeRelativeLength", service, rules, path)
-                    self.Xmax = self._Xmax(self, "Xmax", service, rules, path)
+                    self.XmaxRatio = self._XmaxRatio(self, "XmaxRatio", service, rules, path)
                     self.XminRatio = self._XminRatio(self, "XminRatio", service, rules, path)
                     self.YminRatio = self._YminRatio(self, "YminRatio", service, rules, path)
                     self.Zmin = self._Zmin(self, "Zmin", service, rules, path)
@@ -5694,16 +5694,16 @@ class Root(PyMenu):
                     self.Xmin = self._Xmin(self, "Xmin", service, rules, path)
                     self.YmaxRatio = self._YmaxRatio(self, "YmaxRatio", service, rules, path)
                     self.ZmaxRatio = self._ZmaxRatio(self, "ZmaxRatio", service, rules, path)
-                    self.XmaxRatio = self._XmaxRatio(self, "XmaxRatio", service, rules, path)
+                    self.Xmax = self._Xmax(self, "Xmax", service, rules, path)
 
                 class _SizeRelativeLength(PyTextualCommandArgumentsSubItem):
                     """
                     Determine if you would like to specify the bounding box for the component mesh as a ratio of the geometry length, or by specifying a specific location for the minimum and maximum coordinates.
                     """
 
-                class _Xmax(PyNumericalCommandArgumentsSubItem):
+                class _XmaxRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Extends the maximum size of the bounding box in the X direction by the specified value.
+                    Extends the maximum size of the bounding box in the X direction by the specified value. The value is the ratio relative to the geometry size in the X direction.
                     """
 
                 class _XminRatio(PyNumericalCommandArgumentsSubItem):
@@ -5756,9 +5756,9 @@ class Root(PyMenu):
                     Extends the maximum size of the bounding box in the Z direction by the specified value. The value is the ratio relative to the geometry size in the Z direction.
                     """
 
-                class _XmaxRatio(PyNumericalCommandArgumentsSubItem):
+                class _Xmax(PyNumericalCommandArgumentsSubItem):
                     """
-                    Extends the maximum size of the bounding box in the X direction by the specified value. The value is the ratio relative to the geometry size in the X direction.
+                    Extends the maximum size of the bounding box in the X direction by the specified value.
                     """
 
             class _OffsetObject(PySingletonCommandArgumentsSubItem):
@@ -5773,16 +5773,16 @@ class Root(PyMenu):
                     self.ShowCoordinates = self._ShowCoordinates(self, "ShowCoordinates", service, rules, path)
                     self.Y = self._Y(self, "Y", service, rules, path)
                     self.DefeaturingSize = self._DefeaturingSize(self, "DefeaturingSize", service, rules, path)
-                    self.AspectRatio = self._AspectRatio(self, "AspectRatio", service, rules, path)
+                    self.BoundaryLayerLevels = self._BoundaryLayerLevels(self, "BoundaryLayerLevels", service, rules, path)
                     self.Rate = self._Rate(self, "Rate", service, rules, path)
                     self.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", service, rules, path)
-                    self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
+                    self.AspectRatio = self._AspectRatio(self, "AspectRatio", service, rules, path)
                     self.FlowDirection = self._FlowDirection(self, "FlowDirection", service, rules, path)
                     self.MptMethodType = self._MptMethodType(self, "MptMethodType", service, rules, path)
                     self.EdgeSelectionList = self._EdgeSelectionList(self, "EdgeSelectionList", service, rules, path)
-                    self.BoundaryLayerLevels = self._BoundaryLayerLevels(self, "BoundaryLayerLevels", service, rules, path)
-                    self.X = self._X(self, "X", service, rules, path)
+                    self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
                     self.LastRatioPercentage = self._LastRatioPercentage(self, "LastRatioPercentage", service, rules, path)
+                    self.X = self._X(self, "X", service, rules, path)
                     self.OffsetMethodType = self._OffsetMethodType(self, "OffsetMethodType", service, rules, path)
                     self.FlipDirection = self._FlipDirection(self, "FlipDirection", service, rules, path)
                     self.FirstHeight = self._FirstHeight(self, "FirstHeight", service, rules, path)
@@ -5814,9 +5814,9 @@ class Root(PyMenu):
                     Argument DefeaturingSize.
                     """
 
-                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
+                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the ratio of the prism base length to the prism layer height.
+                    Argument BoundaryLayerLevels.
                     """
 
                 class _Rate(PyNumericalCommandArgumentsSubItem):
@@ -5829,9 +5829,9 @@ class Root(PyMenu):
                     Argument WakeGrowthFactor.
                     """
 
-                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
+                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Select the number of boundary layers to be generated.
+                    Specify the ratio of the prism base length to the prism layer height.
                     """
 
                 class _FlowDirection(PyTextualCommandArgumentsSubItem):
@@ -5849,19 +5849,19 @@ class Root(PyMenu):
                     Argument EdgeSelectionList.
                     """
 
-                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
+                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument BoundaryLayerLevels.
+                    Select the number of boundary layers to be generated.
                     """
 
-                class _X(PyNumericalCommandArgumentsSubItem):
+                class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument X.
+                    Specify the offset height of the last layer as a percentage of the local base mesh size.
                     """
 
-                class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
+                class _X(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the offset height of the last layer as a percentage of the local base mesh size.
+                    Argument X.
                     """
 
                 class _OffsetMethodType(PyTextualCommandArgumentsSubItem):
@@ -5901,32 +5901,32 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.X_Offset = self._X_Offset(self, "X-Offset", service, rules, path)
                     self.HeightNode = self._HeightNode(self, "HeightNode", service, rules, path)
+                    self.X_Offset = self._X_Offset(self, "X-Offset", service, rules, path)
                     self.HeightBackInc = self._HeightBackInc(self, "HeightBackInc", service, rules, path)
                     self.X1 = self._X1(self, "X1", service, rules, path)
                     self.Y1 = self._Y1(self, "Y1", service, rules, path)
                     self.Z_Offset = self._Z_Offset(self, "Z-Offset", service, rules, path)
-                    self.Z2 = self._Z2(self, "Z2", service, rules, path)
-                    self.Node1 = self._Node1(self, "Node1", service, rules, path)
                     self.Z1 = self._Z1(self, "Z1", service, rules, path)
+                    self.Node1 = self._Node1(self, "Node1", service, rules, path)
+                    self.Z2 = self._Z2(self, "Z2", service, rules, path)
                     self.Radius2 = self._Radius2(self, "Radius2", service, rules, path)
                     self.Y2 = self._Y2(self, "Y2", service, rules, path)
                     self.Node3 = self._Node3(self, "Node3", service, rules, path)
+                    self.Y_Offset = self._Y_Offset(self, "Y-Offset", service, rules, path)
                     self.Node2 = self._Node2(self, "Node2", service, rules, path)
                     self.X2 = self._X2(self, "X2", service, rules, path)
-                    self.Y_Offset = self._Y_Offset(self, "Y-Offset", service, rules, path)
                     self.HeightFrontInc = self._HeightFrontInc(self, "HeightFrontInc", service, rules, path)
                     self.Radius1 = self._Radius1(self, "Radius1", service, rules, path)
 
-                class _X_Offset(PyNumericalCommandArgumentsSubItem):
+                class _HeightNode(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument X-Offset.
+                    Argument HeightNode.
                     """
 
-                class _HeightNode(PyTextualCommandArgumentsSubItem):
+                class _X_Offset(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument HeightNode.
+                    Argument X-Offset.
                     """
 
                 class _HeightBackInc(PyNumericalCommandArgumentsSubItem):
@@ -5949,9 +5949,9 @@ class Root(PyMenu):
                     Argument Z-Offset.
                     """
 
-                class _Z2(PyNumericalCommandArgumentsSubItem):
+                class _Z1(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Z2.
+                    Argument Z1.
                     """
 
                 class _Node1(PyTextualCommandArgumentsSubItem):
@@ -5959,9 +5959,9 @@ class Root(PyMenu):
                     Argument Node1.
                     """
 
-                class _Z1(PyNumericalCommandArgumentsSubItem):
+                class _Z2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Z1.
+                    Argument Z2.
                     """
 
                 class _Radius2(PyNumericalCommandArgumentsSubItem):
@@ -5979,6 +5979,11 @@ class Root(PyMenu):
                     Argument Node3.
                     """
 
+                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
+                    """
+                    Argument Y-Offset.
+                    """
+
                 class _Node2(PyTextualCommandArgumentsSubItem):
                     """
                     Argument Node2.
@@ -5989,11 +5994,6 @@ class Root(PyMenu):
                     Argument X2.
                     """
 
-                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
-                    """
-                    Argument Y-Offset.
-                    """
-
                 class _HeightFrontInc(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument HeightFrontInc.
@@ -6981,16 +6981,16 @@ class Root(PyMenu):
                     self.ShowCoordinates = self._ShowCoordinates(self, "ShowCoordinates", service, rules, path)
                     self.Y = self._Y(self, "Y", service, rules, path)
                     self.DefeaturingSize = self._DefeaturingSize(self, "DefeaturingSize", service, rules, path)
-                    self.BoundaryLayerLevels = self._BoundaryLayerLevels(self, "BoundaryLayerLevels", service, rules, path)
-                    self.Rate = self._Rate(self, "Rate", service, rules, path)
                     self.AspectRatio = self._AspectRatio(self, "AspectRatio", service, rules, path)
-                    self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
+                    self.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", service, rules, path)
+                    self.Rate = self._Rate(self, "Rate", service, rules, path)
+                    self.BoundaryLayerLevels = self._BoundaryLayerLevels(self, "BoundaryLayerLevels", service, rules, path)
                     self.FlowDirection = self._FlowDirection(self, "FlowDirection", service, rules, path)
                     self.MptMethodType = self._MptMethodType(self, "MptMethodType", service, rules, path)
                     self.EdgeSelectionList = self._EdgeSelectionList(self, "EdgeSelectionList", service, rules, path)
-                    self.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", service, rules, path)
-                    self.X = self._X(self, "X", service, rules, path)
+                    self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
                     self.LastRatioPercentage = self._LastRatioPercentage(self, "LastRatioPercentage", service, rules, path)
+                    self.X = self._X(self, "X", service, rules, path)
                     self.OffsetMethodType = self._OffsetMethodType(self, "OffsetMethodType", service, rules, path)
                     self.FlipDirection = self._FlipDirection(self, "FlipDirection", service, rules, path)
                     self.FirstHeight = self._FirstHeight(self, "FirstHeight", service, rules, path)
@@ -7022,24 +7022,24 @@ class Root(PyMenu):
                     Specify a value that is used to obtain a rough shape of the selected object(s). The larger the value, the more approximate the shape.
                     """
 
-                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
+                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the number of boundary layers that are to be captured in the refinement region.
+                    Argument AspectRatio.
                     """
 
-                class _Rate(PyNumericalCommandArgumentsSubItem):
+                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Rate.
+                    Specify the factor by which the refinement region expands in the wake of the flow direction.
                     """
 
-                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
+                class _Rate(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument AspectRatio.
+                    Argument Rate.
                     """
 
-                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
+                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument NumberOfLayers.
+                    Specify the number of boundary layers that are to be captured in the refinement region.
                     """
 
                 class _FlowDirection(PyTextualCommandArgumentsSubItem):
@@ -7057,19 +7057,19 @@ class Root(PyMenu):
                     Argument EdgeSelectionList.
                     """
 
-                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
+                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the factor by which the refinement region expands in the wake of the flow direction.
+                    Argument NumberOfLayers.
                     """
 
-                class _X(PyNumericalCommandArgumentsSubItem):
+                class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the X-coordinate for the initial position of the cylindrical refinement region.
+                    Argument LastRatioPercentage.
                     """
 
-                class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
+                class _X(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument LastRatioPercentage.
+                    Specify the X-coordinate for the initial position of the cylindrical refinement region.
                     """
 
                 class _OffsetMethodType(PyTextualCommandArgumentsSubItem):
@@ -7109,8 +7109,8 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.HeightNode = self._HeightNode(self, "HeightNode", service, rules, path)
                     self.X_Offset = self._X_Offset(self, "X-Offset", service, rules, path)
+                    self.HeightNode = self._HeightNode(self, "HeightNode", service, rules, path)
                     self.HeightBackInc = self._HeightBackInc(self, "HeightBackInc", service, rules, path)
                     self.X1 = self._X1(self, "X1", service, rules, path)
                     self.Y1 = self._Y1(self, "Y1", service, rules, path)
@@ -7121,20 +7121,20 @@ class Root(PyMenu):
                     self.Radius2 = self._Radius2(self, "Radius2", service, rules, path)
                     self.Y2 = self._Y2(self, "Y2", service, rules, path)
                     self.Node3 = self._Node3(self, "Node3", service, rules, path)
-                    self.X2 = self._X2(self, "X2", service, rules, path)
                     self.Y_Offset = self._Y_Offset(self, "Y-Offset", service, rules, path)
+                    self.X2 = self._X2(self, "X2", service, rules, path)
                     self.Node2 = self._Node2(self, "Node2", service, rules, path)
                     self.HeightFrontInc = self._HeightFrontInc(self, "HeightFrontInc", service, rules, path)
                     self.Radius1 = self._Radius1(self, "Radius1", service, rules, path)
 
-                class _HeightNode(PyTextualCommandArgumentsSubItem):
+                class _X_Offset(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument HeightNode.
+                    Specify the X-coordinate for the offset of the initial position of the cylinder.
                     """
 
-                class _X_Offset(PyNumericalCommandArgumentsSubItem):
+                class _HeightNode(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify the X-coordinate for the offset of the initial position of the cylinder.
+                    Argument HeightNode.
                     """
 
                 class _HeightBackInc(PyNumericalCommandArgumentsSubItem):
@@ -7187,14 +7187,14 @@ class Root(PyMenu):
                     Argument Node3.
                     """
 
-                class _X2(PyNumericalCommandArgumentsSubItem):
+                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the X-coordinate of the second position of the cylinder.
+                    Specify the Y-coordinate for the offset of the initial position of the cylinder.
                     """
 
-                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
+                class _X2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the Y-coordinate for the offset of the initial position of the cylinder.
+                    Specify the X-coordinate of the second position of the cylinder.
                     """
 
                 class _Node2(PyTextualCommandArgumentsSubItem):
@@ -7256,18 +7256,18 @@ class Root(PyMenu):
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
                     self.CylinderZ2 = self._CylinderZ2(self, "CylinderZ2", service, rules, path)
-                    self.CylinderX2 = self._CylinderX2(self, "CylinderX2", service, rules, path)
                     self.BoxYLength = self._BoxYLength(self, "BoxYLength", service, rules, path)
+                    self.CylinderX2 = self._CylinderX2(self, "CylinderX2", service, rules, path)
                     self.CylinderX1 = self._CylinderX1(self, "CylinderX1", service, rules, path)
-                    self.BoxZLength = self._BoxZLength(self, "BoxZLength", service, rules, path)
-                    self.CylinderY1 = self._CylinderY1(self, "CylinderY1", service, rules, path)
                     self.BoxXLength = self._BoxXLength(self, "BoxXLength", service, rules, path)
+                    self.CylinderY1 = self._CylinderY1(self, "CylinderY1", service, rules, path)
+                    self.BoxZLength = self._BoxZLength(self, "BoxZLength", service, rules, path)
                     self.BoxCenterY = self._BoxCenterY(self, "BoxCenterY", service, rules, path)
                     self.CylinderZ1 = self._CylinderZ1(self, "CylinderZ1", service, rules, path)
                     self.CylinderRadius1 = self._CylinderRadius1(self, "CylinderRadius1", service, rules, path)
                     self.BoxCenterX = self._BoxCenterX(self, "BoxCenterX", service, rules, path)
-                    self.BoxCenterZ = self._BoxCenterZ(self, "BoxCenterZ", service, rules, path)
                     self.CylinderRadius2 = self._CylinderRadius2(self, "CylinderRadius2", service, rules, path)
+                    self.BoxCenterZ = self._BoxCenterZ(self, "BoxCenterZ", service, rules, path)
                     self.CylinderY2 = self._CylinderY2(self, "CylinderY2", service, rules, path)
 
                 class _CylinderZ2(PyNumericalCommandArgumentsSubItem):
@@ -7275,14 +7275,14 @@ class Root(PyMenu):
                     Specify the Z-coordinate of the second position of the cylinder.
                     """
 
-                class _CylinderX2(PyNumericalCommandArgumentsSubItem):
+                class _BoxYLength(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the X-coordinate of the second position of the cylinder.
+                    Argument BoxYLength.
                     """
 
-                class _BoxYLength(PyNumericalCommandArgumentsSubItem):
+                class _CylinderX2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument BoxYLength.
+                    Specify the X-coordinate of the second position of the cylinder.
                     """
 
                 class _CylinderX1(PyNumericalCommandArgumentsSubItem):
@@ -7290,9 +7290,9 @@ class Root(PyMenu):
                     Specify the X-coordinate of the first position of the cylinder.
                     """
 
-                class _BoxZLength(PyNumericalCommandArgumentsSubItem):
+                class _BoxXLength(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument BoxZLength.
+                    Argument BoxXLength.
                     """
 
                 class _CylinderY1(PyNumericalCommandArgumentsSubItem):
@@ -7300,9 +7300,9 @@ class Root(PyMenu):
                     Specify the Y-coordinate of the first position of the cylinder.
                     """
 
-                class _BoxXLength(PyNumericalCommandArgumentsSubItem):
+                class _BoxZLength(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument BoxXLength.
+                    Argument BoxZLength.
                     """
 
                 class _BoxCenterY(PyNumericalCommandArgumentsSubItem):
@@ -7325,14 +7325,14 @@ class Root(PyMenu):
                     Specify the X-coordinate for the initial position of the cylindrical refinement region.
                     """
 
-                class _BoxCenterZ(PyNumericalCommandArgumentsSubItem):
+                class _CylinderRadius2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the Z-coordinate for the initial position of the cylindrical refinement region.
+                    Specify the radius of the cylinder at the second position.
                     """
 
-                class _CylinderRadius2(PyNumericalCommandArgumentsSubItem):
+                class _BoxCenterZ(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the radius of the cylinder at the second position.
+                    Specify the Z-coordinate for the initial position of the cylindrical refinement region.
                     """
 
                 class _CylinderY2(PyNumericalCommandArgumentsSubItem):
@@ -7538,8 +7538,8 @@ class Root(PyMenu):
                     super().__init__(parent, attr, service, rules, path)
                     self.NumberOfLayers = self._NumberOfLayers(self, "NumberOfLayers", service, rules, path)
                     self.LabelSelectionList = self._LabelSelectionList(self, "LabelSelectionList", service, rules, path)
-                    self.ZoneSelectionList = self._ZoneSelectionList(self, "ZoneSelectionList", service, rules, path)
                     self.SelectionType = self._SelectionType(self, "SelectionType", service, rules, path)
+                    self.ZoneSelectionList = self._ZoneSelectionList(self, "ZoneSelectionList", service, rules, path)
                     self.Thickness = self._Thickness(self, "Thickness", service, rules, path)
                     self.FeatureAngle = self._FeatureAngle(self, "FeatureAngle", service, rules, path)
                     self.MeshSize = self._MeshSize(self, "MeshSize", service, rules, path)
@@ -7558,14 +7558,14 @@ class Root(PyMenu):
                     Select a single label that will correspond to the porous region. Use the Filter Text field to provide text and/or regular expressions in filtering the list. The matching list item(s) are automatically displayed in the list. Use ^, |, and & in your expression to indicate boolean operations for NOT, OR, and AND, respectively.  More...
                     """
 
-                class _ZoneSelectionList(PyTextualCommandArgumentsSubItem):
+                class _SelectionType(PyTextualCommandArgumentsSubItem):
                     """
-                    Choose a single face zone from the list below. Use the Filter Text field to provide text and/or regular expressions in filtering the list. The matching list item(s) are automatically displayed in the list. Use ^, |, and & in your expression to indicate boolean operations for NOT, OR, and AND, respectively.  More...
+                    Choose how you want to make your selection (by object, zone, or label).
                     """
 
-                class _SelectionType(PyTextualCommandArgumentsSubItem):
+                class _ZoneSelectionList(PyTextualCommandArgumentsSubItem):
                     """
-                    Choose how you want to make your selection (by object, zone, or label).
+                    Choose a single face zone from the list below. Use the Filter Text field to provide text and/or regular expressions in filtering the list. The matching list item(s) are automatically displayed in the list. Use ^, |, and & in your expression to indicate boolean operations for NOT, OR, and AND, respectively.  More...
                     """
 
                 class _Thickness(PyNumericalCommandArgumentsSubItem):
@@ -7912,9 +7912,9 @@ class Root(PyMenu):
                     super().__init__(parent, attr, service, rules, path)
                     self.PorousRegions = self._PorousRegions(self, "PorousRegions", service, rules, path)
                     self.ZeroThickness = self._ZeroThickness(self, "ZeroThickness", service, rules, path)
-                    self.CloseLeakges = self._CloseLeakges(self, "CloseLeakges", service, rules, path)
-                    self.CloseLeakages = self._CloseLeakages(self, "CloseLeakages", service, rules, path)
                     self.AdvancedOptions = self._AdvancedOptions(self, "AdvancedOptions", service, rules, path)
+                    self.CloseLeakages = self._CloseLeakages(self, "CloseLeakages", service, rules, path)
+                    self.CloseLeakges = self._CloseLeakges(self, "CloseLeakges", service, rules, path)
                     self.ExtractEdgeFeatures = self._ExtractEdgeFeatures(self, "ExtractEdgeFeatures", service, rules, path)
                     self.MovingObjects = self._MovingObjects(self, "MovingObjects", service, rules, path)
                     self.EnablePrimeWrapper = self._EnablePrimeWrapper(self, "EnablePrimeWrapper", service, rules, path)
@@ -7931,9 +7931,9 @@ class Root(PyMenu):
                     Specify whether or not you will need to account for any portions of your geometry with zero-thickness, and apply thickness to them for a more refined surface mesh. If so, then an Add Thickness task will be added to the workflow.
                     """
 
-                class _CloseLeakges(PyTextualCommandArgumentsSubItem):
+                class _AdvancedOptions(PyParameterCommandArgumentsSubItem):
                     """
-                    Specify whether or not your geometry contains any problems (such as gaps or overlapping/intersecting surfaces) that may create leakages that need to be closed. If so, then a Define Leakage Threshold task is added to the workflow.
+                    Display advanced options that you may want to apply to the workflow.
                     """
 
                 class _CloseLeakages(PyTextualCommandArgumentsSubItem):
@@ -7941,9 +7941,9 @@ class Root(PyMenu):
                     Argument CloseLeakages.
                     """
 
-                class _AdvancedOptions(PyParameterCommandArgumentsSubItem):
+                class _CloseLeakges(PyTextualCommandArgumentsSubItem):
                     """
-                    Display advanced options that you may want to apply to the workflow.
+                    Specify whether or not your geometry contains any problems (such as gaps or overlapping/intersecting surfaces) that may create leakages that need to be closed. If so, then a Define Leakage Threshold task is added to the workflow.
                     """
 
                 class _ExtractEdgeFeatures(PyTextualCommandArgumentsSubItem):
@@ -8290,8 +8290,8 @@ class Root(PyMenu):
                     self.MaxLayerHeight = self._MaxLayerHeight(self, "MaxLayerHeight", service, rules, path)
                     self.MidSpanLength = self._MidSpanLength(self, "MidSpanLength", service, rules, path)
                     self.BiasMethod = self._BiasMethod(self, "BiasMethod", service, rules, path)
-                    self.BiasMethodControl = self._BiasMethodControl(self, "BiasMethodControl", service, rules, path)
                     self.MergeCellZones = self._MergeCellZones(self, "MergeCellZones", service, rules, path)
+                    self.BiasMethodControl = self._BiasMethodControl(self, "BiasMethodControl", service, rules, path)
                     self.ShowVMExtrudePreferences = self._ShowVMExtrudePreferences(self, "ShowVMExtrudePreferences", service, rules, path)
 
                 class _MaxLayerHeight(PyNumericalCommandArgumentsSubItem):
@@ -8309,14 +8309,14 @@ class Root(PyMenu):
                     Select from a choice of patterns that you want to apply to your volume mesh extrusion.
                     """
 
-                class _BiasMethodControl(PyTextualCommandArgumentsSubItem):
+                class _MergeCellZones(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument BiasMethodControl.
+                    Indicate whether or not you want to merge the extruded layers with any adjacent regions.
                     """
 
-                class _MergeCellZones(PyParameterCommandArgumentsSubItem):
+                class _BiasMethodControl(PyTextualCommandArgumentsSubItem):
                     """
-                    Indicate whether or not you want to merge the extruded layers with any adjacent regions.
+                    Argument BiasMethodControl.
                     """
 
                 class _ShowVMExtrudePreferences(PyParameterCommandArgumentsSubItem):
@@ -8394,9 +8394,9 @@ class Root(PyMenu):
                     self.RemeshGrowthRate = self._RemeshGrowthRate(self, "RemeshGrowthRate", service, rules, path)
                     self.LocalRemesh = self._LocalRemesh(self, "LocalRemesh", service, rules, path)
                     self.GapFactor = self._GapFactor(self, "GapFactor", service, rules, path)
-                    self.ShowPrism2DPreferences = self._ShowPrism2DPreferences(self, "ShowPrism2DPreferences", service, rules, path)
                     self.RefineStretchedQuads = self._RefineStretchedQuads(self, "RefineStretchedQuads", service, rules, path)
                     self.MaxFaceSkew = self._MaxFaceSkew(self, "MaxFaceSkew", service, rules, path)
+                    self.ShowPrism2DPreferences = self._ShowPrism2DPreferences(self, "ShowPrism2DPreferences", service, rules, path)
                     self.nOrthogonalLayers = self._nOrthogonalLayers(self, "nOrthogonalLayers", service, rules, path)
 
                 class _SplitQuads(PyTextualCommandArgumentsSubItem):
@@ -8429,11 +8429,6 @@ class Root(PyMenu):
                     Argument GapFactor.
                     """
 
-                class _ShowPrism2DPreferences(PyParameterCommandArgumentsSubItem):
-                    """
-                    Argument ShowPrism2DPreferences.
-                    """
-
                 class _RefineStretchedQuads(PyTextualCommandArgumentsSubItem):
                     """
                     Argument RefineStretchedQuads.
@@ -8444,6 +8439,11 @@ class Root(PyMenu):
                     Argument MaxFaceSkew.
                     """
 
+                class _ShowPrism2DPreferences(PyParameterCommandArgumentsSubItem):
+                    """
+                    Argument ShowPrism2DPreferences.
+                    """
+
                 class _nOrthogonalLayers(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument nOrthogonalLayers.
@@ -8456,18 +8456,18 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.MergeEdgeZonesBasedOnLabels = self._MergeEdgeZonesBasedOnLabels(self, "MergeEdgeZonesBasedOnLabels", service, rules, path)
                     self.MergeFaceZonesBasedOnLabels = self._MergeFaceZonesBasedOnLabels(self, "MergeFaceZonesBasedOnLabels", service, rules, path)
+                    self.MergeEdgeZonesBasedOnLabels = self._MergeEdgeZonesBasedOnLabels(self, "MergeEdgeZonesBasedOnLabels", service, rules, path)
                     self.ShowAdvancedOptions = self._ShowAdvancedOptions(self, "ShowAdvancedOptions", service, rules, path)
 
-                class _MergeEdgeZonesBasedOnLabels(PyTextualCommandArgumentsSubItem):
+                class _MergeFaceZonesBasedOnLabels(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument MergeEdgeZonesBasedOnLabels.
+                    Argument MergeFaceZonesBasedOnLabels.
                     """
 
-                class _MergeFaceZonesBasedOnLabels(PyTextualCommandArgumentsSubItem):
+                class _MergeEdgeZonesBasedOnLabels(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument MergeFaceZonesBasedOnLabels.
+                    Argument MergeEdgeZonesBasedOnLabels.
                     """
 
                 class _ShowAdvancedOptions(PyParameterCommandArgumentsSubItem):
@@ -9307,21 +9307,21 @@ class Root(PyMenu):
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
                     self.SMQualityCollapseLimit = self._SMQualityCollapseLimit(self, "SMQualityCollapseLimit", service, rules, path)
-                    self.FoldFaceLimit = self._FoldFaceLimit(self, "FoldFaceLimit", service, rules, path)
+                    self.AutoMerge = self._AutoMerge(self, "AutoMerge", service, rules, path)
                     self.SMSeparation = self._SMSeparation(self, "SMSeparation", service, rules, path)
                     self.ShowSurfaceMeshPreferences = self._ShowSurfaceMeshPreferences(self, "ShowSurfaceMeshPreferences", service, rules, path)
                     self.SMSeparationAngle = self._SMSeparationAngle(self, "SMSeparationAngle", service, rules, path)
                     self.SMQualityImprove = self._SMQualityImprove(self, "SMQualityImprove", service, rules, path)
                     self.TVMAutoControlCreation = self._TVMAutoControlCreation(self, "TVMAutoControlCreation", service, rules, path)
-                    self.AutoMerge = self._AutoMerge(self, "AutoMerge", service, rules, path)
+                    self.FoldFaceLimit = self._FoldFaceLimit(self, "FoldFaceLimit", service, rules, path)
                     self.SMRemoveStep = self._SMRemoveStep(self, "SMRemoveStep", service, rules, path)
                     self.SMStepWidth = self._SMStepWidth(self, "SMStepWidth", service, rules, path)
-                    self.VolumeMeshMaxSize = self._VolumeMeshMaxSize(self, "VolumeMeshMaxSize", service, rules, path)
-                    self.AutoAssignZoneTypes = self._AutoAssignZoneTypes(self, "AutoAssignZoneTypes", service, rules, path)
                     self.SMQualityMaxAngle = self._SMQualityMaxAngle(self, "SMQualityMaxAngle", service, rules, path)
-                    self.SMQualityImproveLimit = self._SMQualityImproveLimit(self, "SMQualityImproveLimit", service, rules, path)
-                    self.AutoSurfaceRemesh = self._AutoSurfaceRemesh(self, "AutoSurfaceRemesh", service, rules, path)
+                    self.AutoAssignZoneTypes = self._AutoAssignZoneTypes(self, "AutoAssignZoneTypes", service, rules, path)
+                    self.VolumeMeshMaxSize = self._VolumeMeshMaxSize(self, "VolumeMeshMaxSize", service, rules, path)
                     self.SelfIntersectCheck = self._SelfIntersectCheck(self, "SelfIntersectCheck", service, rules, path)
+                    self.AutoSurfaceRemesh = self._AutoSurfaceRemesh(self, "AutoSurfaceRemesh", service, rules, path)
+                    self.SMQualityImproveLimit = self._SMQualityImproveLimit(self, "SMQualityImproveLimit", service, rules, path)
                     self.SetVolumeMeshMaxSize = self._SetVolumeMeshMaxSize(self, "SetVolumeMeshMaxSize", service, rules, path)
 
                 class _SMQualityCollapseLimit(PyNumericalCommandArgumentsSubItem):
@@ -9329,9 +9329,9 @@ class Root(PyMenu):
                     Specify the limiting skewness value for cell collapse to improve the mesh. If any remaining triangles are above this limit, these triangles will be aggressively removed using a fixed maximum angle of 120 degrees.
                     """
 
-                class _FoldFaceLimit(PyNumericalCommandArgumentsSubItem):
+                class _AutoMerge(PyParameterCommandArgumentsSubItem):
                     """
-                    Specify the value limiting when folded faces are smoothed or resolved. Folded faces are resolved while under this limit. Set this value to 0 if the number of free nodes (due to a zero-thickness wall such as a baffle for instance) falls below 10.
+                    Argument AutoMerge.
                     """
 
                 class _SMSeparation(PyTextualCommandArgumentsSubItem):
@@ -9359,9 +9359,9 @@ class Root(PyMenu):
                     If your geometry contains small edges, you can choose to extract these edge features when generating the surface mesh by selecting yes. Note that selecting yes , will always extract small edge features regardless of your selection for the Auto Remesh to Remove Clustering? option.
                     """
 
-                class _AutoMerge(PyParameterCommandArgumentsSubItem):
+                class _FoldFaceLimit(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument AutoMerge.
+                    Specify the value limiting when folded faces are smoothed or resolved. Folded faces are resolved while under this limit. Set this value to 0 if the number of free nodes (due to a zero-thickness wall such as a baffle for instance) falls below 10.
                     """
 
                 class _SMRemoveStep(PyTextualCommandArgumentsSubItem):
@@ -9374,9 +9374,9 @@ class Root(PyMenu):
                     Specify the width of the step that you wish to remove.
                     """
 
-                class _VolumeMeshMaxSize(PyNumericalCommandArgumentsSubItem):
+                class _SMQualityMaxAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the maximum size of the elements for the surface mesh.
+                    Specify the maximum angle between the normals of adjacent faces. This quality measure is useful in locating sharp corners in complicated geometries. The angle value ranges from 0 to 180 degrees. Four consecutive attempts are made to improve the quality, each using a larger adjacent angle, until this maximum value.
                     """
 
                 class _AutoAssignZoneTypes(PyTextualCommandArgumentsSubItem):
@@ -9384,14 +9384,14 @@ class Root(PyMenu):
                     Choose whether or not to automatically assign boundary types to zones.
                     """
 
-                class _SMQualityMaxAngle(PyNumericalCommandArgumentsSubItem):
+                class _VolumeMeshMaxSize(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the maximum angle between the normals of adjacent faces. This quality measure is useful in locating sharp corners in complicated geometries. The angle value ranges from 0 to 180 degrees. Four consecutive attempts are made to improve the quality, each using a larger adjacent angle, until this maximum value.
+                    Specify the maximum size of the elements for the surface mesh.
                     """
 
-                class _SMQualityImproveLimit(PyNumericalCommandArgumentsSubItem):
+                class _SelfIntersectCheck(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify a limiting value for skewness to improve the quality of the surface mesh. Quality improvement is attempted on those triangles where the skewness is above this limit.
+                    Choose whether or not to check for self-intersecting faces. Performance may be improved if this is disabled.
                     """
 
                 class _AutoSurfaceRemesh(PyTextualCommandArgumentsSubItem):
@@ -9399,9 +9399,9 @@ class Root(PyMenu):
                     Choose whether or not to automatically remesh in order to remove excessive clustering of nodes. By default (auto), this is done if local sizing has been assigned or Share Topology is invoked, but skipped if not. Performance may be improved if this is disabled. In addition, you can choose to use the much faster refaceting technique as an alternative to automatic remeshing. When importing the mesh, remeshing is only performed if this option is set to yes and then all faces are remeshed; and the refaceting option is not available because the initial mesh cannot be refaceted.
                     """
 
-                class _SelfIntersectCheck(PyTextualCommandArgumentsSubItem):
+                class _SMQualityImproveLimit(PyNumericalCommandArgumentsSubItem):
                     """
-                    Choose whether or not to check for self-intersecting faces. Performance may be improved if this is disabled.
+                    Specify a limiting value for skewness to improve the quality of the surface mesh. Quality improvement is attempted on those triangles where the skewness is above this limit.
                     """
 
                 class _SetVolumeMeshMaxSize(PyTextualCommandArgumentsSubItem):
@@ -9461,18 +9461,18 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.MaxSize = self._MaxSize(self, "MaxSize", service, rules, path)
                     self.RefineFaceting = self._RefineFaceting(self, "RefineFaceting", service, rules, path)
+                    self.MaxSize = self._MaxSize(self, "MaxSize", service, rules, path)
                     self.Tolerance = self._Tolerance(self, "Tolerance", service, rules, path)
 
-                class _MaxSize(PyNumericalCommandArgumentsSubItem):
+                class _RefineFaceting(PyParameterCommandArgumentsSubItem):
                     """
-                    Specify the maximum size of the elements for the surface mesh.
+                    Argument RefineFaceting.
                     """
 
-                class _RefineFaceting(PyParameterCommandArgumentsSubItem):
+                class _MaxSize(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument RefineFaceting.
+                    Specify the maximum size of the elements for the surface mesh.
                     """
 
                 class _Tolerance(PyNumericalCommandArgumentsSubItem):
@@ -9493,11 +9493,11 @@ class Root(PyMenu):
                     self.CreateCADAssemblies = self._CreateCADAssemblies(self, "CreateCADAssemblies", service, rules, path)
                     self.FeatureAngle = self._FeatureAngle(self, "FeatureAngle", service, rules, path)
                     self.OneZonePer = self._OneZonePer(self, "OneZonePer", service, rules, path)
-                    self.UsePartOrBodyAsSuffix = self._UsePartOrBodyAsSuffix(self, "UsePartOrBodyAsSuffix", service, rules, path)
-                    self.ExtractFeatures = self._ExtractFeatures(self, "ExtractFeatures", service, rules, path)
+                    self.ImportCurvatureDataFromCAD = self._ImportCurvatureDataFromCAD(self, "ImportCurvatureDataFromCAD", service, rules, path)
                     self.ImportNamedSelections = self._ImportNamedSelections(self, "ImportNamedSelections", service, rules, path)
+                    self.ExtractFeatures = self._ExtractFeatures(self, "ExtractFeatures", service, rules, path)
                     self.ImportPartNames = self._ImportPartNames(self, "ImportPartNames", service, rules, path)
-                    self.ImportCurvatureDataFromCAD = self._ImportCurvatureDataFromCAD(self, "ImportCurvatureDataFromCAD", service, rules, path)
+                    self.UsePartOrBodyAsSuffix = self._UsePartOrBodyAsSuffix(self, "UsePartOrBodyAsSuffix", service, rules, path)
 
                 class _SavePMDBIntermediateFile(PyParameterCommandArgumentsSubItem):
                     """
@@ -9529,19 +9529,19 @@ class Root(PyMenu):
                     Argument OneZonePer.
                     """
 
-                class _UsePartOrBodyAsSuffix(PyParameterCommandArgumentsSubItem):
+                class _ImportCurvatureDataFromCAD(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument UsePartOrBodyAsSuffix.
+                    Argument ImportCurvatureDataFromCAD.
                     """
 
-                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
+                class _ImportNamedSelections(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ExtractFeatures.
+                    Argument ImportNamedSelections.
                     """
 
-                class _ImportNamedSelections(PyParameterCommandArgumentsSubItem):
+                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ImportNamedSelections.
+                    Argument ExtractFeatures.
                     """
 
                 class _ImportPartNames(PyParameterCommandArgumentsSubItem):
@@ -9549,9 +9549,9 @@ class Root(PyMenu):
                     Argument ImportPartNames.
                     """
 
-                class _ImportCurvatureDataFromCAD(PyParameterCommandArgumentsSubItem):
+                class _UsePartOrBodyAsSuffix(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ImportCurvatureDataFromCAD.
+                    Argument UsePartOrBodyAsSuffix.
                     """
 
             class _ShareTopologyPreferences(PySingletonCommandArgumentsSubItem):
@@ -9566,10 +9566,10 @@ class Root(PyMenu):
                     self.ConnectLabelWildcard = self._ConnectLabelWildcard(self, "ConnectLabelWildcard", service, rules, path)
                     self.AllowDefeaturing = self._AllowDefeaturing(self, "AllowDefeaturing", service, rules, path)
                     self.RelativeShareTopologyTolerance = self._RelativeShareTopologyTolerance(self, "RelativeShareTopologyTolerance", service, rules, path)
-                    self.FluidLabelWildcard = self._FluidLabelWildcard(self, "FluidLabelWildcard", service, rules, path)
+                    self.ShareTopologyAngle = self._ShareTopologyAngle(self, "ShareTopologyAngle", service, rules, path)
                     self.ExecuteJoinIntersect = self._ExecuteJoinIntersect(self, "ExecuteJoinIntersect", service, rules, path)
                     self.Operation = self._Operation(self, "Operation", service, rules, path)
-                    self.ShareTopologyAngle = self._ShareTopologyAngle(self, "ShareTopologyAngle", service, rules, path)
+                    self.FluidLabelWildcard = self._FluidLabelWildcard(self, "FluidLabelWildcard", service, rules, path)
                     self.STToleranceIncrement = self._STToleranceIncrement(self, "STToleranceIncrement", service, rules, path)
                     self.ShowShareTopologyPreferences = self._ShowShareTopologyPreferences(self, "ShowShareTopologyPreferences", service, rules, path)
                     self.PerLabelList = self._PerLabelList(self, "PerLabelList", service, rules, path)
@@ -9602,9 +9602,9 @@ class Root(PyMenu):
                     Specify the relative tolerance for joining or intersecting face pairs, or the relative tolerance for connecting edge and face pairs.
                     """
 
-                class _FluidLabelWildcard(PyTextualCommandArgumentsSubItem):
+                class _ShareTopologyAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument FluidLabelWildcard.
+                    Specify the threshold angle for joining face pairs.
                     """
 
                 class _ExecuteJoinIntersect(PyTextualCommandArgumentsSubItem):
@@ -9617,9 +9617,9 @@ class Root(PyMenu):
                     Choose whether to apply share topology using the Join-Intersect method where you join and/or intersect the problematic faces, or using the Interface Connect method where you connect edges of overlapping face pairs. Note that imprinting of overlapping faces in SCDM/Discovery is highly recommended for the Interface Connect method.
                     """
 
-                class _ShareTopologyAngle(PyNumericalCommandArgumentsSubItem):
+                class _FluidLabelWildcard(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify the threshold angle for joining face pairs.
+                    Argument FluidLabelWildcard.
                     """
 
                 class _STToleranceIncrement(PyNumericalCommandArgumentsSubItem):
@@ -10114,34 +10114,34 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
+                    self.MergeBodyLabels = self._MergeBodyLabels(self, "MergeBodyLabels", service, rules, path)
+                    self.QualityMethod = self._QualityMethod(self, "QualityMethod", service, rules, path)
+                    self.MinPolySize = self._MinPolySize(self, "MinPolySize", service, rules, path)
                     self.UseSizeFieldInSolids = self._UseSizeFieldInSolids(self, "UseSizeFieldInSolids", service, rules, path)
                     self.PolyFeatureAngle = self._PolyFeatureAngle(self, "PolyFeatureAngle", service, rules, path)
-                    self.MinPolySize = self._MinPolySize(self, "MinPolySize", service, rules, path)
-                    self.QualityMethod = self._QualityMethod(self, "QualityMethod", service, rules, path)
-                    self.MergeBodyLabels = self._MergeBodyLabels(self, "MergeBodyLabels", service, rules, path)
                     self.UseSizeField = self._UseSizeField(self, "UseSizeField", service, rules, path)
-                    self.ShowVolumeMeshPreferences = self._ShowVolumeMeshPreferences(self, "ShowVolumeMeshPreferences", service, rules, path)
-                    self.TetInSolids = self._TetInSolids(self, "TetInSolids", service, rules, path)
+                    self.PolyInSolids = self._PolyInSolids(self, "PolyInSolids", service, rules, path)
+                    self.MinEdgeLength = self._MinEdgeLength(self, "MinEdgeLength", service, rules, path)
                     self.AddMultipleQualityMethods = self._AddMultipleQualityMethods(self, "AddMultipleQualityMethods", service, rules, path)
                     self.MaxCellSizeChange = self._MaxCellSizeChange(self, "MaxCellSizeChange", service, rules, path)
                     self.WritePrismControlFile = self._WritePrismControlFile(self, "WritePrismControlFile", service, rules, path)
                     self.MinFaceArea = self._MinFaceArea(self, "MinFaceArea", service, rules, path)
                     self.CheckSelfProximity = self._CheckSelfProximity(self, "CheckSelfProximity", service, rules, path)
                     self.Avoid1_8Transition = self._Avoid1_8Transition(self, "Avoid1_8Transition", service, rules, path)
-                    self.PolyInSolids = self._PolyInSolids(self, "PolyInSolids", service, rules, path)
-                    self.MinEdgeLength = self._MinEdgeLength(self, "MinEdgeLength", service, rules, path)
-                    self.SolidGrowthRate = self._SolidGrowthRate(self, "SolidGrowthRate", service, rules, path)
                     self.PrepareZoneNames = self._PrepareZoneNames(self, "PrepareZoneNames", service, rules, path)
+                    self.ShowVolumeMeshPreferences = self._ShowVolumeMeshPreferences(self, "ShowVolumeMeshPreferences", service, rules, path)
+                    self.SolidGrowthRate = self._SolidGrowthRate(self, "SolidGrowthRate", service, rules, path)
+                    self.TetInSolids = self._TetInSolids(self, "TetInSolids", service, rules, path)
                     self.QualityWarningLimit = self._QualityWarningLimit(self, "QualityWarningLimit", service, rules, path)
 
-                class _UseSizeFieldInSolids(PyTextualCommandArgumentsSubItem):
+                class _MergeBodyLabels(PyTextualCommandArgumentsSubItem):
                     """
-                    This option is available when both the Use Size Field? and Fill Polyhedra in Solids? options are enabled for the poly-hexcore fill method. By default this option is set to no, which specifies growth-rate-based sizing for polyhedra regions during poly-hexcore generation. Selecting yes for this option specifies the sizing for polyhedra regions to be size-field based and is recommended when BOI(s) or body sizing have been defined that include the polyhedra region.
+                    Determine whether or not you would like to merge bodies that contain multiple body labels when generating the volume mesh (the default is yes)
                     """
 
-                class _PolyFeatureAngle(PyNumericalCommandArgumentsSubItem):
+                class _QualityMethod(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify the angle to preserve features when using a polyhedral-based mesh.
+                    Choose from several different types of mesh quality controls (skewness, aspect ratio, change in size, and so on). Choices include Orthogonal (the default for the workflows), Enhanced Orthogonal, and Skewness. For more information, see  More... .
                     """
 
                 class _MinPolySize(PyNumericalCommandArgumentsSubItem):
@@ -10149,14 +10149,14 @@ class Root(PyMenu):
                     Argument MinPolySize.
                     """
 
-                class _QualityMethod(PyTextualCommandArgumentsSubItem):
+                class _UseSizeFieldInSolids(PyTextualCommandArgumentsSubItem):
                     """
-                    Choose from several different types of mesh quality controls (skewness, aspect ratio, change in size, and so on). Choices include Orthogonal (the default for the workflows), Enhanced Orthogonal, and Skewness. For more information, see  More... .
+                    This option is available when both the Use Size Field? and Fill Polyhedra in Solids? options are enabled for the poly-hexcore fill method. By default this option is set to no, which specifies growth-rate-based sizing for polyhedra regions during poly-hexcore generation. Selecting yes for this option specifies the sizing for polyhedra regions to be size-field based and is recommended when BOI(s) or body sizing have been defined that include the polyhedra region.
                     """
 
-                class _MergeBodyLabels(PyTextualCommandArgumentsSubItem):
+                class _PolyFeatureAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Determine whether or not you would like to merge bodies that contain multiple body labels when generating the volume mesh (the default is yes)
+                    Specify the angle to preserve features when using a polyhedral-based mesh.
                     """
 
                 class _UseSizeField(PyTextualCommandArgumentsSubItem):
@@ -10164,14 +10164,14 @@ class Root(PyMenu):
                     Specify whether or not to use size fields as part of generating the volume mesh. By default, this is set to yes when a BOI or body sizing has been defined in the Add Local Sizing task, however, for large cases, it can be turned off for the hexcore and poly-hexcore volume fill methods.
                     """
 
-                class _ShowVolumeMeshPreferences(PyParameterCommandArgumentsSubItem):
+                class _PolyInSolids(PyTextualCommandArgumentsSubItem):
                     """
-                    Display advanced options that you may want to apply to the task.
+                    Indicate whether or not to fill only polyhedra cells in all solid regions during volume meshing using the poly-hexcore volume fill method.  The default value is no. Setting this to yes may improve meshing efficiency.
                     """
 
-                class _TetInSolids(PyTextualCommandArgumentsSubItem):
+                class _MinEdgeLength(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument TetInSolids.
+                    Argument MinEdgeLength.
                     """
 
                 class _AddMultipleQualityMethods(PyTextualCommandArgumentsSubItem):
@@ -10204,14 +10204,14 @@ class Root(PyMenu):
                     Indicate whether or not you want to avoid any potential 1:8 cell transition in the hexcore region of the volume mesh, replacing any abrupt change in the cell size with polyhedral cells to improve solver performance in such transitional areas.
                     """
 
-                class _PolyInSolids(PyTextualCommandArgumentsSubItem):
+                class _PrepareZoneNames(PyTextualCommandArgumentsSubItem):
                     """
-                    Indicate whether or not to fill only polyhedra cells in all solid regions during volume meshing using the poly-hexcore volume fill method.  The default value is no. Setting this to yes may improve meshing efficiency.
+                    Indicate whether or not you want to persistently rename volume mesh components. This will make zone names equivalent to region names, and will make cell and face zone names unique.  Using this field is highly recommended for any parametric study. Persistent renaming only works if all body names are unique.
                     """
 
-                class _MinEdgeLength(PyNumericalCommandArgumentsSubItem):
+                class _ShowVolumeMeshPreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument MinEdgeLength.
+                    Display advanced options that you may want to apply to the task.
                     """
 
                 class _SolidGrowthRate(PyNumericalCommandArgumentsSubItem):
@@ -10219,9 +10219,9 @@ class Root(PyMenu):
                     Specify the rate of growth for a tetrahedron or polyhedron mesh.
                     """
 
-                class _PrepareZoneNames(PyTextualCommandArgumentsSubItem):
+                class _TetInSolids(PyTextualCommandArgumentsSubItem):
                     """
-                    Indicate whether or not you want to persistently rename volume mesh components. This will make zone names equivalent to region names, and will make cell and face zone names unique.  Using this field is highly recommended for any parametric study. Persistent renaming only works if all body names are unique.
+                    Argument TetInSolids.
                     """
 
                 class _QualityWarningLimit(PyNumericalCommandArgumentsSubItem):
@@ -10245,8 +10245,8 @@ class Root(PyMenu):
                     self.MergeBoundaryLayers = self._MergeBoundaryLayers(self, "MergeBoundaryLayers", service, rules, path)
                     self.ShowPrismPreferences = self._ShowPrismPreferences(self, "ShowPrismPreferences", service, rules, path)
                     self.NormalSmoothRelaxationFactor = self._NormalSmoothRelaxationFactor(self, "NormalSmoothRelaxationFactor", service, rules, path)
-                    self.PrismMinAspectRatio = self._PrismMinAspectRatio(self, "PrismMinAspectRatio", service, rules, path)
                     self.StairstepExposedQuads = self._StairstepExposedQuads(self, "StairstepExposedQuads", service, rules, path)
+                    self.PrismMinAspectRatio = self._PrismMinAspectRatio(self, "PrismMinAspectRatio", service, rules, path)
                     self.PrismAdjacentAngle = self._PrismAdjacentAngle(self, "PrismAdjacentAngle", service, rules, path)
 
                 class _PrismKeepFirstLayer(PyTextualCommandArgumentsSubItem):
@@ -10294,14 +10294,14 @@ class Root(PyMenu):
                     Specify the smoothness factor for normal prism layers. Increasing this value will generate more prism layers especially near sharp corners.
                     """
 
-                class _PrismMinAspectRatio(PyNumericalCommandArgumentsSubItem):
+                class _StairstepExposedQuads(PyTextualCommandArgumentsSubItem):
                     """
-                    Controls the minimum aspect ratio for cells at the boundary of the thin volume mesh regions. By default, this option is set to 0.3, other than for Stacked Plates, where it is set to 0.1. For flat parallel plates (not including stacked plates), it is recommended to use a value of 0.1 to produce a high quality thin volume mesh.
+                    This option can be used when generating a tetrahedral mesh with prism cells and is set to No by default. Selecting Yes for this option will enable stair-stepping for exposed quadrilateral faces (exposed quads) on prism cells. Stair-stepping will prevent pyramids from being created on these exposed quads, which generally would lead to poor quality in the exposed quad location.
                     """
 
-                class _StairstepExposedQuads(PyTextualCommandArgumentsSubItem):
+                class _PrismMinAspectRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    This option can be used when generating a tetrahedral mesh with prism cells and is set to No by default. Selecting Yes for this option will enable stair-stepping for exposed quadrilateral faces (exposed quads) on prism cells. Stair-stepping will prevent pyramids from being created on these exposed quads, which generally would lead to poor quality in the exposed quad location.
+                    Controls the minimum aspect ratio for cells at the boundary of the thin volume mesh regions. By default, this option is set to 0.3, other than for Stacked Plates, where it is set to 0.1. For flat parallel plates (not including stacked plates), it is recommended to use a value of 0.1 to produce a high quality thin volume mesh.
                     """
 
                 class _PrismAdjacentAngle(PyNumericalCommandArgumentsSubItem):
@@ -10316,19 +10316,19 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.ShowGlobalThinVolumePreferences = self._ShowGlobalThinVolumePreferences(self, "ShowGlobalThinVolumePreferences", service, rules, path)
                     self.MinAspectRatio = self._MinAspectRatio(self, "MinAspectRatio", service, rules, path)
+                    self.ShowGlobalThinVolumePreferences = self._ShowGlobalThinVolumePreferences(self, "ShowGlobalThinVolumePreferences", service, rules, path)
                     self.StairStep = self._StairStep(self, "StairStep", service, rules, path)
                     self.AutoOrderControls = self._AutoOrderControls(self, "AutoOrderControls", service, rules, path)
 
-                class _ShowGlobalThinVolumePreferences(PyParameterCommandArgumentsSubItem):
+                class _MinAspectRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Display global settings for thin volume meshing.
+                    Controls the minimum aspect ratio for cells at the boundary of the thin volume mesh regions. By default, this option is set to 0.3, other than for Stacked Plates, where it is set to 0.1. For flat parallel plates (not including stacked plates), it is recommended to use a value of 0.1 to produce a high quality thin volume mesh.
                     """
 
-                class _MinAspectRatio(PyNumericalCommandArgumentsSubItem):
+                class _ShowGlobalThinVolumePreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Controls the minimum aspect ratio for cells at the boundary of the thin volume mesh regions. By default, this option is set to 0.3, other than for Stacked Plates, where it is set to 0.1. For flat parallel plates (not including stacked plates), it is recommended to use a value of 0.1 to produce a high quality thin volume mesh.
+                    Display global settings for thin volume meshing.
                     """
 
                 class _StairStep(PyTextualCommandArgumentsSubItem):
@@ -10488,8 +10488,8 @@ class Root(PyMenu):
                     self.SaveSizeFieldFile = self._SaveSizeFieldFile(self, "SaveSizeFieldFile", service, rules, path)
                     self.MaxSize = self._MaxSize(self, "MaxSize", service, rules, path)
                     self.ScopeProximityTo = self._ScopeProximityTo(self, "ScopeProximityTo", service, rules, path)
-                    self.PreviewSizefield = self._PreviewSizefield(self, "PreviewSizefield", service, rules, path)
                     self.CurvatureNormalAngle = self._CurvatureNormalAngle(self, "CurvatureNormalAngle", service, rules, path)
+                    self.PreviewSizefield = self._PreviewSizefield(self, "PreviewSizefield", service, rules, path)
                     self.SaveSizeField = self._SaveSizeField(self, "SaveSizeField", service, rules, path)
                     self.UseSizeFiles = self._UseSizeFiles(self, "UseSizeFiles", service, rules, path)
                     self.AutoCreateScopedSizing = self._AutoCreateScopedSizing(self, "AutoCreateScopedSizing", service, rules, path)
@@ -10519,14 +10519,14 @@ class Root(PyMenu):
                     Argument ScopeProximityTo.
                     """
 
-                class _PreviewSizefield(PyParameterCommandArgumentsSubItem):
+                class _CurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument PreviewSizefield.
+                    Argument CurvatureNormalAngle.
                     """
 
-                class _CurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _PreviewSizefield(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument CurvatureNormalAngle.
+                    Argument PreviewSizefield.
                     """
 
                 class _SaveSizeField(PyParameterCommandArgumentsSubItem):
@@ -11012,8 +11012,8 @@ class Root(PyMenu):
                     self.Y2 = self._Y2(self, "Y2", service, rules, path)
                     self.Node3 = self._Node3(self, "Node3", service, rules, path)
                     self.X2 = self._X2(self, "X2", service, rules, path)
-                    self.Node2 = self._Node2(self, "Node2", service, rules, path)
                     self.Y_Offset = self._Y_Offset(self, "Y-Offset", service, rules, path)
+                    self.Node2 = self._Node2(self, "Node2", service, rules, path)
                     self.HeightFrontInc = self._HeightFrontInc(self, "HeightFrontInc", service, rules, path)
                     self.Radius1 = self._Radius1(self, "Radius1", service, rules, path)
 
@@ -11082,14 +11082,14 @@ class Root(PyMenu):
                     Argument X2.
                     """
 
-                class _Node2(PyTextualCommandArgumentsSubItem):
+                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Node2.
+                    Argument Y-Offset.
                     """
 
-                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
+                class _Node2(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument Y-Offset.
+                    Argument Node2.
                     """
 
                 class _HeightFrontInc(PyNumericalCommandArgumentsSubItem):
@@ -11115,7 +11115,7 @@ class Root(PyMenu):
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
                     self.SizeRelativeLength = self._SizeRelativeLength(self, "SizeRelativeLength", service, rules, path)
-                    self.XmaxRatio = self._XmaxRatio(self, "XmaxRatio", service, rules, path)
+                    self.Xmax = self._Xmax(self, "Xmax", service, rules, path)
                     self.XminRatio = self._XminRatio(self, "XminRatio", service, rules, path)
                     self.YminRatio = self._YminRatio(self, "YminRatio", service, rules, path)
                     self.Zmin = self._Zmin(self, "Zmin", service, rules, path)
@@ -11126,16 +11126,16 @@ class Root(PyMenu):
                     self.Xmin = self._Xmin(self, "Xmin", service, rules, path)
                     self.YmaxRatio = self._YmaxRatio(self, "YmaxRatio", service, rules, path)
                     self.ZmaxRatio = self._ZmaxRatio(self, "ZmaxRatio", service, rules, path)
-                    self.Xmax = self._Xmax(self, "Xmax", service, rules, path)
+                    self.XmaxRatio = self._XmaxRatio(self, "XmaxRatio", service, rules, path)
 
                 class _SizeRelativeLength(PyTextualCommandArgumentsSubItem):
                     """
                     Determine if you would like to specify the bounding box for the construction surface as a ratio of the geometry length, or by specifying a specific location for the minimum and maximum coordinates.
                     """
 
-                class _XmaxRatio(PyNumericalCommandArgumentsSubItem):
+                class _Xmax(PyNumericalCommandArgumentsSubItem):
                     """
-                    Extends the maximum size of the bounding box in the X direction by the specified value. The value is the ratio relative to the geometry size in the X direction.
+                    Extends the maximum size of the bounding box in the X direction by the specified value.
                     """
 
                 class _XminRatio(PyNumericalCommandArgumentsSubItem):
@@ -11188,9 +11188,9 @@ class Root(PyMenu):
                     Extends the maximum size of the bounding box in the Z direction by the specified value. The value is the ratio relative to the geometry size in the Z direction.
                     """
 
-                class _Xmax(PyNumericalCommandArgumentsSubItem):
+                class _XmaxRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Extends the maximum size of the bounding box in the X direction by the specified value.
+                    Extends the maximum size of the bounding box in the X direction by the specified value. The value is the ratio relative to the geometry size in the X direction.
                     """
 
         def create_instance(self) -> _IdentifyConstructionSurfacesCommandArguments:
@@ -11623,9 +11623,9 @@ class Root(PyMenu):
                     self.OneZonePer = self._OneZonePer(self, "OneZonePer", service, rules, path)
                     self.UsePartOrBodyAsSuffix = self._UsePartOrBodyAsSuffix(self, "UsePartOrBodyAsSuffix", service, rules, path)
                     self.ImportNamedSelections = self._ImportNamedSelections(self, "ImportNamedSelections", service, rules, path)
-                    self.ImportCurvatureDataFromCAD = self._ImportCurvatureDataFromCAD(self, "ImportCurvatureDataFromCAD", service, rules, path)
-                    self.ImportPartNames = self._ImportPartNames(self, "ImportPartNames", service, rules, path)
                     self.ExtractFeatures = self._ExtractFeatures(self, "ExtractFeatures", service, rules, path)
+                    self.ImportPartNames = self._ImportPartNames(self, "ImportPartNames", service, rules, path)
+                    self.ImportCurvatureDataFromCAD = self._ImportCurvatureDataFromCAD(self, "ImportCurvatureDataFromCAD", service, rules, path)
 
                 class _SavePMDBIntermediateFile(PyParameterCommandArgumentsSubItem):
                     """
@@ -11667,9 +11667,9 @@ class Root(PyMenu):
                     Argument ImportNamedSelections.
                     """
 
-                class _ImportCurvatureDataFromCAD(PyParameterCommandArgumentsSubItem):
+                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ImportCurvatureDataFromCAD.
+                    Argument ExtractFeatures.
                     """
 
                 class _ImportPartNames(PyParameterCommandArgumentsSubItem):
@@ -11677,9 +11677,9 @@ class Root(PyMenu):
                     Argument ImportPartNames.
                     """
 
-                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
+                class _ImportCurvatureDataFromCAD(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ExtractFeatures.
+                    Argument ImportCurvatureDataFromCAD.
                     """
 
         def create_instance(self) -> _ImportBodyOfInfluenceGeometryCommandArguments:
@@ -11884,11 +11884,11 @@ class Root(PyMenu):
                     self.CreateCADAssemblies = self._CreateCADAssemblies(self, "CreateCADAssemblies", service, rules, path)
                     self.FeatureAngle = self._FeatureAngle(self, "FeatureAngle", service, rules, path)
                     self.OneZonePer = self._OneZonePer(self, "OneZonePer", service, rules, path)
-                    self.UsePartOrBodyAsSuffix = self._UsePartOrBodyAsSuffix(self, "UsePartOrBodyAsSuffix", service, rules, path)
-                    self.ImportNamedSelections = self._ImportNamedSelections(self, "ImportNamedSelections", service, rules, path)
                     self.ImportCurvatureDataFromCAD = self._ImportCurvatureDataFromCAD(self, "ImportCurvatureDataFromCAD", service, rules, path)
-                    self.ImportPartNames = self._ImportPartNames(self, "ImportPartNames", service, rules, path)
                     self.ExtractFeatures = self._ExtractFeatures(self, "ExtractFeatures", service, rules, path)
+                    self.ImportNamedSelections = self._ImportNamedSelections(self, "ImportNamedSelections", service, rules, path)
+                    self.ImportPartNames = self._ImportPartNames(self, "ImportPartNames", service, rules, path)
+                    self.UsePartOrBodyAsSuffix = self._UsePartOrBodyAsSuffix(self, "UsePartOrBodyAsSuffix", service, rules, path)
 
                 class _SavePMDBIntermediateFile(PyParameterCommandArgumentsSubItem):
                     """
@@ -11920,19 +11920,19 @@ class Root(PyMenu):
                     Argument OneZonePer.
                     """
 
-                class _UsePartOrBodyAsSuffix(PyParameterCommandArgumentsSubItem):
+                class _ImportCurvatureDataFromCAD(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument UsePartOrBodyAsSuffix.
+                    Argument ImportCurvatureDataFromCAD.
                     """
 
-                class _ImportNamedSelections(PyParameterCommandArgumentsSubItem):
+                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ImportNamedSelections.
+                    Argument ExtractFeatures.
                     """
 
-                class _ImportCurvatureDataFromCAD(PyParameterCommandArgumentsSubItem):
+                class _ImportNamedSelections(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ImportCurvatureDataFromCAD.
+                    Argument ImportNamedSelections.
                     """
 
                 class _ImportPartNames(PyParameterCommandArgumentsSubItem):
@@ -11940,9 +11940,9 @@ class Root(PyMenu):
                     Argument ImportPartNames.
                     """
 
-                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
+                class _UsePartOrBodyAsSuffix(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ExtractFeatures.
+                    Argument UsePartOrBodyAsSuffix.
                     """
 
         def create_instance(self) -> _ImportGeometryCommandArguments:
@@ -12378,9 +12378,9 @@ class Root(PyMenu):
                     super().__init__(parent, attr, service, rules, path)
                     self.FacetMaxEdgeLength = self._FacetMaxEdgeLength(self, "FacetMaxEdgeLength", service, rules, path)
                     self.FacetResolution = self._FacetResolution(self, "FacetResolution", service, rules, path)
-                    self.NormalAngle = self._NormalAngle(self, "NormalAngle", service, rules, path)
-                    self.MaxEdgeLengthFactor = self._MaxEdgeLengthFactor(self, "MaxEdgeLengthFactor", service, rules, path)
                     self.Deviation = self._Deviation(self, "Deviation", service, rules, path)
+                    self.MaxEdgeLengthFactor = self._MaxEdgeLengthFactor(self, "MaxEdgeLengthFactor", service, rules, path)
+                    self.NormalAngle = self._NormalAngle(self, "NormalAngle", service, rules, path)
                     self.MaxEdgeLength = self._MaxEdgeLength(self, "MaxEdgeLength", service, rules, path)
                     self.CustomNormalAngle = self._CustomNormalAngle(self, "CustomNormalAngle", service, rules, path)
                     self.CustomDeviation = self._CustomDeviation(self, "CustomDeviation", service, rules, path)
@@ -12396,9 +12396,9 @@ class Root(PyMenu):
                     Argument FacetResolution.
                     """
 
-                class _NormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _Deviation(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument NormalAngle.
+                    Argument Deviation.
                     """
 
                 class _MaxEdgeLengthFactor(PyNumericalCommandArgumentsSubItem):
@@ -12406,9 +12406,9 @@ class Root(PyMenu):
                     Argument MaxEdgeLengthFactor.
                     """
 
-                class _Deviation(PyNumericalCommandArgumentsSubItem):
+                class _NormalAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Deviation.
+                    Argument NormalAngle.
                     """
 
                 class _MaxEdgeLength(PyNumericalCommandArgumentsSubItem):
@@ -12535,9 +12535,9 @@ class Root(PyMenu):
                     self.MinSize = self._MinSize(self, "MinSize", service, rules, path)
                     self.WrapMax = self._WrapMax(self, "WrapMax", service, rules, path)
                     self.AdvancedOptions = self._AdvancedOptions(self, "AdvancedOptions", service, rules, path)
-                    self.SizingType = self._SizingType(self, "SizingType", service, rules, path)
                     self.WrapGrowthRate = self._WrapGrowthRate(self, "WrapGrowthRate", service, rules, path)
                     self.InitialSizeControl = self._InitialSizeControl(self, "InitialSizeControl", service, rules, path)
+                    self.SizingType = self._SizingType(self, "SizingType", service, rules, path)
                     self.CellsPerGap = self._CellsPerGap(self, "CellsPerGap", service, rules, path)
                     self.WrapCurvatureNormalAngle = self._WrapCurvatureNormalAngle(self, "WrapCurvatureNormalAngle", service, rules, path)
                     self.TargetSizeControl = self._TargetSizeControl(self, "TargetSizeControl", service, rules, path)
@@ -12588,11 +12588,6 @@ class Root(PyMenu):
                     Display advanced wrap-specific options that are also applied to the task. See this description  for more information about wrap (and target) mesh size controls.
                     """
 
-                class _SizingType(PyTextualCommandArgumentsSubItem):
-                    """
-                    Choose the type of sizing control (curvature, proximity, soft, or boi).
-                    """
-
                 class _WrapGrowthRate(PyNumericalCommandArgumentsSubItem):
                     """
                     Specify the increase in element edge length with each succeeding layer of elements.
@@ -12603,6 +12598,11 @@ class Root(PyMenu):
                     Enable this field to display the initial size control in the graphics window.
                     """
 
+                class _SizingType(PyTextualCommandArgumentsSubItem):
+                    """
+                    Choose the type of sizing control (curvature, proximity, soft, or boi).
+                    """
+
                 class _CellsPerGap(PyNumericalCommandArgumentsSubItem):
                     """
                     Specify the minimum number of layers of elements to be generated in the gaps. The number of cells per gap can be a real value, with a minimum value of 0.01.
@@ -12994,8 +12994,8 @@ class Root(PyMenu):
                     self.SaveSizeFieldFile = self._SaveSizeFieldFile(self, "SaveSizeFieldFile", service, rules, path)
                     self.MaxSize = self._MaxSize(self, "MaxSize", service, rules, path)
                     self.ScopeProximityTo = self._ScopeProximityTo(self, "ScopeProximityTo", service, rules, path)
-                    self.CurvatureNormalAngle = self._CurvatureNormalAngle(self, "CurvatureNormalAngle", service, rules, path)
                     self.PreviewSizefield = self._PreviewSizefield(self, "PreviewSizefield", service, rules, path)
+                    self.CurvatureNormalAngle = self._CurvatureNormalAngle(self, "CurvatureNormalAngle", service, rules, path)
                     self.SaveSizeField = self._SaveSizeField(self, "SaveSizeField", service, rules, path)
                     self.UseSizeFiles = self._UseSizeFiles(self, "UseSizeFiles", service, rules, path)
                     self.AutoCreateScopedSizing = self._AutoCreateScopedSizing(self, "AutoCreateScopedSizing", service, rules, path)
@@ -13025,14 +13025,14 @@ class Root(PyMenu):
                     Argument ScopeProximityTo.
                     """
 
-                class _CurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _PreviewSizefield(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument CurvatureNormalAngle.
+                    Argument PreviewSizefield.
                     """
 
-                class _PreviewSizefield(PyParameterCommandArgumentsSubItem):
+                class _CurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument PreviewSizefield.
+                    Argument CurvatureNormalAngle.
                     """
 
                 class _SaveSizeField(PyParameterCommandArgumentsSubItem):
@@ -14020,10 +14020,10 @@ class Root(PyMenu):
                     self.ConnectLabelWildcard = self._ConnectLabelWildcard(self, "ConnectLabelWildcard", service, rules, path)
                     self.AllowDefeaturing = self._AllowDefeaturing(self, "AllowDefeaturing", service, rules, path)
                     self.RelativeShareTopologyTolerance = self._RelativeShareTopologyTolerance(self, "RelativeShareTopologyTolerance", service, rules, path)
-                    self.ShareTopologyAngle = self._ShareTopologyAngle(self, "ShareTopologyAngle", service, rules, path)
+                    self.FluidLabelWildcard = self._FluidLabelWildcard(self, "FluidLabelWildcard", service, rules, path)
                     self.ExecuteJoinIntersect = self._ExecuteJoinIntersect(self, "ExecuteJoinIntersect", service, rules, path)
                     self.Operation = self._Operation(self, "Operation", service, rules, path)
-                    self.FluidLabelWildcard = self._FluidLabelWildcard(self, "FluidLabelWildcard", service, rules, path)
+                    self.ShareTopologyAngle = self._ShareTopologyAngle(self, "ShareTopologyAngle", service, rules, path)
                     self.STToleranceIncrement = self._STToleranceIncrement(self, "STToleranceIncrement", service, rules, path)
                     self.IntfLabelList = self._IntfLabelList(self, "IntfLabelList", service, rules, path)
                     self.PerLabelList = self._PerLabelList(self, "PerLabelList", service, rules, path)
@@ -14056,9 +14056,9 @@ class Root(PyMenu):
                     Specify the relative tolerance for joining or intersecting face pairs, or the relative tolerance for connecting edge and face pairs.
                     """
 
-                class _ShareTopologyAngle(PyNumericalCommandArgumentsSubItem):
+                class _FluidLabelWildcard(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify the threshold angle for joining face pairs.
+                    Argument FluidLabelWildcard.
                     """
 
                 class _ExecuteJoinIntersect(PyTextualCommandArgumentsSubItem):
@@ -14071,9 +14071,9 @@ class Root(PyMenu):
                     Choose whether to apply share topology using the Join-Intersect method where you join and/or intersect the problematic faces, or using the Interface Connect method where you connect edges of overlapping face pairs. Note that imprinting of overlapping faces in SCDM/Discovery is highly recommended for the Interface Connect method.
                     """
 
-                class _FluidLabelWildcard(PyTextualCommandArgumentsSubItem):
+                class _ShareTopologyAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument FluidLabelWildcard.
+                    Specify the threshold angle for joining face pairs.
                     """
 
                 class _STToleranceIncrement(PyNumericalCommandArgumentsSubItem):
@@ -14118,10 +14118,10 @@ class Root(PyMenu):
                     self.SIQualityIterations = self._SIQualityIterations(self, "SIQualityIterations", service, rules, path)
                     self.SIQualityMaxAngle = self._SIQualityMaxAngle(self, "SIQualityMaxAngle", service, rules, path)
                     self.AllowDefeaturing = self._AllowDefeaturing(self, "AllowDefeaturing", service, rules, path)
-                    self.ShowSMImprovePreferences = self._ShowSMImprovePreferences(self, "ShowSMImprovePreferences", service, rules, path)
+                    self.SIRemoveStep = self._SIRemoveStep(self, "SIRemoveStep", service, rules, path)
                     self.AdvancedImprove = self._AdvancedImprove(self, "AdvancedImprove", service, rules, path)
                     self.SIStepWidth = self._SIStepWidth(self, "SIStepWidth", service, rules, path)
-                    self.SIRemoveStep = self._SIRemoveStep(self, "SIRemoveStep", service, rules, path)
+                    self.ShowSMImprovePreferences = self._ShowSMImprovePreferences(self, "ShowSMImprovePreferences", service, rules, path)
 
                 class _SIStepQualityLimit(PyNumericalCommandArgumentsSubItem):
                     """
@@ -14148,9 +14148,9 @@ class Root(PyMenu):
                     Argument AllowDefeaturing.
                     """
 
-                class _ShowSMImprovePreferences(PyParameterCommandArgumentsSubItem):
+                class _SIRemoveStep(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument ShowSMImprovePreferences.
+                    Argument SIRemoveStep.
                     """
 
                 class _AdvancedImprove(PyTextualCommandArgumentsSubItem):
@@ -14163,9 +14163,9 @@ class Root(PyMenu):
                     Argument SIStepWidth.
                     """
 
-                class _SIRemoveStep(PyTextualCommandArgumentsSubItem):
+                class _ShowSMImprovePreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument SIRemoveStep.
+                    Argument ShowSMImprovePreferences.
                     """
 
             class _SurfaceMeshPreferences(PySingletonCommandArgumentsSubItem):
@@ -14178,19 +14178,19 @@ class Root(PyMenu):
                     self.SMQualityCollapseLimit = self._SMQualityCollapseLimit(self, "SMQualityCollapseLimit", service, rules, path)
                     self.AutoMerge = self._AutoMerge(self, "AutoMerge", service, rules, path)
                     self.SMSeparation = self._SMSeparation(self, "SMSeparation", service, rules, path)
+                    self.SMSeparationAngle = self._SMSeparationAngle(self, "SMSeparationAngle", service, rules, path)
                     self.ShowSurfaceMeshPreferences = self._ShowSurfaceMeshPreferences(self, "ShowSurfaceMeshPreferences", service, rules, path)
-                    self.SMQualityImprove = self._SMQualityImprove(self, "SMQualityImprove", service, rules, path)
                     self.FoldFaceLimit = self._FoldFaceLimit(self, "FoldFaceLimit", service, rules, path)
                     self.TVMAutoControlCreation = self._TVMAutoControlCreation(self, "TVMAutoControlCreation", service, rules, path)
-                    self.SMSeparationAngle = self._SMSeparationAngle(self, "SMSeparationAngle", service, rules, path)
+                    self.SMQualityImprove = self._SMQualityImprove(self, "SMQualityImprove", service, rules, path)
                     self.SMRemoveStep = self._SMRemoveStep(self, "SMRemoveStep", service, rules, path)
                     self.SMStepWidth = self._SMStepWidth(self, "SMStepWidth", service, rules, path)
-                    self.VolumeMeshMaxSize = self._VolumeMeshMaxSize(self, "VolumeMeshMaxSize", service, rules, path)
-                    self.AutoAssignZoneTypes = self._AutoAssignZoneTypes(self, "AutoAssignZoneTypes", service, rules, path)
                     self.SMQualityMaxAngle = self._SMQualityMaxAngle(self, "SMQualityMaxAngle", service, rules, path)
-                    self.SMQualityImproveLimit = self._SMQualityImproveLimit(self, "SMQualityImproveLimit", service, rules, path)
-                    self.AutoSurfaceRemesh = self._AutoSurfaceRemesh(self, "AutoSurfaceRemesh", service, rules, path)
+                    self.AutoAssignZoneTypes = self._AutoAssignZoneTypes(self, "AutoAssignZoneTypes", service, rules, path)
+                    self.VolumeMeshMaxSize = self._VolumeMeshMaxSize(self, "VolumeMeshMaxSize", service, rules, path)
                     self.SelfIntersectCheck = self._SelfIntersectCheck(self, "SelfIntersectCheck", service, rules, path)
+                    self.AutoSurfaceRemesh = self._AutoSurfaceRemesh(self, "AutoSurfaceRemesh", service, rules, path)
+                    self.SMQualityImproveLimit = self._SMQualityImproveLimit(self, "SMQualityImproveLimit", service, rules, path)
                     self.SetVolumeMeshMaxSize = self._SetVolumeMeshMaxSize(self, "SetVolumeMeshMaxSize", service, rules, path)
 
                 class _SMQualityCollapseLimit(PyNumericalCommandArgumentsSubItem):
@@ -14208,14 +14208,14 @@ class Root(PyMenu):
                     Argument SMSeparation.
                     """
 
-                class _ShowSurfaceMeshPreferences(PyParameterCommandArgumentsSubItem):
+                class _SMSeparationAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument ShowSurfaceMeshPreferences.
+                    Argument SMSeparationAngle.
                     """
 
-                class _SMQualityImprove(PyTextualCommandArgumentsSubItem):
+                class _ShowSurfaceMeshPreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument SMQualityImprove.
+                    Argument ShowSurfaceMeshPreferences.
                     """
 
                 class _FoldFaceLimit(PyNumericalCommandArgumentsSubItem):
@@ -14228,9 +14228,9 @@ class Root(PyMenu):
                     Argument TVMAutoControlCreation.
                     """
 
-                class _SMSeparationAngle(PyNumericalCommandArgumentsSubItem):
+                class _SMQualityImprove(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument SMSeparationAngle.
+                    Argument SMQualityImprove.
                     """
 
                 class _SMRemoveStep(PyTextualCommandArgumentsSubItem):
@@ -14243,9 +14243,9 @@ class Root(PyMenu):
                     Argument SMStepWidth.
                     """
 
-                class _VolumeMeshMaxSize(PyNumericalCommandArgumentsSubItem):
+                class _SMQualityMaxAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument VolumeMeshMaxSize.
+                    Argument SMQualityMaxAngle.
                     """
 
                 class _AutoAssignZoneTypes(PyTextualCommandArgumentsSubItem):
@@ -14253,14 +14253,14 @@ class Root(PyMenu):
                     Argument AutoAssignZoneTypes.
                     """
 
-                class _SMQualityMaxAngle(PyNumericalCommandArgumentsSubItem):
+                class _VolumeMeshMaxSize(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument SMQualityMaxAngle.
+                    Argument VolumeMeshMaxSize.
                     """
 
-                class _SMQualityImproveLimit(PyNumericalCommandArgumentsSubItem):
+                class _SelfIntersectCheck(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument SMQualityImproveLimit.
+                    Argument SelfIntersectCheck.
                     """
 
                 class _AutoSurfaceRemesh(PyTextualCommandArgumentsSubItem):
@@ -14268,9 +14268,9 @@ class Root(PyMenu):
                     Argument AutoSurfaceRemesh.
                     """
 
-                class _SelfIntersectCheck(PyTextualCommandArgumentsSubItem):
+                class _SMQualityImproveLimit(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument SelfIntersectCheck.
+                    Argument SMQualityImproveLimit.
                     """
 
                 class _SetVolumeMeshMaxSize(PyTextualCommandArgumentsSubItem):
@@ -14360,10 +14360,10 @@ class Root(PyMenu):
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
                     self.NewLabelObjects = self._NewLabelObjects(self, "NewLabelObjects", service, rules, path)
-                    self.NewLabels = self._NewLabels(self, "NewLabels", service, rules, path)
-                    self.NewLabelType = self._NewLabelType(self, "NewLabelType", service, rules, path)
                     self.NewLabelResolution = self._NewLabelResolution(self, "NewLabelResolution", service, rules, path)
+                    self.NewLabelType = self._NewLabelType(self, "NewLabelType", service, rules, path)
                     self.NewLabelCells = self._NewLabelCells(self, "NewLabelCells", service, rules, path)
+                    self.NewLabels = self._NewLabels(self, "NewLabels", service, rules, path)
                     self.NewLabelMax = self._NewLabelMax(self, "NewLabelMax", service, rules, path)
                     self.NewZoneType = self._NewZoneType(self, "NewZoneType", service, rules, path)
                     self.NewLabelCurvature = self._NewLabelCurvature(self, "NewLabelCurvature", service, rules, path)
@@ -14374,9 +14374,9 @@ class Root(PyMenu):
                     Argument NewLabelObjects.
                     """
 
-                class _NewLabels(PyTextualCommandArgumentsSubItem):
+                class _NewLabelResolution(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument NewLabels.
+                    Argument NewLabelResolution.
                     """
 
                 class _NewLabelType(PyTextualCommandArgumentsSubItem):
@@ -14384,14 +14384,14 @@ class Root(PyMenu):
                     Argument NewLabelType.
                     """
 
-                class _NewLabelResolution(PyTextualCommandArgumentsSubItem):
+                class _NewLabelCells(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument NewLabelResolution.
+                    Argument NewLabelCells.
                     """
 
-                class _NewLabelCells(PyTextualCommandArgumentsSubItem):
+                class _NewLabels(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument NewLabelCells.
+                    Argument NewLabels.
                     """
 
                 class _NewLabelMax(PyTextualCommandArgumentsSubItem):