ansys-fluent-core 0.34.1__py3-none-any.whl → 0.35.0__py3-none-any.whl

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

@@ -96,6 +96,7 @@ class Root(PyMenu):
         self.ModifyMeshRefinement = self.__class__.ModifyMeshRefinement(service, rules, "ModifyMeshRefinement", path)
         self.PartManagement = self.__class__.PartManagement(service, rules, "PartManagement", path)
         self.PartReplacementSettings = self.__class__.PartReplacementSettings(service, rules, "PartReplacementSettings", path)
+        self.PrepareForVolumeMeshing = self.__class__.PrepareForVolumeMeshing(service, rules, "PrepareForVolumeMeshing", path)
         self.RemeshSurface = self.__class__.RemeshSurface(service, rules, "RemeshSurface", path)
         self.RunCustomJournal = self.__class__.RunCustomJournal(service, rules, "RunCustomJournal", path)
         self.SeparateContacts = self.__class__.SeparateContacts(service, rules, "SeparateContacts", path)
@@ -1307,9 +1308,9 @@ class Root(PyMenu):
                         self.Operation = self._Operation(self, "Operation", 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)
                         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)
 
@@ -1363,9 +1364,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 +1374,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 +1527,8 @@ class Root(PyMenu):
                     self.ShowShellBLAdvancedOptions = self._ShowShellBLAdvancedOptions(self, "ShowShellBLAdvancedOptions", 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 +1552,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):
@@ -1769,12 +1770,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.ModifyAtInvalidNormals = self._ModifyAtInvalidNormals(self, "ModifyAtInvalidNormals", service, rules, path)
                     self.SplitPrism = self._SplitPrism(self, "SplitPrism", service, rules, path)
+                    self.ModifyAtInvalidNormals = self._ModifyAtInvalidNormals(self, "ModifyAtInvalidNormals", 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)
@@ -1804,14 +1805,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 _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 _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 _InvalidNormalMethod(PyTextualCommandArgumentsSubItem):
@@ -1824,14 +1825,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):
@@ -2093,9 +2094,9 @@ class Root(PyMenu):
                     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.ShowLocalPrismPreferences = self._ShowLocalPrismPreferences(self, "ShowLocalPrismPreferences", service, rules, path)
                     self.NumberOfSplitLayers = self._NumberOfSplitLayers(self, "NumberOfSplitLayers", service, rules, path)
                     self.LastRatioNumLayers = self._LastRatioNumLayers(self, "LastRatioNumLayers", 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)
@@ -2140,11 +2141,6 @@ class Root(PyMenu):
                     Argument InvalidNormalMethod.
                     """
 
-                class _ShowLocalPrismPreferences(PyParameterCommandArgumentsSubItem):
-                    """
-                    Display advanced options that you may want to apply to this task.
-                    """
-
                 class _NumberOfSplitLayers(PyNumericalCommandArgumentsSubItem):
                     """
                     Indicate the number of split prism layers you wish to apply to each layer that you specified for the boundary layer definition.
@@ -2155,6 +2151,11 @@ class Root(PyMenu):
                     Argument LastRatioNumLayers.
                     """
 
+                class _ShowLocalPrismPreferences(PyParameterCommandArgumentsSubItem):
+                    """
+                    Display advanced options that you may want to apply to this task.
+                    """
+
                 class _AllowedTangencyAtInvalidNormals(PyNumericalCommandArgumentsSubItem):
                     """
                     Controls the tangency of the invalid normal faces. An invalid normal location with all 90 degree angles has a tangency of 1. So, faces are still treated as an invalid normal even if the angle deviates slightly from 90 degrees (resulting in a tangency of 0.98).
@@ -2301,6 +2302,7 @@ class Root(PyMenu):
         ----------
         LocalSettingsName : str
             Specify a name for the size control or use the default value.
+        ComputeForSolidOnly : str
         SelectionType : str
             Choose how you want to make your selection (by object, label, or zone name).
         ObjectSelectionList : list[str]
@@ -2331,6 +2333,7 @@ class Root(PyMenu):
             def __init__(self, service, rules, command, path, id):
                 super().__init__(service, rules, command, path, id)
                 self.LocalSettingsName = self._LocalSettingsName(self, "LocalSettingsName", service, rules, path)
+                self.ComputeForSolidOnly = self._ComputeForSolidOnly(self, "ComputeForSolidOnly", service, rules, path)
                 self.SelectionType = self._SelectionType(self, "SelectionType", service, rules, path)
                 self.ObjectSelectionList = self._ObjectSelectionList(self, "ObjectSelectionList", service, rules, path)
                 self.LabelSelectionList = self._LabelSelectionList(self, "LabelSelectionList", service, rules, path)
@@ -2349,6 +2352,11 @@ class Root(PyMenu):
                 Specify a name for the size control or use the default value.
                 """
 
+            class _ComputeForSolidOnly(PyTextualCommandArgumentsSubItem):
+                """
+                Argument ComputeForSolidOnly.
+                """
+
             class _SelectionType(PyTextualCommandArgumentsSubItem):
                 """
                 Choose how you want to make your selection (by object, label, or zone name).
@@ -2395,11 +2403,11 @@ 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.WrapGrowthRate = self._WrapGrowthRate(self, "WrapGrowthRate", service, rules, path)
-                    self.SizingType = self._SizingType(self, "SizingType", service, rules, path)
                     self.InitialSizeControl = self._InitialSizeControl(self, "InitialSizeControl", service, rules, path)
-                    self.CellsPerGap = self._CellsPerGap(self, "CellsPerGap", service, rules, path)
+                    self.SizingType = self._SizingType(self, "SizingType", service, rules, path)
+                    self.WrapGrowthRate = self._WrapGrowthRate(self, "WrapGrowthRate", service, rules, path)
                     self.WrapCurvatureNormalAngle = self._WrapCurvatureNormalAngle(self, "WrapCurvatureNormalAngle", service, rules, path)
+                    self.CellsPerGap = self._CellsPerGap(self, "CellsPerGap", service, rules, path)
                     self.TargetSizeControl = self._TargetSizeControl(self, "TargetSizeControl", service, rules, path)
                     self.GrowthRate = self._GrowthRate(self, "GrowthRate", service, rules, path)
 
@@ -2448,9 +2456,9 @@ 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 _WrapGrowthRate(PyNumericalCommandArgumentsSubItem):
+                class _InitialSizeControl(PyParameterCommandArgumentsSubItem):
                     """
-                    Specify the increase in element edge length with each succeeding layer of elements.
+                    Enable this field to display the initial size control in the graphics window.
                     """
 
                 class _SizingType(PyTextualCommandArgumentsSubItem):
@@ -2458,19 +2466,19 @@ class Root(PyMenu):
                     Choose the type of sizing control (curvature, proximity, soft, or boi).
                     """
 
-                class _InitialSizeControl(PyParameterCommandArgumentsSubItem):
+                class _WrapGrowthRate(PyNumericalCommandArgumentsSubItem):
                     """
-                    Enable this field to display the initial size control in the graphics window.
+                    Specify the increase in element edge length with each succeeding layer of elements.
                     """
 
-                class _CellsPerGap(PyNumericalCommandArgumentsSubItem):
+                class _WrapCurvatureNormalAngle(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.
+                    Specify the maximum allowable angle (from 0 to 180 degrees) that one element edge is allowed to span given a particular geometry curvature. You can use this field to limit the number of elements that are generated along a curve or surface if the minimum size is too small for that particular curve.
                     """
 
-                class _WrapCurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _CellsPerGap(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the maximum allowable angle (from 0 to 180 degrees) that one element edge is allowed to span given a particular geometry curvature. You can use this field to limit the number of elements that are generated along a curve or surface if the minimum size is too small for that particular curve.
+                    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.
                     """
 
                 class _TargetSizeControl(PyParameterCommandArgumentsSubItem):
@@ -2546,6 +2554,7 @@ class Root(PyMenu):
             Set curvature or proximity based refinement. The edges option considers edge-to-edge proximity, while faces considers face-to-face proximity, and faces and edges considers both. The edge labels option considers edge sizing based on edge labels. Note that when you use the edges or the faces and edges options, you can only select face zones or face labels. Also, saving a size control file after using either of these two options will not be persistent.
         IgnoreOrientation : str
             Specify whether or not you need to apply additional refinement in and around thin areas (such as between plates), without over-refinement. This ignores face proximity within voids and will not allow you to refine in thin voids, but will allow refinement in gaps. This should be used in predominantly fluid regions with no thin solid regions.
+        IgnoreProximityAcrossObjects : str
         BOIZoneorLabel : str
             Choose how you want to select your surface (by label or by zone).
         BOIFaceLabelList : list[str]
@@ -2592,6 +2601,7 @@ class Root(PyMenu):
                 self.BOICellsPerGap = self._BOICellsPerGap(self, "BOICellsPerGap", service, rules, path)
                 self.BOIScopeTo = self._BOIScopeTo(self, "BOIScopeTo", service, rules, path)
                 self.IgnoreOrientation = self._IgnoreOrientation(self, "IgnoreOrientation", service, rules, path)
+                self.IgnoreProximityAcrossObjects = self._IgnoreProximityAcrossObjects(self, "IgnoreProximityAcrossObjects", service, rules, path)
                 self.BOIZoneorLabel = self._BOIZoneorLabel(self, "BOIZoneorLabel", service, rules, path)
                 self.BOIFaceLabelList = self._BOIFaceLabelList(self, "BOIFaceLabelList", service, rules, path)
                 self.BOIFaceZoneList = self._BOIFaceZoneList(self, "BOIFaceZoneList", service, rules, path)
@@ -2694,6 +2704,11 @@ class Root(PyMenu):
                 Specify whether or not you need to apply additional refinement in and around thin areas (such as between plates), without over-refinement. This ignores face proximity within voids and will not allow you to refine in thin voids, but will allow refinement in gaps. This should be used in predominantly fluid regions with no thin solid regions.
                 """
 
+            class _IgnoreProximityAcrossObjects(PyTextualCommandArgumentsSubItem):
+                """
+                Argument IgnoreProximityAcrossObjects.
+                """
+
             class _BOIZoneorLabel(PyTextualCommandArgumentsSubItem):
                 """
                 Choose how you want to select your surface (by label or by zone).
@@ -2999,8 +3014,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 +3045,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):
@@ -3249,8 +3264,8 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.ShowShellBLAdvancedOptions = self._ShowShellBLAdvancedOptions(self, "ShowShellBLAdvancedOptions", service, rules, path)
                     self.ExposeSide = self._ExposeSide(self, "ExposeSide", service, rules, path)
+                    self.ShowShellBLAdvancedOptions = self._ShowShellBLAdvancedOptions(self, "ShowShellBLAdvancedOptions", 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)
@@ -3258,14 +3273,14 @@ class Root(PyMenu):
                     self.GapFactor = self._GapFactor(self, "GapFactor", service, rules, path)
                     self.AdjacentAttachAngle = self._AdjacentAttachAngle(self, "AdjacentAttachAngle", service, rules, path)
 
-                class _ShowShellBLAdvancedOptions(PyParameterCommandArgumentsSubItem):
+                class _ExposeSide(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument ShowShellBLAdvancedOptions.
+                    Argument ExposeSide.
                     """
 
-                class _ExposeSide(PyTextualCommandArgumentsSubItem):
+                class _ShowShellBLAdvancedOptions(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ExposeSide.
+                    Argument ShowShellBLAdvancedOptions.
                     """
 
                 class _MaxAspectRatio(PyNumericalCommandArgumentsSubItem):
@@ -4162,23 +4177,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 +4201,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 +4221,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 +4236,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 +4246,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 +4523,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 +4534,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 +4596,9 @@ class Root(PyMenu):
                     Argument ZmaxRatio.
                     """
 
-                class _Xmax(PyNumericalCommandArgumentsSubItem):
+                class _XmaxRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Xmax.
+                    Argument XmaxRatio.
                     """
 
             class _OffsetObject(PySingletonCommandArgumentsSubItem):
@@ -4598,16 +4613,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.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)
@@ -4639,24 +4654,24 @@ class Root(PyMenu):
                     Argument DefeaturingSize.
                     """
 
-                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
+                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument AspectRatio.
+                    Argument BoundaryLayerLevels.
                     """
 
-                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
+                class _Rate(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument NumberOfLayers.
+                    Argument Rate.
                     """
 
-                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
+                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument WakeGrowthFactor.
+                    Argument AspectRatio.
                     """
 
-                class _Rate(PyNumericalCommandArgumentsSubItem):
+                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Rate.
+                    Argument WakeGrowthFactor.
                     """
 
                 class _FlowDirection(PyTextualCommandArgumentsSubItem):
@@ -4674,19 +4689,19 @@ class Root(PyMenu):
                     Argument EdgeSelectionList.
                     """
 
-                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
+                class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument BoundaryLayerLevels.
+                    Argument NumberOfLayers.
                     """
 
-                class _X(PyNumericalCommandArgumentsSubItem):
+                class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument X.
+                    Argument LastRatioPercentage.
                     """
 
-                class _LastRatioPercentage(PyNumericalCommandArgumentsSubItem):
+                class _X(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument LastRatioPercentage.
+                    Argument X.
                     """
 
                 class _OffsetMethodType(PyTextualCommandArgumentsSubItem):
@@ -4726,32 +4741,32 @@ 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)
                     self.Z_Offset = self._Z_Offset(self, "Z-Offset", 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.Node1 = self._Node1(self, "Node1", service, rules, path)
+                    self.Z1 = self._Z1(self, "Z1", 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.Node2 = self._Node2(self, "Node2", 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 _HeightNode(PyTextualCommandArgumentsSubItem):
+                class _X_Offset(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument HeightNode.
+                    Argument X-Offset.
                     """
 
-                class _X_Offset(PyNumericalCommandArgumentsSubItem):
+                class _HeightNode(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument X-Offset.
+                    Argument HeightNode.
                     """
 
                 class _HeightBackInc(PyNumericalCommandArgumentsSubItem):
@@ -4774,9 +4789,9 @@ class Root(PyMenu):
                     Argument Z-Offset.
                     """
 
-                class _Z1(PyNumericalCommandArgumentsSubItem):
+                class _Z2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Z1.
+                    Argument Z2.
                     """
 
                 class _Node1(PyTextualCommandArgumentsSubItem):
@@ -4784,9 +4799,9 @@ class Root(PyMenu):
                     Argument Node1.
                     """
 
-                class _Z2(PyNumericalCommandArgumentsSubItem):
+                class _Z1(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Z2.
+                    Argument Z1.
                     """
 
                 class _Radius2(PyNumericalCommandArgumentsSubItem):
@@ -4804,9 +4819,9 @@ class Root(PyMenu):
                     Argument Node3.
                     """
 
-                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
+                class _X2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Y-Offset.
+                    Argument X2.
                     """
 
                 class _Node2(PyTextualCommandArgumentsSubItem):
@@ -4814,9 +4829,9 @@ class Root(PyMenu):
                     Argument Node2.
                     """
 
-                class _X2(PyNumericalCommandArgumentsSubItem):
+                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument X2.
+                    Argument Y-Offset.
                     """
 
                 class _HeightFrontInc(PyNumericalCommandArgumentsSubItem):
@@ -5187,8 +5202,8 @@ class Root(PyMenu):
                     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.Rate = self._Rate(self, "Rate", service, rules, path)
                     self.AspectRatio = self._AspectRatio(self, "AspectRatio", 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)
@@ -5236,14 +5251,14 @@ class Root(PyMenu):
                     Argument NumberOfLayers.
                     """
 
-                class _Rate(PyNumericalCommandArgumentsSubItem):
+                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Rate.
+                    Argument AspectRatio.
                     """
 
-                class _AspectRatio(PyNumericalCommandArgumentsSubItem):
+                class _Rate(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument AspectRatio.
+                    Argument Rate.
                     """
 
                 class _FlowDirection(PyTextualCommandArgumentsSubItem):
@@ -5325,9 +5340,9 @@ 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.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.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)
 
@@ -5391,9 +5406,9 @@ class Root(PyMenu):
                     Argument Node3.
                     """
 
-                class _Node2(PyTextualCommandArgumentsSubItem):
+                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument Node2.
+                    Argument Y-Offset.
                     """
 
                 class _X2(PyNumericalCommandArgumentsSubItem):
@@ -5401,9 +5416,9 @@ class Root(PyMenu):
                     Argument X2.
                     """
 
-                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
+                class _Node2(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument Y-Offset.
+                    Argument Node2.
                     """
 
                 class _HeightFrontInc(PyNumericalCommandArgumentsSubItem):
@@ -5470,8 +5485,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):
@@ -5529,14 +5544,14 @@ class Root(PyMenu):
                     Specify the x-coordinate of the offset collar mesh.
                     """
 
-                class _BoxCenterZ(PyNumericalCommandArgumentsSubItem):
+                class _CylinderRadius2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the z-coordinate of the offset collar mesh.
+                    Argument CylinderRadius2.
                     """
 
-                class _CylinderRadius2(PyNumericalCommandArgumentsSubItem):
+                class _BoxCenterZ(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument CylinderRadius2.
+                    Specify the z-coordinate of the offset collar mesh.
                     """
 
                 class _CylinderY2(PyNumericalCommandArgumentsSubItem):
@@ -5683,7 +5698,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)
@@ -5694,16 +5709,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 component mesh 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):
@@ -5756,9 +5771,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.
                     """
 
             class _OffsetObject(PySingletonCommandArgumentsSubItem):
@@ -5775,8 +5790,8 @@ class Root(PyMenu):
                     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.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", service, rules, path)
                     self.BoundaryLayerLevels = self._BoundaryLayerLevels(self, "BoundaryLayerLevels", service, rules, path)
+                    self.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", 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)
@@ -5824,14 +5839,14 @@ class Root(PyMenu):
                     Select the number of boundary layers to be generated.
                     """
 
-                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
+                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument WakeGrowthFactor.
+                    Argument BoundaryLayerLevels.
                     """
 
-                class _BoundaryLayerLevels(PyNumericalCommandArgumentsSubItem):
+                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument BoundaryLayerLevels.
+                    Argument WakeGrowthFactor.
                     """
 
                 class _FlowDirection(PyTextualCommandArgumentsSubItem):
@@ -5901,8 +5916,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)
@@ -5919,14 +5934,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):
@@ -6370,7 +6385,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)
@@ -6381,16 +6396,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 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):
@@ -6443,9 +6458,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) -> _CreateExternalFlowBoundariesCommandArguments:
@@ -6648,8 +6663,8 @@ class Root(PyMenu):
         LeakShieldName : str
         UseSizeField : str
         SizeFieldFileName : str
-        MaxHoleSize : float
         MinHoleSize : float
+        MaxHoleSize : float
         SpecifyObj : bool
         SpecifyLive : bool
         SpecifyDead : bool
@@ -6670,8 +6685,8 @@ class Root(PyMenu):
                 self.LeakShieldName = self._LeakShieldName(self, "LeakShieldName", service, rules, path)
                 self.UseSizeField = self._UseSizeField(self, "UseSizeField", service, rules, path)
                 self.SizeFieldFileName = self._SizeFieldFileName(self, "SizeFieldFileName", service, rules, path)
-                self.MaxHoleSize = self._MaxHoleSize(self, "MaxHoleSize", service, rules, path)
                 self.MinHoleSize = self._MinHoleSize(self, "MinHoleSize", service, rules, path)
+                self.MaxHoleSize = self._MaxHoleSize(self, "MaxHoleSize", service, rules, path)
                 self.SpecifyObj = self._SpecifyObj(self, "SpecifyObj", service, rules, path)
                 self.SpecifyLive = self._SpecifyLive(self, "SpecifyLive", service, rules, path)
                 self.SpecifyDead = self._SpecifyDead(self, "SpecifyDead", service, rules, path)
@@ -6697,14 +6712,14 @@ class Root(PyMenu):
                 Argument SizeFieldFileName.
                 """
 
-            class _MaxHoleSize(PyNumericalCommandArgumentsSubItem):
+            class _MinHoleSize(PyNumericalCommandArgumentsSubItem):
                 """
-                Argument MaxHoleSize.
+                Argument MinHoleSize.
                 """
 
-            class _MinHoleSize(PyNumericalCommandArgumentsSubItem):
+            class _MaxHoleSize(PyNumericalCommandArgumentsSubItem):
                 """
-                Argument MinHoleSize.
+                Argument MaxHoleSize.
                 """
 
             class _SpecifyObj(PyParameterCommandArgumentsSubItem):
@@ -6982,15 +6997,15 @@ 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.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.WakeGrowthFactor = self._WakeGrowthFactor(self, "WakeGrowthFactor", 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.X = self._X(self, "X", 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)
@@ -7027,6 +7042,11 @@ class Root(PyMenu):
                     Specify the number of boundary layers that are to be captured in the refinement region.
                     """
 
+                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
+                    """
+                    Specify the factor by which the refinement region expands in the wake of the flow direction.
+                    """
+
                 class _NumberOfLayers(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument NumberOfLayers.
@@ -7037,11 +7057,6 @@ class Root(PyMenu):
                     Argument AspectRatio.
                     """
 
-                class _WakeGrowthFactor(PyNumericalCommandArgumentsSubItem):
-                    """
-                    Specify the factor by which the refinement region expands in the wake of the flow direction.
-                    """
-
                 class _FlowDirection(PyTextualCommandArgumentsSubItem):
                     """
                     Specify the direction that the flow through this refinement region.
@@ -7062,14 +7077,14 @@ class Root(PyMenu):
                     Argument Rate.
                     """
 
-                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,32 +7124,32 @@ 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)
                     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 _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):
@@ -7157,9 +7172,9 @@ class Root(PyMenu):
                     Specify the Z-coordinate for the offset of the initial position of the cylinder.
                     """
 
-                class _Z2(PyNumericalCommandArgumentsSubItem):
+                class _Z1(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the Z-coordinate of the second position of the cylinder.
+                    Specify the Z-coordinate of the first position of the cylinder.
                     """
 
                 class _Node1(PyTextualCommandArgumentsSubItem):
@@ -7167,9 +7182,9 @@ class Root(PyMenu):
                     Argument Node1.
                     """
 
-                class _Z1(PyNumericalCommandArgumentsSubItem):
+                class _Z2(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the Z-coordinate of the first position of the cylinder.
+                    Specify the Z-coordinate of the second position of the cylinder.
                     """
 
                 class _Radius2(PyNumericalCommandArgumentsSubItem):
@@ -7187,11 +7202,6 @@ class Root(PyMenu):
                     Argument Node3.
                     """
 
-                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
-                    """
-                    Specify the Y-coordinate for the offset of the initial position of the cylinder.
-                    """
-
                 class _Node2(PyTextualCommandArgumentsSubItem):
                     """
                     Argument Node2.
@@ -7202,6 +7212,11 @@ class Root(PyMenu):
                     Specify the X-coordinate of the second position of the cylinder.
                     """
 
+                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
+                    """
+                    Specify the Y-coordinate for the offset of the initial position of the cylinder.
+                    """
+
                 class _HeightFrontInc(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument HeightFrontInc.
@@ -7266,8 +7281,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):
@@ -7325,14 +7340,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):
@@ -7541,8 +7556,8 @@ class Root(PyMenu):
                     self.ZoneSelectionList = self._ZoneSelectionList(self, "ZoneSelectionList", service, rules, path)
                     self.SelectionType = self._SelectionType(self, "SelectionType", 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)
+                    self.FeatureAngle = self._FeatureAngle(self, "FeatureAngle", service, rules, path)
                     self.BufferSize = self._BufferSize(self, "BufferSize", service, rules, path)
                     self.FlipDirection = self._FlipDirection(self, "FlipDirection", service, rules, path)
                     self.NonRectangularBufferSize = self._NonRectangularBufferSize(self, "NonRectangularBufferSize", service, rules, path)
@@ -7573,14 +7588,14 @@ class Root(PyMenu):
                     Specify the thickness (or the total height) of the porous region.
                     """
 
-                class _FeatureAngle(PyNumericalCommandArgumentsSubItem):
+                class _MeshSize(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the angle at which features will be extracted for the porous region.
+                    Specify the cell size for the porous region mesh.
                     """
 
-                class _MeshSize(PyNumericalCommandArgumentsSubItem):
+                class _FeatureAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the cell size for the porous region mesh.
+                    Specify the angle at which features will be extracted for the porous region.
                     """
 
                 class _BufferSize(PyNumericalCommandArgumentsSubItem):
@@ -7912,9 +7927,9 @@ class Root(PyMenu):
                     super().__init__(parent, attr, service, rules, path)
                     self.PorousRegions = self._PorousRegions(self, "PorousRegions", service, rules, path)
                     self.CloseLeakages = self._CloseLeakages(self, "CloseLeakages", service, rules, path)
-                    self.CloseLeakges = self._CloseLeakges(self, "CloseLeakges", service, rules, path)
                     self.AdvancedOptions = self._AdvancedOptions(self, "AdvancedOptions", service, rules, path)
                     self.ZeroThickness = self._ZeroThickness(self, "ZeroThickness", 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,11 +7946,6 @@ class Root(PyMenu):
                     Argument CloseLeakages.
                     """
 
-                class _CloseLeakges(PyTextualCommandArgumentsSubItem):
-                    """
-                    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 _AdvancedOptions(PyParameterCommandArgumentsSubItem):
                     """
                     Display advanced options that you may want to apply to the workflow.
@@ -7946,6 +7956,11 @@ 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):
+                    """
+                    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):
                     """
                     Specify whether or not you will need to extract additional edge features from your imported geometry. These edge features will be captured. If so, then an Extract Edge Features task will be added to the workflow.
@@ -8294,19 +8309,19 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.MaxLayerHeight = self._MaxLayerHeight(self, "MaxLayerHeight", service, rules, path)
                     self.BiasMethod = self._BiasMethod(self, "BiasMethod", service, rules, path)
+                    self.MaxLayerHeight = self._MaxLayerHeight(self, "MaxLayerHeight", service, rules, path)
                     self.MergeCellZones = self._MergeCellZones(self, "MergeCellZones", service, rules, path)
                     self.ShowVMExtrudePreferences = self._ShowVMExtrudePreferences(self, "ShowVMExtrudePreferences", service, rules, path)
 
-                class _MaxLayerHeight(PyNumericalCommandArgumentsSubItem):
+                class _BiasMethod(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument MaxLayerHeight.
+                    Select from a choice of patterns that you want to apply to your volume mesh extrusion.
                     """
 
-                class _BiasMethod(PyTextualCommandArgumentsSubItem):
+                class _MaxLayerHeight(PyNumericalCommandArgumentsSubItem):
                     """
-                    Select from a choice of patterns that you want to apply to your volume mesh extrusion.
+                    Argument MaxLayerHeight.
                     """
 
                 class _MergeCellZones(PyParameterCommandArgumentsSubItem):
@@ -8386,12 +8401,12 @@ class Root(PyMenu):
                     self.SplitQuads = self._SplitQuads(self, "SplitQuads", service, rules, path)
                     self.MaxAspectRatio = self._MaxAspectRatio(self, "MaxAspectRatio", service, rules, path)
                     self.MinAspectRatio = self._MinAspectRatio(self, "MinAspectRatio", service, rules, path)
-                    self.LocalRemesh = self._LocalRemesh(self, "LocalRemesh", service, rules, path)
                     self.RemeshGrowthRate = self._RemeshGrowthRate(self, "RemeshGrowthRate", service, rules, path)
-                    self.GapFactor = self._GapFactor(self, "GapFactor", service, rules, path)
-                    self.ShowPrism2DPreferences = self._ShowPrism2DPreferences(self, "ShowPrism2DPreferences", service, rules, path)
+                    self.LocalRemesh = self._LocalRemesh(self, "LocalRemesh", service, rules, path)
                     self.MaxFaceSkew = self._MaxFaceSkew(self, "MaxFaceSkew", service, rules, path)
                     self.RefineStretchedQuads = self._RefineStretchedQuads(self, "RefineStretchedQuads", service, rules, path)
+                    self.GapFactor = self._GapFactor(self, "GapFactor", service, rules, path)
+                    self.ShowPrism2DPreferences = self._ShowPrism2DPreferences(self, "ShowPrism2DPreferences", service, rules, path)
                     self.nOrthogonalLayers = self._nOrthogonalLayers(self, "nOrthogonalLayers", service, rules, path)
 
                 class _SplitQuads(PyTextualCommandArgumentsSubItem):
@@ -8409,24 +8424,14 @@ class Root(PyMenu):
                     Argument MinAspectRatio.
                     """
 
-                class _LocalRemesh(PyTextualCommandArgumentsSubItem):
-                    """
-                    Argument LocalRemesh.
-                    """
-
                 class _RemeshGrowthRate(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument RemeshGrowthRate.
                     """
 
-                class _GapFactor(PyNumericalCommandArgumentsSubItem):
-                    """
-                    Argument GapFactor.
-                    """
-
-                class _ShowPrism2DPreferences(PyParameterCommandArgumentsSubItem):
+                class _LocalRemesh(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument ShowPrism2DPreferences.
+                    Argument LocalRemesh.
                     """
 
                 class _MaxFaceSkew(PyNumericalCommandArgumentsSubItem):
@@ -8439,6 +8444,16 @@ class Root(PyMenu):
                     Argument RefineStretchedQuads.
                     """
 
+                class _GapFactor(PyNumericalCommandArgumentsSubItem):
+                    """
+                    Argument GapFactor.
+                    """
+
+                class _ShowPrism2DPreferences(PyParameterCommandArgumentsSubItem):
+                    """
+                    Argument ShowPrism2DPreferences.
+                    """
+
                 class _nOrthogonalLayers(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument nOrthogonalLayers.
@@ -9163,8 +9178,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)
@@ -9194,14 +9209,14 @@ class Root(PyMenu):
                     Set proximity based refinement. Edges considers edge-to-edge proximity, while Faces considers face-to-face proximity, and Faces and Edges considers both.  More...
                     """
 
-                class _CurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _PreviewSizefield(PyParameterCommandArgumentsSubItem):
                     """
-                    Specify the maximum allowable angle (from 0 to 180 degrees) that one element edge is allowed to span given a particular geometry curvature. You can use this field to limit the number of elements that are generated along a curve or surface if the minimum size is too small for that particular curve.  More...
+                    Enable this option to visualize the size field in the graphics window.
                     """
 
-                class _PreviewSizefield(PyParameterCommandArgumentsSubItem):
+                class _CurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Enable this option to visualize the size field in the graphics window.
+                    Specify the maximum allowable angle (from 0 to 180 degrees) that one element edge is allowed to span given a particular geometry curvature. You can use this field to limit the number of elements that are generated along a curve or surface if the minimum size is too small for that particular curve.  More...
                     """
 
                 class _SaveSizeField(PyParameterCommandArgumentsSubItem):
@@ -9303,18 +9318,18 @@ class Root(PyMenu):
                     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.SMQualityImprove = self._SMQualityImprove(self, "SMQualityImprove", service, rules, path)
+                    self.SMSeparation = self._SMSeparation(self, "SMSeparation", service, rules, path)
                     self.SMSeparationAngle = self._SMSeparationAngle(self, "SMSeparationAngle", service, rules, path)
-                    self.AutoMerge = self._AutoMerge(self, "AutoMerge", service, rules, path)
                     self.ShowSurfaceMeshPreferences = self._ShowSurfaceMeshPreferences(self, "ShowSurfaceMeshPreferences", service, rules, path)
+                    self.SMQualityImprove = self._SMQualityImprove(self, "SMQualityImprove", service, rules, path)
                     self.TVMAutoControlCreation = self._TVMAutoControlCreation(self, "TVMAutoControlCreation", service, rules, path)
-                    self.SMSeparation = self._SMSeparation(self, "SMSeparation", service, rules, path)
+                    self.AutoMerge = self._AutoMerge(self, "AutoMerge", service, rules, path)
                     self.SMRemoveStep = self._SMRemoveStep(self, "SMRemoveStep", service, rules, path)
-                    self.SMStepWidth = self._SMStepWidth(self, "SMStepWidth", service, rules, path)
                     self.ParallelRegionCompute = self._ParallelRegionCompute(self, "ParallelRegionCompute", service, rules, path)
-                    self.VolumeMeshMaxSize = self._VolumeMeshMaxSize(self, "VolumeMeshMaxSize", service, rules, path)
-                    self.AutoAssignZoneTypes = self._AutoAssignZoneTypes(self, "AutoAssignZoneTypes", service, rules, path)
+                    self.SMStepWidth = self._SMStepWidth(self, "SMStepWidth", service, rules, path)
                     self.SMQualityMaxAngle = self._SMQualityMaxAngle(self, "SMQualityMaxAngle", 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)
@@ -9330,9 +9345,9 @@ class Root(PyMenu):
                     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 _SMQualityImprove(PyTextualCommandArgumentsSubItem):
+                class _SMSeparation(PyTextualCommandArgumentsSubItem):
                     """
-                    Choose whether or not to apply quality measures during surface mesh generation. You should disable this option when using Multizone meshing of very thin structures, relative to the minimum size.
+                    Choose whether or not to separate zones. This is required to select faces for capping. If Named Selections have already been defined at these locations, then separation is not needed. Performance may be improved if this is disabled.
                     """
 
                 class _SMSeparationAngle(PyNumericalCommandArgumentsSubItem):
@@ -9340,14 +9355,14 @@ class Root(PyMenu):
                     Specify a desired angle for determining separation. Assigning a smaller separation angle will produce more zones.
                     """
 
-                class _AutoMerge(PyParameterCommandArgumentsSubItem):
+                class _ShowSurfaceMeshPreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument AutoMerge.
+                    Display advanced options that you may want to apply to the task.
                     """
 
-                class _ShowSurfaceMeshPreferences(PyParameterCommandArgumentsSubItem):
+                class _SMQualityImprove(PyTextualCommandArgumentsSubItem):
                     """
-                    Display advanced options that you may want to apply to the task.
+                    Choose whether or not to apply quality measures during surface mesh generation. You should disable this option when using Multizone meshing of very thin structures, relative to the minimum size.
                     """
 
                 class _TVMAutoControlCreation(PyTextualCommandArgumentsSubItem):
@@ -9355,9 +9370,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 _SMSeparation(PyTextualCommandArgumentsSubItem):
+                class _AutoMerge(PyParameterCommandArgumentsSubItem):
                     """
-                    Choose whether or not to separate zones. This is required to select faces for capping. If Named Selections have already been defined at these locations, then separation is not needed. Performance may be improved if this is disabled.
+                    Argument AutoMerge.
                     """
 
                 class _SMRemoveStep(PyTextualCommandArgumentsSubItem):
@@ -9365,19 +9380,19 @@ class Root(PyMenu):
                     Indicate if there are any small imperfections (ledge or step artifacts from the original CAD geometry) that can be removed as part of this task. If you select yes, then you must specify a Max Step Width.
                     """
 
-                class _SMStepWidth(PyNumericalCommandArgumentsSubItem):
+                class _ParallelRegionCompute(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify the width of the step that you wish to remove.
+                    Argument ParallelRegionCompute.
                     """
 
-                class _ParallelRegionCompute(PyTextualCommandArgumentsSubItem):
+                class _SMStepWidth(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument ParallelRegionCompute.
+                    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):
@@ -9385,9 +9400,9 @@ 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 _SelfIntersectCheck(PyTextualCommandArgumentsSubItem):
@@ -9462,18 +9477,18 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.RefineFaceting = self._RefineFaceting(self, "RefineFaceting", service, rules, path)
                     self.MaxSize = self._MaxSize(self, "MaxSize", service, rules, path)
+                    self.RefineFaceting = self._RefineFaceting(self, "RefineFaceting", service, rules, path)
                     self.Tolerance = self._Tolerance(self, "Tolerance", service, rules, path)
 
-                class _RefineFaceting(PyParameterCommandArgumentsSubItem):
+                class _MaxSize(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument RefineFaceting.
+                    Specify the maximum size of the elements for the surface mesh.
                     """
 
-                class _MaxSize(PyNumericalCommandArgumentsSubItem):
+                class _RefineFaceting(PyParameterCommandArgumentsSubItem):
                     """
-                    Specify the maximum size of the elements for the surface mesh.
+                    Argument RefineFaceting.
                     """
 
                 class _Tolerance(PyNumericalCommandArgumentsSubItem):
@@ -9494,11 +9509,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.ImportCurvatureDataFromCAD = self._ImportCurvatureDataFromCAD(self, "ImportCurvatureDataFromCAD", service, rules, path)
-                    self.ExtractFeatures = self._ExtractFeatures(self, "ExtractFeatures", service, rules, path)
                     self.UsePartOrBodyAsSuffix = self._UsePartOrBodyAsSuffix(self, "UsePartOrBodyAsSuffix", service, rules, path)
-                    self.ImportPartNames = self._ImportPartNames(self, "ImportPartNames", 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)
 
                 class _SavePMDBIntermediateFile(PyParameterCommandArgumentsSubItem):
                     """
@@ -9530,19 +9545,19 @@ class Root(PyMenu):
                     Argument OneZonePer.
                     """
 
-                class _ImportCurvatureDataFromCAD(PyParameterCommandArgumentsSubItem):
+                class _UsePartOrBodyAsSuffix(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ImportCurvatureDataFromCAD.
+                    Argument UsePartOrBodyAsSuffix.
                     """
 
-                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
+                class _ImportNamedSelections(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ExtractFeatures.
+                    Argument ImportNamedSelections.
                     """
 
-                class _UsePartOrBodyAsSuffix(PyParameterCommandArgumentsSubItem):
+                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument UsePartOrBodyAsSuffix.
+                    Argument ExtractFeatures.
                     """
 
                 class _ImportPartNames(PyParameterCommandArgumentsSubItem):
@@ -9550,9 +9565,9 @@ class Root(PyMenu):
                     Argument ImportPartNames.
                     """
 
-                class _ImportNamedSelections(PyParameterCommandArgumentsSubItem):
+                class _ImportCurvatureDataFromCAD(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ImportNamedSelections.
+                    Argument ImportCurvatureDataFromCAD.
                     """
 
             class _ShareTopologyPreferences(PySingletonCommandArgumentsSubItem):
@@ -9567,10 +9582,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.IntfLabelList = self._IntfLabelList(self, "IntfLabelList", service, rules, path)
                     self.PerLabelList = self._PerLabelList(self, "PerLabelList", service, rules, path)
@@ -9603,9 +9618,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):
@@ -9618,9 +9633,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):
@@ -10033,9 +10048,9 @@ 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.HexMinCellLength = self._HexMinCellLength(self, "HexMinCellLength", service, rules, path)
-                    self.TetPolyMaxCellLength = self._TetPolyMaxCellLength(self, "TetPolyMaxCellLength", service, rules, path)
                     self.PeelLayers = self._PeelLayers(self, "PeelLayers", service, rules, path)
+                    self.TetPolyMaxCellLength = self._TetPolyMaxCellLength(self, "TetPolyMaxCellLength", service, rules, path)
+                    self.HexMinCellLength = self._HexMinCellLength(self, "HexMinCellLength", service, rules, path)
                     self.Type = self._Type(self, "Type", service, rules, path)
                     self.CellSizing = self._CellSizing(self, "CellSizing", service, rules, path)
                     self.HexMaxSize = self._HexMaxSize(self, "HexMaxSize", service, rules, path)
@@ -10048,9 +10063,9 @@ class Root(PyMenu):
                     Argument MaxSize.
                     """
 
-                class _HexMinCellLength(PyNumericalCommandArgumentsSubItem):
+                class _PeelLayers(PyNumericalCommandArgumentsSubItem):
                     """
-                    The minimum cell length for the hexcore or  poly-hexcore volume fill types.
+                    Specify the number of layers that control the gap between the hexahedra core and the geometry.  This distance is assumed to be the height of an ideal tetrahedral cell on the boundary face.
                     """
 
                 class _TetPolyMaxCellLength(PyNumericalCommandArgumentsSubItem):
@@ -10058,9 +10073,9 @@ class Root(PyMenu):
                     The maximum cell length for either the tetrahedron, polyhedron, or poly-hexcore volume fill types.
                     """
 
-                class _PeelLayers(PyNumericalCommandArgumentsSubItem):
+                class _HexMinCellLength(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the number of layers that control the gap between the hexahedra core and the geometry.  This distance is assumed to be the height of an ideal tetrahedral cell on the boundary face.
+                    The minimum cell length for the hexcore or  poly-hexcore volume fill types.
                     """
 
                 class _Type(PyTextualCommandArgumentsSubItem):
@@ -10115,13 +10130,13 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.UseSizeFieldInSolids = self._UseSizeFieldInSolids(self, "UseSizeFieldInSolids", 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.PolyFeatureAngle = self._PolyFeatureAngle(self, "PolyFeatureAngle", service, rules, path)
-                    self.SizeFieldPeriodicity = self._SizeFieldPeriodicity(self, "SizeFieldPeriodicity", service, rules, path)
-                    self.MergeBodyLabels = self._MergeBodyLabels(self, "MergeBodyLabels", service, rules, path)
                     self.UseSizeField = self._UseSizeField(self, "UseSizeField", service, rules, path)
+                    self.SizeFieldPeriodicity = self._SizeFieldPeriodicity(self, "SizeFieldPeriodicity", service, rules, path)
+                    self.PolyFeatureAngle = self._PolyFeatureAngle(self, "PolyFeatureAngle", service, rules, path)
+                    self.UseSizeFieldInSolids = self._UseSizeFieldInSolids(self, "UseSizeFieldInSolids", service, rules, path)
                     self.PolyInSolids = self._PolyInSolids(self, "PolyInSolids", service, rules, path)
                     self.TetInSolids = self._TetInSolids(self, "TetInSolids", service, rules, path)
                     self.AddMultipleQualityMethods = self._AddMultipleQualityMethods(self, "AddMultipleQualityMethods", service, rules, path)
@@ -10130,15 +10145,15 @@ class Root(PyMenu):
                     self.PrepareZoneNames = self._PrepareZoneNames(self, "PrepareZoneNames", 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.ShowVolumeMeshPreferences = self._ShowVolumeMeshPreferences(self, "ShowVolumeMeshPreferences", service, rules, path)
                     self.MinEdgeLength = self._MinEdgeLength(self, "MinEdgeLength", service, rules, path)
+                    self.ShowVolumeMeshPreferences = self._ShowVolumeMeshPreferences(self, "ShowVolumeMeshPreferences", service, rules, path)
                     self.SolidGrowthRate = self._SolidGrowthRate(self, "SolidGrowthRate", service, rules, path)
                     self.MinFaceArea = self._MinFaceArea(self, "MinFaceArea", 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 _QualityMethod(PyTextualCommandArgumentsSubItem):
@@ -10151,9 +10166,9 @@ class Root(PyMenu):
                     Argument MinPolySize.
                     """
 
-                class _PolyFeatureAngle(PyNumericalCommandArgumentsSubItem):
+                class _UseSizeField(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify the angle to preserve features when using a polyhedral-based mesh.
+                    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 _SizeFieldPeriodicity(PyTextualCommandArgumentsSubItem):
@@ -10161,14 +10176,14 @@ class Root(PyMenu):
                     Argument SizeFieldPeriodicity.
                     """
 
-                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):
+                class _UseSizeFieldInSolids(PyTextualCommandArgumentsSubItem):
                     """
-                    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.
+                    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 _PolyInSolids(PyTextualCommandArgumentsSubItem):
@@ -10211,14 +10226,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 _ShowVolumeMeshPreferences(PyParameterCommandArgumentsSubItem):
+                class _MinEdgeLength(PyNumericalCommandArgumentsSubItem):
                     """
-                    Display advanced options that you may want to apply to the task.
+                    Argument MinEdgeLength.
                     """
 
-                class _MinEdgeLength(PyNumericalCommandArgumentsSubItem):
+                class _ShowVolumeMeshPreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument MinEdgeLength.
+                    Display advanced options that you may want to apply to the task.
                     """
 
                 class _SolidGrowthRate(PyNumericalCommandArgumentsSubItem):
@@ -10252,8 +10267,8 @@ class Root(PyMenu):
                     self.MergeBoundaryLayers = self._MergeBoundaryLayers(self, "MergeBoundaryLayers", service, rules, path)
                     self.NormalSmoothRelaxationFactor = self._NormalSmoothRelaxationFactor(self, "NormalSmoothRelaxationFactor", service, rules, path)
                     self.ShowPrismPreferences = self._ShowPrismPreferences(self, "ShowPrismPreferences", 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):
@@ -10301,14 +10316,14 @@ class Root(PyMenu):
                     Display global settings for your boundary layers. Note that these settings are not applied for Multizone boundary layers
                     """
 
-                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):
@@ -10323,14 +10338,14 @@ 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.AutoOrderControls = self._AutoOrderControls(self, "AutoOrderControls", service, rules, path)
                     self.StairStep = self._StairStep(self, "StairStep", service, rules, path)
-                    self.MinAspectRatio = self._MinAspectRatio(self, "MinAspectRatio", service, rules, path)
+                    self.ShowGlobalThinVolumePreferences = self._ShowGlobalThinVolumePreferences(self, "ShowGlobalThinVolumePreferences", 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 _AutoOrderControls(PyTextualCommandArgumentsSubItem):
@@ -10343,9 +10358,9 @@ class Root(PyMenu):
                     Use this option to invoke stair-stepping at thin volume mesh regions.
                     """
 
-                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 _InvokePrimsControl(PyTextualCommandArgumentsSubItem):
@@ -10750,10 +10765,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):
                     """
@@ -10780,9 +10795,9 @@ class Root(PyMenu):
                     Argument AllowDefeaturing.
                     """
 
-                class _ShowSMImprovePreferences(PyParameterCommandArgumentsSubItem):
+                class _SIRemoveStep(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument ShowSMImprovePreferences.
+                    Argument SIRemoveStep.
                     """
 
                 class _AdvancedImprove(PyTextualCommandArgumentsSubItem):
@@ -10795,9 +10810,9 @@ class Root(PyMenu):
                     Argument SIStepWidth.
                     """
 
-                class _SIRemoveStep(PyTextualCommandArgumentsSubItem):
+                class _ShowSMImprovePreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument SIRemoveStep.
+                    Argument ShowSMImprovePreferences.
                     """
 
         def create_instance(self) -> _GeometrySetupCommandArguments:
@@ -11006,8 +11021,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)
@@ -11018,20 +11033,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.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.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):
@@ -11084,6 +11099,11 @@ class Root(PyMenu):
                     Argument Node3.
                     """
 
+                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
+                    """
+                    Argument Y-Offset.
+                    """
+
                 class _X2(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument X2.
@@ -11094,11 +11114,6 @@ class Root(PyMenu):
                     Argument Node2.
                     """
 
-                class _Y_Offset(PyNumericalCommandArgumentsSubItem):
-                    """
-                    Argument Y-Offset.
-                    """
-
                 class _HeightFrontInc(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument HeightFrontInc.
@@ -11629,10 +11644,10 @@ class Root(PyMenu):
                     self.FeatureAngle = self._FeatureAngle(self, "FeatureAngle", service, rules, path)
                     self.OneZonePer = self._OneZonePer(self, "OneZonePer", 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.UsePartOrBodyAsSuffix = self._UsePartOrBodyAsSuffix(self, "UsePartOrBodyAsSuffix", service, rules, path)
+                    self.ImportPartNames = self._ImportPartNames(self, "ImportPartNames", service, rules, path)
+                    self.ImportNamedSelections = self._ImportNamedSelections(self, "ImportNamedSelections", service, rules, path)
 
                 class _SavePMDBIntermediateFile(PyParameterCommandArgumentsSubItem):
                     """
@@ -11669,14 +11684,14 @@ class Root(PyMenu):
                     Argument ImportCurvatureDataFromCAD.
                     """
 
-                class _ImportNamedSelections(PyParameterCommandArgumentsSubItem):
+                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ImportNamedSelections.
+                    Argument ExtractFeatures.
                     """
 
-                class _ExtractFeatures(PyParameterCommandArgumentsSubItem):
+                class _UsePartOrBodyAsSuffix(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument ExtractFeatures.
+                    Argument UsePartOrBodyAsSuffix.
                     """
 
                 class _ImportPartNames(PyParameterCommandArgumentsSubItem):
@@ -11684,9 +11699,9 @@ class Root(PyMenu):
                     Argument ImportPartNames.
                     """
 
-                class _UsePartOrBodyAsSuffix(PyParameterCommandArgumentsSubItem):
+                class _ImportNamedSelections(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument UsePartOrBodyAsSuffix.
+                    Argument ImportNamedSelections.
                     """
 
         def create_instance(self) -> _ImportBodyOfInfluenceGeometryCommandArguments:
@@ -11776,23 +11791,23 @@ class Root(PyMenu):
 
                 def __init__(self, parent, attr, service, rules, path):
                     super().__init__(parent, attr, service, rules, path)
-                    self.EdgeLabel = self._EdgeLabel(self, "EdgeLabel", service, rules, path)
+                    self.MergeNodes = self._MergeNodes(self, "MergeNodes", service, rules, path)
                     self.MaxFacetLengthOption = self._MaxFacetLengthOption(self, "MaxFacetLengthOption", service, rules, path)
                     self.CISeparation = self._CISeparation(self, "CISeparation", service, rules, path)
-                    self.FacetedBodies = self._FacetedBodies(self, "FacetedBodies", service, rules, path)
+                    self.EdgeLabel = self._EdgeLabel(self, "EdgeLabel", service, rules, path)
                     self.CIRefaceting = self._CIRefaceting(self, "CIRefaceting", service, rules, path)
-                    self.MergeNodes = self._MergeNodes(self, "MergeNodes", service, rules, path)
+                    self.FacetedBodies = self._FacetedBodies(self, "FacetedBodies", service, rules, path)
                     self.AutomaticObjectCreation = self._AutomaticObjectCreation(self, "AutomaticObjectCreation", service, rules, path)
-                    self.MaxFacetLengthRatio = self._MaxFacetLengthRatio(self, "MaxFacetLengthRatio", service, rules, path)
                     self.MaxFacetLength = self._MaxFacetLength(self, "MaxFacetLength", service, rules, path)
                     self.ShowImportCadPreferences = self._ShowImportCadPreferences(self, "ShowImportCadPreferences", service, rules, path)
+                    self.MaxFacetLengthRatio = self._MaxFacetLengthRatio(self, "MaxFacetLengthRatio", service, rules, path)
                     self.ExtractAngle = self._ExtractAngle(self, "ExtractAngle", service, rules, path)
                     self.CISeparationAngle = self._CISeparationAngle(self, "CISeparationAngle", service, rules, path)
                     self.CITolerence = self._CITolerence(self, "CITolerence", service, rules, path)
 
-                class _EdgeLabel(PyTextualCommandArgumentsSubItem):
+                class _MergeNodes(PyTextualCommandArgumentsSubItem):
                     """
-                    Specify whether or not the imported CAD geometry already includes specific edges with assigned names (named selections). These named edges can be available later in the workflow when you are adding local size controls.
+                    Argument MergeNodes.
                     """
 
                 class _MaxFacetLengthOption(PyTextualCommandArgumentsSubItem):
@@ -11805,9 +11820,9 @@ class Root(PyMenu):
                     Choose whether or not you are going to separate zones upon import based on a region, a region and a specified separation angle, a face, or neither. This is required to select faces for local sizing. If Named Selections have already been defined at these locations, then separation is not needed.
                     """
 
-                class _FacetedBodies(PyTextualCommandArgumentsSubItem):
+                class _EdgeLabel(PyTextualCommandArgumentsSubItem):
                     """
-                    When performing faceting and wrapping operations in your CAD tool lead to non-CAD geometries, set this option to yes to be able to use such geometries in the workflow. To ensure a relatively good quality surface mesh, you should shrink wrap any faceted bodies. In addition, each shrink-wrapped faceted body should be defined in its own unique component within the CAD environment.
+                    Specify whether or not the imported CAD geometry already includes specific edges with assigned names (named selections). These named edges can be available later in the workflow when you are adding local size controls.
                     """
 
                 class _CIRefaceting(PyParameterCommandArgumentsSubItem):
@@ -11815,9 +11830,9 @@ class Root(PyMenu):
                     Enable this option to be able to set the Tolerance and the Max Facet Length custom faceting options for the imported geometry.
                     """
 
-                class _MergeNodes(PyTextualCommandArgumentsSubItem):
+                class _FacetedBodies(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument MergeNodes.
+                    When performing faceting and wrapping operations in your CAD tool lead to non-CAD geometries, set this option to yes to be able to use such geometries in the workflow. To ensure a relatively good quality surface mesh, you should shrink wrap any faceted bodies. In addition, each shrink-wrapped faceted body should be defined in its own unique component within the CAD environment.
                     """
 
                 class _AutomaticObjectCreation(PyTextualCommandArgumentsSubItem):
@@ -11825,11 +11840,6 @@ class Root(PyMenu):
                     Determine whether or not mesh objects and labels are automatically created upon import, potentially and dramatically increasing the mesh import speed for very large cases. By default, this is set to yes however, if it is set to no, then no labels are created and a single mesh object is created employing all zones.
                     """
 
-                class _MaxFacetLengthRatio(PyNumericalCommandArgumentsSubItem):
-                    """
-                    Argument MaxFacetLengthRatio.
-                    """
-
                 class _MaxFacetLength(PyNumericalCommandArgumentsSubItem):
                     """
                     Enables you to specify a maximum facet size for the imported model to avoid very large facets during the file import. Depending on the CAD geometry, this may yield more accuracy.
@@ -11840,6 +11850,11 @@ class Root(PyMenu):
                     Display advanced options that you may want to apply to the task.
                     """
 
+                class _MaxFacetLengthRatio(PyNumericalCommandArgumentsSubItem):
+                    """
+                    Argument MaxFacetLengthRatio.
+                    """
+
                 class _ExtractAngle(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument ExtractAngle.
@@ -12554,11 +12569,11 @@ 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.WrapGrowthRate = self._WrapGrowthRate(self, "WrapGrowthRate", service, rules, path)
                     self.InitialSizeControl = self._InitialSizeControl(self, "InitialSizeControl", service, rules, path)
+                    self.WrapGrowthRate = self._WrapGrowthRate(self, "WrapGrowthRate", service, rules, path)
                     self.SizingType = self._SizingType(self, "SizingType", service, rules, path)
-                    self.WrapCurvatureNormalAngle = self._WrapCurvatureNormalAngle(self, "WrapCurvatureNormalAngle", 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)
                     self.GrowthRate = self._GrowthRate(self, "GrowthRate", service, rules, path)
 
@@ -12607,14 +12622,14 @@ 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 _WrapGrowthRate(PyNumericalCommandArgumentsSubItem):
+                class _InitialSizeControl(PyParameterCommandArgumentsSubItem):
                     """
-                    Specify the increase in element edge length with each succeeding layer of elements.
+                    Enable this field to display the initial size control in the graphics window.
                     """
 
-                class _InitialSizeControl(PyParameterCommandArgumentsSubItem):
+                class _WrapGrowthRate(PyNumericalCommandArgumentsSubItem):
                     """
-                    Enable this field to display the initial size control in the graphics window.
+                    Specify the increase in element edge length with each succeeding layer of elements.
                     """
 
                 class _SizingType(PyTextualCommandArgumentsSubItem):
@@ -12622,14 +12637,14 @@ class Root(PyMenu):
                     Choose the type of sizing control (curvature, proximity, soft, or boi).
                     """
 
-                class _WrapCurvatureNormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _CellsPerGap(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the maximum allowable angle (from 0 to 180 degrees) that one element edge is allowed to span given a particular geometry curvature. You can use this field to limit the number of elements that are generated along a curve or surface if the minimum size is too small for that particular curve.
+                    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.
                     """
 
-                class _CellsPerGap(PyNumericalCommandArgumentsSubItem):
+                class _WrapCurvatureNormalAngle(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.
+                    Specify the maximum allowable angle (from 0 to 180 degrees) that one element edge is allowed to span given a particular geometry curvature. You can use this field to limit the number of elements that are generated along a curve or surface if the minimum size is too small for that particular curve.
                     """
 
                 class _TargetSizeControl(PyParameterCommandArgumentsSubItem):
@@ -13333,10 +13348,10 @@ class Root(PyMenu):
                     super().__init__(parent, attr, service, rules, path)
                     self.FacetMaxEdgeLength = self._FacetMaxEdgeLength(self, "FacetMaxEdgeLength", service, rules, path)
                     self.MaxSize = self._MaxSize(self, "MaxSize", service, rules, path)
-                    self.Deviation = self._Deviation(self, "Deviation", service, rules, path)
                     self.MaxEdgeLengthFactor = self._MaxEdgeLengthFactor(self, "MaxEdgeLengthFactor", service, rules, path)
-                    self.Refacet = self._Refacet(self, "Refacet", service, rules, path)
                     self.NormalAngle = self._NormalAngle(self, "NormalAngle", service, rules, path)
+                    self.Refacet = self._Refacet(self, "Refacet", service, rules, path)
+                    self.Deviation = self._Deviation(self, "Deviation", service, rules, path)
 
                 class _FacetMaxEdgeLength(PyTextualCommandArgumentsSubItem):
                     """
@@ -13348,14 +13363,14 @@ class Root(PyMenu):
                     Specify a maximum element size for the imported model to avoid very large facets during the file import.
                     """
 
-                class _Deviation(PyNumericalCommandArgumentsSubItem):
+                class _MaxEdgeLengthFactor(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the distance between facet edges and the geometry edges. Decreasing this value will result in more facets along curved edges.
+                    Specifies the maximum size of the facets relative to the bounding box of the geometry.
                     """
 
-                class _MaxEdgeLengthFactor(PyNumericalCommandArgumentsSubItem):
+                class _NormalAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specifies the maximum size of the facets relative to the bounding box of the geometry.
+                    Specify a rotational angle (in degrees) of transformation.
                     """
 
                 class _Refacet(PyParameterCommandArgumentsSubItem):
@@ -13363,9 +13378,9 @@ class Root(PyMenu):
                     Select this option when you want to change faceting of the selected object. Refaceting will refacet the original CAD geometry. Only the faceted CAD geometry is used during the meshing process. The refaceting settings control how far the facet edges are from the model and the size of the facets.  More...
                     """
 
-                class _NormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _Deviation(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify a rotational angle (in degrees) of transformation.
+                    Specify the distance between facet edges and the geometry edges. Decreasing this value will result in more facets along curved edges.
                     """
 
             class _IgnoreSolidNames(PyParameterCommandArgumentsSubItem):
@@ -13428,8 +13443,8 @@ class Root(PyMenu):
                     super().__init__(parent, attr, service, rules, path)
                     self.MaxSize = self._MaxSize(self, "MaxSize", service, rules, path)
                     self.RefacetDuringLoad = self._RefacetDuringLoad(self, "RefacetDuringLoad", service, rules, path)
-                    self.Deviation = self._Deviation(self, "Deviation", service, rules, path)
                     self.NormalAngle = self._NormalAngle(self, "NormalAngle", service, rules, path)
+                    self.Deviation = self._Deviation(self, "Deviation", service, rules, path)
 
                 class _MaxSize(PyNumericalCommandArgumentsSubItem):
                     """
@@ -13441,14 +13456,14 @@ class Root(PyMenu):
                     This option is available when DSCO is selected for the Import Route. When enabled, this option will refacet the geometry as it is converted to a .fmd file. This option eliminates the need for any refaceting operation after the geometry is loaded, which can be expensive.
                     """
 
-                class _Deviation(PyNumericalCommandArgumentsSubItem):
+                class _NormalAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify the distance between facet edges and the geometry edges. Decreasing this value will result in more facets along curved edges.
+                    Specify a rotational angle (in degrees) of transformation.
                     """
 
-                class _NormalAngle(PyNumericalCommandArgumentsSubItem):
+                class _Deviation(PyNumericalCommandArgumentsSubItem):
                     """
-                    Specify a rotational angle (in degrees) of transformation.
+                    Specify the distance between facet edges and the geometry edges. Decreasing this value will result in more facets along curved edges.
                     """
 
         def create_instance(self) -> _PartManagementCommandArguments:
@@ -13579,6 +13594,47 @@ class Root(PyMenu):
             if args is not None:
                 return self._PartReplacementSettingsCommandArguments(*args)
 
+    class PrepareForVolumeMeshing(PyCommand):
+        """
+        Command PrepareForVolumeMeshing.
+
+        Parameters
+        ----------
+        MergeZonesBasedOnLabels : bool
+        SoftTargetSkewness : float
+        HardTargetSkewness : float
+
+        Returns
+        -------
+        bool
+        """
+        class _PrepareForVolumeMeshingCommandArguments(PyCommandArguments):
+            def __init__(self, service, rules, command, path, id):
+                super().__init__(service, rules, command, path, id)
+                self.MergeZonesBasedOnLabels = self._MergeZonesBasedOnLabels(self, "MergeZonesBasedOnLabels", service, rules, path)
+                self.SoftTargetSkewness = self._SoftTargetSkewness(self, "SoftTargetSkewness", service, rules, path)
+                self.HardTargetSkewness = self._HardTargetSkewness(self, "HardTargetSkewness", service, rules, path)
+
+            class _MergeZonesBasedOnLabels(PyParameterCommandArgumentsSubItem):
+                """
+                Argument MergeZonesBasedOnLabels.
+                """
+
+            class _SoftTargetSkewness(PyNumericalCommandArgumentsSubItem):
+                """
+                Argument SoftTargetSkewness.
+                """
+
+            class _HardTargetSkewness(PyNumericalCommandArgumentsSubItem):
+                """
+                Argument HardTargetSkewness.
+                """
+
+        def create_instance(self) -> _PrepareForVolumeMeshingCommandArguments:
+            args = self._get_create_instance_args()
+            if args is not None:
+                return self._PrepareForVolumeMeshingCommandArguments(*args)
+
     class RemeshSurface(PyCommand):
         """
         Command RemeshSurface.
@@ -14039,14 +14095,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.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.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.PerLabelList = self._PerLabelList(self, "PerLabelList", service, rules, path)
+                    self.IntfLabelList = self._IntfLabelList(self, "IntfLabelList", service, rules, path)
                     self.AdvancedImprove = self._AdvancedImprove(self, "AdvancedImprove", service, rules, path)
                     self.NumberOfJoinTries = self._NumberOfJoinTries(self, "NumberOfJoinTries", service, rules, path)
 
@@ -14075,9 +14131,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):
@@ -14090,9 +14146,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):
@@ -14100,9 +14156,9 @@ class Root(PyMenu):
                     Specify the increment by which the tolerance changes for each attempt to join face pairs.
                     """
 
-                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 _PerLabelList(PyTextualCommandArgumentsSubItem):
@@ -14110,9 +14166,9 @@ class Root(PyMenu):
                     Argument PerLabelList.
                     """
 
-                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 _AdvancedImprove(PyTextualCommandArgumentsSubItem):
@@ -14137,10 +14193,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.SIRemoveStep = self._SIRemoveStep(self, "SIRemoveStep", service, rules, path)
+                    self.ShowSMImprovePreferences = self._ShowSMImprovePreferences(self, "ShowSMImprovePreferences", service, rules, path)
                     self.AdvancedImprove = self._AdvancedImprove(self, "AdvancedImprove", service, rules, path)
                     self.SIStepWidth = self._SIStepWidth(self, "SIStepWidth", service, rules, path)
-                    self.ShowSMImprovePreferences = self._ShowSMImprovePreferences(self, "ShowSMImprovePreferences", service, rules, path)
+                    self.SIRemoveStep = self._SIRemoveStep(self, "SIRemoveStep", service, rules, path)
 
                 class _SIStepQualityLimit(PyNumericalCommandArgumentsSubItem):
                     """
@@ -14167,9 +14223,9 @@ class Root(PyMenu):
                     Argument AllowDefeaturing.
                     """
 
-                class _SIRemoveStep(PyTextualCommandArgumentsSubItem):
+                class _ShowSMImprovePreferences(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument SIRemoveStep.
+                    Argument ShowSMImprovePreferences.
                     """
 
                 class _AdvancedImprove(PyTextualCommandArgumentsSubItem):
@@ -14182,9 +14238,9 @@ class Root(PyMenu):
                     Argument SIStepWidth.
                     """
 
-                class _ShowSMImprovePreferences(PyParameterCommandArgumentsSubItem):
+                class _SIRemoveStep(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument ShowSMImprovePreferences.
+                    Argument SIRemoveStep.
                     """
 
             class _SurfaceMeshPreferences(PySingletonCommandArgumentsSubItem):
@@ -14195,19 +14251,19 @@ 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.SMQualityImprove = self._SMQualityImprove(self, "SMQualityImprove", service, rules, path)
+                    self.ShowSurfaceMeshPreferences = self._ShowSurfaceMeshPreferences(self, "ShowSurfaceMeshPreferences", service, rules, path)
                     self.SMSeparationAngle = self._SMSeparationAngle(self, "SMSeparationAngle", service, rules, path)
                     self.SMSeparation = self._SMSeparation(self, "SMSeparation", service, rules, path)
-                    self.ShowSurfaceMeshPreferences = self._ShowSurfaceMeshPreferences(self, "ShowSurfaceMeshPreferences", 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.ParallelRegionCompute = self._ParallelRegionCompute(self, "ParallelRegionCompute", 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.ParallelRegionCompute = self._ParallelRegionCompute(self, "ParallelRegionCompute", service, rules, path)
                     self.SMQualityMaxAngle = self._SMQualityMaxAngle(self, "SMQualityMaxAngle", 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)
@@ -14218,9 +14274,9 @@ class Root(PyMenu):
                     Argument SMQualityCollapseLimit.
                     """
 
-                class _FoldFaceLimit(PyNumericalCommandArgumentsSubItem):
+                class _AutoMerge(PyParameterCommandArgumentsSubItem):
                     """
-                    Argument FoldFaceLimit.
+                    Argument AutoMerge.
                     """
 
                 class _SMQualityImprove(PyTextualCommandArgumentsSubItem):
@@ -14228,6 +14284,11 @@ class Root(PyMenu):
                     Argument SMQualityImprove.
                     """
 
+                class _ShowSurfaceMeshPreferences(PyParameterCommandArgumentsSubItem):
+                    """
+                    Argument ShowSurfaceMeshPreferences.
+                    """
+
                 class _SMSeparationAngle(PyNumericalCommandArgumentsSubItem):
                     """
                     Argument SMSeparationAngle.
@@ -14238,19 +14299,14 @@ class Root(PyMenu):
                     Argument SMSeparation.
                     """
 
-                class _ShowSurfaceMeshPreferences(PyParameterCommandArgumentsSubItem):
-                    """
-                    Argument ShowSurfaceMeshPreferences.
-                    """
-
                 class _TVMAutoControlCreation(PyTextualCommandArgumentsSubItem):
                     """
                     Argument TVMAutoControlCreation.
                     """
 
-                class _AutoMerge(PyParameterCommandArgumentsSubItem):
+                class _FoldFaceLimit(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument AutoMerge.
+                    Argument FoldFaceLimit.
                     """
 
                 class _SMRemoveStep(PyTextualCommandArgumentsSubItem):
@@ -14258,19 +14314,19 @@ class Root(PyMenu):
                     Argument SMRemoveStep.
                     """
 
-                class _ParallelRegionCompute(PyTextualCommandArgumentsSubItem):
+                class _SMStepWidth(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument ParallelRegionCompute.
+                    Argument SMStepWidth.
                     """
 
-                class _SMStepWidth(PyNumericalCommandArgumentsSubItem):
+                class _ParallelRegionCompute(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument SMStepWidth.
+                    Argument ParallelRegionCompute.
                     """
 
-                class _VolumeMeshMaxSize(PyNumericalCommandArgumentsSubItem):
+                class _SMQualityMaxAngle(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument VolumeMeshMaxSize.
+                    Argument SMQualityMaxAngle.
                     """
 
                 class _AutoAssignZoneTypes(PyTextualCommandArgumentsSubItem):
@@ -14278,9 +14334,9 @@ class Root(PyMenu):
                     Argument AutoAssignZoneTypes.
                     """
 
-                class _SMQualityMaxAngle(PyNumericalCommandArgumentsSubItem):
+                class _VolumeMeshMaxSize(PyNumericalCommandArgumentsSubItem):
                     """
-                    Argument SMQualityMaxAngle.
+                    Argument VolumeMeshMaxSize.
                     """
 
                 class _SelfIntersectCheck(PyTextualCommandArgumentsSubItem):
@@ -14387,8 +14443,8 @@ class Root(PyMenu):
                     self.NewLabelObjects = self._NewLabelObjects(self, "NewLabelObjects", service, rules, path)
                     self.NewLabelCells = self._NewLabelCells(self, "NewLabelCells", service, rules, path)
                     self.NewLabelType = self._NewLabelType(self, "NewLabelType", service, rules, path)
-                    self.NewLabels = self._NewLabels(self, "NewLabels", service, rules, path)
                     self.NewLabelResolution = self._NewLabelResolution(self, "NewLabelResolution", 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)
@@ -14409,14 +14465,14 @@ class Root(PyMenu):
                     Argument NewLabelType.
                     """
 
-                class _NewLabels(PyTextualCommandArgumentsSubItem):
+                class _NewLabelResolution(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument NewLabels.
+                    Argument NewLabelResolution.
                     """
 
-                class _NewLabelResolution(PyTextualCommandArgumentsSubItem):
+                class _NewLabels(PyTextualCommandArgumentsSubItem):
                     """
-                    Argument NewLabelResolution.
+                    Argument NewLabels.
                     """
 
                 class _NewLabelMax(PyTextualCommandArgumentsSubItem):